diff --git a/.npmignore b/.npmignore
index 02270857e37..3af34bded4a 100644
--- a/.npmignore
+++ b/.npmignore
@@ -3,7 +3,11 @@ doc
 scripts
 src
 tests
+internal
+tslint.json
 Jakefile.js
-.travis.yml
+.editorconfig
+.gitattributes
 .settings/
+.travis.yml
 .vscode/
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index 572ac835cd4..03e319f6b16 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,7 @@
 language: node_js
 
 node_js:
+  - '4'
   - '0.10'
 
-sudo: false
\ No newline at end of file
+sudo: false
diff --git a/Jakefile.js b/Jakefile.js
index e99043d3f5f..5b93462d855 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -628,10 +628,9 @@ function deleteTemporaryProjectOutput() {
 
 var testTimeout = 20000;
 desc("Runs the tests using the built run.js file. Syntax is jake runtests. Optional parameters 'host=', 'tests=[regex], reporter=[list|spec|json|<more>]', debug=true.");
-task("runtests", ["tests", builtLocalDirectory], function() {
+task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
     cleanTestDirs();
     var debug = process.env.debug || process.env.d;
-    host = "mocha"
     tests = process.env.test || process.env.tests || process.env.t;
     var light = process.env.light || false;
     var testConfigFile = 'test.config';
@@ -653,9 +652,16 @@ task("runtests", ["tests", builtLocalDirectory], function() {
     reporter = process.env.reporter || process.env.r || 'mocha-fivemat-progress-reporter';
     // timeout normally isn't necessary but Travis-CI has been timing out on compiler baselines occasionally
     // default timeout is 2sec which really should be enough, but maybe we just need a small amount longer
-    var cmd = host + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
+    var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
     console.log(cmd);
-    exec(cmd, deleteTemporaryProjectOutput);
+    exec(cmd, function() {
+        deleteTemporaryProjectOutput();
+        var lint = jake.Task['lint'];
+        lint.addListener('complete', function () {
+            complete();
+        });
+        lint.invoke();
+    });
 }, {async: true});
 
 desc("Generates code coverage data via instanbul");
@@ -825,7 +831,7 @@ var tslintRulesOutFiles = tslintRules.map(function(p) {
 desc("Compiles tslint rules to js");
 task("build-rules", tslintRulesOutFiles);
 tslintRulesFiles.forEach(function(ruleFile, i) {
-    compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ true, /*noOutFile*/ true, /*generateDeclarations*/ false, path.join(builtLocalDirectory, "tslint")); 
+    compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ false, /*noOutFile*/ true, /*generateDeclarations*/ false, path.join(builtLocalDirectory, "tslint")); 
 });
 
 function getLinterOptions() {
@@ -859,8 +865,6 @@ function lintFileAsync(options, path, cb) {
 
 var lintTargets = compilerSources.concat(harnessCoreSources);
 
-// if the codebase were free of linter errors we could make jake runtests
-// run this task automatically
 desc("Runs tslint on the compiler sources");
 task("lint", ["build-rules"], function() {
     var lintOptions = getLinterOptions();
diff --git a/lib/lib.core.es6.d.ts b/lib/lib.core.es6.d.ts
index 6d6a68559f8..fd115497f8a 100644
--- a/lib/lib.core.es6.d.ts
+++ b/lib/lib.core.es6.d.ts
@@ -3965,34 +3965,7 @@ interface ObjectConstructor {
       * Copy the values of all of the enumerable own properties from one or more source objects to a 
       * target object. Returns the target object.
       * @param target The target object to copy to.
-      * @param source The source object from which to copy properties.
-      */
-    assign<T, U>(target: T, source: U): T & U;
-
-    /**
-      * Copy the values of all of the enumerable own properties from one or more source objects to a 
-      * target object. Returns the target object.
-      * @param target The target object to copy to.
-      * @param source1 The first source object from which to copy properties.
-      * @param source2 The second source object from which to copy properties.
-      */
-    assign<T, U, V>(target: T, source1: U, source2: V): T & U & V;
-
-    /**
-      * Copy the values of all of the enumerable own properties from one or more source objects to a 
-      * target object. Returns the target object.
-      * @param target The target object to copy to.
-      * @param source1 The first source object from which to copy properties.
-      * @param source2 The second source object from which to copy properties.
-      * @param source3 The third source object from which to copy properties.
-      */
-    assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
-
-    /**
-      * Copy the values of all of the enumerable own properties from one or more source objects to a 
-      * target object. Returns the target object.
-      * @param target The target object to copy to.
-      * @param sources One or more source objects from which to copy properties
+      * @param sources One or more source objects to copy properties from.
       */
     assign(target: any, ...sources: any[]): any;
 
diff --git a/package.json b/package.json
index 607a38552ba..28f2c1b5755 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,7 @@
     },
     "scripts": {
         "pretest": "jake tests",
-        "test": "jake runtests && npm run lint",
+        "test": "jake runtests",
         "build": "npm run build:compiler && npm run build:tests",
         "build:compiler": "jake local",
         "build:tests": "jake tests",
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 65768332360..c12a9afad62 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -185,8 +185,9 @@ namespace ts {
         function declareSymbol(symbolTable: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
             Debug.assert(!hasDynamicName(node));
 
+            let isDefaultExport = node.flags & NodeFlags.Default;
             // The exported symbol for an export default function/class node is always named "default"
-            let name = node.flags & NodeFlags.Default && parent ? "default" : getDeclarationName(node);
+            let name = isDefaultExport && parent ? "default" : getDeclarationName(node);
 
             let symbol: Symbol;
             if (name !== undefined) {
@@ -227,6 +228,13 @@ namespace ts {
                     let message = symbol.flags & SymbolFlags.BlockScopedVariable
                         ? Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : Diagnostics.Duplicate_identifier_0;
+
+                    forEach(symbol.declarations, declaration => {
+                        if (declaration.flags & NodeFlags.Default) {
+                            message = Diagnostics.A_module_cannot_have_multiple_default_exports;
+                        }
+                    });
+
                     forEach(symbol.declarations, declaration => {
                         file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));
                     });
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 1cabea864dc..1d890b15031 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -383,20 +383,72 @@ namespace ts {
             // return undefined if we can't find a symbol.
         }
 
-        /** Returns true if node1 is defined before node 2**/
-        function isDefinedBefore(node1: Node, node2: Node): boolean {
-            let file1 = getSourceFileOfNode(node1);
-            let file2 = getSourceFileOfNode(node2);
-            if (file1 === file2) {
-                return node1.pos <= node2.pos;
+        function isBlockScopedNameDeclaredBeforeUse(declaration: Declaration, usage: Node): boolean {
+            const declarationFile = getSourceFileOfNode(declaration);
+            const useFile = getSourceFileOfNode(usage);
+            if (declarationFile !== useFile) {
+                if (modulekind || (!compilerOptions.outFile && !compilerOptions.out)) {
+                    // nodes are in different files and order cannot be determines
+                    return true;
+                }
+
+                const sourceFiles = host.getSourceFiles();
+                return indexOf(sourceFiles, declarationFile) <= indexOf(sourceFiles, useFile);
             }
 
-            if (!compilerOptions.outFile && !compilerOptions.out) {
-                return true;
+            if (declaration.pos <= usage.pos) {
+                // declaration is before usage
+                // still might be illegal if usage is in the initializer of the variable declaration
+                return declaration.kind !== SyntaxKind.VariableDeclaration ||
+                    !isImmediatelyUsedInInitializerOfBlockScopedVariable(<VariableDeclaration>declaration, usage);
             }
 
-            let sourceFiles = host.getSourceFiles();
-            return sourceFiles.indexOf(file1) <= sourceFiles.indexOf(file2);
+            // declaration is after usage
+            // can be legal if usage is deferred (i.e. inside function or in initializer of instance property)
+            return isUsedInFunctionOrNonStaticProperty(declaration, usage);
+
+            function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration: VariableDeclaration, usage: Node): boolean {
+                const container = getEnclosingBlockScopeContainer(declaration);
+
+                if (declaration.parent.parent.kind === SyntaxKind.VariableStatement ||
+                    declaration.parent.parent.kind === SyntaxKind.ForStatement) {
+                    // variable statement/for statement case,
+                    // use site should not be inside variable declaration (initializer of declaration or binding element)
+                    return isSameScopeDescendentOf(usage, declaration, container);
+                }
+                else if (declaration.parent.parent.kind === SyntaxKind.ForOfStatement ||
+                    declaration.parent.parent.kind === SyntaxKind.ForInStatement) {
+                    // ForIn/ForOf case - use site should not be used in expression part
+                    let expression = (<ForInStatement | ForOfStatement>declaration.parent.parent).expression;
+                    return isSameScopeDescendentOf(usage, expression, container);
+                }
+            }
+
+            function isUsedInFunctionOrNonStaticProperty(declaration: Declaration, usage: Node): boolean {
+                const container = getEnclosingBlockScopeContainer(declaration);
+                let current = usage;
+                while (current) {
+                    if (current === container) {
+                        return false;
+                    }
+
+                    if (isFunctionLike(current)) {
+                        return true;
+                    }
+
+                    const initializerOfNonStaticProperty = current.parent &&
+                        current.parent.kind === SyntaxKind.PropertyDeclaration &&
+                        (current.parent.flags & NodeFlags.Static) === 0 &&
+                        (<PropertyDeclaration>current.parent).initializer === current;
+
+                    if (initializerOfNonStaticProperty) {
+                        return true;
+                    }
+
+                    current = current.parent;
+                }
+                return false;
+            }
         }
 
         // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
@@ -610,8 +662,11 @@ namespace ts {
                 // block - scope variable and namespace module. However, only when we
                 // try to resolve name in /*1*/ which is used in variable position,
                 // we want to check for block- scoped
-                if (meaning & SymbolFlags.BlockScopedVariable && result.flags & SymbolFlags.BlockScopedVariable) {
-                    checkResolvedBlockScopedVariable(result, errorLocation);
+                if (meaning & SymbolFlags.BlockScopedVariable) {
+                    const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
+                    if (exportOrLocalSymbol.flags & SymbolFlags.BlockScopedVariable) {
+                        checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
+                    }
                 }
             }
             return result;
@@ -624,34 +679,7 @@ namespace ts {
 
             Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined");
 
-            // first check if usage is lexically located after the declaration
-            let isUsedBeforeDeclaration = !isDefinedBefore(declaration, errorLocation);
-            if (!isUsedBeforeDeclaration) {
-                // lexical check succeeded however code still can be illegal.
-                // - block scoped variables cannot be used in its initializers
-                //   let x = x; // illegal but usage is lexically after definition
-                // - in ForIn/ForOf statements variable cannot be contained in expression part
-                //   for (let x in x)
-                //   for (let x of x)
-
-                // climb up to the variable declaration skipping binding patterns
-                let variableDeclaration = <VariableDeclaration>getAncestor(declaration, SyntaxKind.VariableDeclaration);
-                let container = getEnclosingBlockScopeContainer(variableDeclaration);
-
-                if (variableDeclaration.parent.parent.kind === SyntaxKind.VariableStatement ||
-                    variableDeclaration.parent.parent.kind === SyntaxKind.ForStatement) {
-                    // variable statement/for statement case,
-                    // use site should not be inside variable declaration (initializer of declaration or binding element)
-                    isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, variableDeclaration, container);
-                }
-                else if (variableDeclaration.parent.parent.kind === SyntaxKind.ForOfStatement ||
-                    variableDeclaration.parent.parent.kind === SyntaxKind.ForInStatement) {
-                    // ForIn/ForOf case - use site should not be used in expression part
-                    let expression = (<ForInStatement | ForOfStatement>variableDeclaration.parent.parent).expression;
-                    isUsedBeforeDeclaration = isSameScopeDescendentOf(errorLocation, expression, container);
-                }
-            }
-            if (isUsedBeforeDeclaration) {
+            if (!isBlockScopedNameDeclaredBeforeUse(<Declaration>getAncestor(declaration, SyntaxKind.VariableDeclaration), errorLocation)) {
                 error(errorLocation, Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationNameToString(declaration.name));
             }
         }
@@ -2209,7 +2237,7 @@ namespace ts {
 
         /**
          * Push an entry on the type resolution stack. If an entry with the given target and the given property name
-         * is already on the stack, and no entries in between already have a type, then a circularity has occurred. 
+         * is already on the stack, and no entries in between already have a type, then a circularity has occurred.
          * In this case, the result values of the existing entry and all entries pushed after it are changed to false,
          * and the value false is returned. Otherwise, the new entry is just pushed onto the stack, and true is returned.
          * In order to see if the same query has already been done before, the target object and the propertyName both
@@ -3171,8 +3199,8 @@ namespace ts {
                 members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
                 callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature);
                 constructSignatures = instantiateList(source.declaredConstructSignatures, mapper, instantiateSignature);
-                stringIndexType = source.declaredStringIndexType ? instantiateType(source.declaredStringIndexType, mapper) : undefined;
-                numberIndexType = source.declaredNumberIndexType ? instantiateType(source.declaredNumberIndexType, mapper) : undefined;
+                stringIndexType = instantiateType(source.declaredStringIndexType, mapper);
+                numberIndexType = instantiateType(source.declaredNumberIndexType, mapper);
             }
             let baseTypes = getBaseTypes(source);
             if (baseTypes.length) {
@@ -3371,7 +3399,7 @@ namespace ts {
             setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType);
         }
 
-        function resolveAnonymousTypeMembers(type: ObjectType) {
+        function resolveAnonymousTypeMembers(type: AnonymousType) {
             let symbol = type.symbol;
             let members: SymbolTable;
             let callSignatures: Signature[];
@@ -3379,7 +3407,14 @@ namespace ts {
             let stringIndexType: Type;
             let numberIndexType: Type;
 
-            if (symbol.flags & SymbolFlags.TypeLiteral) {
+            if (type.target) {
+                members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
+                callSignatures = instantiateList(getSignaturesOfType(type.target, SignatureKind.Call), type.mapper, instantiateSignature);
+                constructSignatures = instantiateList(getSignaturesOfType(type.target, SignatureKind.Construct), type.mapper, instantiateSignature);
+                stringIndexType = instantiateType(getIndexTypeOfType(type.target, IndexKind.String), type.mapper);
+                numberIndexType = instantiateType(getIndexTypeOfType(type.target, IndexKind.Number), type.mapper);
+            }
+            else if (symbol.flags & SymbolFlags.TypeLiteral) {
                 members = symbol.members;
                 callSignatures = getSignaturesOfSymbol(members["__call"]);
                 constructSignatures = getSignaturesOfSymbol(members["__new"]);
@@ -3424,7 +3459,7 @@ namespace ts {
                     resolveClassOrInterfaceMembers(<InterfaceType>type);
                 }
                 else if (type.flags & TypeFlags.Anonymous) {
-                    resolveAnonymousTypeMembers(<ObjectType>type);
+                    resolveAnonymousTypeMembers(<AnonymousType>type);
                 }
                 else if (type.flags & TypeFlags.Tuple) {
                     resolveTupleTypeMembers(<TupleType>type);
@@ -4543,7 +4578,7 @@ namespace ts {
             }
             let result = createSignature(signature.declaration, freshTypeParameters,
                 instantiateList(signature.parameters, mapper, instantiateSymbol),
-                signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined,
+                instantiateType(signature.resolvedReturnType, mapper),
                 freshTypePredicate,
                 signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals);
             result.target = signature;
@@ -4575,7 +4610,7 @@ namespace ts {
             return result;
         }
 
-        function instantiateAnonymousType(type: ObjectType, mapper: TypeMapper): ObjectType {
+        function instantiateAnonymousType(type: AnonymousType, mapper: TypeMapper): ObjectType {
             if (mapper.instantiations) {
                 let cachedType = mapper.instantiations[type.id];
                 if (cachedType) {
@@ -4586,27 +4621,21 @@ namespace ts {
                 mapper.instantiations = [];
             }
             // Mark the anonymous type as instantiated such that our infinite instantiation detection logic can recognize it
-            let result = <ResolvedType>createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol);
-            result.properties = instantiateList(getPropertiesOfObjectType(type), mapper, instantiateSymbol);
-            result.members = createSymbolTable(result.properties);
-            result.callSignatures = instantiateList(getSignaturesOfType(type, SignatureKind.Call), mapper, instantiateSignature);
-            result.constructSignatures = instantiateList(getSignaturesOfType(type, SignatureKind.Construct), mapper, instantiateSignature);
-            let stringIndexType = getIndexTypeOfType(type, IndexKind.String);
-            let numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
-            if (stringIndexType) result.stringIndexType = instantiateType(stringIndexType, mapper);
-            if (numberIndexType) result.numberIndexType = instantiateType(numberIndexType, mapper);
+            let result = <AnonymousType>createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol);
+            result.target = type;
+            result.mapper = mapper;
             mapper.instantiations[type.id] = result;
             return result;
         }
 
         function instantiateType(type: Type, mapper: TypeMapper): Type {
-            if (mapper !== identityMapper) {
+            if (type && mapper !== identityMapper) {
                 if (type.flags & TypeFlags.TypeParameter) {
                     return mapper(<TypeParameter>type);
                 }
                 if (type.flags & TypeFlags.Anonymous) {
                     return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) ?
-                        instantiateAnonymousType(<ObjectType>type, mapper) : type;
+                        instantiateAnonymousType(<AnonymousType>type, mapper) : type;
                 }
                 if (type.flags & TypeFlags.Reference) {
                     return createTypeReference((<TypeReference>type).target, instantiateList((<TypeReference>type).typeArguments, mapper, instantiateType));
@@ -5242,7 +5271,7 @@ namespace ts {
                     // Only want to compare the construct signatures for abstractness guarantees.
 
                     // Because the "abstractness" of a class is the same across all construct signatures
-                    // (internally we are checking the corresponding declaration), it is enough to perform 
+                    // (internally we are checking the corresponding declaration), it is enough to perform
                     // the check and report an error once over all pairs of source and target construct signatures.
                     //
                     // sourceSig and targetSig are (possibly) undefined.
@@ -6641,7 +6670,7 @@ namespace ts {
             let needToCaptureLexicalThis = false;
 
             if (!isCallExpression) {
-                // adjust the container reference in case if super is used inside arrow functions with arbitrary deep nesting                                    
+                // adjust the container reference in case if super is used inside arrow functions with arbitrary deep nesting
                 while (container && container.kind === SyntaxKind.ArrowFunction) {
                     container = getSuperContainer(container, /*includeFunctions*/ true);
                     needToCaptureLexicalThis = languageVersion < ScriptTarget.ES6;
@@ -6651,7 +6680,7 @@ namespace ts {
             let canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             let nodeCheckFlag: NodeCheckFlags = 0;
 
-            // always set NodeCheckFlags for 'super' expression node            
+            // always set NodeCheckFlags for 'super' expression node
             if (canUseSuperExpression) {
                 if ((container.flags & NodeFlags.Static) || isCallExpression) {
                     nodeCheckFlag = NodeCheckFlags.SuperStatic;
@@ -7312,15 +7341,15 @@ namespace ts {
         }
 
         function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper?: TypeMapper): Type {
+            let inDestructuringPattern = isAssignmentTarget(node);
             // Grammar checking
-            checkGrammarObjectLiteralExpression(node);
+            checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
 
             let propertiesTable: SymbolTable = {};
             let propertiesArray: Symbol[] = [];
             let contextualType = getContextualType(node);
             let contextualTypeHasPattern = contextualType && contextualType.pattern &&
                 (contextualType.pattern.kind === SyntaxKind.ObjectBindingPattern || contextualType.pattern.kind === SyntaxKind.ObjectLiteralExpression);
-            let inDestructuringPattern = isAssignmentTarget(node);
             let typeFlags: TypeFlags = 0;
 
             for (let memberDecl of node.properties) {
@@ -7344,7 +7373,10 @@ namespace ts {
                     if (inDestructuringPattern) {
                         // If object literal is an assignment pattern and if the assignment pattern specifies a default value
                         // for the property, make the property optional.
-                        if (memberDecl.kind === SyntaxKind.PropertyAssignment && hasDefaultValue((<PropertyAssignment>memberDecl).initializer)) {
+                        const isOptional =
+                            (memberDecl.kind === SyntaxKind.PropertyAssignment && hasDefaultValue((<PropertyAssignment>memberDecl).initializer)) ||
+                            (memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment && (<ShorthandPropertyAssignment>memberDecl).objectAssignmentInitializer);
+                        if (isOptional) {
                             prop.flags |= SymbolFlags.Optional;
                         }
                     }
@@ -7631,7 +7663,9 @@ namespace ts {
                 // Look up the value in the current scope
                 if (valueSymbol && valueSymbol !== unknownSymbol) {
                     links.jsxFlags |= JsxFlags.ClassElement;
-                    getSymbolLinks(valueSymbol).referenced = true;
+                    if (valueSymbol.flags & SymbolFlags.Alias) {
+                        markAliasSymbolAsReferenced(valueSymbol);
+                    }
                 }
 
                 return valueSymbol || unknownSymbol;
@@ -7975,6 +8009,11 @@ namespace ts {
                 return true;
             }
             // An instance property must be accessed through an instance of the enclosing class
+            if (type.flags & TypeFlags.ThisType) {
+                // get the original type -- represented as the type constraint of the 'this' type
+                type = getConstraintOfTypeParameter(<TypeParameter>type);
+            }
+
             // TODO: why is the first part of this check here?
             if (!(getTargetType(type).flags & (TypeFlags.Class | TypeFlags.Interface) && hasBaseType(<InterfaceType>type, enclosingClass))) {
                 error(node, Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass));
@@ -8122,6 +8161,7 @@ namespace ts {
 
         /**
          * If indexArgumentExpression is a string literal or number literal, returns its text.
+         * If indexArgumentExpression is a constant value, returns its string value.
          * If indexArgumentExpression is a well known symbol, returns the property name corresponding
          *    to this symbol, as long as it is a proper symbol reference.
          * Otherwise, returns undefined.
@@ -8130,6 +8170,12 @@ namespace ts {
             if (indexArgumentExpression.kind === SyntaxKind.StringLiteral || indexArgumentExpression.kind === SyntaxKind.NumericLiteral) {
                 return (<LiteralExpression>indexArgumentExpression).text;
             }
+            if (indexArgumentExpression.kind === SyntaxKind.ElementAccessExpression || indexArgumentExpression.kind === SyntaxKind.PropertyAccessExpression) {
+                let value = getConstantValue(<ElementAccessExpression | PropertyAccessExpression>indexArgumentExpression);
+                if (value !== undefined) {
+                    return value.toString();
+                }
+            }
             if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, /*reportError*/ false)) {
                 let rightHandSideName = (<Identifier>(<PropertyAccessExpression>indexArgumentExpression).name).text;
                 return getPropertyNameForKnownSymbolName(rightHandSideName);
@@ -8565,7 +8611,7 @@ namespace ts {
                         // A method or accessor declaration decorator will have two or three arguments (see
                         // `PropertyDecorator` and `MethodDecorator` in core.d.ts)
 
-                        // If we are emitting decorators for ES3, we will only pass two arguments. 
+                        // If we are emitting decorators for ES3, we will only pass two arguments.
                         if (languageVersion === ScriptTarget.ES3) {
                             return 2;
                         }
@@ -9741,7 +9787,7 @@ namespace ts {
                         return !symbol || symbol === unknownSymbol || (symbol.flags & ~SymbolFlags.EnumMember) !== 0;
                     }
                     case SyntaxKind.ElementAccessExpression:
-                        //  old compiler doesn't check indexed assess
+                        //  old compiler doesn't check indexed access
                         return true;
                     case SyntaxKind.ParenthesizedExpression:
                         return isReferenceOrErrorExpression((<ParenthesizedExpression>n).expression);
@@ -9899,32 +9945,32 @@ namespace ts {
             return (symbol.flags & SymbolFlags.ConstEnum) !== 0;
         }
 
-        function checkInstanceOfExpression(node: BinaryExpression, leftType: Type, rightType: Type): Type {
+        function checkInstanceOfExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
             // TypeScript 1.0 spec (April 2014): 4.15.4
             // The instanceof operator requires the left operand to be of type Any, an object type, or a type parameter type,
             // and the right operand to be of type Any or a subtype of the 'Function' interface type.
             // The result is always of the Boolean primitive type.
             // NOTE: do not raise error if leftType is unknown as related error was already reported
             if (allConstituentTypesHaveKind(leftType, TypeFlags.Primitive)) {
-                error(node.left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
+                error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
             // NOTE: do not raise error if right is unknown as related error was already reported
             if (!(isTypeAny(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
-                error(node.right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
+                error(right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
             }
             return booleanType;
         }
 
-        function checkInExpression(node: BinaryExpression, leftType: Type, rightType: Type): Type {
+        function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
             // TypeScript 1.0 spec (April 2014): 4.15.5
             // The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type,
             // and the right operand to be of type Any, an object type, or a type parameter type.
             // The result is always of the Boolean primitive type.
             if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbol)) {
-                error(node.left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
+                error(left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
             }
             if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, TypeFlags.ObjectType | TypeFlags.TypeParameter)) {
-                error(node.right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
+                error(right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
             return booleanType;
         }
@@ -9941,7 +9987,12 @@ namespace ts {
                         isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) ||
                         getIndexTypeOfType(sourceType, IndexKind.String);
                     if (type) {
-                        checkDestructuringAssignment((<PropertyAssignment>p).initializer || name, type);
+                        if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                            checkDestructuringAssignment(<ShorthandPropertyAssignment>p, type);
+                        }
+                        else {
+                            checkDestructuringAssignment((<PropertyAssignment>p).initializer || name, type);
+                        }
                     }
                     else {
                         error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(sourceType), declarationNameToString(name));
@@ -10001,7 +10052,19 @@ namespace ts {
             return sourceType;
         }
 
-        function checkDestructuringAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type {
+        function checkDestructuringAssignment(exprOrAssignment: Expression | ShorthandPropertyAssignment, sourceType: Type, contextualMapper?: TypeMapper): Type {
+            let target: Expression;
+            if (exprOrAssignment.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                const prop = <ShorthandPropertyAssignment>exprOrAssignment;
+                if (prop.objectAssignmentInitializer) {
+                    checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, contextualMapper);
+                }
+                target = (<ShorthandPropertyAssignment>exprOrAssignment).name;
+            }
+            else {
+                target = <Expression>exprOrAssignment;
+            }
+
             if (target.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>target).operatorToken.kind === SyntaxKind.EqualsToken) {
                 checkBinaryExpression(<BinaryExpression>target, contextualMapper);
                 target = (<BinaryExpression>target).left;
@@ -10024,15 +10087,21 @@ namespace ts {
         }
 
         function checkBinaryExpression(node: BinaryExpression, contextualMapper?: TypeMapper) {
-            let operator = node.operatorToken.kind;
-            if (operator === SyntaxKind.EqualsToken && (node.left.kind === SyntaxKind.ObjectLiteralExpression || node.left.kind === SyntaxKind.ArrayLiteralExpression)) {
-                return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper);
+            return checkBinaryLikeExpression(node.left, node.operatorToken, node.right, contextualMapper, node);
+        }
+
+        function checkBinaryLikeExpression(left: Expression, operatorToken: Node, right: Expression, contextualMapper?: TypeMapper, errorNode?: Node) {
+            let operator = operatorToken.kind;
+            if (operator === SyntaxKind.EqualsToken && (left.kind === SyntaxKind.ObjectLiteralExpression || left.kind === SyntaxKind.ArrayLiteralExpression)) {
+                return checkDestructuringAssignment(left, checkExpression(right, contextualMapper), contextualMapper);
             }
-            let leftType = checkExpression(node.left, contextualMapper);
-            let rightType = checkExpression(node.right, contextualMapper);
+            let leftType = checkExpression(left, contextualMapper);
+            let rightType = checkExpression(right, contextualMapper);
             switch (operator) {
                 case SyntaxKind.AsteriskToken:
+                case SyntaxKind.AsteriskAsteriskToken:
                 case SyntaxKind.AsteriskEqualsToken:
+                case SyntaxKind.AsteriskAsteriskEqualsToken:
                 case SyntaxKind.SlashToken:
                 case SyntaxKind.SlashEqualsToken:
                 case SyntaxKind.PercentToken:
@@ -10051,7 +10120,7 @@ namespace ts {
                 case SyntaxKind.CaretEqualsToken:
                 case SyntaxKind.AmpersandToken:
                 case SyntaxKind.AmpersandEqualsToken:
-                    // TypeScript 1.0 spec (April 2014): 4.15.1
+                    // TypeScript 1.0 spec (April 2014): 4.19.1
                     // These operators require their operands to be of type Any, the Number primitive type,
                     // or an enum type. Operands of an enum type are treated
                     // as having the primitive type Number. If one operand is the null or undefined value,
@@ -10065,13 +10134,13 @@ namespace ts {
                     // try and return them a helpful suggestion
                     if ((leftType.flags & TypeFlags.Boolean) &&
                         (rightType.flags & TypeFlags.Boolean) &&
-                        (suggestedOperator = getSuggestedBooleanOperator(node.operatorToken.kind)) !== undefined) {
-                        error(node, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(node.operatorToken.kind), tokenToString(suggestedOperator));
+                        (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) {
+                        error(errorNode || operatorToken, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(operatorToken.kind), tokenToString(suggestedOperator));
                     }
                     else {
                         // otherwise just check each operand separately and report errors as normal
-                        let leftOk = checkArithmeticOperandType(node.left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
-                        let rightOk = checkArithmeticOperandType(node.right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
+                        let leftOk = checkArithmeticOperandType(left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
+                        let rightOk = checkArithmeticOperandType(right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
                         if (leftOk && rightOk) {
                             checkAssignmentOperator(numberType);
                         }
@@ -10080,7 +10149,7 @@ namespace ts {
                     return numberType;
                 case SyntaxKind.PlusToken:
                 case SyntaxKind.PlusEqualsToken:
-                    // TypeScript 1.0 spec (April 2014): 4.15.2
+                    // TypeScript 1.0 spec (April 2014): 4.19.2
                     // The binary + operator requires both operands to be of the Number primitive type or an enum type,
                     // or at least one of the operands to be of type Any or the String primitive type.
 
@@ -10137,9 +10206,9 @@ namespace ts {
                     }
                     return booleanType;
                 case SyntaxKind.InstanceOfKeyword:
-                    return checkInstanceOfExpression(node, leftType, rightType);
+                    return checkInstanceOfExpression(left, right, leftType, rightType);
                 case SyntaxKind.InKeyword:
-                    return checkInExpression(node, leftType, rightType);
+                    return checkInExpression(left, right, leftType, rightType);
                 case SyntaxKind.AmpersandAmpersandToken:
                     return rightType;
                 case SyntaxKind.BarBarToken:
@@ -10154,8 +10223,8 @@ namespace ts {
             // Return true if there was no error, false if there was an error.
             function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean {
                 let offendingSymbolOperand =
-                    someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? node.left :
-                        someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right :
+                    someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? left :
+                        someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? right :
                             undefined;
                 if (offendingSymbolOperand) {
                     error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator));
@@ -10189,17 +10258,17 @@ namespace ts {
                     // requires VarExpr to be classified as a reference
                     // A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1)
                     // and the type of the non - compound operation to be assignable to the type of VarExpr.
-                    let ok = checkReferenceExpression(node.left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant);
+                    let ok = checkReferenceExpression(left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant);
                     // Use default messages
                     if (ok) {
                         // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported
-                        checkTypeAssignableTo(valueType, leftType, node.left, /*headMessage*/ undefined);
+                        checkTypeAssignableTo(valueType, leftType, left, /*headMessage*/ undefined);
                     }
                 }
             }
 
             function reportOperatorError() {
-                error(node, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, tokenToString(node.operatorToken.kind), typeToString(leftType), typeToString(rightType));
+                error(errorNode || operatorToken, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, tokenToString(operatorToken.kind), typeToString(leftType), typeToString(rightType));
             }
         }
 
@@ -11303,7 +11372,8 @@ namespace ts {
         }
 
         function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage) {
-            if (!(type.flags & TypeFlags.Any) && isTypeAssignableTo(type, getGlobalThenableType())) {
+            type = getWidenedType(type);
+            if (!isTypeAny(type) && isTypeAssignableTo(type, getGlobalThenableType())) {
                 if (location) {
                     if (!message) {
                         message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member;
@@ -11721,10 +11791,6 @@ namespace ts {
             checkSignatureDeclaration(node);
             let isAsync = isAsyncFunctionLike(node);
             if (isAsync) {
-                if (!compilerOptions.experimentalAsyncFunctions) {
-                    error(node, Diagnostics.Experimental_support_for_async_functions_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalAsyncFunctions_to_remove_this_warning);
-                }
-
                 emitAwaiter = true;
             }
 
@@ -12541,7 +12607,12 @@ namespace ts {
                         if (isAsyncFunctionLike(func)) {
                             let promisedType = getPromisedType(returnType);
                             let awaitedType = checkAwaitedType(exprType, node.expression, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member);
-                            checkTypeAssignableTo(awaitedType, promisedType, node.expression);
+                            if (promisedType) {
+                                // If the function has a return type, but promisedType is
+                                // undefined, an error will be reported in checkAsyncFunctionReturnType
+                                // so we don't need to report one here.
+                                checkTypeAssignableTo(awaitedType, promisedType, node.expression);
+                            }
                         }
                         else {
                             checkTypeAssignableTo(exprType, returnType, node.expression);
@@ -13151,13 +13222,13 @@ namespace ts {
                         autoValue = computeConstantValueForEnumMemberInitializer(initializer, enumType, enumIsConst, ambient);
                     }
                     else if (ambient && !enumIsConst) {
-                        // In ambient enum declarations that specify no const modifier, enum member declarations 
+                        // In ambient enum declarations that specify no const modifier, enum member declarations
                         // that omit a value are considered computed members (as opposed to having auto-incremented values assigned).
                         autoValue = undefined;
                     }
                     else if (previousEnumMemberIsNonConstant) {
-                        // If the member declaration specifies no value, the member is considered a constant enum member. 
-                        // If the member is the first member in the enum declaration, it is assigned the value zero. 
+                        // If the member declaration specifies no value, the member is considered a constant enum member.
+                        // If the member is the first member in the enum declaration, it is assigned the value zero.
                         // Otherwise, it is assigned the value of the immediately preceding member plus one,
                         // and an error occurs if the immediately preceding member is not a constant enum member
                         error(member.name, Diagnostics.Enum_member_must_have_initializer);
@@ -13308,7 +13379,7 @@ namespace ts {
                             }
 
                             // illegal case: forward reference
-                            if (!isDefinedBefore(propertyDecl, member)) {
+                            if (!isBlockScopedNameDeclaredBeforeUse(propertyDecl, member)) {
                                 reportError = false;
                                 error(e, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
                                 return undefined;
@@ -13857,6 +13928,7 @@ namespace ts {
                     break;
                 case SyntaxKind.ClassExpression:
                     forEach((<ClassExpression>node).members, checkSourceElement);
+                    forEachChild(node, checkFunctionAndClassExpressionBodies);
                     break;
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.MethodSignature:
@@ -14097,7 +14169,7 @@ namespace ts {
                         case SyntaxKind.ClassDeclaration:
                         case SyntaxKind.InterfaceDeclaration:
                             // If we didn't come from static member of class or interface,
-                            // add the type parameters into the symbol table 
+                            // add the type parameters into the symbol table
                             // (type parameters of classDeclaration/classExpression and interface are in member property of the symbol.
                             // Note: that the memberFlags come from previous iteration.
                             if (!(memberFlags & NodeFlags.Static)) {
@@ -14504,7 +14576,7 @@ namespace ts {
             moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
 
             const symbolLinks = getSymbolLinks(moduleSymbol);
-            if (symbolLinks.exportsSomeValue == undefined) {
+            if (symbolLinks.exportsSomeValue === undefined) {
                 // for export assignments - check if resolved symbol for RHS is itself a value
                 // otherwise - check if at least one export is value
                 symbolLinks.exportsSomeValue = hasExportAssignment
@@ -14788,31 +14860,6 @@ namespace ts {
             return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
         }
 
-        function getBlockScopedVariableId(n: Identifier): number {
-            Debug.assert(!nodeIsSynthesized(n));
-
-            let isVariableDeclarationOrBindingElement =
-                n.parent.kind === SyntaxKind.BindingElement || (n.parent.kind === SyntaxKind.VariableDeclaration && (<VariableDeclaration>n.parent).name === n);
-
-            let symbol =
-                (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) ||
-                getNodeLinks(n).resolvedSymbol ||
-                resolveName(n, n.text, SymbolFlags.Value | SymbolFlags.Alias, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined);
-
-            let isLetOrConst =
-                symbol &&
-                (symbol.flags & SymbolFlags.BlockScopedVariable) &&
-                symbol.valueDeclaration.parent.kind !== SyntaxKind.CatchClause;
-
-            if (isLetOrConst) {
-                // side-effect of calling this method:
-                //   assign id to symbol if it was not yet set
-                getSymbolLinks(symbol);
-                return symbol.id;
-            }
-            return undefined;
-        }
-
         function instantiateSingleCallFunctionType(functionType: Type, typeArguments: Type[]): Type {
             if (functionType === unknownType) {
                 return unknownType;
@@ -14847,7 +14894,6 @@ namespace ts {
                 isEntityNameVisible,
                 getConstantValue,
                 collectLinkedAliases,
-                getBlockScopedVariableId,
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
                 isOptionalParameter,
@@ -15459,7 +15505,7 @@ namespace ts {
             }
         }
 
-        function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression) {
+        function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression, inDestructuring: boolean) {
             let seen: Map<SymbolFlags> = {};
             let Property = 1;
             let GetAccessor = 2;
@@ -15475,6 +15521,12 @@ namespace ts {
                     continue;
                 }
 
+                if (prop.kind === SyntaxKind.ShorthandPropertyAssignment && !inDestructuring && (<ShorthandPropertyAssignment>prop).objectAssignmentInitializer) {
+                    // having objectAssignmentInitializer is only valid in ObjectAssignmentPattern
+                    // outside of destructuring it is a syntax error
+                    return grammarErrorOnNode((<ShorthandPropertyAssignment>prop).equalsToken, Diagnostics.can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment);
+                }
+
                 // ECMA-262 11.1.5 Object Initialiser
                 // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
                 // a.This production is contained in strict code and IsDataDescriptor(previous) is true and
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 11062983aaa..acf0474b7bf 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -77,6 +77,7 @@ namespace ts {
                 "system": ModuleKind.System,
                 "umd": ModuleKind.UMD,
                 "es6": ModuleKind.ES6,
+                "es2015": ModuleKind.ES2015,
             },
             description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es6,
             paramType: Diagnostics.KIND,
@@ -205,7 +206,12 @@ namespace ts {
         {
             name: "target",
             shortName: "t",
-            type: { "es3": ScriptTarget.ES3, "es5": ScriptTarget.ES5, "es6": ScriptTarget.ES6 },
+            type: {
+                "es3": ScriptTarget.ES3,
+                "es5": ScriptTarget.ES5,
+                "es6": ScriptTarget.ES6,
+                "es2015": ScriptTarget.ES2015,
+            },
             description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental,
             paramType: Diagnostics.VERSION,
             error: Diagnostics.Argument_for_target_option_must_be_ES3_ES5_or_ES6
@@ -222,11 +228,6 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Watch_input_files,
         },
-        {
-            name: "experimentalAsyncFunctions",
-            type: "boolean",
-            description: Diagnostics.Enables_experimental_support_for_ES7_async_functions
-        },
         {
             name: "experimentalDecorators",
             type: "boolean",
@@ -389,7 +390,7 @@ namespace ts {
         catch (e) {
             return { error: createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message) };
         }
-        return parseConfigFileText(fileName, text);
+        return parseConfigFileTextToJson(fileName, text);
     }
 
     /**
@@ -397,7 +398,7 @@ namespace ts {
       * @param fileName The path to the config file
       * @param jsonText The text of the config file
       */
-    export function parseConfigFileText(fileName: string, jsonText: string): { config?: any; error?: Diagnostic } {
+    export function parseConfigFileTextToJson(fileName: string, jsonText: string): { config?: any; error?: Diagnostic } {
         try {
             return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} };
         }
@@ -412,7 +413,7 @@ namespace ts {
       * @param basePath A root directory to resolve relative path entries in the config
       *    file to. e.g. outDir
       */
-    export function parseConfigFile(json: any, host: ParseConfigHost, basePath: string): ParsedCommandLine {
+    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string): ParsedCommandLine {
         let errors: Diagnostic[] = [];
 
         return {
@@ -448,6 +449,9 @@ namespace ts {
                             }
                             if (opt.isFilePath) {
                                 value = normalizePath(combinePaths(basePath, value));
+                                if (value === "") {
+                                    value = ".";
+                                }
                             }
                             options[opt.name] = value;
                         }
@@ -497,4 +501,4 @@ namespace ts {
             return fileNames;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index ce59c3b3bc6..9a4f5452eed 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -437,8 +437,12 @@ namespace ts {
     }
 
     export function concatenateDiagnosticMessageChains(headChain: DiagnosticMessageChain, tailChain: DiagnosticMessageChain): DiagnosticMessageChain {
-        Debug.assert(!headChain.next);
-        headChain.next = tailChain;
+        let lastChain = headChain;
+        while (lastChain.next) {
+            lastChain = lastChain.next;
+        }
+
+        lastChain.next = tailChain;
         return headChain;
     }
 
@@ -700,6 +704,9 @@ namespace ts {
     }
 
     export function getBaseFileName(path: string) {
+        if (!path) {
+            return undefined;
+        }
         let i = path.lastIndexOf(directorySeparator);
         return i < 0 ? path : path.substring(i + 1);
     }
@@ -722,6 +729,23 @@ namespace ts {
      *  List of supported extensions in order of file resolution precedence.
      */
     export const supportedExtensions = [".ts", ".tsx", ".d.ts"];
+    /**
+     *  List of extensions that will be used to look for external modules.
+     *  This list is kept separate from supportedExtensions to for cases when we'll allow to include .js files in compilation,
+     *  but still would like to load only TypeScript files as modules 
+     */
+    export const moduleFileExtensions = supportedExtensions;
+
+    export function isSupportedSourceFileName(fileName: string) {
+        if (!fileName) { return false; }
+
+        for (let extension of supportedExtensions) {
+            if (fileExtensionIs(fileName, extension)) {
+                return true;
+            }
+        }
+        return false;
+    }
 
     const extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     export function removeFileExtension(path: string): string {
@@ -817,4 +841,14 @@ namespace ts {
             Debug.assert(false, message);
         }
     }
-}
+
+    export function copyListRemovingItem<T>(item: T, list: T[]) {
+        let copiedList: T[] = [];
+        for (var i = 0, len = list.length; i < len; i++) {
+            if (list[i] !== item) {
+                copiedList.push(list[i]);
+            }
+        }
+        return copiedList;
+    }
+}
\ No newline at end of file
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index f6656edb250..a8ed6ac6127 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -783,10 +783,6 @@
         "category": "Error",
         "code": 1245
     },
-    "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning.": {
-        "category": "Error",
-        "code": 1246
-    },
 
     "'with' statements are not allowed in an async function block.": {
         "category": "Error",
@@ -800,6 +796,10 @@
         "category": "Error",
         "code": 1311
     },
+    "'=' can only be used in an object literal property inside a destructuring assignment.": {
+        "category": "Error",
+        "code": 1312
+    },    
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -1656,6 +1656,10 @@
         "category": "Error",
         "code": 2527
     },
+    "A module cannot have multiple default exports.": {
+        "category": "Error",
+        "code": 2528
+    },
     "JSX element attributes type '{0}' must be an object type.": {
         "category": "Error",
         "code": 2600
@@ -2274,10 +2278,6 @@
         "category": "Message",
         "code": 6066
     },
-    "Option 'experimentalAsyncFunctions' cannot be specified when targeting ES5 or lower.": {
-        "category": "Message",
-        "code": 6067
-    },
     "Enables experimental support for ES7 async functions.": {
         "category": "Message",
         "code": 6068
@@ -2469,5 +2469,13 @@
     "A constructor cannot contain a 'super' call when its class extends 'null'": {
       "category": "Error",
       "code": 17005
+    },
+    "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.": {
+      "category": "Error",
+      "code": 17006
+    },
+    "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.": {
+      "category": "Error",
+      "code": 17007
     }
 }
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index bf670bd2c42..1d0be8e7959 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -446,7 +446,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             /** If removeComments is true, no leading-comments needed to be emitted **/
             let emitLeadingCommentsOfPosition = compilerOptions.removeComments ? function (pos: number) { } : emitLeadingCommentsOfPositionWorker;
 
-            let moduleEmitDelegates: Map<(node: SourceFile, startIndex: number) => void> = {
+            let moduleEmitDelegates: Map<(node: SourceFile) => void> = {
                 [ModuleKind.ES6]: emitES6Module,
                 [ModuleKind.AMD]: emitAMDModule,
                 [ModuleKind.System]: emitSystemModule,
@@ -2311,6 +2311,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write(": ");
                     emit(node.name);
                 }
+
+                if (languageVersion >= ScriptTarget.ES6 && node.objectAssignmentInitializer) {
+                    write(" = ");
+                    emit(node.objectAssignmentInitializer);
+                }
             }
 
             function tryEmitConstantValue(node: PropertyAccessExpression | ElementAccessExpression): boolean {
@@ -2778,6 +2783,68 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
             }
 
+            /**
+             * Emit ES7 exponentiation operator downlevel using Math.pow
+             * @param node a binary expression node containing exponentiationOperator (**, **=) 
+             */
+            function emitExponentiationOperator(node: BinaryExpression) {
+                let leftHandSideExpression = node.left;
+                if (node.operatorToken.kind === SyntaxKind.AsteriskAsteriskEqualsToken) {
+                    let synthesizedLHS: ElementAccessExpression | PropertyAccessExpression;
+                    let shouldEmitParentheses = false;
+                    if (isElementAccessExpression(leftHandSideExpression)) {
+                        shouldEmitParentheses = true;
+                        write("(");
+
+                        synthesizedLHS = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression, /*startsOnNewLine*/ false);
+
+                        let identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
+                        synthesizedLHS.expression = identifier;
+
+                        if (leftHandSideExpression.argumentExpression.kind !== SyntaxKind.NumericLiteral &&
+                            leftHandSideExpression.argumentExpression.kind !== SyntaxKind.StringLiteral) {
+                            let tempArgumentExpression = createAndRecordTempVariable(TempFlags._i);
+                            (<ElementAccessExpression>synthesizedLHS).argumentExpression = tempArgumentExpression;
+                            emitAssignment(tempArgumentExpression, leftHandSideExpression.argumentExpression, /*shouldEmitCommaBeforeAssignment*/ true);
+                        }
+                        else {
+                            (<ElementAccessExpression>synthesizedLHS).argumentExpression = leftHandSideExpression.argumentExpression;
+                        }
+                        write(", ");
+                    }
+                    else if (isPropertyAccessExpression(leftHandSideExpression)) {
+                        shouldEmitParentheses = true;
+                        write("(");
+                        synthesizedLHS = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression, /*startsOnNewLine*/ false);
+
+                        let identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldemitCommaBeforeAssignment*/ false);
+                        synthesizedLHS.expression = identifier;
+
+                        (<PropertyAccessExpression>synthesizedLHS).dotToken = leftHandSideExpression.dotToken;
+                        (<PropertyAccessExpression>synthesizedLHS).name = leftHandSideExpression.name;
+                        write(", ");
+                    }
+
+                    emit(synthesizedLHS || leftHandSideExpression);
+                    write(" = ");
+                    write("Math.pow(");
+                    emit(synthesizedLHS || leftHandSideExpression);
+                    write(", ");
+                    emit(node.right);
+                    write(")");
+                    if (shouldEmitParentheses) {
+                        write(")");
+                    }
+                }
+                else {
+                    write("Math.pow(");
+                    emit(leftHandSideExpression);
+                    write(", ");
+                    emit(node.right);
+                    write(")");
+                }
+            }
+
             function emitBinaryExpression(node: BinaryExpression) {
                 if (languageVersion < ScriptTarget.ES6 && node.operatorToken.kind === SyntaxKind.EqualsToken &&
                     (node.left.kind === SyntaxKind.ObjectLiteralExpression || node.left.kind === SyntaxKind.ArrayLiteralExpression)) {
@@ -2795,12 +2862,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         emitNodeWithoutSourceMap(node.left);
                         write(`", `);
                     }
-                    emit(node.left);
-                    let indentedBeforeOperator = indentIfOnDifferentLines(node, node.left, node.operatorToken, node.operatorToken.kind !== SyntaxKind.CommaToken ? " " : undefined);
-                    write(tokenToString(node.operatorToken.kind));
-                    let indentedAfterOperator = indentIfOnDifferentLines(node, node.operatorToken, node.right, " ");
-                    emit(node.right);
-                    decreaseIndentIf(indentedBeforeOperator, indentedAfterOperator);
+
+                    if (node.operatorToken.kind === SyntaxKind.AsteriskAsteriskToken || node.operatorToken.kind === SyntaxKind.AsteriskAsteriskEqualsToken) {
+                        // Downleveled emit exponentiation operator using Math.pow
+                        emitExponentiationOperator(node);
+                    }
+                    else {
+                        emit(node.left);
+                        // Add indentation before emit the operator if the operator is on different line
+                        // For example:
+                        //      3
+                        //      + 2;
+                        //   emitted as
+                        //      3
+                        //          + 2;
+                        let indentedBeforeOperator = indentIfOnDifferentLines(node, node.left, node.operatorToken, node.operatorToken.kind !== SyntaxKind.CommaToken ? " " : undefined);
+                        write(tokenToString(node.operatorToken.kind));
+                        let indentedAfterOperator = indentIfOnDifferentLines(node, node.operatorToken, node.right, " ");
+                        emit(node.right);
+                        decreaseIndentIf(indentedBeforeOperator, indentedAfterOperator);
+                    }
+
                     if (exportChanged) {
                         write(")");
                     }
@@ -3437,6 +3519,58 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(";");
             }
 
+            /**
+             * Emit an assignment to a given identifier, 'name', with a given expression, 'value'.
+             * @param name an identifier as a left-hand-side operand of the assignment
+             * @param value an expression as a right-hand-side operand of the assignment
+             * @param shouldEmitCommaBeforeAssignment a boolean indicating whether to prefix an assignment with comma
+             */
+            function emitAssignment(name: Identifier, value: Expression, shouldEmitCommaBeforeAssignment: boolean) {
+                if (shouldEmitCommaBeforeAssignment) {
+                    write(", ");
+                }
+
+                let exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name);
+
+                if (exportChanged) {
+                    write(`${exportFunctionForFile}("`);
+                    emitNodeWithCommentsAndWithoutSourcemap(name);
+                    write(`", `);
+                }
+
+                const isVariableDeclarationOrBindingElement =
+                    name.parent && (name.parent.kind === SyntaxKind.VariableDeclaration || name.parent.kind === SyntaxKind.BindingElement);
+
+                if (isVariableDeclarationOrBindingElement) {
+                    emitModuleMemberName(<Declaration>name.parent);
+                }
+                else {
+                    emit(name);
+                }
+
+                write(" = ");
+                emit(value);
+
+                if (exportChanged) {
+                    write(")");
+                }
+            }
+
+            /**
+             * Create temporary variable, emit an assignment of the variable the given expression
+             * @param expression an expression to assign to the newly created temporary variable
+             * @param canDefineTempVariablesInPlace a boolean indicating whether you can define the temporary variable at an assignment location
+             * @param shouldEmitCommaBeforeAssignment a boolean indicating whether an assignment should prefix with comma
+             */
+            function emitTempVariableAssignment(expression: Expression, canDefineTempVariablesInPlace: boolean, shouldEmitCommaBeforeAssignment: boolean): Identifier {
+                let identifier = createTempVariable(TempFlags.Auto);
+                if (!canDefineTempVariablesInPlace) {
+                    recordTempDeclaration(identifier);
+                }
+                emitAssignment(identifier, expression, shouldEmitCommaBeforeAssignment);
+                return identifier;
+            }
+
             function emitDestructuring(root: BinaryExpression | VariableDeclaration | ParameterDeclaration, isAssignmentExpressionStatement: boolean, value?: Expression) {
                 let emitCount = 0;
 
@@ -3462,36 +3596,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emitBindingElement(<BindingElement>root, value);
                 }
 
-                function emitAssignment(name: Identifier, value: Expression) {
-                    if (emitCount++) {
-                        write(", ");
-                    }
-
-                    const isVariableDeclarationOrBindingElement =
-                        name.parent && (name.parent.kind === SyntaxKind.VariableDeclaration || name.parent.kind === SyntaxKind.BindingElement);
-
-                    let exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name);
-
-                    if (exportChanged) {
-                        write(`${exportFunctionForFile}("`);
-                        emitNodeWithCommentsAndWithoutSourcemap(name);
-                        write(`", `);
-                    }
-
-                    if (isVariableDeclarationOrBindingElement) {
-                        emitModuleMemberName(<Declaration>name.parent);
-                    }
-                    else {
-                        emit(name);
-                    }
-
-                    write(" = ");
-                    emit(value);
-
-                    if (exportChanged) {
-                        write(")");
-                    }
-                }
 
                 /**
                  * Ensures that there exists a declared identifier whose value holds the given expression.
@@ -3507,11 +3611,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         return expr;
                     }
 
-                    let identifier = createTempVariable(TempFlags.Auto);
-                    if (!canDefineTempVariablesInPlace) {
-                        recordTempDeclaration(identifier);
-                    }
-                    emitAssignment(identifier, expr);
+                    let identifier = emitTempVariableAssignment(expr, canDefineTempVariablesInPlace, emitCount > 0);
+                    emitCount++;
                     return identifier;
                 }
 
@@ -3574,7 +3675,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     for (let p of properties) {
                         if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) {
                             let propName = <Identifier | LiteralExpression>(<PropertyAssignment>p).name;
-                            emitDestructuringAssignment((<PropertyAssignment>p).initializer || propName, createPropertyAccessForDestructuringProperty(value, propName));
+                            let target = p.kind === SyntaxKind.ShorthandPropertyAssignment ? <ShorthandPropertyAssignment>p : (<PropertyAssignment>p).initializer || propName;
+                            emitDestructuringAssignment(target, createPropertyAccessForDestructuringProperty(value, propName));
                         }
                     }
                 }
@@ -3599,8 +3701,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                 }
 
-                function emitDestructuringAssignment(target: Expression, value: Expression) {
-                    if (target.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>target).operatorToken.kind === SyntaxKind.EqualsToken) {
+                function emitDestructuringAssignment(target: Expression | ShorthandPropertyAssignment, value: Expression) {
+                    if (target.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                        if ((<ShorthandPropertyAssignment>target).objectAssignmentInitializer) {
+                            value = createDefaultValueCheck(value, (<ShorthandPropertyAssignment>target).objectAssignmentInitializer);
+                        }
+                        target = (<ShorthandPropertyAssignment>target).name;
+                    }
+                    else if (target.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>target).operatorToken.kind === SyntaxKind.EqualsToken) {
                         value = createDefaultValueCheck(value, (<BinaryExpression>target).right);
                         target = (<BinaryExpression>target).left;
                     }
@@ -3611,7 +3719,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         emitArrayLiteralAssignment(<ArrayLiteralExpression>target, value);
                     }
                     else {
-                        emitAssignment(<Identifier>target, value);
+                        emitAssignment(<Identifier>target, value, /*shouldEmitCommaBeforeAssignment*/ emitCount > 0);
+                        emitCount++;
                     }
                 }
 
@@ -3680,7 +3789,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         }
                     }
                     else {
-                        emitAssignment(<Identifier>target.name, value);
+                        emitAssignment(<Identifier>target.name, value, /*shouldEmitCommaBeforeAssignment*/ emitCount > 0);
+                        emitCount++;
                     }
                 }
             }
@@ -3785,7 +3895,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         write(";");
                     }
                 }
-                if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile) {
+                if (modulekind !== ModuleKind.ES6 && node.parent === currentSourceFile) {
                     forEach(node.declarationList.declarations, emitExportVariableAssignments);
                 }
             }
@@ -4011,7 +4121,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 emitSignatureAndBody(node);
-                if (languageVersion < ScriptTarget.ES6 && node.kind === SyntaxKind.FunctionDeclaration && node.parent === currentSourceFile && node.name) {
+                if (modulekind !== ModuleKind.ES6 && node.kind === SyntaxKind.FunctionDeclaration && node.parent === currentSourceFile && node.name) {
                     emitExportMemberAssignments((<FunctionDeclaration>node).name);
                 }
 
@@ -4687,6 +4797,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 else {
                     emitClassLikeDeclarationForES6AndHigher(node);
                 }
+                if (modulekind !== ModuleKind.ES6 && node.parent === currentSourceFile && node.name) {
+                    emitExportMemberAssignments(node.name);
+                }
             }
 
             function emitClassLikeDeclarationForES6AndHigher(node: ClassLikeDeclaration) {
@@ -4785,8 +4898,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 // emit name if
                 // - node has a name
-                // - this is default export and target is not ES6 (for ES6 `export default` does not need to be compiled downlevel)                
-                if ((node.name || (node.flags & NodeFlags.Default && languageVersion < ScriptTarget.ES6)) && !thisNodeIsDecorated) {
+                // - this is default export with static initializers
+                if ((node.name || (node.flags & NodeFlags.Default && staticProperties.length > 0)) && !thisNodeIsDecorated) {
                     write(" ");
                     emitDeclarationName(node);
                 }
@@ -4934,10 +5047,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (node.kind === SyntaxKind.ClassDeclaration) {
                     emitExportMemberAssignment(<ClassDeclaration>node);
                 }
-
-                if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile && node.name) {
-                    emitExportMemberAssignments(node.name);
-                }
             }
 
             function emitClassMemberPrefix(node: ClassLikeDeclaration, member: Node) {
@@ -5509,7 +5618,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emitEnd(node);
                     write(";");
                 }
-                if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile) {
+                if (modulekind !== ModuleKind.ES6 && node.parent === currentSourceFile) {
                     if (modulekind === ModuleKind.System && (node.flags & NodeFlags.Export)) {
                         // write the call to exporter for enum
                         writeLine();
@@ -5645,8 +5754,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             /*
-             * Some bundlers (SystemJS builder) sometimes want to rename dependencies. 
-             * Here we check if alternative name was provided for a given moduleName and return it if possible. 
+             * Some bundlers (SystemJS builder) sometimes want to rename dependencies.
+             * Here we check if alternative name was provided for a given moduleName and return it if possible.
              */
             function tryRenameExternalModule(moduleName: LiteralExpression): string {
                 if (currentSourceFile.renamedDependencies && hasProperty(currentSourceFile.renamedDependencies, moduleName.text)) {
@@ -6600,7 +6709,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write("}"); // execute
             }
 
-            function emitSystemModule(node: SourceFile, startIndex: number): void {
+            function emitSystemModule(node: SourceFile): void {
                 collectExternalModuleInfo(node);
                 // System modules has the following shape
                 // System.register(['dep-1', ... 'dep-n'], function(exports) {/* module body function */})
@@ -6645,6 +6754,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(`], function(${exportFunctionForFile}) {`);
                 writeLine();
                 increaseIndent();
+                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
                 emitEmitHelpers(node);
                 emitCaptureThisForNodeIfNecessary(node);
                 emitSystemModuleBody(node, dependencyGroups, startIndex);
@@ -6738,7 +6848,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(") {");
             }
 
-            function emitAMDModule(node: SourceFile, startIndex: number) {
+            function emitAMDModule(node: SourceFile) {
                 emitEmitHelpers(node);
                 collectExternalModuleInfo(node);
 
@@ -6749,6 +6859,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
                 emitAMDDependencies(node, /*includeNonAmdDependencies*/ true);
                 increaseIndent();
+                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
                 emitExportStarHelper();
                 emitCaptureThisForNodeIfNecessary(node);
                 emitLinesStartingAt(node.statements, startIndex);
@@ -6759,7 +6870,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write("});");
             }
 
-            function emitCommonJSModule(node: SourceFile, startIndex: number) {
+            function emitCommonJSModule(node: SourceFile) {
+                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
                 emitEmitHelpers(node);
                 collectExternalModuleInfo(node);
                 emitExportStarHelper();
@@ -6769,7 +6881,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitExportEquals(/*emitAsReturn*/ false);
             }
 
-            function emitUMDModule(node: SourceFile, startIndex: number) {
+            function emitUMDModule(node: SourceFile) {
                 emitEmitHelpers(node);
                 collectExternalModuleInfo(node);
 
@@ -6788,6 +6900,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 })(`);
                 emitAMDFactoryHeader(dependencyNames);
                 increaseIndent();
+                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
                 emitExportStarHelper();
                 emitCaptureThisForNodeIfNecessary(node);
                 emitLinesStartingAt(node.statements, startIndex);
@@ -6798,11 +6911,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write("});");
             }
 
-            function emitES6Module(node: SourceFile, startIndex: number) {
+            function emitES6Module(node: SourceFile) {
                 externalImports = undefined;
                 exportSpecifiers = undefined;
                 exportEquals = undefined;
                 hasExportStarsToExportValues = false;
+                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
                 emitEmitHelpers(node);
                 emitCaptureThisForNodeIfNecessary(node);
                 emitLinesStartingAt(node.statements, startIndex);
@@ -6849,7 +6963,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     if (isLineBreak(c)) {
                         if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) {
                             let part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1);
-                            result = (result ? result + "\" + ' ' + \"" : "") + part;
+                            result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part);
                         }
                         firstNonWhitespace = -1;
                     }
@@ -6863,7 +6977,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 if (firstNonWhitespace !== -1) {
                     let part = text.substr(firstNonWhitespace);
-                    result = (result ? result + "\" + ' ' + \"" : "") + part;
+                    result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part);
                 }
 
                 if (result) {
@@ -6991,14 +7105,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitShebang();
                 emitDetachedComments(node);
 
-                // emit prologue directives prior to __extends
-                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
-
                 if (isExternalModule(node) || compilerOptions.isolatedModules) {
                     let emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[ModuleKind.CommonJS];
-                    emitModule(node, startIndex);
+                    emitModule(node);
                 }
                 else {
+                    // emit prologue directives prior to __extends
+                    let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
                     externalImports = undefined;
                     exportSpecifiers = undefined;
                     exportEquals = undefined;
@@ -7076,7 +7189,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         return shouldEmitEnumDeclaration(<EnumDeclaration>node);
                 }
 
-                // If the node is emitted in specialized fashion, dont emit comments as this node will handle 
+                // If the node is emitted in specialized fashion, dont emit comments as this node will handle
                 // emitting comments when emitting itself
                 Debug.assert(!isSpecializedCommentHandling(node));
 
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 08f21e80e14..1551706a337 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -57,11 +57,17 @@ namespace ts {
                 return visitNode(cbNode, (<TypeParameterDeclaration>node).name) ||
                     visitNode(cbNode, (<TypeParameterDeclaration>node).constraint) ||
                     visitNode(cbNode, (<TypeParameterDeclaration>node).expression);
+            case SyntaxKind.ShorthandPropertyAssignment:
+                return visitNodes(cbNodes, node.decorators) ||
+                    visitNodes(cbNodes, node.modifiers) ||
+                    visitNode(cbNode, (<ShorthandPropertyAssignment>node).name) ||
+                    visitNode(cbNode, (<ShorthandPropertyAssignment>node).questionToken) ||
+                    visitNode(cbNode, (<ShorthandPropertyAssignment>node).equalsToken) ||
+                    visitNode(cbNode, (<ShorthandPropertyAssignment>node).objectAssignmentInitializer);
             case SyntaxKind.Parameter:
             case SyntaxKind.PropertyDeclaration:
             case SyntaxKind.PropertySignature:
             case SyntaxKind.PropertyAssignment:
-            case SyntaxKind.ShorthandPropertyAssignment:
             case SyntaxKind.VariableDeclaration:
             case SyntaxKind.BindingElement:
                 return visitNodes(cbNodes, node.decorators) ||
@@ -856,7 +862,7 @@ namespace ts {
             let saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
 
             // Note: it is not actually necessary to save/restore the context flags here.  That's
-            // because the saving/restorating of these flags happens naturally through the recursive
+            // because the saving/restoring of these flags happens naturally through the recursive
             // descent nature of our parser.  However, we still store this here just so we can
             // assert that that invariant holds.
             let saveContextFlags = contextFlags;
@@ -1124,7 +1130,15 @@ namespace ts {
             if (token === SyntaxKind.DefaultKeyword) {
                 return nextTokenIsClassOrFunction();
             }
+            if (token === SyntaxKind.StaticKeyword) {
+                nextToken();
+                return canFollowModifier();
+            }
+
             nextToken();
+            if (scanner.hasPrecedingLineBreak()) {
+                return false;
+            }
             return canFollowModifier();
         }
 
@@ -3017,7 +3031,31 @@ namespace ts {
                 let newPrecedence = getBinaryOperatorPrecedence();
 
                 // Check the precedence to see if we should "take" this operator
-                if (newPrecedence <= precedence) {
+                // - For left associative operator (all operator but **), consume the operator,
+                //   recursively call the function below, and parse binaryExpression as a rightOperand
+                //   of the caller if the new precendence of the operator is greater then or equal to the current precendence.
+                //   For example:
+                //      a - b - c;
+                //            ^token; leftOperand = b. Return b to the caller as a rightOperand
+                //      a * b - c
+                //            ^token; leftOperand = b. Return b to the caller as a rightOperand
+                //      a - b * c;
+                //            ^token; leftOperand = b. Return b * c to the caller as a rightOperand
+                // - For right associative operator (**), consume the operator, recursively call the function
+                //   and parse binaryExpression as a rightOperand of the caller if the new precendence of
+                //   the operator is strictly grater than the current precendence
+                //   For example:
+                //      a ** b ** c;
+                //             ^^token; leftOperand = b. Return b ** c to the caller as a rightOperand
+                //      a - b ** c;
+                //            ^^token; leftOperand = b. Return b ** c to the caller as a rightOperand
+                //      a ** b - c
+                //             ^token; leftOperand = b. Return b to the caller as a rightOperand
+                const consumeCurrentOperator = token === SyntaxKind.AsteriskAsteriskToken ?
+                    newPrecedence >= precedence :
+                    newPrecedence > precedence;
+
+                if (!consumeCurrentOperator) {
                     break;
                 }
 
@@ -3091,6 +3129,8 @@ namespace ts {
                 case SyntaxKind.SlashToken:
                 case SyntaxKind.PercentToken:
                     return 10;
+                case SyntaxKind.AsteriskAsteriskToken:
+                    return 11;
             }
 
             // -1 is lower than all other precedences.  Returning it will cause binary expression
@@ -3117,28 +3157,29 @@ namespace ts {
             let node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
             node.operator = token;
             nextToken();
-            node.operand = parseUnaryExpressionOrHigher();
+            node.operand = parseSimpleUnaryExpression();
+
             return finishNode(node);
         }
 
         function parseDeleteExpression() {
             let node = <DeleteExpression>createNode(SyntaxKind.DeleteExpression);
             nextToken();
-            node.expression = parseUnaryExpressionOrHigher();
+            node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
         }
 
         function parseTypeOfExpression() {
             let node = <TypeOfExpression>createNode(SyntaxKind.TypeOfExpression);
             nextToken();
-            node.expression = parseUnaryExpressionOrHigher();
+            node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
         }
 
         function parseVoidExpression() {
             let node = <VoidExpression>createNode(SyntaxKind.VoidExpression);
             nextToken();
-            node.expression = parseUnaryExpressionOrHigher();
+            node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
         }
 
@@ -3158,22 +3199,63 @@ namespace ts {
         function parseAwaitExpression() {
             const node = <AwaitExpression>createNode(SyntaxKind.AwaitExpression);
             nextToken();
-            node.expression = parseUnaryExpressionOrHigher();
+            node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
         }
 
-        function parseUnaryExpressionOrHigher(): UnaryExpression {
+        /**
+         * Parse ES7 unary expression and await expression
+         * 
+         * ES7 UnaryExpression:
+         *      1) SimpleUnaryExpression[?yield]
+         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
+         */
+        function parseUnaryExpressionOrHigher(): UnaryExpression | BinaryExpression {
             if (isAwaitExpression()) {
                 return parseAwaitExpression();
             }
 
+            if (isIncrementExpression()) {
+                let incrementExpression = parseIncrementExpression();
+                return token === SyntaxKind.AsteriskAsteriskToken ?
+                    <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
+                    incrementExpression;
+            }
+
+            let unaryOperator = token;
+            let simpleUnaryExpression = parseSimpleUnaryExpression();
+            if (token === SyntaxKind.AsteriskAsteriskToken) {
+                let diagnostic: Diagnostic;
+                let start = skipTrivia(sourceText, simpleUnaryExpression.pos);
+                if (simpleUnaryExpression.kind === SyntaxKind.TypeAssertionExpression) {
+                    parseErrorAtPosition(start, simpleUnaryExpression.end - start, Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
+                }
+                else {
+                    parseErrorAtPosition(start, simpleUnaryExpression.end - start, Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, tokenToString(unaryOperator));
+                }
+            }
+            return simpleUnaryExpression;
+        }
+
+        /**
+         * Parse ES7 simple-unary expression or higher:
+         *
+         * ES7 SimpleUnaryExpression:
+         *      1) IncrementExpression[?yield]
+         *      2) delete UnaryExpression[?yield]
+         *      3) void UnaryExpression[?yield]
+         *      4) typeof UnaryExpression[?yield]
+         *      5) + UnaryExpression[?yield]
+         *      6) - UnaryExpression[?yield]
+         *      7) ~ UnaryExpression[?yield]
+         *      8) ! UnaryExpression[?yield]
+         */
+        function parseSimpleUnaryExpression(): UnaryExpression {
             switch (token) {
                 case SyntaxKind.PlusToken:
                 case SyntaxKind.MinusToken:
                 case SyntaxKind.TildeToken:
                 case SyntaxKind.ExclamationToken:
-                case SyntaxKind.PlusPlusToken:
-                case SyntaxKind.MinusMinusToken:
                     return parsePrefixUnaryExpression();
                 case SyntaxKind.DeleteKeyword:
                     return parseDeleteExpression();
@@ -3182,19 +3264,73 @@ namespace ts {
                 case SyntaxKind.VoidKeyword:
                     return parseVoidExpression();
                 case SyntaxKind.LessThanToken:
-                    if (sourceFile.languageVariant !== LanguageVariant.JSX) {
-                        return parseTypeAssertion();
-                    }
-                    if (lookAhead(nextTokenIsIdentifierOrKeyword)) {
-                        return parseJsxElementOrSelfClosingElement(/*inExpressionContext*/ true);
-                    }
-                    // Fall through
+                    // This is modified UnaryExpression grammar in TypeScript
+                    //  UnaryExpression (modified):
+                    //      < type > UnaryExpression
+                    return parseTypeAssertion();
                 default:
-                    return parsePostfixExpressionOrHigher();
+                    return parseIncrementExpression();
             }
         }
 
-        function parsePostfixExpressionOrHigher(): PostfixExpression {
+        /**
+         * Check if the current token can possibly be an ES7 increment expression.
+         *
+         * ES7 IncrementExpression:
+         *      LeftHandSideExpression[?Yield]
+         *      LeftHandSideExpression[?Yield][no LineTerminator here]++
+         *      LeftHandSideExpression[?Yield][no LineTerminator here]--
+         *      ++LeftHandSideExpression[?Yield]
+         *      --LeftHandSideExpression[?Yield]
+         */
+        function isIncrementExpression(): boolean {
+            // This function is called inside parseUnaryExpression to decide
+            // whether to call parseSimpleUnaryExpression or call parseIncrmentExpression directly
+            switch (token) {
+                case SyntaxKind.PlusToken:
+                case SyntaxKind.MinusToken:
+                case SyntaxKind.TildeToken:
+                case SyntaxKind.ExclamationToken:
+                case SyntaxKind.DeleteKeyword:
+                case SyntaxKind.TypeOfKeyword:
+                case SyntaxKind.VoidKeyword:
+                    return false;
+                case SyntaxKind.LessThanToken:
+                    // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
+                    if (sourceFile.languageVariant !== LanguageVariant.JSX) {
+                        return false;
+                    }
+                    // We are in JSX context and the token is part of JSXElement.
+                    // Fall through
+                default:
+                    return true;
+            }
+        }
+
+        /**
+         * Parse ES7 IncrementExpression. IncrementExpression is used instead of ES6's PostFixExpression.
+         *
+         * ES7 IncrementExpression[yield]:
+         *      1) LeftHandSideExpression[?yield]
+         *      2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++
+         *      3) LeftHandSideExpression[?yield] [[no LineTerminator here]]--
+         *      4) ++LeftHandSideExpression[?yield]
+         *      5) --LeftHandSideExpression[?yield]
+         * In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression
+         */
+        function parseIncrementExpression(): IncrementExpression {
+            if (token === SyntaxKind.PlusPlusToken || token === SyntaxKind.MinusMinusToken) {
+                let node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
+                node.operator = token;
+                nextToken();
+                node.operand = parseLeftHandSideExpressionOrHigher();
+                return finishNode(node);
+            }
+            else if (sourceFile.languageVariant === LanguageVariant.JSX && token === SyntaxKind.LessThanToken && lookAhead(nextTokenIsIdentifierOrKeyword)) {
+                // JSXElement is part of primaryExpression
+                return parseJsxElementOrSelfClosingElement(/*inExpressionContext*/ true);
+            }
+
             let expression = parseLeftHandSideExpressionOrHigher();
 
             Debug.assert(isLeftHandSideExpression(expression));
@@ -3491,7 +3627,7 @@ namespace ts {
             parseExpected(SyntaxKind.LessThanToken);
             node.type = parseType();
             parseExpected(SyntaxKind.GreaterThanToken);
-            node.expression = parseUnaryExpressionOrHigher();
+            node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
         }
 
@@ -3750,11 +3886,23 @@ namespace ts {
                 return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken);
             }
 
-            // Parse to check if it is short-hand property assignment or normal property assignment
-            if ((token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken) && tokenIsIdentifier) {
+            // check if it is short-hand property assignment or normal property assignment
+            // NOTE: if token is EqualsToken it is interpreted as CoverInitializedName production
+            // CoverInitializedName[Yield] :
+            //     IdentifierReference[?Yield] Initializer[In, ?Yield]
+            // this is necessary because ObjectLiteral productions are also used to cover grammar for ObjectAssignmentPattern
+            const isShorthandPropertyAssignment =
+                tokenIsIdentifier && (token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken || token === SyntaxKind.EqualsToken);
+
+            if (isShorthandPropertyAssignment) {
                 let shorthandDeclaration = <ShorthandPropertyAssignment>createNode(SyntaxKind.ShorthandPropertyAssignment, fullStart);
                 shorthandDeclaration.name = <Identifier>propertyName;
                 shorthandDeclaration.questionToken = questionToken;
+                const equalsToken = parseOptionalToken(SyntaxKind.EqualsToken);
+                if (equalsToken) {
+                    shorthandDeclaration.equalsToken = equalsToken;
+                    shorthandDeclaration.objectAssignmentInitializer = allowInAnd(parseAssignmentExpressionOrHigher);
+                }
                 return finishNode(shorthandDeclaration);
             }
             else {
@@ -4157,8 +4305,12 @@ namespace ts {
                     case SyntaxKind.ModuleKeyword:
                     case SyntaxKind.NamespaceKeyword:
                         return nextTokenIsIdentifierOrStringLiteralOnSameLine();
+                    case SyntaxKind.AbstractKeyword:
                     case SyntaxKind.AsyncKeyword:
                     case SyntaxKind.DeclareKeyword:
+                    case SyntaxKind.PrivateKeyword:
+                    case SyntaxKind.ProtectedKeyword:
+                    case SyntaxKind.PublicKeyword:
                         nextToken();
                         // ASI takes effect for this modifier.
                         if (scanner.hasPrecedingLineBreak()) {
@@ -4178,11 +4330,7 @@ namespace ts {
                         }
                         continue;
 
-                    case SyntaxKind.PublicKeyword:
-                    case SyntaxKind.PrivateKeyword:
-                    case SyntaxKind.ProtectedKeyword:
                     case SyntaxKind.StaticKeyword:
-                    case SyntaxKind.AbstractKeyword:
                         nextToken();
                         continue;
                     default:
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index c6d3a245a8d..86719ff30b4 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -53,13 +53,13 @@ namespace ts {
         if (getRootLength(moduleName) !== 0 || nameStartsWithDotSlashOrDotDotSlash(moduleName)) {
             let failedLookupLocations: string[] = [];
             let candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-            let resolvedFileName = loadNodeModuleFromFile(candidate, /* loadOnlyDts */ false, failedLookupLocations, host);
+            let resolvedFileName = loadNodeModuleFromFile(candidate, failedLookupLocations, host);
 
             if (resolvedFileName) {
                 return { resolvedModule: { resolvedFileName }, failedLookupLocations };
             }
 
-            resolvedFileName = loadNodeModuleFromDirectory(candidate, /* loadOnlyDts */ false, failedLookupLocations, host);
+            resolvedFileName = loadNodeModuleFromDirectory(candidate, failedLookupLocations, host);
             return resolvedFileName
                 ? { resolvedModule: { resolvedFileName }, failedLookupLocations }
                 : { resolvedModule: undefined, failedLookupLocations };
@@ -69,13 +69,8 @@ namespace ts {
         }
     }
 
-    function loadNodeModuleFromFile(candidate: string, loadOnlyDts: boolean, failedLookupLocation: string[], host: ModuleResolutionHost): string {
-        if (loadOnlyDts) {
-            return tryLoad(".d.ts");
-        }
-        else {
-            return forEach(supportedExtensions, tryLoad);
-        }
+    function loadNodeModuleFromFile(candidate: string, failedLookupLocation: string[], host: ModuleResolutionHost): string {
+        return forEach(moduleFileExtensions, tryLoad);
 
         function tryLoad(ext: string): string {
             let fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
@@ -89,7 +84,7 @@ namespace ts {
         }
     }
 
-    function loadNodeModuleFromDirectory(candidate: string, loadOnlyDts: boolean, failedLookupLocation: string[], host: ModuleResolutionHost): string {
+    function loadNodeModuleFromDirectory(candidate: string, failedLookupLocation: string[], host: ModuleResolutionHost): string {
         let packageJsonPath = combinePaths(candidate, "package.json");
         if (host.fileExists(packageJsonPath)) {
 
@@ -105,7 +100,7 @@ namespace ts {
             }
 
             if (jsonContent.typings) {
-                let result = loadNodeModuleFromFile(normalizePath(combinePaths(candidate, jsonContent.typings)), loadOnlyDts, failedLookupLocation, host);
+                let result = loadNodeModuleFromFile(normalizePath(combinePaths(candidate, jsonContent.typings)), failedLookupLocation, host);
                 if (result) {
                     return result;
                 }
@@ -116,7 +111,7 @@ namespace ts {
             failedLookupLocation.push(packageJsonPath);
         }
 
-        return loadNodeModuleFromFile(combinePaths(candidate, "index"), loadOnlyDts, failedLookupLocation, host);
+        return loadNodeModuleFromFile(combinePaths(candidate, "index"), failedLookupLocation, host);
     }
 
     function loadModuleFromNodeModules(moduleName: string, directory: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
@@ -127,12 +122,12 @@ namespace ts {
             if (baseName !== "node_modules") {
                 let nodeModulesFolder = combinePaths(directory, "node_modules");
                 let candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
-                let result = loadNodeModuleFromFile(candidate, /* loadOnlyDts */ true, failedLookupLocations, host);
+                let result = loadNodeModuleFromFile(candidate, failedLookupLocations, host);
                 if (result) {
                     return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations };
                 }
 
-                result = loadNodeModuleFromDirectory(candidate, /* loadOnlyDts */ true, failedLookupLocations, host);
+                result = loadNodeModuleFromDirectory(candidate, failedLookupLocations, host);
                 if (result) {
                     return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations };
                 }
@@ -1076,11 +1071,6 @@ namespace ts {
                 !options.experimentalDecorators) {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators"));
             }
-
-            if (options.experimentalAsyncFunctions &&
-                options.target !== ScriptTarget.ES6) {
-                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_experimentalAsyncFunctions_cannot_be_specified_when_targeting_ES5_or_lower));
-            }
         }
     }
 }
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index ee4dea04f09..a827d755302 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -136,6 +136,7 @@ namespace ts {
         "=>": SyntaxKind.EqualsGreaterThanToken,
         "+": SyntaxKind.PlusToken,
         "-": SyntaxKind.MinusToken,
+        "**": SyntaxKind.AsteriskAsteriskToken,
         "*": SyntaxKind.AsteriskToken,
         "/": SyntaxKind.SlashToken,
         "%": SyntaxKind.PercentToken,
@@ -158,6 +159,7 @@ namespace ts {
         "+=": SyntaxKind.PlusEqualsToken,
         "-=": SyntaxKind.MinusEqualsToken,
         "*=": SyntaxKind.AsteriskEqualsToken,
+        "**=": SyntaxKind.AsteriskAsteriskEqualsToken,
         "/=": SyntaxKind.SlashEqualsToken,
         "%=": SyntaxKind.PercentEqualsToken,
         "<<=": SyntaxKind.LessThanLessThanEqualsToken,
@@ -1200,6 +1202,12 @@ namespace ts {
                         if (text.charCodeAt(pos + 1) === CharacterCodes.equals) {
                             return pos += 2, token = SyntaxKind.AsteriskEqualsToken;
                         }
+                        if (text.charCodeAt(pos + 1) === CharacterCodes.asterisk) {
+                            if (text.charCodeAt(pos + 2) === CharacterCodes.equals) {
+                                return pos += 3, token = SyntaxKind.AsteriskAsteriskEqualsToken;
+                            }
+                            return pos += 2, token = SyntaxKind.AsteriskAsteriskToken;
+                        }
                         return pos++, token = SyntaxKind.AsteriskToken;
                     case CharacterCodes.plus:
                         if (text.charCodeAt(pos + 1) === CharacterCodes.plus) {
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index 76f12666878..0872a2e5ba5 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -8,7 +8,8 @@ namespace ts {
         write(s: string): void;
         readFile(path: string, encoding?: string): string;
         writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
-        watchFile?(path: string, callback: (path: string, removed: boolean) => void): FileWatcher;
+        watchFile?(path: string, callback: (path: string, removed?: boolean) => void): FileWatcher;
+        watchDirectory?(path: string, callback: (path: string) => void, recursive?: boolean): FileWatcher;
         resolvePath(path: string): string;
         fileExists(path: string): boolean;
         directoryExists(path: string): boolean;
@@ -20,6 +21,12 @@ namespace ts {
         exit(exitCode?: number): void;
     }
 
+    interface WatchedFile {
+        fileName: string;
+        callback: (fileName: string, removed?: boolean) => void;
+        mtime: Date;
+    }
+
     export interface FileWatcher {
         close(): void;
     }
@@ -192,6 +199,103 @@ namespace ts {
             const _path = require("path");
             const _os = require("os");
 
+            // average async stat takes about 30 microseconds
+            // set chunk size to do 30 files in < 1 millisecond
+            function createWatchedFileSet(interval = 2500, chunkSize = 30) {
+                let watchedFiles: WatchedFile[] = [];
+                let nextFileToCheck = 0;
+                let watchTimer: any;
+
+                function getModifiedTime(fileName: string): Date {
+                    return _fs.statSync(fileName).mtime;
+                }
+
+                function poll(checkedIndex: number) {
+                    let watchedFile = watchedFiles[checkedIndex];
+                    if (!watchedFile) {
+                        return;
+                    }
+
+                    _fs.stat(watchedFile.fileName, (err: any, stats: any) => {
+                        if (err) {
+                            watchedFile.callback(watchedFile.fileName);
+                        }
+                        else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
+                            watchedFile.mtime = getModifiedTime(watchedFile.fileName);
+                            watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0);
+                        }
+                    });
+                }
+
+                // this implementation uses polling and
+                // stat due to inconsistencies of fs.watch
+                // and efficiency of stat on modern filesystems
+                function startWatchTimer() {
+                    watchTimer = setInterval(() => {
+                        let count = 0;
+                        let nextToCheck = nextFileToCheck;
+                        let firstCheck = -1;
+                        while ((count < chunkSize) && (nextToCheck !== firstCheck)) {
+                            poll(nextToCheck);
+                            if (firstCheck < 0) {
+                                firstCheck = nextToCheck;
+                            }
+                            nextToCheck++;
+                            if (nextToCheck === watchedFiles.length) {
+                                nextToCheck = 0;
+                            }
+                            count++;
+                        }
+                        nextFileToCheck = nextToCheck;
+                    }, interval);
+                }
+
+                function addFile(fileName: string, callback: (fileName: string, removed?: boolean) => void): WatchedFile {
+                    let file: WatchedFile = {
+                        fileName,
+                        callback,
+                        mtime: getModifiedTime(fileName)
+                    };
+
+                    watchedFiles.push(file);
+                    if (watchedFiles.length === 1) {
+                        startWatchTimer();
+                    }
+                    return file;
+                }
+
+                function removeFile(file: WatchedFile) {
+                    watchedFiles = copyListRemovingItem(file, watchedFiles);
+                }
+
+                return {
+                    getModifiedTime: getModifiedTime,
+                    poll: poll,
+                    startWatchTimer: startWatchTimer,
+                    addFile: addFile,
+                    removeFile: removeFile
+                };
+            }
+
+            // REVIEW: for now this implementation uses polling.
+            // The advantage of polling is that it works reliably
+            // on all os and with network mounted files.
+            // For 90 referenced files, the average time to detect 
+            // changes is 2*msInterval (by default 5 seconds).
+            // The overhead of this is .04 percent (1/2500) with
+            // average pause of < 1 millisecond (and max
+            // pause less than 1.5 milliseconds); question is
+            // do we anticipate reference sets in the 100s and
+            // do we care about waiting 10-20 seconds to detect
+            // changes for large reference sets? If so, do we want
+            // to increase the chunk size or decrease the interval
+            // time dynamically to match the large reference set?
+            let watchedFileSet = createWatchedFileSet();
+
+            function isNode4OrLater(): Boolean {
+                return parseInt(process.version.charAt(1)) >= 4;
+            }
+
             const platform: string = _os.platform();
             // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
             const useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin";
@@ -284,25 +388,36 @@ namespace ts {
                 readFile,
                 writeFile,
                 watchFile: (fileName, callback) => {
-                    // watchFile polls a file every 250ms, picking up file notifications.
-                    _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged);
-
-                    return {
-                        close() { _fs.unwatchFile(fileName, fileChanged); }
-                    };
-
-                    function fileChanged(curr: any, prev: any) {
-                        // mtime.getTime() equals 0 if file was removed
-                        if (curr.mtime.getTime() === 0) {
-                            callback(fileName, /* removed */ true);
-                            return;
-                        }
-                        if (+curr.mtime <= +prev.mtime) {
-                            return;
-                        }
-
-                        callback(fileName, /* removed */ false);
+                    // Node 4.0 stablized the `fs.watch` function on Windows which avoids polling
+                    // and is more efficient than `fs.watchFile` (ref: https://github.com/nodejs/node/pull/2649
+                    // and https://github.com/Microsoft/TypeScript/issues/4643), therefore
+                    // if the current node.js version is newer than 4, use `fs.watch` instead.
+                    if (isNode4OrLater()) {
+                        // Note: in node the callback of fs.watch is given only the relative file name as a parameter
+                        return _fs.watch(fileName, (eventName: string, relativeFileName: string) => callback(fileName));
                     }
+
+                    let watchedFile = watchedFileSet.addFile(fileName, callback);
+                    return {
+                        close: () => watchedFileSet.removeFile(watchedFile)
+                    };
+                },
+                watchDirectory: (path, callback, recursive) => {
+                    // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows 
+                    // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
+                    return _fs.watch(
+                        path,
+                        { persisten: true, recursive: !!recursive },
+                        (eventName: string, relativeFileName: string) => {
+                            // In watchDirectory we only care about adding and removing files (when event name is
+                            // "rename"); changes made within files are handled by corresponding fileWatchers (when
+                            // event name is "change")
+                            if (eventName === "rename") {
+                                // When deleting a file, the passed baseFileName is null
+                                callback(!relativeFileName ? relativeFileName : normalizePath(ts.combinePaths(path, relativeFileName)));
+                            };
+                        }
+                    );
                 },
                 resolvePath: function (path: string): string {
                     return _path.resolve(path);
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index 7b74024aec4..9d79d435a04 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -147,14 +147,17 @@ namespace ts {
 
     export function executeCommandLine(args: string[]): void {
         let commandLine = parseCommandLine(args);
-        let configFileName: string;                 // Configuration file name (if any)
-        let configFileWatcher: FileWatcher;         // Configuration file watcher
-        let cachedProgram: Program;                 // Program cached from last compilation
-        let rootFileNames: string[];                // Root fileNames for compilation
-        let compilerOptions: CompilerOptions;       // Compiler options for compilation
-        let compilerHost: CompilerHost;             // Compiler host
-        let hostGetSourceFile: typeof compilerHost.getSourceFile;  // getSourceFile method from default host
-        let timerHandle: number;                    // Handle for 0.25s wait timer
+        let configFileName: string;                                 // Configuration file name (if any)
+        let cachedConfigFileText: string;                           // Cached configuration file text, used for reparsing (if any)
+        let configFileWatcher: FileWatcher;                         // Configuration file watcher
+        let directoryWatcher: FileWatcher;                          // Directory watcher to monitor source file addition/removal
+        let cachedProgram: Program;                                 // Program cached from last compilation
+        let rootFileNames: string[];                                // Root fileNames for compilation
+        let compilerOptions: CompilerOptions;                       // Compiler options for compilation
+        let compilerHost: CompilerHost;                             // Compiler host
+        let hostGetSourceFile: typeof compilerHost.getSourceFile;   // getSourceFile method from default host
+        let timerHandleForRecompilation: number;                    // Handle for 0.25s wait timer to trigger recompilation
+        let timerHandleForDirectoryChanges: number;                 // Handle for 0.25s wait timer to trigger directory change handler
 
         if (commandLine.options.locale) {
             if (!isJSONSupported()) {
@@ -218,28 +221,49 @@ namespace ts {
             if (configFileName) {
                 configFileWatcher = sys.watchFile(configFileName, configFileChanged);
             }
+            if (sys.watchDirectory && configFileName) {
+                let directory = ts.getDirectoryPath(configFileName);
+                directoryWatcher = sys.watchDirectory(
+                    // When the configFileName is just "tsconfig.json", the watched directory should be 
+                    // the current direcotry; if there is a given "project" parameter, then the configFileName
+                    // is an absolute file name.
+                    directory == "" ? "." : directory,
+                    watchedDirectoryChanged, /*recursive*/ true);
+            }
         }
 
         performCompilation();
 
+        function parseConfigFile(): ParsedCommandLine {
+            if (!cachedConfigFileText) {
+                try {
+                    cachedConfigFileText = sys.readFile(configFileName);
+                }
+                catch (e) {
+                    let error = createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, configFileName, e.message);
+                    reportWatchDiagnostic(error);
+                    sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                    return;
+                }
+            }
+
+            let result = parseConfigFileTextToJson(configFileName, cachedConfigFileText);
+            let configObject = result.config;
+            let configParseResult = parseJsonConfigFileContent(configObject, sys, getDirectoryPath(configFileName));
+            if (configParseResult.errors.length > 0) {
+                reportDiagnostics(configParseResult.errors);
+                sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                return;
+            }
+            return configParseResult;
+        }
+
         // Invoked to perform initial compilation or re-compilation in watch mode
         function performCompilation() {
 
             if (!cachedProgram) {
                 if (configFileName) {
-
-                    let result = readConfigFile(configFileName, sys.readFile);
-                    if (result.error) {
-                        reportWatchDiagnostic(result.error);
-                        return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
-                    }
-
-                    let configObject = result.config;
-                    let configParseResult = parseConfigFile(configObject, sys, getDirectoryPath(configFileName));
-                    if (configParseResult.errors.length > 0) {
-                        reportDiagnostics(configParseResult.errors);
-                        return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
-                    }
+                    let configParseResult = parseConfigFile();
                     rootFileNames = configParseResult.fileNames;
                     compilerOptions = extend(commandLine.options, configParseResult.options);
                 }
@@ -275,7 +299,7 @@ namespace ts {
             let sourceFile = hostGetSourceFile(fileName, languageVersion, onError);
             if (sourceFile && compilerOptions.watch) {
                 // Attach a file watcher
-                sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (fileName, removed) => sourceFileChanged(sourceFile, removed));
+                sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (fileName: string, removed?: boolean) => sourceFileChanged(sourceFile, removed));
             }
             return sourceFile;
         }
@@ -297,7 +321,7 @@ namespace ts {
         }
 
         // If a source file changes, mark it as unwatched and start the recompilation timer
-        function sourceFileChanged(sourceFile: SourceFile, removed: boolean) {
+        function sourceFileChanged(sourceFile: SourceFile, removed?: boolean) {
             sourceFile.fileWatcher.close();
             sourceFile.fileWatcher = undefined;
             if (removed) {
@@ -306,27 +330,54 @@ namespace ts {
                     rootFileNames.splice(index, 1);
                 }
             }
-            startTimer();
+            startTimerForRecompilation();
         }
 
         // If the configuration file changes, forget cached program and start the recompilation timer
         function configFileChanged() {
             setCachedProgram(undefined);
-            startTimer();
+            cachedConfigFileText = undefined;
+            startTimerForRecompilation();
+        }
+
+        function watchedDirectoryChanged(fileName: string) {
+            if (fileName && !ts.isSupportedSourceFileName(fileName)) {
+                return;
+            }
+
+            startTimerForHandlingDirectoryChanges();
+        }
+
+        function startTimerForHandlingDirectoryChanges() {
+            if (timerHandleForDirectoryChanges) {
+                clearTimeout(timerHandleForDirectoryChanges);
+            }
+            timerHandleForDirectoryChanges = setTimeout(directoryChangeHandler, 250);
+        }
+
+        function directoryChangeHandler() {
+            let parsedCommandLine = parseConfigFile();
+            let newFileNames = ts.map(parsedCommandLine.fileNames, compilerHost.getCanonicalFileName);
+            let canonicalRootFileNames = ts.map(rootFileNames, compilerHost.getCanonicalFileName);
+
+            if (!arrayStructurallyIsEqualTo(newFileNames, canonicalRootFileNames)) {
+                setCachedProgram(undefined);
+                startTimerForRecompilation();
+            }
         }
 
         // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives batch
         // operations (such as saving all modified files in an editor) a chance to complete before we kick
         // off a new compilation.
-        function startTimer() {
-            if (timerHandle) {
-                clearTimeout(timerHandle);
+        function startTimerForRecompilation() {
+            if (timerHandleForRecompilation) {
+                clearTimeout(timerHandleForRecompilation);
             }
-            timerHandle = setTimeout(recompile, 250);
+            timerHandleForRecompilation = setTimeout(recompile, 250);
         }
 
         function recompile() {
-            timerHandle = undefined;
+            timerHandleForRecompilation = undefined;
             reportWatchDiagnostic(createCompilerDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation));
             performCompilation();
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 08dbd22ff7c..fa935091516 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -64,6 +64,7 @@ namespace ts {
         PlusToken,
         MinusToken,
         AsteriskToken,
+        AsteriskAsteriskToken,
         SlashToken,
         PercentToken,
         PlusPlusToken,
@@ -86,6 +87,7 @@ namespace ts {
         PlusEqualsToken,
         MinusEqualsToken,
         AsteriskEqualsToken,
+        AsteriskAsteriskEqualsToken,
         SlashEqualsToken,
         PercentEqualsToken,
         LessThanLessThanEqualsToken,
@@ -562,6 +564,10 @@ namespace ts {
     export interface ShorthandPropertyAssignment extends ObjectLiteralElement {
         name: Identifier;
         questionToken?: Node;
+        // used when ObjectLiteralExpression is used in ObjectAssignmentPattern
+        // it is grammar error to appear in actual object initializer
+        equalsToken?: Node;
+        objectAssignmentInitializer?: Expression;
     }
 
     // SyntaxKind.VariableDeclaration
@@ -707,12 +713,16 @@ namespace ts {
         _unaryExpressionBrand: any;
     }
 
-    export interface PrefixUnaryExpression extends UnaryExpression {
+    export interface IncrementExpression extends UnaryExpression {
+        _incrementExpressionBrand: any;
+    }
+
+    export interface PrefixUnaryExpression extends IncrementExpression {
         operator: SyntaxKind;
         operand: UnaryExpression;
     }
 
-    export interface PostfixUnaryExpression extends PostfixExpression {
+    export interface PostfixUnaryExpression extends IncrementExpression {
         operand: LeftHandSideExpression;
         operator: SyntaxKind;
     }
@@ -721,7 +731,7 @@ namespace ts {
         _postfixExpressionBrand: any;
     }
 
-    export interface LeftHandSideExpression extends PostfixExpression {
+    export interface LeftHandSideExpression extends IncrementExpression {
         _leftHandSideExpressionBrand: any;
     }
 
@@ -1598,7 +1608,6 @@ namespace ts {
         isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
-        getBlockScopedVariableId(node: Identifier): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
         getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind;
         isOptionalParameter(node: ParameterDeclaration): boolean;
@@ -1882,7 +1891,7 @@ namespace ts {
     }
 
     export interface TupleType extends ObjectType {
-        elementTypes: Type[];           // Element types
+        elementTypes: Type[];  // Element types
     }
 
     export interface UnionOrIntersectionType extends Type {
@@ -1897,6 +1906,13 @@ namespace ts {
 
     export interface IntersectionType extends UnionOrIntersectionType { }
 
+    /* @internal */
+    // An instantiated anonymous type has a target and a mapper
+    export interface AnonymousType extends ObjectType {
+        target?: AnonymousType;  // Instantiation target
+        mapper?: TypeMapper;     // Instantiation mapper
+    }
+
     /* @internal */
     // Resolved object, union, or intersection type
     export interface ResolvedType extends ObjectType, UnionOrIntersectionType {
@@ -2072,7 +2088,6 @@ namespace ts {
         watch?: boolean;
         isolatedModules?: boolean;
         experimentalDecorators?: boolean;
-        experimentalAsyncFunctions?: boolean;
         emitDecoratorMetadata?: boolean;
         moduleResolution?: ModuleResolutionKind;
         /* @internal */ stripInternal?: boolean;
@@ -2090,6 +2105,7 @@ namespace ts {
         UMD = 3,
         System = 4,
         ES6 = 5,
+        ES2015 = ES6,
     }
 
     export const enum JsxEmit {
@@ -2115,12 +2131,13 @@ namespace ts {
         ES3 = 0,
         ES5 = 1,
         ES6 = 2,
+        ES2015 = ES6,
         Latest = ES6,
     }
 
     export const enum LanguageVariant {
         Standard,
-        JSX
+        JSX,
     }
 
     export interface ParsedCommandLine {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 5127b98ab3a..ccfab49375d 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -896,6 +896,14 @@ namespace ts {
         return nodeIsDecorated(node) || childIsDecorated(node);
     }
 
+    export function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression {
+        return node.kind === SyntaxKind.PropertyAccessExpression;
+    }
+
+    export function isElementAccessExpression(node: Node): node is ElementAccessExpression {
+        return node.kind === SyntaxKind.ElementAccessExpression;
+    }
+
     export function isExpression(node: Node): boolean {
         switch (node.kind) {
             case SyntaxKind.SuperKeyword:
@@ -1414,7 +1422,7 @@ namespace ts {
      * where Symbol is literally the word "Symbol", and name is any identifierName
      */
     export function isWellKnownSymbolSyntactically(node: Expression): boolean {
-        return node.kind === SyntaxKind.PropertyAccessExpression && isESSymbolIdentifier((<PropertyAccessExpression>node).expression);
+        return isPropertyAccessExpression(node) && isESSymbolIdentifier(node.expression);
     }
 
     export function getPropertyNameForPropertyNameNode(name: DeclarationName): string {
@@ -2047,8 +2055,8 @@ namespace ts {
         if (node.kind === SyntaxKind.Identifier) {
             return true;
         }
-        else if (node.kind === SyntaxKind.PropertyAccessExpression) {
-            return isSupportedExpressionWithTypeArgumentsRest((<PropertyAccessExpression>node).expression);
+        else if (isPropertyAccessExpression(node)) {
+            return isSupportedExpressionWithTypeArgumentsRest(node.expression);
         }
         else {
             return false;
@@ -2406,4 +2414,16 @@ namespace ts {
             }
         }
     }
+
+    export function arrayStructurallyIsEqualTo<T>(array1: Array<T>, array2: Array<T>): boolean {
+        if (!array1 || !array2) {
+            return false;
+        }
+
+        if (array1.length !== array2.length) {
+            return false;
+        }
+
+        return arrayIsEqualTo(array1.sort(), array2.sort());
+    }
 }
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index a846077a85f..457ece7e132 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -100,6 +100,8 @@ namespace FourSlash {
         end: number;
     }
 
+    export import IndentStyle = ts.IndentStyle;
+
     let entityMap: ts.Map<string> = {
         "&": "&amp;",
         "\"": "&quot;",
@@ -309,6 +311,7 @@ namespace FourSlash {
                 TabSize: 4,
                 NewLineCharacter: Harness.IO.newLine(),
                 ConvertTabsToSpaces: true,
+                IndentStyle: ts.IndentStyle.Smart,
                 InsertSpaceAfterCommaDelimiter: true,
                 InsertSpaceAfterSemicolonInForStatements: true,
                 InsertSpaceBeforeAndAfterBinaryOperators: true,
@@ -588,14 +591,21 @@ namespace FourSlash {
             }
         }
 
-        public verifyCompletionListItemsCountIsGreaterThan(count: number) {
+        public verifyCompletionListItemsCountIsGreaterThan(count: number, negative: boolean) {
             this.taoInvalidReason = "verifyCompletionListItemsCountIsGreaterThan NYI";
 
             let completions = this.getCompletionListAtCaret();
             let itemsCount = completions.entries.length;
 
-            if (itemsCount <= count) {
-                this.raiseError(`Expected completion list items count to be greater than ${count}, but is actually ${itemsCount}`);
+            if (negative) {
+                if (itemsCount > count) {
+                    this.raiseError(`Expected completion list items count to not be greater than ${count}, but is actually ${itemsCount}`);
+                }
+            }
+            else {
+                if (itemsCount <= count) {
+                    this.raiseError(`Expected completion list items count to be greater than ${count}, but is actually ${itemsCount}`);
+                }
             }
         }
 
@@ -1695,24 +1705,28 @@ namespace FourSlash {
             }
         }
 
-        private getIndentation(fileName: string, position: number): number {
-            return this.languageService.getIndentationAtPosition(fileName, position, this.formatCodeOptions);
+        private getIndentation(fileName: string, position: number, indentStyle: ts.IndentStyle): number {
+
+            let formatOptions = ts.clone(this.formatCodeOptions);
+            formatOptions.IndentStyle = indentStyle;
+
+            return this.languageService.getIndentationAtPosition(fileName, position, formatOptions);
         }
 
-        public verifyIndentationAtCurrentPosition(numberOfSpaces: number) {
+        public verifyIndentationAtCurrentPosition(numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) {
             this.taoInvalidReason = "verifyIndentationAtCurrentPosition NYI";
 
-            let actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition);
+            let actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition, indentStyle);
             let lineCol = this.getLineColStringAtPosition(this.currentCaretPosition);
             if (actual !== numberOfSpaces) {
                 this.raiseError(`verifyIndentationAtCurrentPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`);
             }
         }
 
-        public verifyIndentationAtPosition(fileName: string, position: number, numberOfSpaces: number) {
+        public verifyIndentationAtPosition(fileName: string, position: number, numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) {
             this.taoInvalidReason = "verifyIndentationAtPosition NYI";
 
-            let actual = this.getIndentation(fileName, position);
+            let actual = this.getIndentation(fileName, position, indentStyle);
             let lineCol = this.getLineColStringAtPosition(position);
             if (actual !== numberOfSpaces) {
                 this.raiseError(`verifyIndentationAtPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`);
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index dfde2bd1c08..df5efccdcb5 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -572,6 +572,10 @@ namespace Harness.LanguageService {
             return { close() { } };
         }
 
+        watchDirectory(path: string, callback: (path: string) => void, recursive?: boolean): ts.FileWatcher {
+            return { close() { } };
+        }
+
         close(): void {
         }
 
@@ -614,7 +618,9 @@ namespace Harness.LanguageService {
             // This host is just a proxy for the clientHost, it uses the client
             // host to answer server queries about files on disk
             let serverHost = new SessionServerHost(clientHost);
-            let server = new ts.server.Session(serverHost, Buffer.byteLength, process.hrtime, serverHost);
+            let server = new ts.server.Session(serverHost,
+                Buffer ? Buffer.byteLength : (string: string, encoding?: string) => string.length,
+                process.hrtime, serverHost);
 
             // Fake the connection between the client and the server
             serverHost.writeMessage = client.onMessage.bind(client);
diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts
index 3027afae9dc..19c989bcd6f 100644
--- a/src/harness/rwcRunner.ts
+++ b/src/harness/rwcRunner.ts
@@ -78,8 +78,8 @@ namespace RWC {
                     let tsconfigFile = ts.forEach(ioLog.filesRead, f => isTsConfigFile(f) ? f : undefined);
                     if (tsconfigFile) {
                         let tsconfigFileContents = getHarnessCompilerInputUnit(tsconfigFile.path);
-                        let parsedTsconfigFileContents = ts.parseConfigFileText(tsconfigFile.path, tsconfigFileContents.content);
-                        let configParseResult = ts.parseConfigFile(parsedTsconfigFileContents.config, Harness.IO, ts.getDirectoryPath(tsconfigFile.path));
+                        let parsedTsconfigFileContents = ts.parseConfigFileTextToJson(tsconfigFile.path, tsconfigFileContents.content);
+                        let configParseResult = ts.parseJsonConfigFileContent(parsedTsconfigFileContents.config, Harness.IO, ts.getDirectoryPath(tsconfigFile.path));
                         fileNames = configParseResult.fileNames;
                         opts.options = ts.extend(opts.options, configParseResult.options);
                     }
diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
index 0fef0779965..9db4fbcd41c 100644
--- a/src/harness/typeWriter.ts
+++ b/src/harness/typeWriter.ts
@@ -57,7 +57,9 @@ class TypeWriterWalker {
                     symbolString += ", ";
                     let declSourceFile = declaration.getSourceFile();
                     let declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
-                    symbolString += `Decl(${ ts.getBaseFileName(declSourceFile.fileName) }, ${ declLineAndCharacter.line }, ${ declLineAndCharacter.character })`;
+                    let fileName = ts.getBaseFileName(declSourceFile.fileName);
+                    let isLibFile = /lib(.*)\.d\.ts/i.test(fileName);
+                    symbolString += `Decl(${ fileName }, ${ isLibFile ? "--" : declLineAndCharacter.line }, ${ isLibFile ? "--" : declLineAndCharacter.character })`;
                 }
             }
             symbolString += ")";
diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts
index e34ce36633f..fa985344412 100644
--- a/src/lib/dom.generated.d.ts
+++ b/src/lib/dom.generated.d.ts
@@ -1067,7 +1067,7 @@ declare var CanvasPattern: {
 
 interface CanvasRenderingContext2D {
     canvas: HTMLCanvasElement;
-    fillStyle: any;
+    fillStyle: string | CanvasGradient | CanvasPattern;
     font: string;
     globalAlpha: number;
     globalCompositeOperation: string;
@@ -1082,7 +1082,7 @@ interface CanvasRenderingContext2D {
     shadowColor: string;
     shadowOffsetX: number;
     shadowOffsetY: number;
-    strokeStyle: any;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
     textAlign: string;
     textBaseline: string;
     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
@@ -2450,8 +2450,6 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven
     importNode(importedNode: Node, deep: boolean): Node;
     msElementsFromPoint(x: number, y: number): NodeList;
     msElementsFromRect(left: number, top: number, width: number, height: number): NodeList;
-    msGetPrintDocumentForNamedFlow(flowName: string): Document;
-    msSetPrintDocumentUriForNamedFlow(flowName: string, uri: string): void;
     /**
       * Opens a new window and loads a document specified by a given URL. Also, opens a new window that uses the url parameter and the name parameter to collect the output of the write method and the writeln method.
       * @param url Specifies a MIME type for the document.
@@ -7273,27 +7271,6 @@ declare var MSHTMLWebViewElement: {
     new(): MSHTMLWebViewElement;
 }
 
-interface MSHeaderFooter {
-    URL: string;
-    dateLong: string;
-    dateShort: string;
-    font: string;
-    htmlFoot: string;
-    htmlHead: string;
-    page: number;
-    pageTotal: number;
-    textFoot: string;
-    textHead: string;
-    timeLong: string;
-    timeShort: string;
-    title: string;
-}
-
-declare var MSHeaderFooter: {
-    prototype: MSHeaderFooter;
-    new(): MSHeaderFooter;
-}
-
 interface MSInputMethodContext extends EventTarget {
     compositionEndOffset: number;
     compositionStartOffset: number;
@@ -7452,24 +7429,6 @@ declare var MSPointerEvent: {
     new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent;
 }
 
-interface MSPrintManagerTemplatePrinter extends MSTemplatePrinter, EventTarget {
-    percentScale: number;
-    showHeaderFooter: boolean;
-    shrinkToFit: boolean;
-    drawPreviewPage(element: HTMLElement, pageNumber: number): void;
-    endPrint(): void;
-    getPrintTaskOptionValue(key: string): any;
-    invalidatePreview(): void;
-    setPageCount(pageCount: number): void;
-    startPrint(): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
-}
-
-declare var MSPrintManagerTemplatePrinter: {
-    prototype: MSPrintManagerTemplatePrinter;
-    new(): MSPrintManagerTemplatePrinter;
-}
-
 interface MSRangeCollection {
     length: number;
     item(index: number): Range;
@@ -7517,63 +7476,6 @@ declare var MSStreamReader: {
     new(): MSStreamReader;
 }
 
-interface MSTemplatePrinter {
-    collate: boolean;
-    copies: number;
-    currentPage: boolean;
-    currentPageAvail: boolean;
-    duplex: boolean;
-    footer: string;
-    frameActive: boolean;
-    frameActiveEnabled: boolean;
-    frameAsShown: boolean;
-    framesetDocument: boolean;
-    header: string;
-    headerFooterFont: string;
-    marginBottom: number;
-    marginLeft: number;
-    marginRight: number;
-    marginTop: number;
-    orientation: string;
-    pageFrom: number;
-    pageHeight: number;
-    pageTo: number;
-    pageWidth: number;
-    selectedPages: boolean;
-    selection: boolean;
-    selectionEnabled: boolean;
-    unprintableBottom: number;
-    unprintableLeft: number;
-    unprintableRight: number;
-    unprintableTop: number;
-    usePrinterCopyCollate: boolean;
-    createHeaderFooter(): MSHeaderFooter;
-    deviceSupports(property: string): any;
-    ensurePrintDialogDefaults(): boolean;
-    getPageMarginBottom(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginBottomImportant(pageRule: CSSPageRule): boolean;
-    getPageMarginLeft(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginLeftImportant(pageRule: CSSPageRule): boolean;
-    getPageMarginRight(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginRightImportant(pageRule: CSSPageRule): boolean;
-    getPageMarginTop(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginTopImportant(pageRule: CSSPageRule): boolean;
-    printBlankPage(): void;
-    printNonNative(document: any): boolean;
-    printNonNativeFrames(document: any, activeFrame: boolean): void;
-    printPage(element: HTMLElement): void;
-    showPageSetupDialog(): boolean;
-    showPrintDialog(): boolean;
-    startDoc(title: string): boolean;
-    stopDoc(): void;
-    updatePageStatus(status: number): void;
-}
-
-declare var MSTemplatePrinter: {
-    prototype: MSTemplatePrinter;
-    new(): MSTemplatePrinter;
-}
-
 interface MSWebViewAsyncOperation extends EventTarget {
     error: DOMError;
     oncomplete: (ev: Event) => any;
@@ -7991,6 +7893,10 @@ declare var Node: {
 }
 
 interface NodeFilter {
+    acceptNode(n: Node): number;
+}
+
+declare var NodeFilter: {
     FILTER_ACCEPT: number;
     FILTER_REJECT: number;
     FILTER_SKIP: number;
@@ -8008,7 +7914,6 @@ interface NodeFilter {
     SHOW_PROCESSING_INSTRUCTION: number;
     SHOW_TEXT: number;
 }
-declare var NodeFilter: NodeFilter;
 
 interface NodeIterator {
     expandEntityReferences: boolean;
@@ -8718,7 +8623,6 @@ declare var SVGDescElement: {
 
 interface SVGElement extends Element {
     id: string;
-    className: any;
     onclick: (ev: MouseEvent) => any;
     ondblclick: (ev: MouseEvent) => any;
     onfocusin: (ev: FocusEvent) => any;
@@ -8732,6 +8636,7 @@ interface SVGElement extends Element {
     ownerSVGElement: SVGSVGElement;
     viewportElement: SVGElement;
     xmlbase: string;
+    className: any;
     addEventListener(type: "MSGestureChange", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -11871,7 +11776,6 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     locationbar: BarProp;
     menubar: BarProp;
     msAnimationStartTime: number;
-    msTemplatePrinter: MSTemplatePrinter;
     name: string;
     navigator: Navigator;
     offscreenBuffering: string | boolean;
@@ -12608,7 +12512,6 @@ interface XMLHttpRequestEventTarget {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
-
 interface NodeListOf<TNode extends Node> extends NodeList {
     length: number;
     item(index: number): TNode;
@@ -12629,8 +12532,6 @@ interface EventListenerObject {
     handleEvent(evt: Event): void;
 }
 
-declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
-
 interface MessageEventInit extends EventInit {
     data?: any;
     origin?: string;
@@ -12646,6 +12547,8 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+
 interface ErrorEventHandler {
     (message: string, filename?: string, lineno?: number, colno?: number, error?:Error): void;
 }
@@ -12706,7 +12609,6 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msAnimationStartTime: number;
-declare var msTemplatePrinter: MSTemplatePrinter;
 declare var name: string;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;
diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts
index f37ea5c6ed2..7e160fffa45 100644
--- a/src/lib/webworker.generated.d.ts
+++ b/src/lib/webworker.generated.d.ts
@@ -894,7 +894,6 @@ interface WorkerUtils extends Object, WindowBase64 {
     setTimeout(handler: any, timeout?: any, ...args: any[]): number;
 }
 
-
 interface BlobPropertyBag {
     type?: string;
     endings?: string;
@@ -909,8 +908,6 @@ interface EventListenerObject {
     handleEvent(evt: Event): void;
 }
 
-declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
-
 interface MessageEventInit extends EventInit {
     data?: any;
     origin?: string;
@@ -926,6 +923,8 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+
 interface ErrorEventHandler {
     (message: string, filename?: string, lineno?: number, colno?: number, error?:Error): void;
 }
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 7ab46fc689e..09f8a372463 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -78,19 +78,19 @@ namespace ts.server {
             return this.snap().getChangeRange(oldSnapshot);
         }
     }
-    
+
     interface TimestampedResolvedModule extends ResolvedModuleWithFailedLookupLocations {
-        lastCheckTime: number; 
+        lastCheckTime: number;
     }
-    
+
     export class LSHost implements ts.LanguageServiceHost {
         ls: ts.LanguageService = null;
         compilationSettings: ts.CompilerOptions;
         filenameToScript: ts.Map<ScriptInfo> = {};
         roots: ScriptInfo[] = [];
-        private resolvedModuleNames: ts.FileMap<Map<TimestampedResolvedModule>>;        
+        private resolvedModuleNames: ts.FileMap<Map<TimestampedResolvedModule>>;
         private moduleResolutionHost: ts.ModuleResolutionHost;
-        
+
         constructor(public host: ServerHost, public project: Project) {
             this.resolvedModuleNames = ts.createFileMap<Map<TimestampedResolvedModule>>(ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames))
             this.moduleResolutionHost = {
@@ -98,15 +98,15 @@ namespace ts.server {
                 readFile: fileName => this.host.readFile(fileName)
             }
         }
-        
+
         resolveModuleNames(moduleNames: string[], containingFile: string): ResolvedModule[] {
             let currentResolutionsInFile = this.resolvedModuleNames.get(containingFile);
-            
+
             let newResolutions: Map<TimestampedResolvedModule> = {};
             let resolvedModules: ResolvedModule[] = [];
-            
+
             let compilerOptions = this.getCompilationSettings();
-                        
+
             for (let moduleName of moduleNames) {
                 // check if this is a duplicate entry in the list
                 let resolution = lookUp(newResolutions, moduleName);
@@ -122,21 +122,21 @@ namespace ts.server {
                         newResolutions[moduleName] = resolution;
                     }
                 }
-                
+
                 ts.Debug.assert(resolution !== undefined);
-                
+
                 resolvedModules.push(resolution.resolvedModule);
             }
             
             // replace old results with a new one
             this.resolvedModuleNames.set(containingFile, newResolutions);
             return resolvedModules;
-            
+
             function moduleResolutionIsValid(resolution: TimestampedResolvedModule): boolean {
                 if (!resolution) {
                     return false;
                 }
-                
+
                 if (resolution.resolvedModule) {
                     // TODO: consider checking failedLookupLocations  
                     // TODO: use lastCheckTime to track expiration for module name resolution 
@@ -147,7 +147,7 @@ namespace ts.server {
                 // after all there is no point to invalidate it if we have no idea where to look for the module.
                 return resolution.failedLookupLocations.length === 0;
             }
-        }        
+        }
 
         getDefaultLibFileName() {
             var nodeModuleBinDir = ts.getDirectoryPath(ts.normalizePath(this.host.getExecutingFilePath()));
@@ -224,12 +224,13 @@ namespace ts.server {
                 this.roots.push(info);
             }
         }
-        
+
         removeRoot(info: ScriptInfo) {
             var scriptInfo = ts.lookUp(this.filenameToScript, info.fileName);
             if (scriptInfo) {
                 this.filenameToScript[info.fileName] = undefined;
                 this.roots = copyListRemovingItem(info, this.roots);
+                this.resolvedModuleNames.remove(info.fileName);
             }
         }
 
@@ -354,6 +355,9 @@ namespace ts.server {
         compilerService: CompilerService;
         projectFilename: string;
         projectFileWatcher: FileWatcher;
+        directoryWatcher: FileWatcher;
+        // Used to keep track of what directories are watched for this project
+        directoriesWatchedForTsconfig: string[] = [];
         program: ts.Program;
         filenameToSourceFile: ts.Map<ts.SourceFile> = {};
         updateGraphSeq = 0;
@@ -377,6 +381,10 @@ namespace ts.server {
             return this.projectService.openFile(filename, false);
         }
 
+        getRootFiles() {
+            return this.compilerService.host.roots.map(info => info.fileName);
+        }
+
         getFileNames() {
             let sourceFiles = this.program.getSourceFiles();
             return sourceFiles.map(sourceFile => sourceFile.fileName);
@@ -429,13 +437,11 @@ namespace ts.server {
 
         // add a root file to project
         addRoot(info: ScriptInfo) {
-            info.defaultProject = this;
             this.compilerService.host.addRoot(info);
         }
         
         // remove a root file from project
         removeRoot(info: ScriptInfo) {
-            info.defaultProject = undefined;
             this.compilerService.host.removeRoot(info);
         }
 
@@ -491,7 +497,13 @@ namespace ts.server {
         openFilesReferenced: ScriptInfo[] = [];
         // open files that are roots of a configured project
         openFileRootsConfigured: ScriptInfo[] = [];
+        // a path to directory watcher map that detects added tsconfig files
+        directoryWatchersForTsconfig: ts.Map<FileWatcher> = {};
+        // count of how many projects are using the directory watcher. If the 
+        // number becomes 0 for a watcher, then we should close it.
+        directoryWatchersRefCount: ts.Map<number> = {};
         hostConfiguration: HostConfiguration;
+        timerForDetectingProjectFilelistChanges: Map<NodeJS.Timer> = {};
 
         constructor(public host: ServerHost, public psLogger: Logger, public eventHandler?: ProjectServiceEventHandler) {
             // ts.disableIncrementalParsing = true;
@@ -532,8 +544,82 @@ namespace ts.server {
             }
         }
 
+        /**
+         * This is the callback function when a watched directory has added or removed source code files.
+         * @param project the project that associates with this directory watcher
+         * @param fileName the absolute file name that changed in watched directory
+         */
+        directoryWatchedForSourceFilesChanged(project: Project, fileName: string) {
+            // If a change was made inside "folder/file", node will trigger the callback twice:
+            // one with the fileName being "folder/file", and the other one with "folder".
+            // We don't respond to the second one.
+            if (fileName && !ts.isSupportedSourceFileName(fileName)) {
+                return;
+            }
+
+            this.log("Detected source file changes: " + fileName);
+            this.startTimerForDetectingProjectFilelistChanges(project);
+        }
+
+        startTimerForDetectingProjectFilelistChanges(project: Project) {
+            if (this.timerForDetectingProjectFilelistChanges[project.projectFilename]) {
+                clearTimeout(this.timerForDetectingProjectFilelistChanges[project.projectFilename]);
+            }
+            this.timerForDetectingProjectFilelistChanges[project.projectFilename] = setTimeout(
+                () => this.handleProjectFilelistChanges(project),
+                250
+            );
+        }
+
+        handleProjectFilelistChanges(project: Project) {
+            let { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);
+            let newRootFiles = projectOptions.files.map((f => this.getCanonicalFileName(f)));
+            let currentRootFiles = project.getRootFiles().map((f => this.getCanonicalFileName(f)));
+
+            if (!arrayStructurallyIsEqualTo(currentRootFiles, newRootFiles)) {
+                // For configured projects, the change is made outside the tsconfig file, and
+                // it is not likely to affect the project for other files opened by the client. We can 
+                // just update the current project.
+                this.updateConfiguredProject(project);
+
+                // Call updateProjectStructure to clean up inferred projects we may have 
+                // created for the new files
+                this.updateProjectStructure();
+            }
+        }
+
+        /**
+         * This is the callback function when a watched directory has an added tsconfig file.
+         */
+        directoryWatchedForTsconfigChanged(fileName: string) {
+            if (ts.getBaseFileName(fileName) != "tsconfig.json") {
+                this.log(fileName + " is not tsconfig.json");
+                return;
+            }
+
+            this.log("Detected newly added tsconfig file: " + fileName);
+
+            let { succeeded, projectOptions, error } = this.configFileToProjectOptions(fileName);
+            let rootFilesInTsconfig = projectOptions.files.map(f => this.getCanonicalFileName(f));
+            let openFileRoots = this.openFileRoots.map(s => this.getCanonicalFileName(s.fileName));
+
+            // We should only care about the new tsconfig file if it contains any
+            // opened root files of existing inferred projects
+            for (let openFileRoot of openFileRoots) {
+                if (rootFilesInTsconfig.indexOf(openFileRoot) >= 0) {
+                    this.reloadProjects();
+                    return;
+                }
+            }
+        }
+
+        getCanonicalFileName(fileName: string) {
+            let name = this.host.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+            return ts.normalizePath(name);
+        }
+
         watchedProjectConfigFileChanged(project: Project) {
-            this.log("Config File Changed: " + project.projectFilename);
+            this.log("Config file changed: " + project.projectFilename);
             this.updateConfiguredProject(project);
             this.updateProjectStructure();
         }
@@ -567,11 +653,29 @@ namespace ts.server {
         }
 
         createInferredProject(root: ScriptInfo) {
-            var iproj = new Project(this);
-            iproj.addRoot(root);
-            iproj.finishGraph();
-            this.inferredProjects.push(iproj);
-            return iproj;
+            var project = new Project(this);
+            project.addRoot(root);
+
+            let currentPath = ts.getDirectoryPath(root.fileName);
+            let parentPath = ts.getDirectoryPath(currentPath);
+            while (currentPath != parentPath) {
+                if (!project.projectService.directoryWatchersForTsconfig[currentPath]) {
+                    this.log("Add watcher for: " + currentPath);
+                    project.projectService.directoryWatchersForTsconfig[currentPath] =
+                        this.host.watchDirectory(currentPath, fileName => this.directoryWatchedForTsconfigChanged(fileName));
+                    project.projectService.directoryWatchersRefCount[currentPath] = 1;
+                }
+                else {
+                    project.projectService.directoryWatchersRefCount[currentPath] += 1;
+                }
+                project.directoriesWatchedForTsconfig.push(currentPath);
+                currentPath = parentPath;
+                parentPath = ts.getDirectoryPath(parentPath);
+            }
+
+            project.finishGraph();
+            this.inferredProjects.push(project);
+            return project;
         }
 
         fileDeletedInFilesystem(info: ScriptInfo) {
@@ -585,6 +689,9 @@ namespace ts.server {
             if (!info.isOpen) {
                 this.filenameToScriptInfo[info.fileName] = undefined;
                 var referencingProjects = this.findReferencingProjects(info);
+                if (info.defaultProject) {
+                    info.defaultProject.removeRoot(info);
+                }
                 for (var i = 0, len = referencingProjects.length; i < len; i++) {
                     referencingProjects[i].removeReferencedFile(info);
                 }
@@ -615,9 +722,24 @@ namespace ts.server {
             this.configuredProjects = configuredProjects;
         }
 
-        removeConfiguredProject(project: Project) {
-            project.projectFileWatcher.close();
-            this.configuredProjects = copyListRemovingItem(project, this.configuredProjects);
+        removeProject(project: Project) {
+            this.log("remove project: " + project.getRootFiles().toString());
+            if (project.isConfiguredProject()) {
+                project.projectFileWatcher.close();
+                project.directoryWatcher.close();
+                this.configuredProjects = copyListRemovingItem(project, this.configuredProjects);
+            }
+            else {
+                for (let directory of project.directoriesWatchedForTsconfig) {
+                    // if the ref count for this directory watcher drops to 0, it's time to close it
+                    if (!(--project.projectService.directoryWatchersRefCount[directory])) {
+                        this.log("Close directory watcher for: " + directory);
+                        project.projectService.directoryWatchersForTsconfig[directory].close();
+                        delete project.projectService.directoryWatchersForTsconfig[directory];
+                    }
+                }
+                this.inferredProjects = copyListRemovingItem(project, this.inferredProjects);
+            }
 
             let fileNames = project.getFileNames();
             for (let fileName of fileNames) {
@@ -659,8 +781,7 @@ namespace ts.server {
                         // if r referenced by the new project
                         if (info.defaultProject.getSourceFile(r)) {
                             // remove project rooted at r
-                            this.inferredProjects =
-                            copyListRemovingItem(r.defaultProject, this.inferredProjects);
+                            this.removeProject(r.defaultProject);
                             // put r in referenced open file list
                             this.openFilesReferenced.push(r);
                             // set default project of r to the new project
@@ -683,6 +804,11 @@ namespace ts.server {
           * @param info The file that has been closed or newly configured
           */
         closeOpenFile(info: ScriptInfo) {
+            // Closing file should trigger re-reading the file content from disk. This is 
+            // because the user may chose to discard the buffer content before saving 
+            // to the disk, and the server's version of the file can be out of sync.
+            info.svc.reloadFromFile(info.fileName);
+
             var openFileRoots: ScriptInfo[] = [];
             var removedProject: Project;
             for (var i = 0, len = this.openFileRoots.length; i < len; i++) {
@@ -713,19 +839,14 @@ namespace ts.server {
                 this.openFileRootsConfigured = openFileRootsConfigured;
             }
             if (removedProject) {
-                if (removedProject.isConfiguredProject()) {
-                    this.configuredProjects = copyListRemovingItem(removedProject, this.configuredProjects);
-                }
-                else {
-                    this.inferredProjects = copyListRemovingItem(removedProject, this.inferredProjects);
-                }
+                this.removeProject(removedProject);
                 var openFilesReferenced: ScriptInfo[] = [];
                 var orphanFiles: ScriptInfo[] = [];
                 // for all open, referenced files f
                 for (var i = 0, len = this.openFilesReferenced.length; i < len; i++) {
                     var f = this.openFilesReferenced[i];
                     // if f was referenced by the removed project, remember it
-                    if (f.defaultProject === removedProject) {
+                    if (f.defaultProject === removedProject || !f.defaultProject) {
                         f.defaultProject = undefined;
                         orphanFiles.push(f);
                     }
@@ -769,7 +890,11 @@ namespace ts.server {
             return referencingProjects;
         }
 
+        /**
+         * This function rebuilds the project for every file opened by the client
+         */
         reloadProjects() {
+            this.log("reload projects.");
             // First check if there is new tsconfig file added for inferred project roots
             for (let info of this.openFileRoots) {
                 this.openOrUpdateConfiguredProjectForFile(info.fileName);
@@ -830,14 +955,25 @@ namespace ts.server {
                 var rootFile = this.openFileRoots[i];
                 var rootedProject = rootFile.defaultProject;
                 var referencingProjects = this.findReferencingProjects(rootFile, rootedProject);
-                if (referencingProjects.length === 0) {
-                    rootFile.defaultProject = rootedProject;
-                    openFileRoots.push(rootFile);
+
+                if (rootFile.defaultProject && rootFile.defaultProject.isConfiguredProject()) {
+                    // If the root file has already been added into a configured project,
+                    // meaning the original inferred project is gone already. 
+                    if (!rootedProject.isConfiguredProject()) {
+                        this.removeProject(rootedProject);
+                    }
+                    this.openFileRootsConfigured.push(rootFile);
                 }
                 else {
-                    // remove project from inferred projects list because root captured
-                    this.inferredProjects = copyListRemovingItem(rootedProject, this.inferredProjects);
-                    this.openFilesReferenced.push(rootFile);
+                    if (referencingProjects.length === 0) {
+                        rootFile.defaultProject = rootedProject;
+                        openFileRoots.push(rootFile);
+                    }
+                    else {
+                        // remove project from inferred projects list because root captured
+                        this.removeProject(rootedProject);
+                        this.openFilesReferenced.push(rootFile);
+                    }
                 }
             }
             this.openFileRoots = openFileRoots;
@@ -922,6 +1058,11 @@ namespace ts.server {
             return info;
         }
 
+        /**
+         * This function tries to search for a tsconfig.json for the given file. If we found it, 
+         * we first detect if there is already a configured project created for it: if so, we re-read
+         * the tsconfig file content and update the project; otherwise we create a new one. 
+         */
         openOrUpdateConfiguredProjectForFile(fileName: string) {
             let searchPath = ts.normalizePath(getDirectoryPath(fileName));
             this.log("Search path: " + searchPath, "Info");
@@ -1041,17 +1182,17 @@ namespace ts.server {
             // file references will be relative to dirPath (or absolute)
             var dirPath = ts.getDirectoryPath(configFilename);
             var contents = this.host.readFile(configFilename)
-            var rawConfig: { config?: ProjectOptions; error?: Diagnostic; } = ts.parseConfigFileText(configFilename, contents);
+            var rawConfig: { config?: ProjectOptions; error?: Diagnostic; } = ts.parseConfigFileTextToJson(configFilename, contents);
             if (rawConfig.error) {
                 return { succeeded: false, error: rawConfig.error };
             }
             else {
-                var parsedCommandLine = ts.parseConfigFile(rawConfig.config, this.host, dirPath);
+                var parsedCommandLine = ts.parseJsonConfigFileContent(rawConfig.config, this.host, dirPath);
                 if (parsedCommandLine.errors && (parsedCommandLine.errors.length > 0)) {
                     return { succeeded: false, error: { errorMsg: "tsconfig option errors" } };
                 }
                 else if (parsedCommandLine.fileNames == null) {
-                    return { succeeded: false, error: { errorMsg: "no files found" } }
+                    return { succeeded: false, error: { errorMsg: "no files found" } };
                 }
                 else {
                     var projectOptions: ProjectOptions = {
@@ -1070,27 +1211,32 @@ namespace ts.server {
                 return error;
             }
             else {
-                let proj = this.createProject(configFilename, projectOptions);
-                for (let i = 0, len = projectOptions.files.length; i < len; i++) {
-                    let rootFilename = projectOptions.files[i];
+                let project = this.createProject(configFilename, projectOptions);
+                for (let rootFilename of projectOptions.files) {
                     if (this.host.fileExists(rootFilename)) {
                         let info = this.openFile(rootFilename, /*openedByClient*/ clientFileName == rootFilename);
-                        proj.addRoot(info);
+                        project.addRoot(info);
                     }
                     else {
                         return { errorMsg: "specified file " + rootFilename + " not found" };
                     }
                 }
-                proj.finishGraph();
-                proj.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(proj));
-                return { success: true, project: proj };
+                project.finishGraph();
+                project.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(project));
+                this.log("Add recursive watcher for: " + ts.getDirectoryPath(configFilename));
+                project.directoryWatcher = this.host.watchDirectory(
+                    ts.getDirectoryPath(configFilename),
+                    path => this.directoryWatchedForSourceFilesChanged(project, path),
+                    /*recursive*/ true
+                );
+                return { success: true, project: project };
             }
         }
 
         updateConfiguredProject(project: Project) {
             if (!this.host.fileExists(project.projectFilename)) {
                 this.log("Config file deleted");
-                this.removeConfiguredProject(project);
+                this.removeProject(project);
             }
             else {
                 let { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);
@@ -1105,7 +1251,9 @@ namespace ts.server {
 
                     for (let fileName of fileNamesToRemove) {
                         let info = this.getScriptInfo(fileName);
-                        project.removeRoot(info);
+                        if (info) {
+                            project.removeRoot(info);
+                        }
                     }
 
                     for (let fileName of fileNamesToAdd) {
@@ -1177,6 +1325,7 @@ namespace ts.server {
             TabSize: 4,
             NewLineCharacter: ts.sys ? ts.sys.newLine : '\n',
             ConvertTabsToSpaces: true,
+            IndentStyle: ts.IndentStyle.Smart,
             InsertSpaceAfterCommaDelimiter: true,
             InsertSpaceAfterSemicolonInForStatements: true,
             InsertSpaceBeforeAndAfterBinaryOperators: true,
@@ -1187,7 +1336,6 @@ namespace ts.server {
             PlaceOpenBraceOnNewLineForFunctions: false,
             PlaceOpenBraceOnNewLineForControlBlocks: false,
         }
-
     }
 
     export interface LineCollection {
@@ -1217,9 +1365,9 @@ namespace ts.server {
         goSubtree: boolean;
         done: boolean;
         leaf(relativeStart: number, relativeLength: number, lineCollection: LineLeaf): void;
-        pre? (relativeStart: number, relativeLength: number, lineCollection: LineCollection,
+        pre?(relativeStart: number, relativeLength: number, lineCollection: LineCollection,
             parent: LineNode, nodeType: CharRangeSection): LineCollection;
-        post? (relativeStart: number, relativeLength: number, lineCollection: LineCollection,
+        post?(relativeStart: number, relativeLength: number, lineCollection: LineCollection,
             parent: LineNode, nodeType: CharRangeSection): LineCollection;
     }
 
diff --git a/src/server/server.ts b/src/server/server.ts
index c3942b01a39..39864fc8477 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -11,7 +11,7 @@ namespace ts.server {
         input: process.stdin,
         output: process.stdout,
         terminal: false,
-    });
+    });  
 
     class Logger implements ts.server.Logger {
         fd = -1;
@@ -58,7 +58,7 @@ namespace ts.server {
         isVerbose() {
             return this.loggingEnabled() && (this.level == "verbose");
         }
-
+        
 
         msg(s: string, type = "Err") {
             if (this.fd < 0) {
@@ -83,95 +83,6 @@ namespace ts.server {
         }
     }
 
-    interface WatchedFile {
-        fileName: string;
-        callback: (fileName: string, removed: boolean) => void;
-        mtime: Date;
-    }
-
-    class WatchedFileSet {
-        private watchedFiles: WatchedFile[] = [];
-        private nextFileToCheck = 0;
-        private watchTimer: NodeJS.Timer;
-
-        // average async stat takes about 30 microseconds
-        // set chunk size to do 30 files in < 1 millisecond
-        constructor(public interval = 2500, public chunkSize = 30) {
-        }
-
-        private static copyListRemovingItem<T>(item: T, list: T[]) {
-            var copiedList: T[] = [];
-            for (var i = 0, len = list.length; i < len; i++) {
-                if (list[i] != item) {
-                    copiedList.push(list[i]);
-                }
-            }
-            return copiedList;
-        }
-
-        private static getModifiedTime(fileName: string): Date {
-            return fs.statSync(fileName).mtime;
-        }
-
-        private poll(checkedIndex: number) {
-            var watchedFile = this.watchedFiles[checkedIndex];
-            if (!watchedFile) {
-                return;
-            }
-
-            fs.stat(watchedFile.fileName,(err, stats) => {
-                if (err) {
-                    watchedFile.callback(watchedFile.fileName, /* removed */ false);
-                }
-                else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
-                    watchedFile.mtime = WatchedFileSet.getModifiedTime(watchedFile.fileName);
-                    watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0);
-                }
-            });
-        }
-
-        // this implementation uses polling and
-        // stat due to inconsistencies of fs.watch
-        // and efficiency of stat on modern filesystems
-        private startWatchTimer() {
-            this.watchTimer = setInterval(() => {
-                var count = 0;
-                var nextToCheck = this.nextFileToCheck;
-                var firstCheck = -1;
-                while ((count < this.chunkSize) && (nextToCheck !== firstCheck)) {
-                    this.poll(nextToCheck);
-                    if (firstCheck < 0) {
-                        firstCheck = nextToCheck;
-                    }
-                    nextToCheck++;
-                    if (nextToCheck === this.watchedFiles.length) {
-                        nextToCheck = 0;
-                    }
-                    count++;
-                }
-                this.nextFileToCheck = nextToCheck;
-            }, this.interval);
-        }
-
-        addFile(fileName: string, callback: (fileName: string, removed: boolean) => void ): WatchedFile {
-            var file: WatchedFile = {
-                fileName,
-                callback,
-                mtime: WatchedFileSet.getModifiedTime(fileName)
-            };
-
-            this.watchedFiles.push(file);
-            if (this.watchedFiles.length === 1) {
-                this.startWatchTimer();
-            }
-            return file;
-        }
-
-        removeFile(file: WatchedFile) {
-            this.watchedFiles = WatchedFileSet.copyListRemovingItem(file, this.watchedFiles);
-        }
-    }
-
     class IOSession extends Session {
         constructor(host: ServerHost, logger: ts.server.Logger) {
             super(host, Buffer.byteLength, process.hrtime, logger);
@@ -244,31 +155,10 @@ namespace ts.server {
 
     var logger = createLoggerFromEnv();
 
-    // REVIEW: for now this implementation uses polling.
-    // The advantage of polling is that it works reliably
-    // on all os and with network mounted files.
-    // For 90 referenced files, the average time to detect
-    // changes is 2*msInterval (by default 5 seconds).
-    // The overhead of this is .04 percent (1/2500) with
-    // average pause of < 1 millisecond (and max
-    // pause less than 1.5 milliseconds); question is
-    // do we anticipate reference sets in the 100s and
-    // do we care about waiting 10-20 seconds to detect
-    // changes for large reference sets? If so, do we want
-    // to increase the chunk size or decrease the interval
-    // time dynamically to match the large reference set?
-    var watchedFileSet = new WatchedFileSet();
-    ts.sys.watchFile = function (fileName, callback) {
-        var watchedFile = watchedFileSet.addFile(fileName, callback);
-        return {
-            close: () => watchedFileSet.removeFile(watchedFile)
-        }
-
-    };
     var ioSession = new IOSession(ts.sys, logger);
     process.on('uncaughtException', function(err: Error) {
         ioSession.logError(err, "unknown");
     });
     // Start listening
     ioSession.listen();
-}
+}
\ No newline at end of file
diff --git a/src/server/session.ts b/src/server/session.ts
index da044e7b4c6..550b551e51a 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -21,6 +21,21 @@ namespace ts.server {
         return spaceCache[n];
     }
 
+    export function generateIndentString(n: number, editorOptions: EditorOptions): string {
+        if (editorOptions.ConvertTabsToSpaces) {
+            return generateSpaces(n);
+        } else {
+            var result = "";
+            for (var i = 0; i < Math.floor(n / editorOptions.TabSize); i++) {
+                result += "\t";
+            }
+            for (var i = 0; i < n % editorOptions.TabSize; i++) {
+                result += " ";
+            }
+            return result;
+        }
+    }
+    
     interface FileStart {
         file: string;
         start: ILineInfo;
@@ -606,28 +621,27 @@ namespace ts.server {
                                 TabSize: formatOptions.TabSize,
                                 NewLineCharacter: "\n",
                                 ConvertTabsToSpaces: formatOptions.ConvertTabsToSpaces,
+                                IndentStyle: ts.IndentStyle.Smart,
                             };
-                            var indentPosition =
-                                compilerService.languageService.getIndentationAtPosition(file, position, editorOptions);
+                            var preferredIndent = compilerService.languageService.getIndentationAtPosition(file, position, editorOptions);
+                            var hasIndent = 0;
                             for (var i = 0, len = lineText.length; i < len; i++) {
                                 if (lineText.charAt(i) == " ") {
-                                    indentPosition--;
+                                    hasIndent++;
                                 }
                                 else if (lineText.charAt(i) == "\t") {
-                                    indentPosition -= editorOptions.IndentSize;
+                                    hasIndent += editorOptions.TabSize;
                                 }
                                 else {
                                     break;
                                 }
                             }
-                            if (indentPosition > 0) {
-                                var spaces = generateSpaces(indentPosition);
-                                edits.push({ span: ts.createTextSpanFromBounds(position, position), newText: spaces });
-                            }
-                            else if (indentPosition < 0) {
+                            // i points to the first non whitespace character
+                            if (preferredIndent !== hasIndent) {
+                                var firstNoWhiteSpacePosition = lineInfo.offset + i;
                                 edits.push({
-                                    span: ts.createTextSpanFromBounds(position, position - indentPosition),
-                                    newText: ""
+                                    span: ts.createTextSpanFromBounds(lineInfo.offset, firstNoWhiteSpacePosition),
+                                    newText: generateIndentString(preferredIndent, editorOptions)
                                 });
                             }
                         }
@@ -779,6 +793,7 @@ namespace ts.server {
         }
 
         private closeClientFile(fileName: string) {
+            if (!fileName) { return; }
             var file = ts.normalizePath(fileName);
             this.projectService.closeClientFile(file);
         }
diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts
index 02e785f6b3e..12efb774dd3 100644
--- a/src/services/formatting/rules.ts
+++ b/src/services/formatting/rules.ts
@@ -214,10 +214,13 @@ namespace ts.formatting {
         public SpaceBetweenYieldOrYieldStarAndOperand: Rule;
 
         // Async functions
+        public SpaceBetweenAsyncAndOpenParen: Rule;
         public SpaceBetweenAsyncAndFunctionKeyword: Rule;
 
-        // Tagged template string
+        // Template strings
         public SpaceBetweenTagAndTemplateString: Rule;
+        public NoSpaceAfterTemplateHeadAndMiddle: Rule;
+        public NoSpaceBeforeTemplateMiddleAndTail: Rule;
 
         constructor() {
             ///
@@ -367,10 +370,13 @@ namespace ts.formatting {
             this.SpaceBetweenYieldOrYieldStarAndOperand = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.YieldKeyword, SyntaxKind.AsteriskToken]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), RuleAction.Space));
 
             // Async-await
+            this.SpaceBetweenAsyncAndOpenParen = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsArrowFunctionContext, Rules.IsSameLineTokenContext), RuleAction.Space));
             this.SpaceBetweenAsyncAndFunctionKeyword = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.FunctionKeyword), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space));
 
             // template string
             this.SpaceBetweenTagAndTemplateString = new Rule(RuleDescriptor.create3(SyntaxKind.Identifier, Shared.TokenRange.FromTokens([SyntaxKind.NoSubstitutionTemplateLiteral, SyntaxKind.TemplateHead])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space));
+            this.NoSpaceAfterTemplateHeadAndMiddle = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete));
+            this.NoSpaceBeforeTemplateMiddleAndTail = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.TemplateMiddle, SyntaxKind.TemplateTail])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete));
 
             // These rules are higher in priority than user-configurable rules.
             this.HighPriorityCommonRules =
@@ -398,8 +404,8 @@ namespace ts.formatting {
                 this.NoSpaceBeforeOpenParenInFuncCall,
                 this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator,
                 this.SpaceAfterVoidOperator,
-                this.SpaceBetweenAsyncAndFunctionKeyword,
-                this.SpaceBetweenTagAndTemplateString,
+                this.SpaceBetweenAsyncAndOpenParen, this.SpaceBetweenAsyncAndFunctionKeyword,
+                this.SpaceBetweenTagAndTemplateString, this.NoSpaceAfterTemplateHeadAndMiddle, this.NoSpaceBeforeTemplateMiddleAndTail,
 
                 // TypeScript-specific rules
                 this.NoSpaceAfterConstructor, this.NoSpaceAfterModuleImport,
@@ -699,6 +705,10 @@ namespace ts.formatting {
             return context.currentTokenSpan.kind !== SyntaxKind.CommaToken;
         }
 
+        static IsArrowFunctionContext(context: FormattingContext): boolean {
+            return context.contextNode.kind === SyntaxKind.ArrowFunction;
+        }
+
         static IsSameLineTokenContext(context: FormattingContext): boolean {
             return context.TokensAreOnSameLine();
         }
diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts
index 8035c963cf3..3b68cd0ebb2 100644
--- a/src/services/formatting/smartIndenter.ts
+++ b/src/services/formatting/smartIndenter.ts
@@ -13,6 +13,12 @@ namespace ts.formatting {
                 return 0; // past EOF
             }
 
+            // no indentation when the indent style is set to none,
+            // so we can return fast
+            if (options.IndentStyle === IndentStyle.None) {
+                return 0;
+            }
+
             let precedingToken = findPrecedingToken(position, sourceFile);
             if (!precedingToken) {
                 return 0;
@@ -26,6 +32,26 @@ namespace ts.formatting {
 
             let lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
 
+            // indentation is first non-whitespace character in a previous line
+            // for block indentation, we should look for a line which contains something that's not
+            // whitespace.
+            if (options.IndentStyle === IndentStyle.Block) {
+
+                // move backwards until we find a line with a non-whitespace character,
+                // then find the first non-whitespace character for that line.
+                let current = position;
+                while (current > 0){
+                    let char = sourceFile.text.charCodeAt(current);
+                    if (!isWhiteSpace(char) && !isLineBreak(char)) {
+                        break;
+                    }
+                    current--;
+                }
+
+                let lineStart = ts.getLineStartPositionForPosition(current, sourceFile);
+                return SmartIndenter.findFirstNonWhitespaceColumn(lineStart, current, sourceFile, options);
+            }
+
             if (precedingToken.kind === SyntaxKind.CommaToken && precedingToken.parent.kind !== SyntaxKind.BinaryExpression) {
                 // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
                 let actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options);
@@ -218,7 +244,7 @@ namespace ts.formatting {
         function getStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter {
             return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
         }
-        
+
         export function childStartsOnTheSameLineWithElseInIfStatement(parent: Node, child: TextRangeWithKind, childStartLine: number, sourceFile: SourceFile): boolean {
             if (parent.kind === SyntaxKind.IfStatement && (<IfStatement>parent).elseStatement === child) {
                 let elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile);
@@ -319,7 +345,7 @@ namespace ts.formatting {
             }
 
             return Value.Unknown;
-            
+
             function getStartingExpression(node: PropertyAccessExpression | CallExpression | ElementAccessExpression) {
                 while (true) {
                     switch (node.kind) {
@@ -465,4 +491,4 @@ namespace ts.formatting {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/services/services.ts b/src/services/services.ts
index 82fa9de5203..15c6e3df56f 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -1189,6 +1189,13 @@ namespace ts {
         TabSize: number;
         NewLineCharacter: string;
         ConvertTabsToSpaces: boolean;
+        IndentStyle: IndentStyle;
+    }
+
+    export enum IndentStyle {
+        None = 0,
+        Block = 1,
+        Smart = 2,
     }
 
     export interface FormatCodeOptions extends EditorOptions {
@@ -1850,8 +1857,8 @@ namespace ts {
         // so pass --noResolve to avoid reporting missing file errors.
         options.noResolve = true;
 
-        // Parse
-        let inputFileName = transpileOptions.fileName || "module.ts";
+        // if jsx is specified then treat file as .tsx
+        let inputFileName = transpileOptions.fileName || (options.jsx ? "module.tsx" : "module.ts");
         let sourceFile = createSourceFile(inputFileName, input, options.target);
         if (transpileOptions.moduleName) {
             sourceFile.moduleName = transpileOptions.moduleName;
@@ -3105,6 +3112,7 @@ namespace ts {
             let node = currentToken;
             let isRightOfDot = false;
             let isRightOfOpenTag = false;
+            let isStartingCloseTag = false;
 
             let location = getTouchingPropertyName(sourceFile, position);
             if (contextToken) {
@@ -3130,9 +3138,14 @@ namespace ts {
                         return undefined;
                     }
                 }
-                else if (kind === SyntaxKind.LessThanToken && sourceFile.languageVariant === LanguageVariant.JSX) {
-                    isRightOfOpenTag = true;
-                    location = contextToken;
+                else if (sourceFile.languageVariant === LanguageVariant.JSX) {
+                    if (kind === SyntaxKind.LessThanToken) {
+                        isRightOfOpenTag = true;
+                        location = contextToken;
+                    }
+                    else if (kind === SyntaxKind.SlashToken && contextToken.parent.kind === SyntaxKind.JsxClosingElement) {
+                        isStartingCloseTag = true;
+                    }
                 }
             }
 
@@ -3155,6 +3168,13 @@ namespace ts {
                 isMemberCompletion = true;
                 isNewIdentifierLocation = false;
             }
+            else if (isStartingCloseTag) {
+                let tagName = (<JsxElement>contextToken.parent.parent).openingElement.tagName;
+                symbols = [typeChecker.getSymbolAtLocation(tagName)];
+
+                isMemberCompletion = true;
+                isNewIdentifierLocation = false;
+            }
             else {
                 // For JavaScript or TypeScript, if we're not after a dot, then just try to get the
                 // global symbols in scope.  These results should be valid for either language as
@@ -3311,11 +3331,29 @@ namespace ts {
                 let start = new Date().getTime();
                 let result = isInStringOrRegularExpressionOrTemplateLiteral(contextToken) ||
                     isSolelyIdentifierDefinitionLocation(contextToken) ||
-                    isDotOfNumericLiteral(contextToken);
+                    isDotOfNumericLiteral(contextToken) ||
+                    isInJsxText(contextToken);
                 log("getCompletionsAtPosition: isCompletionListBlocker: " + (new Date().getTime() - start));
                 return result;
             }
 
+            function isInJsxText(contextToken: Node): boolean {
+                if (contextToken.kind === SyntaxKind.JsxText) {
+                    return true;
+                }
+
+                if (contextToken.kind === SyntaxKind.GreaterThanToken && contextToken.parent) {
+                    if (contextToken.parent.kind === SyntaxKind.JsxOpeningElement) {
+                        return true;
+                    }
+
+                    if (contextToken.parent.kind === SyntaxKind.JsxClosingElement || contextToken.parent.kind === SyntaxKind.JsxSelfClosingElement) {
+                        return contextToken.parent.parent && contextToken.parent.parent.kind === SyntaxKind.JsxElement;
+                    }
+                }
+                return false;
+            }
+
             function isNewIdentifierDefinitionLocation(previousToken: Node): boolean {
                 if (previousToken) {
                     let containingNodeKind = previousToken.parent.kind;
@@ -3683,14 +3721,20 @@ namespace ts {
 
                 // Previous token may have been a keyword that was converted to an identifier.
                 switch (contextToken.getText()) {
+                    case "abstract":
+                    case "async":
                     case "class":
-                    case "interface":
+                    case "const":
+                    case "declare":
                     case "enum":
                     case "function":
-                    case "var":
-                    case "static":
+                    case "interface":
                     case "let":
-                    case "const":
+                    case "private":
+                    case "protected":
+                    case "public":
+                    case "static":
+                    case "var":
                     case "yield":
                         return true;
                 }
@@ -4099,8 +4143,9 @@ namespace ts {
                         let useConstructSignatures = callExpression.kind === SyntaxKind.NewExpression || callExpression.expression.kind === SyntaxKind.SuperKeyword;
                         let allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures();
 
-                        if (!contains(allSignatures, signature.target || signature)) {
-                            // Get the first signature if there
+                        if (!contains(allSignatures, signature.target) && !contains(allSignatures, signature)) {
+                            // Get the first signature if there is one -- allSignatures may contain
+                            // either the original signature or its target, so check for either
                             signature = allSignatures.length ? allSignatures[0] : undefined;
                         }
 
diff --git a/src/services/shims.ts b/src/services/shims.ts
index 351514a1499..e919625395d 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -990,7 +990,7 @@ namespace ts {
                 () => {
                     let text = sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength());
 
-                    let result = parseConfigFileText(fileName, text);
+                    let result = parseConfigFileTextToJson(fileName, text);
 
                     if (result.error) {
                         return {
@@ -1000,7 +1000,7 @@ namespace ts {
                         };
                     }
 
-                    var configFile = parseConfigFile(result.config, this.host, getDirectoryPath(normalizeSlashes(fileName)));
+                    var configFile = parseJsonConfigFileContent(result.config, this.host, getDirectoryPath(normalizeSlashes(fileName)));
 
                     return {
                         options: configFile.options,
diff --git a/tests/baselines/reference/2dArrays.symbols b/tests/baselines/reference/2dArrays.symbols
index c069f2dae8c..a42a40e2b6b 100644
--- a/tests/baselines/reference/2dArrays.symbols
+++ b/tests/baselines/reference/2dArrays.symbols
@@ -25,11 +25,11 @@ class Board {
 >allShipsSunk : Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
 
         return this.ships.every(function (val) { return val.isSunk; });
->this.ships.every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>this.ships.every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >this.ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
 >this : Symbol(Board, Decl(2dArrays.ts, 5, 1))
 >ships : Symbol(ships, Decl(2dArrays.ts, 7, 13))
->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
 >val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
 >val : Symbol(val, Decl(2dArrays.ts, 12, 42))
diff --git a/tests/baselines/reference/APISample_linter.js b/tests/baselines/reference/APISample_linter.js
index 4a467a60a84..aeff3a327f5 100644
--- a/tests/baselines/reference/APISample_linter.js
+++ b/tests/baselines/reference/APISample_linter.js
@@ -75,26 +75,26 @@ function delint(sourceFile) {
     delintNode(sourceFile);
     function delintNode(node) {
         switch (node.kind) {
-            case 197 /* ForStatement */:
-            case 198 /* ForInStatement */:
-            case 196 /* WhileStatement */:
-            case 195 /* DoStatement */:
-                if (node.statement.kind !== 190 /* Block */) {
+            case 199 /* ForStatement */:
+            case 200 /* ForInStatement */:
+            case 198 /* WhileStatement */:
+            case 197 /* DoStatement */:
+                if (node.statement.kind !== 192 /* Block */) {
                     report(node, "A looping statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 194 /* IfStatement */:
+            case 196 /* IfStatement */:
                 var ifStatement = node;
-                if (ifStatement.thenStatement.kind !== 190 /* Block */) {
+                if (ifStatement.thenStatement.kind !== 192 /* Block */) {
                     report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
                 }
                 if (ifStatement.elseStatement &&
-                    ifStatement.elseStatement.kind !== 190 /* Block */ &&
-                    ifStatement.elseStatement.kind !== 194 /* IfStatement */) {
+                    ifStatement.elseStatement.kind !== 192 /* Block */ &&
+                    ifStatement.elseStatement.kind !== 196 /* IfStatement */) {
                     report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 179 /* BinaryExpression */:
+            case 181 /* BinaryExpression */:
                 var op = node.operatorToken.kind;
                 if (op === 30 /* EqualsEqualsToken */ || op == 31 /* ExclamationEqualsToken */) {
                     report(node, "Use '===' and '!=='.");
diff --git a/tests/baselines/reference/ES5SymbolType1.symbols b/tests/baselines/reference/ES5SymbolType1.symbols
index ea6c9084046..be316276f52 100644
--- a/tests/baselines/reference/ES5SymbolType1.symbols
+++ b/tests/baselines/reference/ES5SymbolType1.symbols
@@ -3,7 +3,7 @@ var s: symbol;
 >s : Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
 
 s.toString();
->s.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>s.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols b/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols
index f56b2f526d4..90f2701b534 100644
--- a/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols
+++ b/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols
@@ -11,11 +11,11 @@ module A {
 
     export var beez: Array<B>;
 >beez : Symbol(beez, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 5, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >B : Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))
 
     export var beez2 = new Array<B>();
 >beez2 : Symbol(beez2, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 6, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >B : Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))
 }
diff --git a/tests/baselines/reference/TypeGuardWithArrayUnion.symbols b/tests/baselines/reference/TypeGuardWithArrayUnion.symbols
index 57bcdf70e79..2ff91774b83 100644
--- a/tests/baselines/reference/TypeGuardWithArrayUnion.symbols
+++ b/tests/baselines/reference/TypeGuardWithArrayUnion.symbols
@@ -14,12 +14,12 @@ function saySize(message: Message | Message[]) {
 
     if (message instanceof Array) {
 >message : Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         return message.length;  // Should have type Message[] here
->message.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>message.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >message : Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
index eff45630aae..bada6c561f1 100644
--- a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
+++ b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols
@@ -35,7 +35,7 @@ var d: string;
 
 var e: Object;
 >e : Symbol(e, Decl(additionOperatorWithAnyAndEveryType.ts, 12, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // any as left operand, result is type Any except plusing string
 var r1 = a + a;
diff --git a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
index 0fb0f428716..68fac31d4f8 100644
--- a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
+++ b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols
@@ -19,7 +19,7 @@ var d: string;
 
 var e: Object;
 >e : Symbol(e, Decl(additionOperatorWithStringAndEveryType.ts, 6, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f: void;
 >f : Symbol(f, Decl(additionOperatorWithStringAndEveryType.ts, 7, 3))
diff --git a/tests/baselines/reference/anyAssignabilityInInheritance.symbols b/tests/baselines/reference/anyAssignabilityInInheritance.symbols
index 0f659dddd21..50148d7df99 100644
--- a/tests/baselines/reference/anyAssignabilityInInheritance.symbols
+++ b/tests/baselines/reference/anyAssignabilityInInheritance.symbols
@@ -56,8 +56,8 @@ var r3 = foo3(a); // any
 declare function foo5(x: Date): Date;
 >foo5 : Symbol(foo5, Decl(anyAssignabilityInInheritance.ts, 19, 17), Decl(anyAssignabilityInInheritance.ts, 21, 37))
 >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 21, 22))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function foo5(x: any): any;
 >foo5 : Symbol(foo5, Decl(anyAssignabilityInInheritance.ts, 19, 17), Decl(anyAssignabilityInInheritance.ts, 21, 37))
@@ -71,8 +71,8 @@ var r3 = foo3(a); // any
 declare function foo6(x: RegExp): RegExp;
 >foo6 : Symbol(foo6, Decl(anyAssignabilityInInheritance.ts, 23, 17), Decl(anyAssignabilityInInheritance.ts, 25, 41))
 >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 25, 22))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function foo6(x: any): any;
 >foo6 : Symbol(foo6, Decl(anyAssignabilityInInheritance.ts, 23, 17), Decl(anyAssignabilityInInheritance.ts, 25, 41))
@@ -277,8 +277,8 @@ var r3 = foo3(a); // any
 declare function foo17(x: Object): Object;
 >foo17 : Symbol(foo17, Decl(anyAssignabilityInInheritance.ts, 79, 17), Decl(anyAssignabilityInInheritance.ts, 81, 42))
 >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 81, 23))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function foo17(x: any): any;
 >foo17 : Symbol(foo17, Decl(anyAssignabilityInInheritance.ts, 79, 17), Decl(anyAssignabilityInInheritance.ts, 81, 42))
diff --git a/tests/baselines/reference/anyAssignableToEveryType.symbols b/tests/baselines/reference/anyAssignableToEveryType.symbols
index 19dc94c7a43..b1b2f87c050 100644
--- a/tests/baselines/reference/anyAssignableToEveryType.symbols
+++ b/tests/baselines/reference/anyAssignableToEveryType.symbols
@@ -44,7 +44,7 @@ var d: boolean = a;
 
 var e: Date = a;
 >e : Symbol(e, Decl(anyAssignableToEveryType.ts, 17, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3))
 
 var f: any = a;
@@ -57,7 +57,7 @@ var g: void = a;
 
 var h: Object = a;
 >h : Symbol(h, Decl(anyAssignableToEveryType.ts, 20, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3))
 
 var i: {} = a;
@@ -70,7 +70,7 @@ var j: () => {} = a;
 
 var k: Function = a;
 >k : Symbol(k, Decl(anyAssignableToEveryType.ts, 23, 3))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3))
 
 var l: (x: number) => string = a;
@@ -109,12 +109,12 @@ var o: <T>(x: T) => T = a;
 
 var p: Number = a;
 >p : Symbol(p, Decl(anyAssignableToEveryType.ts, 31, 3))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3))
 
 var q: String = a;
 >q : Symbol(q, Decl(anyAssignableToEveryType.ts, 32, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3))
 
 function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
@@ -122,7 +122,7 @@ function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
 >T : Symbol(T, Decl(anyAssignableToEveryType.ts, 34, 13))
 >U : Symbol(U, Decl(anyAssignableToEveryType.ts, 34, 15))
 >V : Symbol(V, Decl(anyAssignableToEveryType.ts, 34, 32))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(anyAssignableToEveryType.ts, 34, 49))
 >T : Symbol(T, Decl(anyAssignableToEveryType.ts, 34, 13))
 >y : Symbol(y, Decl(anyAssignableToEveryType.ts, 34, 54))
diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
index daf7947e694..c1b5df88fb0 100644
--- a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
+++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols
@@ -3,9 +3,9 @@ var paired: any[];
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
 
 paired.reduce(function (a1, a2) {
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24))
 >a2 : Symbol(a2, Decl(anyInferenceAnonymousFunctions.ts, 2, 27))
 
@@ -15,9 +15,9 @@ paired.reduce(function (a1, a2) {
 } , []);
 
 paired.reduce((b1, b2) => {
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15))
 >b2 : Symbol(b2, Decl(anyInferenceAnonymousFunctions.ts, 8, 18))
 
@@ -27,24 +27,24 @@ paired.reduce((b1, b2) => {
 } , []);
 
 paired.reduce((b3, b4) => b3.concat({}), []);
->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 >b4 : Symbol(b4, Decl(anyInferenceAnonymousFunctions.ts, 13, 18))
 >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15))
 
 paired.map((c1) => c1.count);
->paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12))
 
 paired.map(function (c2) { return c2.count; });
->paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21))
 
diff --git a/tests/baselines/reference/argsInScope.symbols b/tests/baselines/reference/argsInScope.symbols
index 7ea039819aa..6faf88facd9 100644
--- a/tests/baselines/reference/argsInScope.symbols
+++ b/tests/baselines/reference/argsInScope.symbols
@@ -11,9 +11,9 @@ class C {
        for (var i = 0; i < arguments.length; i++) {
 >i : Symbol(i, Decl(argsInScope.ts, 2, 15))
 >i : Symbol(i, Decl(argsInScope.ts, 2, 15))
->arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25))
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(argsInScope.ts, 2, 15))
 
            // WScript.Echo("param: " + arguments[i]);
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
index b4351e579f5..d2d05cf3132 100644
--- a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
+++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
@@ -14,9 +14,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
 >arguments : Symbol(arguments)
 
         result.push(arg + arg);
->result.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>result.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12))
 >arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12))
     }
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
index 2c5e611de68..7a4e75de66b 100644
--- a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
@@ -9,9 +9,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
     let blah = arguments[Symbol.iterator];
 >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7))
 >arguments : Symbol(arguments)
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
     let result = [];
 >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7))
@@ -21,9 +21,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
 >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7))
 
         result.push(arg + arg);
->result.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>result.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12))
 >arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12))
     }
diff --git a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
index 1c3b54ef427..813f9e2f424 100644
--- a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
+++ b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols
@@ -10,9 +10,9 @@ class A {
         return {
             selectedValue: arguments.length
 >selectedValue : Symbol(selectedValue, Decl(argumentsUsedInObjectLiteralProperty.ts, 2, 16))
->arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
->length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25))
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 
         };
     }
diff --git a/tests/baselines/reference/arrayAugment.symbols b/tests/baselines/reference/arrayAugment.symbols
index 8310729032f..90a506077ad 100644
--- a/tests/baselines/reference/arrayAugment.symbols
+++ b/tests/baselines/reference/arrayAugment.symbols
@@ -1,12 +1,12 @@
 === tests/cases/compiler/arrayAugment.ts ===
 interface Array<T> {
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(arrayAugment.ts, 0, 0))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(arrayAugment.ts, 0, 16))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 16))
 
     split: (parts: number) => T[][];
 >split : Symbol(split, Decl(arrayAugment.ts, 0, 20))
 >parts : Symbol(parts, Decl(arrayAugment.ts, 1, 12))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(arrayAugment.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 16))
 }
 
 var x = [''];
diff --git a/tests/baselines/reference/arrayConcat2.symbols b/tests/baselines/reference/arrayConcat2.symbols
index 8c0af7be702..daedee6e9c8 100644
--- a/tests/baselines/reference/arrayConcat2.symbols
+++ b/tests/baselines/reference/arrayConcat2.symbols
@@ -3,21 +3,21 @@ var a: string[] = [];
 >a : Symbol(a, Decl(arrayConcat2.ts, 0, 3))
 
 a.concat("hello", 'world');
->a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>a.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(arrayConcat2.ts, 0, 3))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 a.concat('Hello');
->a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>a.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(arrayConcat2.ts, 0, 3))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b = new Array<string>();
 >b : Symbol(b, Decl(arrayConcat2.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 b.concat('hello');
->b.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>b.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(arrayConcat2.ts, 5, 3))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/arrayConcatMap.symbols b/tests/baselines/reference/arrayConcatMap.symbols
index 1ff4bc3bff5..5ef9d811723 100644
--- a/tests/baselines/reference/arrayConcatMap.symbols
+++ b/tests/baselines/reference/arrayConcatMap.symbols
@@ -1,14 +1,14 @@
 === tests/cases/compiler/arrayConcatMap.ts ===
 var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >x : Symbol(x, Decl(arrayConcatMap.ts, 0, 3))
->[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->[].concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>[].concat([{ a: 1 }], [{ a: 2 }])          .map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>[].concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 20))
 >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 32))
 
           .map(b => b.a);
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15))
 
diff --git a/tests/baselines/reference/arrayConstructors1.symbols b/tests/baselines/reference/arrayConstructors1.symbols
index cab2b0dc68a..1c69de79e00 100644
--- a/tests/baselines/reference/arrayConstructors1.symbols
+++ b/tests/baselines/reference/arrayConstructors1.symbols
@@ -4,28 +4,28 @@ var x: string[];
 
 x = new Array(1);
 >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 x = new Array('hi', 'bye'); 
 >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 x = new Array<string>('hi', 'bye');
 >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var y: number[];
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
 
 y = new Array(1);
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 y = new Array(1,2);
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 y = new Array<number>(1, 2);
 >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/arrayLiteral.symbols b/tests/baselines/reference/arrayLiteral.symbols
index 77673863b64..17c8ed019b5 100644
--- a/tests/baselines/reference/arrayLiteral.symbols
+++ b/tests/baselines/reference/arrayLiteral.symbols
@@ -6,7 +6,7 @@ var x = [];
 
 var x = new Array(1);
 >x : Symbol(x, Decl(arrayLiteral.ts, 2, 3), Decl(arrayLiteral.ts, 3, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var y = [1];
 >y : Symbol(y, Decl(arrayLiteral.ts, 5, 3), Decl(arrayLiteral.ts, 6, 3), Decl(arrayLiteral.ts, 7, 3))
@@ -16,14 +16,14 @@ var y = [1, 2];
 
 var y = new Array<number>();
 >y : Symbol(y, Decl(arrayLiteral.ts, 5, 3), Decl(arrayLiteral.ts, 6, 3), Decl(arrayLiteral.ts, 7, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var x2: number[] = [];
 >x2 : Symbol(x2, Decl(arrayLiteral.ts, 9, 3), Decl(arrayLiteral.ts, 10, 3))
 
 var x2: number[] = new Array(1);
 >x2 : Symbol(x2, Decl(arrayLiteral.ts, 9, 3), Decl(arrayLiteral.ts, 10, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var y2: number[] = [1];
 >y2 : Symbol(y2, Decl(arrayLiteral.ts, 12, 3), Decl(arrayLiteral.ts, 13, 3), Decl(arrayLiteral.ts, 14, 3))
@@ -33,5 +33,5 @@ var y2: number[] = [1, 2];
 
 var y2: number[] = new Array<number>();
 >y2 : Symbol(y2, Decl(arrayLiteral.ts, 12, 3), Decl(arrayLiteral.ts, 13, 3), Decl(arrayLiteral.ts, 14, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
index 071596c9af1..1d47bf26493 100644
--- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
+++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols
@@ -35,14 +35,14 @@ var cs = [a, b, c]; // { x: number; y?: number };[]
 var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
 >ds : Symbol(ds, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 3))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 11))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 29))
 
 var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
 >es : Symbol(es, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 3))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 11))
 >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 29))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2]; // (a: { x: number; y?: number }) => number[]
 >fs : Symbol(fs, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 3))
diff --git a/tests/baselines/reference/arrayLiterals2ES5.symbols b/tests/baselines/reference/arrayLiterals2ES5.symbols
index c69b79de272..4db8372a601 100644
--- a/tests/baselines/reference/arrayLiterals2ES5.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES5.symbols
@@ -80,14 +80,14 @@ var temp4 = [];
 
 interface myArray extends Array<Number> { }
 >myArray : Symbol(myArray, Decl(arrayLiterals2ES5.ts, 42, 15))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES5.ts, 44, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var d0 = [1, true, ...temp,];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES5.ts, 46, 3))
diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols
index 75202d69690..0c7dc1495df 100644
--- a/tests/baselines/reference/arrayLiterals2ES6.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES6.symbols
@@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 
 interface myArray extends Array<Number> { }
 >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3))
diff --git a/tests/baselines/reference/arrayconcat.symbols b/tests/baselines/reference/arrayconcat.symbols
index 64e63d7c2ec..4fee1860be6 100644
--- a/tests/baselines/reference/arrayconcat.symbols
+++ b/tests/baselines/reference/arrayconcat.symbols
@@ -39,29 +39,29 @@ class parser {
 >this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
 >options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
->this.options.sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
+>this.options.sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
 >this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
 >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1))
 >options : Symbol(options, Decl(arrayconcat.ts, 10, 14))
->sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
+>sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(arrayconcat.ts, 14, 44))
 >b : Symbol(b, Decl(arrayconcat.ts, 14, 46))
 
             var aName = a.name.toLowerCase();
 >aName : Symbol(aName, Decl(arrayconcat.ts, 15, 15))
->a.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>a.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >a.name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20))
 >a : Symbol(a, Decl(arrayconcat.ts, 14, 44))
 >name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
             var bName = b.name.toLowerCase();
 >bName : Symbol(bName, Decl(arrayconcat.ts, 16, 15))
->b.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>b.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >b.name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20))
 >b : Symbol(b, Decl(arrayconcat.ts, 14, 46))
 >name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
             if (aName > bName) {
 >aName : Symbol(aName, Decl(arrayconcat.ts, 15, 15))
diff --git a/tests/baselines/reference/arrowFunctionExpressions.symbols b/tests/baselines/reference/arrowFunctionExpressions.symbols
index 61c575933da..853c5074580 100644
--- a/tests/baselines/reference/arrowFunctionExpressions.symbols
+++ b/tests/baselines/reference/arrowFunctionExpressions.symbols
@@ -3,16 +3,16 @@
 var a = (p: string) => p.length;
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9))
->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
 var a = (p: string) => { return p.length; }
 >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9))
->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
 // Identifier => Block is equivalent to(Identifier) => Block
 var b = j => { return 0; }
@@ -147,9 +147,9 @@ function someFn() {
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 45, 15))
 
     arr(3)(4).toExponential();
->arr(3)(4).toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>arr(3)(4).toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 45, 7))
->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 }
 
 // Arrow function used in function
@@ -162,9 +162,9 @@ function someOtherFn() {
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 51, 15))
 
     arr(4).charAt(0);
->arr(4).charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>arr(4).charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 51, 7))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 }
 
 // Arrow function used in nested function in function
@@ -222,9 +222,9 @@ function someOuterFn() {
 >innerFn : Symbol(innerFn, Decl(arrowFunctionExpressions.ts, 77, 30))
 
             return () => n.length;
->n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>n.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 77, 15))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
         }
         return innerFn;
 >innerFn : Symbol(innerFn, Decl(arrowFunctionExpressions.ts, 77, 30))
@@ -237,9 +237,9 @@ var h = someOuterFn()('')()();
 >someOuterFn : Symbol(someOuterFn, Decl(arrowFunctionExpressions.ts, 72, 14))
 
 h.toExponential();
->h.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>h.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >h : Symbol(h, Decl(arrowFunctionExpressions.ts, 85, 3))
->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 
 // Arrow function used in try/catch/finally in function
 function tryCatchFn() {
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
index c1d1cf40d90..aa2f19c1f60 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols
@@ -1,13 +1,13 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody5.ts ===
 var a = () => <Error>{ name: "foo", message: "bar" };      
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 3))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 22))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 35))
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 3))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 23))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 36))
 
@@ -18,7 +18,7 @@ var c = () => ({ name: "foo", message: "bar" });
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 3))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 25))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 38))
 
diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
index 80530cde016..141b0d49880 100644
--- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
+++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols
@@ -1,13 +1,13 @@
 === tests/cases/compiler/arrowFunctionWithObjectLiteralBody6.ts ===
 var a = () => <Error>{ name: "foo", message: "bar" };      
 >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 3))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 22))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 35))
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 3))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 23))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 36))
 
@@ -18,7 +18,7 @@ var c = () => ({ name: "foo", message: "bar" });
 
 var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 3))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 25))
 >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 38))
 
diff --git a/tests/baselines/reference/asOperator1.symbols b/tests/baselines/reference/asOperator1.symbols
index 27353ec7b30..343d3422b5c 100644
--- a/tests/baselines/reference/asOperator1.symbols
+++ b/tests/baselines/reference/asOperator1.symbols
@@ -8,12 +8,12 @@ var x = undefined as number;
 
 var y = (null as string).length;
 >y : Symbol(y, Decl(asOperator1.ts, 2, 3))
->(null as string).length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>(null as string).length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
 var z = Date as any as string;
 >z : Symbol(z, Decl(asOperator1.ts, 3, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 // Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string'
 var j = 32 as number|string;
diff --git a/tests/baselines/reference/asiAbstract.errors.txt b/tests/baselines/reference/asiAbstract.errors.txt
new file mode 100644
index 00000000000..3cc8999a2f2
--- /dev/null
+++ b/tests/baselines/reference/asiAbstract.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/compiler/asiAbstract.ts(1,1): error TS2304: Cannot find name 'abstract'.
+tests/cases/compiler/asiAbstract.ts(3,3): error TS1244: Abstract methods can only appear within an abstract class.
+
+
+==== tests/cases/compiler/asiAbstract.ts (2 errors) ====
+    abstract
+    ~~~~~~~~
+!!! error TS2304: Cannot find name 'abstract'.
+    class NonAbstractClass {
+      abstract s();
+      ~~~~~~~~
+!!! error TS1244: Abstract methods can only appear within an abstract class.
+    }
+    
+    class C2 {
+        abstract
+        nonAbstractFunction() {
+        }
+    }
+    
+    class C3 {
+        abstract
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asiAbstract.js b/tests/baselines/reference/asiAbstract.js
new file mode 100644
index 00000000000..8d5b412d022
--- /dev/null
+++ b/tests/baselines/reference/asiAbstract.js
@@ -0,0 +1,36 @@
+//// [asiAbstract.ts]
+abstract
+class NonAbstractClass {
+  abstract s();
+}
+
+class C2 {
+    abstract
+    nonAbstractFunction() {
+    }
+}
+
+class C3 {
+    abstract
+}
+
+
+//// [asiAbstract.js]
+abstract;
+var NonAbstractClass = (function () {
+    function NonAbstractClass() {
+    }
+    return NonAbstractClass;
+})();
+var C2 = (function () {
+    function C2() {
+    }
+    C2.prototype.nonAbstractFunction = function () {
+    };
+    return C2;
+})();
+var C3 = (function () {
+    function C3() {
+    }
+    return C3;
+})();
diff --git a/tests/baselines/reference/asiPublicPrivateProtected.errors.txt b/tests/baselines/reference/asiPublicPrivateProtected.errors.txt
new file mode 100644
index 00000000000..96d243536fb
--- /dev/null
+++ b/tests/baselines/reference/asiPublicPrivateProtected.errors.txt
@@ -0,0 +1,52 @@
+tests/cases/compiler/asiPublicPrivateProtected.ts(1,1): error TS2304: Cannot find name 'public'.
+tests/cases/compiler/asiPublicPrivateProtected.ts(12,1): error TS2304: Cannot find name 'private'.
+tests/cases/compiler/asiPublicPrivateProtected.ts(23,1): error TS2304: Cannot find name 'protected'.
+
+
+==== tests/cases/compiler/asiPublicPrivateProtected.ts (3 errors) ====
+    public
+    ~~~~~~
+!!! error TS2304: Cannot find name 'public'.
+    class NonPublicClass {
+        public s() {
+        }
+    }
+    
+    class NonPublicClass2 {
+        public
+        private nonPublicFunction() {
+        }
+    }
+    private
+    ~~~~~~~
+!!! error TS2304: Cannot find name 'private'.
+    class NonPrivateClass {
+        private s() {
+        }
+    }
+    
+    class NonPrivateClass2 {
+        private
+        public nonPrivateFunction() {
+        }
+    }
+    protected
+    ~~~~~~~~~
+!!! error TS2304: Cannot find name 'protected'.
+    class NonProtectedClass {
+      protected s() {
+      }
+    }
+    
+    class NonProtectedClass2 {
+        protected
+        public nonProtectedFunction() {
+        }
+    }
+    
+    class ClassWithThreeMembers {
+        public
+        private
+        protected
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asiPublicPrivateProtected.js b/tests/baselines/reference/asiPublicPrivateProtected.js
new file mode 100644
index 00000000000..a17bcb7509a
--- /dev/null
+++ b/tests/baselines/reference/asiPublicPrivateProtected.js
@@ -0,0 +1,93 @@
+//// [asiPublicPrivateProtected.ts]
+public
+class NonPublicClass {
+    public s() {
+    }
+}
+
+class NonPublicClass2 {
+    public
+    private nonPublicFunction() {
+    }
+}
+private
+class NonPrivateClass {
+    private s() {
+    }
+}
+
+class NonPrivateClass2 {
+    private
+    public nonPrivateFunction() {
+    }
+}
+protected
+class NonProtectedClass {
+  protected s() {
+  }
+}
+
+class NonProtectedClass2 {
+    protected
+    public nonProtectedFunction() {
+    }
+}
+
+class ClassWithThreeMembers {
+    public
+    private
+    protected
+}
+
+
+//// [asiPublicPrivateProtected.js]
+public;
+var NonPublicClass = (function () {
+    function NonPublicClass() {
+    }
+    NonPublicClass.prototype.s = function () {
+    };
+    return NonPublicClass;
+})();
+var NonPublicClass2 = (function () {
+    function NonPublicClass2() {
+    }
+    NonPublicClass2.prototype.nonPublicFunction = function () {
+    };
+    return NonPublicClass2;
+})();
+private;
+var NonPrivateClass = (function () {
+    function NonPrivateClass() {
+    }
+    NonPrivateClass.prototype.s = function () {
+    };
+    return NonPrivateClass;
+})();
+var NonPrivateClass2 = (function () {
+    function NonPrivateClass2() {
+    }
+    NonPrivateClass2.prototype.nonPrivateFunction = function () {
+    };
+    return NonPrivateClass2;
+})();
+protected;
+var NonProtectedClass = (function () {
+    function NonProtectedClass() {
+    }
+    NonProtectedClass.prototype.s = function () {
+    };
+    return NonProtectedClass;
+})();
+var NonProtectedClass2 = (function () {
+    function NonProtectedClass2() {
+    }
+    NonProtectedClass2.prototype.nonProtectedFunction = function () {
+    };
+    return NonProtectedClass2;
+})();
+var ClassWithThreeMembers = (function () {
+    function ClassWithThreeMembers() {
+    }
+    return ClassWithThreeMembers;
+})();
diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols b/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols
index 8218de9be79..ea9440cf1a9 100644
--- a/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols
+++ b/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols
@@ -106,23 +106,23 @@ var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(assignmentCompatWithCallSignatures3.ts, 18, 3))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 18, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 18, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures3.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 
 var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(assignmentCompatWithCallSignatures3.ts, 19, 3))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 19, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 19, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 
 var a14: (x: { a: string; b: number }) => Object;
@@ -130,7 +130,7 @@ var a14: (x: { a: string; b: number }) => Object;
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 20, 10))
 >a : Symbol(a, Decl(assignmentCompatWithCallSignatures3.ts, 20, 14))
 >b : Symbol(b, Decl(assignmentCompatWithCallSignatures3.ts, 20, 25))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var a15: {
 >a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures3.ts, 21, 3))
@@ -189,8 +189,8 @@ var a18: {
 
         (a: Date): Date;
 >a : Symbol(a, Decl(assignmentCompatWithCallSignatures3.ts, 40, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }
@@ -407,14 +407,14 @@ b11 = a11; // ok
 var b12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
 >b12 : Symbol(b12, Decl(assignmentCompatWithCallSignatures3.ts, 77, 3))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 77, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 77, 33))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 77, 48))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 77, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 
 a12 = b12; // ok
@@ -428,10 +428,10 @@ b12 = a12; // ok
 var b13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
 >b13 : Symbol(b13, Decl(assignmentCompatWithCallSignatures3.ts, 80, 3))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 80, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27))
 >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 80, 36))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 80, 51))
 >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 80, 10))
diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols b/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols
index ef02b7a08d3..4ef01deaea8 100644
--- a/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols
+++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols
@@ -106,23 +106,23 @@ var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(assignmentCompatWithConstructSignatures3.ts, 18, 3))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 18, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 18, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures3.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27))
 
 var a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(assignmentCompatWithConstructSignatures3.ts, 19, 3))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 19, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 19, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27))
 
 var a14: new (x: { a: string; b: number }) => Object;
@@ -130,7 +130,7 @@ var a14: new (x: { a: string; b: number }) => Object;
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 20, 14))
 >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures3.ts, 20, 18))
 >b : Symbol(b, Decl(assignmentCompatWithConstructSignatures3.ts, 20, 29))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var a15: {
 >a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures3.ts, 21, 3))
@@ -189,8 +189,8 @@ var a18: {
 
         new (a: Date): Date;
 >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures3.ts, 40, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }
@@ -407,14 +407,14 @@ b11 = a11; // ok
 var b12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
 >b12 : Symbol(b12, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 3))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 37))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 52))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27))
 
 a12 = b12; // ok
@@ -428,10 +428,10 @@ b12 = a12; // ok
 var b13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
 >b13 : Symbol(b13, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 3))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27))
 >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 40))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0))
 >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 55))
 >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 14))
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
index 349a51c43ba..a8a5aef325a 100644
--- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
@@ -2,6 +2,6 @@
 
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 };
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols
index 5f820eec862..2f516d7d758 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols
@@ -10,9 +10,9 @@ class C {
 
       var fn = async () => await other.apply(this, arguments);      
 >fn : Symbol(fn, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 3, 9))
->other.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>other.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >other : Symbol(other, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 1, 13))
->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >this : Symbol(C, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 0, 0))
 >arguments : Symbol(arguments)
    }
diff --git a/tests/baselines/reference/asyncAwait_es6.symbols b/tests/baselines/reference/asyncAwait_es6.symbols
index 2eb28e12211..3c668b15b36 100644
--- a/tests/baselines/reference/asyncAwait_es6.symbols
+++ b/tests/baselines/reference/asyncAwait_es6.symbols
@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es6.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es6.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es6.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es6.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwait_es6.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es6.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es6.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37))
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
index b970dbbf888..f1946aa712f 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
index d17f4bf899e..34623ded262 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
   return;
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt
new file mode 100644
index 00000000000..8c029eaaaf4
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt
@@ -0,0 +1,56 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,16): error TS1055: Type '{}' is not a valid async function return type.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(7,16): error TS1055: Type 'any' is not a valid async function return type.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,16): error TS1055: Type 'number' is not a valid async function return type.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,16): error TS1055: Type 'PromiseLike<void>' is not a valid async function return type.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(10,16): error TS1055: Type 'typeof Thenable' is not a valid async function return type.
+  Type 'Thenable' is not assignable to type 'PromiseLike<any>'.
+    Types of property 'then' are incompatible.
+      Type '() => void' is not assignable to type '{ <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>; <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>; }'.
+        Type 'void' is not assignable to type 'PromiseLike<any>'.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(17,16): error TS1059: Return expression in async function does not have a valid callable 'then' member.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(23,25): error TS1058: Operand for 'await' does not have a valid callable 'then' member.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts (7 errors) ====
+    declare class Thenable { then(): void; }
+    declare let a: any;
+    declare let obj: { then: string; };
+    declare let thenable: Thenable;
+    async function fn1() { } // valid: Promise<void>
+    async function fn2(): { } { } // error
+                   ~~~
+!!! error TS1055: Type '{}' is not a valid async function return type.
+    async function fn3(): any { } // error
+                   ~~~
+!!! error TS1055: Type 'any' is not a valid async function return type.
+    async function fn4(): number { } // error
+                   ~~~
+!!! error TS1055: Type 'number' is not a valid async function return type.
+    async function fn5(): PromiseLike<void> { } // error
+                   ~~~
+!!! error TS1055: Type 'PromiseLike<void>' is not a valid async function return type.
+    async function fn6(): Thenable { } // error
+                   ~~~
+!!! error TS1055: Type 'typeof Thenable' is not a valid async function return type.
+!!! error TS1055:   Type 'Thenable' is not assignable to type 'PromiseLike<any>'.
+!!! error TS1055:     Types of property 'then' are incompatible.
+!!! error TS1055:       Type '() => void' is not assignable to type '{ <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>; <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>; }'.
+!!! error TS1055:         Type 'void' is not assignable to type 'PromiseLike<any>'.
+    async function fn7() { return; } // valid: Promise<void>
+    async function fn8() { return 1; } // valid: Promise<number>
+    async function fn9() { return null; } // valid: Promise<any>
+    async function fn10() { return undefined; } // valid: Promise<any>
+    async function fn11() { return a; } // valid: Promise<any>
+    async function fn12() { return obj; } // valid: Promise<{ then: string; }>
+    async function fn13() { return thenable; } // error
+                   ~~~~
+!!! error TS1059: Return expression in async function does not have a valid callable 'then' member.
+    async function fn14() { await 1; } // valid: Promise<void>
+    async function fn15() { await null; } // valid: Promise<void>
+    async function fn16() { await undefined; } // valid: Promise<void>
+    async function fn17() { await a; } // valid: Promise<void>
+    async function fn18() { await obj; } // valid: Promise<void>
+    async function fn19() { await thenable; } // error
+                            ~~~~~~~~~~~~~~
+!!! error TS1058: Operand for 'await' does not have a valid callable 'then' member.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.js b/tests/baselines/reference/asyncFunctionDeclaration15_es6.js
new file mode 100644
index 00000000000..c72062e24b2
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.js
@@ -0,0 +1,84 @@
+//// [asyncFunctionDeclaration15_es6.ts]
+declare class Thenable { then(): void; }
+declare let a: any;
+declare let obj: { then: string; };
+declare let thenable: Thenable;
+async function fn1() { } // valid: Promise<void>
+async function fn2(): { } { } // error
+async function fn3(): any { } // error
+async function fn4(): number { } // error
+async function fn5(): PromiseLike<void> { } // error
+async function fn6(): Thenable { } // error
+async function fn7() { return; } // valid: Promise<void>
+async function fn8() { return 1; } // valid: Promise<number>
+async function fn9() { return null; } // valid: Promise<any>
+async function fn10() { return undefined; } // valid: Promise<any>
+async function fn11() { return a; } // valid: Promise<any>
+async function fn12() { return obj; } // valid: Promise<{ then: string; }>
+async function fn13() { return thenable; } // error
+async function fn14() { await 1; } // valid: Promise<void>
+async function fn15() { await null; } // valid: Promise<void>
+async function fn16() { await undefined; } // valid: Promise<void>
+async function fn17() { await a; } // valid: Promise<void>
+async function fn18() { await obj; } // valid: Promise<void>
+async function fn19() { await thenable; } // error
+
+
+//// [asyncFunctionDeclaration15_es6.js]
+function fn1() {
+    return __awaiter(this, void 0, Promise, function* () { });
+} // valid: Promise<void>
+function fn2() {
+    return __awaiter(this, void 0, Promise, function* () { });
+} // error
+function fn3() {
+    return __awaiter(this, void 0, Promise, function* () { });
+} // error
+function fn4() {
+    return __awaiter(this, void 0, Promise, function* () { });
+} // error
+function fn5() {
+    return __awaiter(this, void 0, PromiseLike, function* () { });
+} // error
+function fn6() {
+    return __awaiter(this, void 0, Thenable, function* () { });
+} // error
+function fn7() {
+    return __awaiter(this, void 0, Promise, function* () { return; });
+} // valid: Promise<void>
+function fn8() {
+    return __awaiter(this, void 0, Promise, function* () { return 1; });
+} // valid: Promise<number>
+function fn9() {
+    return __awaiter(this, void 0, Promise, function* () { return null; });
+} // valid: Promise<any>
+function fn10() {
+    return __awaiter(this, void 0, Promise, function* () { return undefined; });
+} // valid: Promise<any>
+function fn11() {
+    return __awaiter(this, void 0, Promise, function* () { return a; });
+} // valid: Promise<any>
+function fn12() {
+    return __awaiter(this, void 0, Promise, function* () { return obj; });
+} // valid: Promise<{ then: string; }>
+function fn13() {
+    return __awaiter(this, void 0, Promise, function* () { return thenable; });
+} // error
+function fn14() {
+    return __awaiter(this, void 0, Promise, function* () { yield 1; });
+} // valid: Promise<void>
+function fn15() {
+    return __awaiter(this, void 0, Promise, function* () { yield null; });
+} // valid: Promise<void>
+function fn16() {
+    return __awaiter(this, void 0, Promise, function* () { yield undefined; });
+} // valid: Promise<void>
+function fn17() {
+    return __awaiter(this, void 0, Promise, function* () { yield a; });
+} // valid: Promise<void>
+function fn18() {
+    return __awaiter(this, void 0, Promise, function* () { yield obj; });
+} // valid: Promise<void>
+function fn19() {
+    return __awaiter(this, void 0, Promise, function* () { yield thenable; });
+} // error
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
index c99ae35266b..b1721789f5c 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/augmentArray.symbols b/tests/baselines/reference/augmentArray.symbols
index 8c52363d601..ae0caddb1c6 100644
--- a/tests/baselines/reference/augmentArray.symbols
+++ b/tests/baselines/reference/augmentArray.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/augmentArray.ts ===
 interface Array<T> {
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(augmentArray.ts, 0, 0))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(augmentArray.ts, 0, 16))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentArray.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(augmentArray.ts, 0, 16))
 
     (): any[];
 }
diff --git a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
index 81c8b13d207..c3dfe5996b9 100644
--- a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
+++ b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols
@@ -8,7 +8,7 @@ interface Bar { b }
 >b : Symbol(b, Decl(augmentedTypeBracketAccessIndexSignature.ts, 1, 15))
 
 interface Object {
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11), Decl(augmentedTypeBracketAccessIndexSignature.ts, 1, 19))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketAccessIndexSignature.ts, 1, 19))
 
     [n: number]: Foo;
 >n : Symbol(n, Decl(augmentedTypeBracketAccessIndexSignature.ts, 4, 5))
@@ -16,7 +16,7 @@ interface Object {
 }
 
 interface Function {
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(augmentedTypeBracketAccessIndexSignature.ts, 5, 1))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketAccessIndexSignature.ts, 5, 1))
 
     [n: number]: Bar;
 >n : Symbol(n, Decl(augmentedTypeBracketAccessIndexSignature.ts, 8, 5))
diff --git a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
index cc9c2ba62ef..d12e8e13793 100644
--- a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
+++ b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols
@@ -1,12 +1,12 @@
 === tests/cases/compiler/augmentedTypeBracketNamedPropertyAccess.ts ===
 interface Object {
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 0, 0))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 0, 0))
 
     data: number;
 >data : Symbol(data, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 0, 18))
 }
 interface Function {
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 2, 1))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 2, 1))
 
     functionData: string;
 >functionData : Symbol(functionData, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 3, 20))
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
index 6ee2b1de415..fd532aeca74 100644
--- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = await p || a;
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
index 9c65780cfad..3117f62da17 100644
--- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = await p && a;
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
index 69d02403e85..e50f194bbee 100644
--- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
@@ -4,11 +4,11 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = await p + a;
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
index c88e0f247a5..02e05faeab0 100644
--- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = await p, a;
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
index 0ee4a03f3c5..061364240f8 100644
--- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var o: { a: boolean; };
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols
index d70728a5b2d..debe9180bcc 100644
--- a/tests/baselines/reference/awaitCallExpression1_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = fn(a, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols
index a3fd474060a..be9a11410c2 100644
--- a/tests/baselines/reference/awaitCallExpression2_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = fn(await p, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols
index 6dde8fc7f58..612e33c456c 100644
--- a/tests/baselines/reference/awaitCallExpression3_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = fn(a, await p, a);
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols
index ca563274b51..6925e5a44ea 100644
--- a/tests/baselines/reference/awaitCallExpression4_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = (await pfn)(a, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols
index 4c75a6fec6d..8bdce5cd12c 100644
--- a/tests/baselines/reference/awaitCallExpression5_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = o.fn(a, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols
index effed91ec06..ad79f75ab49 100644
--- a/tests/baselines/reference/awaitCallExpression6_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = o.fn(await p, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols
index 3393d2a0759..0da1dd16016 100644
--- a/tests/baselines/reference/awaitCallExpression7_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = o.fn(a, await p, a);
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols
index 331ebbdb7e1..d2d4fa2264d 100644
--- a/tests/baselines/reference/awaitCallExpression8_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "before";
     var b = (await po).fn(a, a, a);
diff --git a/tests/baselines/reference/awaitUnion_es6.symbols b/tests/baselines/reference/awaitUnion_es6.symbols
index 2db3b1a2fdb..48524c4526d 100644
--- a/tests/baselines/reference/awaitUnion_es6.symbols
+++ b/tests/baselines/reference/awaitUnion_es6.symbols
@@ -4,20 +4,20 @@ declare let a: number | string;
 
 declare let b: PromiseLike<number> | PromiseLike<string>;
 >b : Symbol(b, Decl(awaitUnion_es6.ts, 1, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163))
->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --))
 
 declare let c: PromiseLike<number | string>;
 >c : Symbol(c, Decl(awaitUnion_es6.ts, 2, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --))
 
 declare let d: number | PromiseLike<string>;
 >d : Symbol(d, Decl(awaitUnion_es6.ts, 3, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --))
 
 declare let e: number | PromiseLike<number | string>;
 >e : Symbol(e, Decl(awaitUnion_es6.ts, 4, 11))
->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163))
+>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --))
 
 async function f() {
 >f : Symbol(f, Decl(awaitUnion_es6.ts, 4, 53))
diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
index e6b6def0944..626777523ab 100644
--- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
+++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols
@@ -58,20 +58,20 @@ var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => vo
 >r6 : Symbol(r6, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 3))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 17))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 38))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { }; 
 >r7 : Symbol(r7, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 3))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 9))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 38))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 59))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void
 >r8 : Symbol(r8, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 3))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 17))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 38))
 
 var r10: Base = true ? derived : derived2; // no error since we use the contextual type in BCT
@@ -93,7 +93,7 @@ function foo5<T, U>(t: T, u: U): Object {
 >T : Symbol(T, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 14))
 >u : Symbol(u, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 25))
 >U : Symbol(U, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 16))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     return true ? t : u; // BCT is Object
 >t : Symbol(t, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 20))
diff --git a/tests/baselines/reference/binopAssignmentShouldHaveType.symbols b/tests/baselines/reference/binopAssignmentShouldHaveType.symbols
index d984647149e..98f4ffee743 100644
--- a/tests/baselines/reference/binopAssignmentShouldHaveType.symbols
+++ b/tests/baselines/reference/binopAssignmentShouldHaveType.symbols
@@ -21,12 +21,12 @@ module Test {
 >name : Symbol(name, Decl(binopAssignmentShouldHaveType.ts, 8, 6))
 
    if ((name= this.getName()).length > 0) {
->(name= this.getName()).length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>(name= this.getName()).length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(binopAssignmentShouldHaveType.ts, 8, 6))
 >this.getName : Symbol(getName, Decl(binopAssignmentShouldHaveType.ts, 3, 19))
 >this : Symbol(Bug, Decl(binopAssignmentShouldHaveType.ts, 2, 13))
 >getName : Symbol(getName, Decl(binopAssignmentShouldHaveType.ts, 3, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     console.log(name);
 >console : Symbol(console, Decl(binopAssignmentShouldHaveType.ts, 0, 11))
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
index 1e2d28f51c2..39c16a701b6 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
+++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols
@@ -88,9 +88,9 @@ var ResultIsNumber11 = ~(STRING + STRING);
 
 var ResultIsNumber12 = ~STRING.charAt(0);
 >ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 // multiple ~ operators
 var ResultIsNumber13 = ~~STRING;
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt
new file mode 100644
index 00000000000..94c58bccb04
--- /dev/null
+++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt
@@ -0,0 +1,118 @@
+tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(2,13): error TS2448: Block-scoped variable 'x' used before its declaration.
+tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(58,20): error TS2448: Block-scoped variable 'x' used before its declaration.
+tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(65,20): error TS2448: Block-scoped variable 'x' used before its declaration.
+tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(100,12): error TS2448: Block-scoped variable 'x' used before its declaration.
+
+
+==== tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts (4 errors) ====
+    function foo0() {
+        let a = x;
+                ~
+!!! error TS2448: Block-scoped variable 'x' used before its declaration.
+        let x;
+    }
+    
+    function foo1() {
+        let a = () => x;
+        let x;
+    }
+    
+    function foo2() {
+        let a = function () { return x; }
+        let x;
+    }
+    
+    function foo3() {
+        class X {
+            m() { return x;}
+        }
+        let x;
+    }
+    
+    function foo4() {
+        let y = class {
+            m() { return x; }
+        };
+        let x;
+    }
+    
+    function foo5() {
+        let x = () => y;
+        let y = () => x;
+    }
+    
+    function foo6() {
+        function f() {
+            return x;
+        }
+        let x;
+    }
+    
+    function foo7() {
+        class A {
+            a = x;
+        }
+        let x;
+    }
+    
+    function foo8() {
+        let y = class {
+            a = x;
+        }
+        let x;
+    }
+    
+    function foo9() {
+        let y = class {
+            static a = x;
+                       ~
+!!! error TS2448: Block-scoped variable 'x' used before its declaration.
+        }
+        let x;
+    }
+    
+    function foo10() {
+        class A {
+            static a = x;
+                       ~
+!!! error TS2448: Block-scoped variable 'x' used before its declaration.
+        }
+        let x;
+    }
+    
+    function foo11() {
+        function f () {
+            let y = class {
+                static a = x;
+            }
+        }
+        let x;
+    }
+    
+    function foo12() {
+        function f () {
+            let y = class {
+                a;
+                constructor() {
+                    this.a = x;
+                }
+            }
+        }
+        let x;
+    }
+    
+    function foo13() {
+        let a = {
+            get a() { return x } 
+        }
+        let x
+    }
+    
+    function foo14() {
+        let a = {
+            a: x 
+               ~
+!!! error TS2448: Block-scoped variable 'x' used before its declaration.
+        }
+        let x
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js
new file mode 100644
index 00000000000..5ed3ac62e6a
--- /dev/null
+++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js
@@ -0,0 +1,216 @@
+//// [blockScopedVariablesUseBeforeDef.ts]
+function foo0() {
+    let a = x;
+    let x;
+}
+
+function foo1() {
+    let a = () => x;
+    let x;
+}
+
+function foo2() {
+    let a = function () { return x; }
+    let x;
+}
+
+function foo3() {
+    class X {
+        m() { return x;}
+    }
+    let x;
+}
+
+function foo4() {
+    let y = class {
+        m() { return x; }
+    };
+    let x;
+}
+
+function foo5() {
+    let x = () => y;
+    let y = () => x;
+}
+
+function foo6() {
+    function f() {
+        return x;
+    }
+    let x;
+}
+
+function foo7() {
+    class A {
+        a = x;
+    }
+    let x;
+}
+
+function foo8() {
+    let y = class {
+        a = x;
+    }
+    let x;
+}
+
+function foo9() {
+    let y = class {
+        static a = x;
+    }
+    let x;
+}
+
+function foo10() {
+    class A {
+        static a = x;
+    }
+    let x;
+}
+
+function foo11() {
+    function f () {
+        let y = class {
+            static a = x;
+        }
+    }
+    let x;
+}
+
+function foo12() {
+    function f () {
+        let y = class {
+            a;
+            constructor() {
+                this.a = x;
+            }
+        }
+    }
+    let x;
+}
+
+function foo13() {
+    let a = {
+        get a() { return x } 
+    }
+    let x
+}
+
+function foo14() {
+    let a = {
+        a: x 
+    }
+    let x
+}
+
+//// [blockScopedVariablesUseBeforeDef.js]
+function foo0() {
+    var a = x;
+    var x;
+}
+function foo1() {
+    var a = function () { return x; };
+    var x;
+}
+function foo2() {
+    var a = function () { return x; };
+    var x;
+}
+function foo3() {
+    var X = (function () {
+        function X() {
+        }
+        X.prototype.m = function () { return x; };
+        return X;
+    })();
+    var x;
+}
+function foo4() {
+    var y = (function () {
+        function class_1() {
+        }
+        class_1.prototype.m = function () { return x; };
+        return class_1;
+    })();
+    var x;
+}
+function foo5() {
+    var x = function () { return y; };
+    var y = function () { return x; };
+}
+function foo6() {
+    function f() {
+        return x;
+    }
+    var x;
+}
+function foo7() {
+    var A = (function () {
+        function A() {
+            this.a = x;
+        }
+        return A;
+    })();
+    var x;
+}
+function foo8() {
+    var y = (function () {
+        function class_2() {
+            this.a = x;
+        }
+        return class_2;
+    })();
+    var x;
+}
+function foo9() {
+    var y = (function () {
+        function class_3() {
+        }
+        class_3.a = x;
+        return class_3;
+    })();
+    var x;
+}
+function foo10() {
+    var A = (function () {
+        function A() {
+        }
+        A.a = x;
+        return A;
+    })();
+    var x;
+}
+function foo11() {
+    function f() {
+        var y = (function () {
+            function class_4() {
+            }
+            class_4.a = x;
+            return class_4;
+        })();
+    }
+    var x;
+}
+function foo12() {
+    function f() {
+        var y = (function () {
+            function class_5() {
+                this.a = x;
+            }
+            return class_5;
+        })();
+    }
+    var x;
+}
+function foo13() {
+    var a = {
+        get a() { return x; }
+    };
+    var x;
+}
+function foo14() {
+    var a = {
+        a: x
+    };
+    var x;
+}
diff --git a/tests/baselines/reference/booleanPropertyAccess.symbols b/tests/baselines/reference/booleanPropertyAccess.symbols
index c552f268d01..f69c3f6a789 100644
--- a/tests/baselines/reference/booleanPropertyAccess.symbols
+++ b/tests/baselines/reference/booleanPropertyAccess.symbols
@@ -4,12 +4,12 @@ var x = true;
 
 var a = x.toString();
 >a : Symbol(a, Decl(booleanPropertyAccess.ts, 2, 3))
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(booleanPropertyAccess.ts, 0, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var b = x['toString']();
 >b : Symbol(b, Decl(booleanPropertyAccess.ts, 3, 3))
 >x : Symbol(x, Decl(booleanPropertyAccess.ts, 0, 3))
->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols b/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols
index d0fe78cb178..12bc165575b 100644
--- a/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols
+++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols
@@ -110,23 +110,23 @@ interface A { // T
     a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance2.ts, 19, 71))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 20, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 20, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance2.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27))
 
     a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance2.ts, 20, 64))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 21, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 21, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27))
 
     a14: (x: { a: string; b: number }) => Object;
@@ -134,7 +134,7 @@ interface A { // T
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 10))
 >a : Symbol(a, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 14))
 >b : Symbol(b, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 25))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     a15: {
 >a15 : Symbol(a15, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 49))
@@ -195,8 +195,8 @@ interface A { // T
 
             (a: Date): Date;
 >a : Symbol(a, Decl(callSignatureAssignabilityInInheritance2.ts, 42, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         }): any[];
     };
@@ -332,23 +332,23 @@ interface I extends A {
     a12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance2.ts, 60, 43))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 33))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 48))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27))
 
     a13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 73))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 36))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 51))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 10))
diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols b/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols
index d5a68430887..89797dceb70 100644
--- a/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols
+++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols
@@ -111,23 +111,23 @@ interface A { // T
     a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance5.ts, 20, 71))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 21, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 21, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance5.ts, 4, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27))
 
     a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance5.ts, 21, 64))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 22, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 22, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27))
 
     a14: (x: { a: string; b: number }) => Object;
@@ -135,7 +135,7 @@ interface A { // T
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 23, 10))
 >a : Symbol(a, Decl(callSignatureAssignabilityInInheritance5.ts, 23, 14))
 >b : Symbol(b, Decl(callSignatureAssignabilityInInheritance5.ts, 23, 25))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface B extends A {
@@ -280,23 +280,23 @@ interface I extends B {
     a12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance5.ts, 43, 43))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 33))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 48))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27))
 
     a13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 73))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 10))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27))
 >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 36))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 51))
 >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 10))
diff --git a/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols
index f2b9de48425..414d9138f3c 100644
--- a/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols
+++ b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols
@@ -54,7 +54,7 @@ var a: {
     (x, y): Object;
 >x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType.ts, 20, 5))
 >y : Symbol(y, Decl(callSignaturesThatDifferOnlyByReturnType.ts, 20, 7))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     (x, y): any; // error
 >x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType.ts, 21, 5))
diff --git a/tests/baselines/reference/callWithSpread.symbols b/tests/baselines/reference/callWithSpread.symbols
index c5ac7fe66b2..bc1dd7468c9 100644
--- a/tests/baselines/reference/callWithSpread.symbols
+++ b/tests/baselines/reference/callWithSpread.symbols
@@ -93,7 +93,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpread.ts, 7, 3))
 
 (<Function>xa[1].foo)(...[1, 2, "abc"]);
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >xa[1].foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
 >xa : Symbol(xa, Decl(callWithSpread.ts, 10, 3))
 >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13))
diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols
index d8604d8358a..26dd9b548d5 100644
--- a/tests/baselines/reference/callWithSpreadES6.symbols
+++ b/tests/baselines/reference/callWithSpreadES6.symbols
@@ -94,7 +94,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3))
 
 (<Function>xa[1].foo)(...[1, 2, "abc"]);
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 4036, 1))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13))
 >xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3))
 >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13))
diff --git a/tests/baselines/reference/callbacksDontShareTypes.symbols b/tests/baselines/reference/callbacksDontShareTypes.symbols
index 80a5f234d38..1d7583cec2d 100644
--- a/tests/baselines/reference/callbacksDontShareTypes.symbols
+++ b/tests/baselines/reference/callbacksDontShareTypes.symbols
@@ -56,9 +56,9 @@ var c2: Collection<number>;
 var rf1 = (x: number) => { return x.toFixed() };
 >rf1 : Symbol(rf1, Decl(callbacksDontShareTypes.ts, 13, 3))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11))
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
 var r1a = _.map(c2, (x) => { return x.toFixed() });
 >r1a : Symbol(r1a, Decl(callbacksDontShareTypes.ts, 14, 3))
@@ -67,9 +67,9 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63))
 >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21))
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
 var r1b = _.map(c2, rf1); // this line should not cause the following 2 to have errors 
 >r1b : Symbol(r1b, Decl(callbacksDontShareTypes.ts, 15, 3))
@@ -86,9 +86,9 @@ var r5a = _.map<number, string>(c2, (x) => { return x.toFixed() });
 >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63))
 >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37))
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
 var r5b = _.map<number, string>(c2, rf1);
 >r5b : Symbol(r5b, Decl(callbacksDontShareTypes.ts, 17, 3))
diff --git a/tests/baselines/reference/castNewObjectBug.symbols b/tests/baselines/reference/castNewObjectBug.symbols
index 3db7f7e065a..f9423710f4f 100644
--- a/tests/baselines/reference/castNewObjectBug.symbols
+++ b/tests/baselines/reference/castNewObjectBug.symbols
@@ -5,5 +5,5 @@ interface Foo { }
 var xx = <Foo> new Object();
 >xx : Symbol(xx, Decl(castNewObjectBug.ts, 1, 3))
 >Foo : Symbol(Foo, Decl(castNewObjectBug.ts, 0, 0))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/chainedAssignment2.symbols b/tests/baselines/reference/chainedAssignment2.symbols
index 84eb8428a64..3335c3cbb43 100644
--- a/tests/baselines/reference/chainedAssignment2.symbols
+++ b/tests/baselines/reference/chainedAssignment2.symbols
@@ -10,11 +10,11 @@ var c: boolean;
 
 var d: Date;
 >d : Symbol(d, Decl(chainedAssignment2.ts, 3, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var e: RegExp;
 >e : Symbol(e, Decl(chainedAssignment2.ts, 4, 3))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 a = b = c = d = e = null;
 >a : Symbol(a, Decl(chainedAssignment2.ts, 0, 3))
diff --git a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
index 5eb563d3ef6..8232c44a620 100644
--- a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
+++ b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols
@@ -51,9 +51,9 @@ var s2 = s.groupBy(s => s.length);
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 7, 3))
 >groupBy : Symbol(Sequence.groupBy, Decl(chainedSpecializationToObjectTypeLiteral.ts, 3, 57))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
 var s3 = s2.each(x => { x.key /* Type is K, should be number */ });
 >s3 : Symbol(s3, Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 3))
diff --git a/tests/baselines/reference/checkForObjectTooStrict.symbols b/tests/baselines/reference/checkForObjectTooStrict.symbols
index 48e04392c3b..e47aa47c9d1 100644
--- a/tests/baselines/reference/checkForObjectTooStrict.symbols
+++ b/tests/baselines/reference/checkForObjectTooStrict.symbols
@@ -29,12 +29,12 @@ class Bar extends Foo.Object { // should work
 
 class Baz extends Object {
 >Baz : Symbol(Baz, Decl(checkForObjectTooStrict.ts, 18, 1))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor () { // ERROR, as expected
 
         super();
->super : Symbol(ObjectConstructor, Decl(lib.d.ts, 124, 1))
+>super : Symbol(ObjectConstructor, Decl(lib.d.ts, --, --))
 
     }
 
diff --git a/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt b/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt
deleted file mode 100644
index 5af440ed4df..00000000000
--- a/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'A'.
-tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(11,1): error TS2511: Cannot create an instance of the abstract class 'B'.
-tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(12,1): error TS2511: Cannot create an instance of the abstract class 'C'.
-
-
-==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts (3 errors) ====
-    abstract class A {}
-    
-    abstract
-    class B {}
-    
-    abstract
-    
-    class C {}
-    
-    new A;
-    ~~~~~
-!!! error TS2511: Cannot create an instance of the abstract class 'A'.
-    new B;
-    ~~~~~
-!!! error TS2511: Cannot create an instance of the abstract class 'B'.
-    new C;
-    ~~~~~
-!!! error TS2511: Cannot create an instance of the abstract class 'C'.
\ No newline at end of file
diff --git a/tests/baselines/reference/classAbstractSingleLineDecl.errors.txt b/tests/baselines/reference/classAbstractSingleLineDecl.errors.txt
new file mode 100644
index 00000000000..0670ea108ea
--- /dev/null
+++ b/tests/baselines/reference/classAbstractSingleLineDecl.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts(3,1): error TS2304: Cannot find name 'abstract'.
+tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts(6,1): error TS2304: Cannot find name 'abstract'.
+tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'A'.
+
+
+==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts (3 errors) ====
+    abstract class A {}
+    
+    abstract
+    ~~~~~~~~
+!!! error TS2304: Cannot find name 'abstract'.
+    class B {}
+    
+    abstract
+    ~~~~~~~~
+!!! error TS2304: Cannot find name 'abstract'.
+    
+    class C {}
+    
+    new A;
+    ~~~~~
+!!! error TS2511: Cannot create an instance of the abstract class 'A'.
+    new B;
+    new C;
\ No newline at end of file
diff --git a/tests/baselines/reference/classAbstractMultiLineDecl.js b/tests/baselines/reference/classAbstractSingleLineDecl.js
similarity index 72%
rename from tests/baselines/reference/classAbstractMultiLineDecl.js
rename to tests/baselines/reference/classAbstractSingleLineDecl.js
index 3a92e2aa1e5..772ed564a66 100644
--- a/tests/baselines/reference/classAbstractMultiLineDecl.js
+++ b/tests/baselines/reference/classAbstractSingleLineDecl.js
@@ -1,4 +1,4 @@
-//// [classAbstractMultiLineDecl.ts]
+//// [classAbstractSingleLineDecl.ts]
 abstract class A {}
 
 abstract
@@ -12,17 +12,19 @@ new A;
 new B;
 new C;
 
-//// [classAbstractMultiLineDecl.js]
+//// [classAbstractSingleLineDecl.js]
 var A = (function () {
     function A() {
     }
     return A;
 })();
+abstract;
 var B = (function () {
     function B() {
     }
     return B;
 })();
+abstract;
 var C = (function () {
     function C() {
     }
diff --git a/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols b/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols
index c035b17bcc6..28c31e639a7 100644
--- a/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols
+++ b/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols
@@ -9,19 +9,19 @@ var c: C;
 
 var r = c.toString();
 >r : Symbol(r, Decl(classAppearsToHaveMembersOfObject.ts, 3, 3))
->c.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>c.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >c : Symbol(c, Decl(classAppearsToHaveMembersOfObject.ts, 2, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r2 = c.hasOwnProperty('');
 >r2 : Symbol(r2, Decl(classAppearsToHaveMembersOfObject.ts, 4, 3))
->c.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>c.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 >c : Symbol(c, Decl(classAppearsToHaveMembersOfObject.ts, 2, 3))
->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
 var o: Object = c;
 >o : Symbol(o, Decl(classAppearsToHaveMembersOfObject.ts, 5, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >c : Symbol(c, Decl(classAppearsToHaveMembersOfObject.ts, 2, 3))
 
 var o2: {} = c;
diff --git a/tests/baselines/reference/classExtendingBuiltinType.symbols b/tests/baselines/reference/classExtendingBuiltinType.symbols
index 08e85be570e..78f2195c8db 100644
--- a/tests/baselines/reference/classExtendingBuiltinType.symbols
+++ b/tests/baselines/reference/classExtendingBuiltinType.symbols
@@ -1,41 +1,41 @@
 === tests/cases/conformance/classes/classDeclarations/classExtendingBuiltinType.ts ===
 class C1 extends Object { }
 >C1 : Symbol(C1, Decl(classExtendingBuiltinType.ts, 0, 0))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C2 extends Function { }
 >C2 : Symbol(C2, Decl(classExtendingBuiltinType.ts, 0, 27))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C3 extends String { }
 >C3 : Symbol(C3, Decl(classExtendingBuiltinType.ts, 1, 29))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C4 extends Boolean { }
 >C4 : Symbol(C4, Decl(classExtendingBuiltinType.ts, 2, 27))
->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11))
+>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C5 extends Number { }
 >C5 : Symbol(C5, Decl(classExtendingBuiltinType.ts, 3, 28))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C6 extends Date { }
 >C6 : Symbol(C6, Decl(classExtendingBuiltinType.ts, 4, 27))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C7 extends RegExp { }
 >C7 : Symbol(C7, Decl(classExtendingBuiltinType.ts, 5, 25))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C8 extends Error { }
 >C8 : Symbol(C8, Decl(classExtendingBuiltinType.ts, 6, 27))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C9 extends Array { }
 >C9 : Symbol(C9, Decl(classExtendingBuiltinType.ts, 7, 26))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class C10 extends Array<number> { }
 >C10 : Symbol(C10, Decl(classExtendingBuiltinType.ts, 8, 26))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols
index 7239eac77e6..e30810f5cf9 100644
--- a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols
+++ b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols
@@ -20,11 +20,11 @@ class C {
 
     [x: string]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 7, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: number]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 8, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     0: number;
 }
@@ -44,11 +44,11 @@ interface I {
 
     [x: string]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 16, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: number]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 17, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     0: number;
 }
diff --git a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols
index 48bcbfa5149..13a716f9e8c 100644
--- a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols
+++ b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols
@@ -20,11 +20,11 @@ class C {
 
     [x: string]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 7, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: number]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 8, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     0: number;
 
@@ -47,11 +47,11 @@ interface I {
 
     [x: string]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 18, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: number]: Object;
 >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 19, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     0: number;
 }
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols
index 4b7f24a9048..ba9618a5ecf 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols
@@ -13,7 +13,7 @@ var STRING: string;
 
 var OBJECT: Object;
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //The second operand type is any
 ANY, ANY;
@@ -75,8 +75,8 @@ var x: any;
 
 "string", [null, 1];
 "string".charAt(0), [null, 1];
->"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 true, x("any");
 >x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3))
@@ -99,8 +99,8 @@ var resultIsAny8 = ("string", null);
 
 var resultIsAny9 = ("string".charAt(0), undefined);
 >resultIsAny9 : Symbol(resultIsAny9, Decl(commaOperatorWithSecondOperandAnyType.ts, 33, 3))
->"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var resultIsAny10 = (true, x("any"));
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols
index bd520c1876d..9be885bf41c 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols
@@ -13,7 +13,7 @@ var STRING: string;
 
 var OBJECT: Object;
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //The second operand type is boolean
 ANY, BOOLEAN;
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols
index 3da456eaa5f..bf5ff9437a3 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols
@@ -13,7 +13,7 @@ var STRING: string;
 
 var OBJECT: Object;
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //The second operand type is number
 ANY, NUMBER;
@@ -79,9 +79,9 @@ BOOLEAN = false, 1;
 >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3))
 
 STRING.trim(), NUMBER = 1;
->STRING.trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32))
+>STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3))
->trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32))
+>trim : Symbol(String.trim, Decl(lib.d.ts, --, --))
 >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3))
 
 var resultIsNumber6 = (null, NUMBER);
@@ -107,8 +107,8 @@ var resultIsNumber10 = ("", NUMBER = 1);
 
 var resultIsNumber11 = (STRING.trim(), NUMBER = 1);
 >resultIsNumber11 : Symbol(resultIsNumber11, Decl(commaOperatorWithSecondOperandNumberType.ts, 33, 3))
->STRING.trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32))
+>STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3))
->trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32))
+>trim : Symbol(String.trim, Decl(lib.d.ts, --, --))
 >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3))
 
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
index 42f24f77d50..3b8473318c0 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols
@@ -13,7 +13,7 @@ var STRING: string;
 
 var OBJECT: Object;
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 class CLASS {
 >CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19))
@@ -82,12 +82,12 @@ true, {}
 >BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3))
 
 "string", new Date()
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 STRING.toLowerCase(), new CLASS()
->STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19))
 
 var resultIsObject6 = (null, OBJECT);
@@ -110,12 +110,12 @@ var resultIsObject9 = (!BOOLEAN, { a: 1, b: "s" });
 
 var resultIsObject10 = ("string", new Date());
 >resultIsObject10 : Symbol(resultIsObject10, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var resultIsObject11 = (STRING.toLowerCase(), new CLASS());
 >resultIsObject11 : Symbol(resultIsObject11, Decl(commaOperatorWithSecondOperandObjectType.ts, 37, 3))
->STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19))
 
diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols
index d0c800858f7..3c674237a21 100644
--- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols
+++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols
@@ -13,7 +13,7 @@ var STRING: string;
 
 var OBJECT: Object;
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var resultIsString: string;
 >resultIsString : Symbol(resultIsString, Decl(commaOperatorWithSecondOperandStringType.ts, 6, 3))
@@ -71,7 +71,7 @@ null, STRING;
 
 ANY = new Date(), STRING;
 >ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3))
 
 true, "";
@@ -80,13 +80,13 @@ BOOLEAN == undefined, "";
 >undefined : Symbol(undefined)
 
 ["a", "b"], NUMBER.toString();
->NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 OBJECT = new Object, STRING + "string";
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3))
 
 var resultIsString6 = (null, STRING);
@@ -96,7 +96,7 @@ var resultIsString6 = (null, STRING);
 var resultIsString7 = (ANY = new Date(), STRING);
 >resultIsString7 : Symbol(resultIsString7, Decl(commaOperatorWithSecondOperandStringType.ts, 31, 3))
 >ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3))
 
 var resultIsString8 = (true, "");
@@ -109,12 +109,12 @@ var resultIsString9 = (BOOLEAN == undefined, "");
 
 var resultIsString10 = (["a", "b"], NUMBER.toString());
 >resultIsString10 : Symbol(resultIsString10, Decl(commaOperatorWithSecondOperandStringType.ts, 34, 3))
->NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 var resultIsString11 = (new Object, STRING + "string");
 >resultIsString11 : Symbol(resultIsString11, Decl(commaOperatorWithSecondOperandStringType.ts, 35, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3))
 
diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols
index bd39a21519f..3a580bc49e9 100644
--- a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols
+++ b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols
@@ -13,7 +13,7 @@ var STRING: string;
 
 var OBJECT: Object;
 >OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //Expected: work well
 ANY, BOOLEAN, NUMBER;
@@ -76,10 +76,10 @@ var resultIsObject1 = (NUMBER, STRING, OBJECT);
 null, true, 1;
 ++NUMBER, STRING.charAt(0), new Object();
 >NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var resultIsNumber2 = (null, true, 1);
 >resultIsNumber2 : Symbol(resultIsNumber2, Decl(commaOperatorsMultipleOperators.ts, 24, 3))
@@ -87,8 +87,8 @@ var resultIsNumber2 = (null, true, 1);
 var resultIsObject2 = (++NUMBER, STRING.charAt(0), new Object());
 >resultIsObject2 : Symbol(resultIsObject2, Decl(commaOperatorsMultipleOperators.ts, 25, 3))
 >NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/commentInMethodCall.symbols b/tests/baselines/reference/commentInMethodCall.symbols
index ff286983e23..9db0719cf89 100644
--- a/tests/baselines/reference/commentInMethodCall.symbols
+++ b/tests/baselines/reference/commentInMethodCall.symbols
@@ -4,9 +4,9 @@ var s: string[];
 >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3))
 
 s.map(// do something
->s.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>s.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 
     function () { });
 
diff --git a/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols b/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols
index c6586cc3068..a5acf69be2f 100644
--- a/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols
+++ b/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols
@@ -16,7 +16,7 @@ class A1 {
 
     public e: Object;
 >e : Symbol(e, Decl(comparisonOperatorWithIdenticalObjects.ts, 4, 18))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     public fn(a: string): string {
 >fn : Symbol(fn, Decl(comparisonOperatorWithIdenticalObjects.ts, 5, 21))
@@ -42,7 +42,7 @@ class B1 {
 
     public e: Object;
 >e : Symbol(e, Decl(comparisonOperatorWithIdenticalObjects.ts, 14, 18))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     public fn(b: string): string {
 >fn : Symbol(fn, Decl(comparisonOperatorWithIdenticalObjects.ts, 15, 21))
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.js b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.js
new file mode 100644
index 00000000000..4f02150cbe6
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.js
@@ -0,0 +1,56 @@
+//// [compoundExponentiationAssignmentLHSCanBeAssigned1.ts]
+enum E { a, b, c }
+
+var a: any;
+var b: number;
+var c: E;
+
+var x1: any;
+x1 **= a;
+x1 **= b;
+x1 **= c;
+x1 **= null;
+x1 **= undefined;
+
+var x2: number;
+x2 **= a;
+x2 **= b;
+x2 **= c;
+x2 **= null;
+x2 **= undefined;
+
+var x3: E;
+x3 **= a;
+x3 **= b;
+x3 **= c;
+x3 **= null;
+x3 **= undefined;
+
+//// [compoundExponentiationAssignmentLHSCanBeAssigned1.js]
+var E;
+(function (E) {
+    E[E["a"] = 0] = "a";
+    E[E["b"] = 1] = "b";
+    E[E["c"] = 2] = "c";
+})(E || (E = {}));
+var a;
+var b;
+var c;
+var x1;
+x1 = Math.pow(x1, a);
+x1 = Math.pow(x1, b);
+x1 = Math.pow(x1, c);
+x1 = Math.pow(x1, null);
+x1 = Math.pow(x1, undefined);
+var x2;
+x2 = Math.pow(x2, a);
+x2 = Math.pow(x2, b);
+x2 = Math.pow(x2, c);
+x2 = Math.pow(x2, null);
+x2 = Math.pow(x2, undefined);
+var x3;
+x3 = Math.pow(x3, a);
+x3 = Math.pow(x3, b);
+x3 = Math.pow(x3, c);
+x3 = Math.pow(x3, null);
+x3 = Math.pow(x3, undefined);
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.symbols b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.symbols
new file mode 100644
index 00000000000..982c658bc03
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.symbols
@@ -0,0 +1,84 @@
+=== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts ===
+enum E { a, b, c }
+>E : Symbol(E, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 0, 0))
+>a : Symbol(E.a, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 0, 8))
+>b : Symbol(E.b, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 0, 11))
+>c : Symbol(E.c, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 0, 14))
+
+var a: any;
+>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 2, 3))
+
+var b: number;
+>b : Symbol(b, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 3, 3))
+
+var c: E;
+>c : Symbol(c, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 4, 3))
+>E : Symbol(E, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 0, 0))
+
+var x1: any;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 6, 3))
+
+x1 **= a;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 6, 3))
+>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 2, 3))
+
+x1 **= b;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 6, 3))
+>b : Symbol(b, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 3, 3))
+
+x1 **= c;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 6, 3))
+>c : Symbol(c, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 4, 3))
+
+x1 **= null;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 6, 3))
+
+x1 **= undefined;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 6, 3))
+>undefined : Symbol(undefined)
+
+var x2: number;
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 13, 3))
+
+x2 **= a;
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 13, 3))
+>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 2, 3))
+
+x2 **= b;
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 13, 3))
+>b : Symbol(b, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 3, 3))
+
+x2 **= c;
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 13, 3))
+>c : Symbol(c, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 4, 3))
+
+x2 **= null;
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 13, 3))
+
+x2 **= undefined;
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 13, 3))
+>undefined : Symbol(undefined)
+
+var x3: E;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 20, 3))
+>E : Symbol(E, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 0, 0))
+
+x3 **= a;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 20, 3))
+>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 2, 3))
+
+x3 **= b;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 20, 3))
+>b : Symbol(b, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 3, 3))
+
+x3 **= c;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 20, 3))
+>c : Symbol(c, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 4, 3))
+
+x3 **= null;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 20, 3))
+
+x3 **= undefined;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSCanBeAssigned1.ts, 20, 3))
+>undefined : Symbol(undefined)
+
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.types b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.types
new file mode 100644
index 00000000000..060a231da1b
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSCanBeAssigned1.types
@@ -0,0 +1,102 @@
+=== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts ===
+enum E { a, b, c }
+>E : E
+>a : E
+>b : E
+>c : E
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+var c: E;
+>c : E
+>E : E
+
+var x1: any;
+>x1 : any
+
+x1 **= a;
+>x1 **= a : number
+>x1 : any
+>a : any
+
+x1 **= b;
+>x1 **= b : number
+>x1 : any
+>b : number
+
+x1 **= c;
+>x1 **= c : number
+>x1 : any
+>c : E
+
+x1 **= null;
+>x1 **= null : number
+>x1 : any
+>null : null
+
+x1 **= undefined;
+>x1 **= undefined : number
+>x1 : any
+>undefined : undefined
+
+var x2: number;
+>x2 : number
+
+x2 **= a;
+>x2 **= a : number
+>x2 : number
+>a : any
+
+x2 **= b;
+>x2 **= b : number
+>x2 : number
+>b : number
+
+x2 **= c;
+>x2 **= c : number
+>x2 : number
+>c : E
+
+x2 **= null;
+>x2 **= null : number
+>x2 : number
+>null : null
+
+x2 **= undefined;
+>x2 **= undefined : number
+>x2 : number
+>undefined : undefined
+
+var x3: E;
+>x3 : E
+>E : E
+
+x3 **= a;
+>x3 **= a : number
+>x3 : E
+>a : any
+
+x3 **= b;
+>x3 **= b : number
+>x3 : E
+>b : number
+
+x3 **= c;
+>x3 **= c : number
+>x3 : E
+>c : E
+
+x3 **= null;
+>x3 **= null : number
+>x3 : E
+>null : null
+
+x3 **= undefined;
+>x3 **= undefined : number
+>x3 : E
+>undefined : undefined
+
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.errors.txt b/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.errors.txt
new file mode 100644
index 00000000000..8d152712808
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.errors.txt
@@ -0,0 +1,267 @@
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(7,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(8,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(8,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(9,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(9,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(10,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(11,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(11,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(12,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(13,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(13,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(14,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(14,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(15,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(15,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(18,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(19,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(19,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(20,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(20,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(21,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(22,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(22,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(23,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(24,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(24,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(25,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(25,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(26,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(26,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(29,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(30,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(31,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(31,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(32,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(33,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(33,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(34,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(35,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(35,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(36,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(36,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(37,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(41,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(41,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(42,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(42,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(43,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(44,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(44,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(45,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(46,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(47,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(48,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(51,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(52,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(53,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(54,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(57,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(58,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(59,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts(60,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts (68 errors) ====
+    enum E { a, b }
+    
+    var a: any;
+    var b: void;
+    
+    var x1: boolean;
+    x1 **= a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= b;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= true;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= 0;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= ''
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= E.a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= {};
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= null;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x1 **= undefined;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var x2: string;
+    x2 **= a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= b;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= true;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= 0;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= ''
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= E.a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= {};
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= null;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x2 **= undefined;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var x3: {};
+    x3 **= a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= b;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= true;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= 0;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= ''
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= E.a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= {};
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= null;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x3 **= undefined;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var x4: void;
+    x4 **= a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= b;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= true;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= 0;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= ''
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= E.a;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= {};
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= null;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x4 **= undefined;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var x5: number;
+    x5 **= b;
+           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x5 **= true;
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x5 **= ''
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x5 **= {};
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var x6: E;
+    x6 **= b;
+           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x6 **= true;
+           ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x6 **= ''
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    x6 **= {};
+           ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.js b/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.js
new file mode 100644
index 00000000000..b04e60d373b
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.js
@@ -0,0 +1,120 @@
+//// [compoundExponentiationAssignmentLHSCannotBeAssigned.ts]
+enum E { a, b }
+
+var a: any;
+var b: void;
+
+var x1: boolean;
+x1 **= a;
+x1 **= b;
+x1 **= true;
+x1 **= 0;
+x1 **= ''
+x1 **= E.a;
+x1 **= {};
+x1 **= null;
+x1 **= undefined;
+
+var x2: string;
+x2 **= a;
+x2 **= b;
+x2 **= true;
+x2 **= 0;
+x2 **= ''
+x2 **= E.a;
+x2 **= {};
+x2 **= null;
+x2 **= undefined;
+
+var x3: {};
+x3 **= a;
+x3 **= b;
+x3 **= true;
+x3 **= 0;
+x3 **= ''
+x3 **= E.a;
+x3 **= {};
+x3 **= null;
+x3 **= undefined;
+
+var x4: void;
+x4 **= a;
+x4 **= b;
+x4 **= true;
+x4 **= 0;
+x4 **= ''
+x4 **= E.a;
+x4 **= {};
+x4 **= null;
+x4 **= undefined;
+
+var x5: number;
+x5 **= b;
+x5 **= true;
+x5 **= ''
+x5 **= {};
+
+var x6: E;
+x6 **= b;
+x6 **= true;
+x6 **= ''
+x6 **= {};
+
+//// [compoundExponentiationAssignmentLHSCannotBeAssigned.js]
+var E;
+(function (E) {
+    E[E["a"] = 0] = "a";
+    E[E["b"] = 1] = "b";
+})(E || (E = {}));
+var a;
+var b;
+var x1;
+x1 = Math.pow(x1, a);
+x1 = Math.pow(x1, b);
+x1 = Math.pow(x1, true);
+x1 = Math.pow(x1, 0);
+x1 = Math.pow(x1, '');
+x1 = Math.pow(x1, E.a);
+x1 = Math.pow(x1, {});
+x1 = Math.pow(x1, null);
+x1 = Math.pow(x1, undefined);
+var x2;
+x2 = Math.pow(x2, a);
+x2 = Math.pow(x2, b);
+x2 = Math.pow(x2, true);
+x2 = Math.pow(x2, 0);
+x2 = Math.pow(x2, '');
+x2 = Math.pow(x2, E.a);
+x2 = Math.pow(x2, {});
+x2 = Math.pow(x2, null);
+x2 = Math.pow(x2, undefined);
+var x3;
+x3 = Math.pow(x3, a);
+x3 = Math.pow(x3, b);
+x3 = Math.pow(x3, true);
+x3 = Math.pow(x3, 0);
+x3 = Math.pow(x3, '');
+x3 = Math.pow(x3, E.a);
+x3 = Math.pow(x3, {});
+x3 = Math.pow(x3, null);
+x3 = Math.pow(x3, undefined);
+var x4;
+x4 = Math.pow(x4, a);
+x4 = Math.pow(x4, b);
+x4 = Math.pow(x4, true);
+x4 = Math.pow(x4, 0);
+x4 = Math.pow(x4, '');
+x4 = Math.pow(x4, E.a);
+x4 = Math.pow(x4, {});
+x4 = Math.pow(x4, null);
+x4 = Math.pow(x4, undefined);
+var x5;
+x5 = Math.pow(x5, b);
+x5 = Math.pow(x5, true);
+x5 = Math.pow(x5, '');
+x5 = Math.pow(x5, {});
+var x6;
+x6 = Math.pow(x6, b);
+x6 = Math.pow(x6, true);
+x6 = Math.pow(x6, '');
+x6 = Math.pow(x6, {});
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.js b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.js
new file mode 100644
index 00000000000..f41962cf9e1
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.js
@@ -0,0 +1,48 @@
+//// [compoundExponentiationAssignmentLHSIsReference.ts]
+var value;
+
+// identifiers: variable and parameter
+var x1: number;
+x1 **= value;
+
+function fn1(x2: number) {
+    x2 **= value;
+}
+
+// property accesses
+var x3: { a: number };
+x3.a **= value;
+
+x3['a'] **= value;
+
+// parentheses, the contained expression is reference
+(x1) **= value;
+
+function fn2(x4: number) {
+    (x4) **= value;
+}
+
+(x3.a) **= value;
+
+(x3['a']) **= value;
+
+//// [compoundExponentiationAssignmentLHSIsReference.js]
+var value;
+// identifiers: variable and parameter
+var x1;
+x1 = Math.pow(x1, value);
+function fn1(x2) {
+    x2 = Math.pow(x2, value);
+}
+// property accesses
+var x3;
+(_a = x3, _a.a = Math.pow(_a.a, value));
+(_b = x3, _b['a'] = Math.pow(_b['a'], value));
+// parentheses, the contained expression is reference
+(x1) = Math.pow((x1), value);
+function fn2(x4) {
+    (x4) = Math.pow((x4), value);
+}
+(x3.a) = Math.pow((x3.a), value);
+(x3['a']) = Math.pow((x3['a']), value);
+var _a, _b;
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols
new file mode 100644
index 00000000000..775d43b0c58
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.symbols
@@ -0,0 +1,62 @@
+=== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsReference.ts ===
+var value;
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+
+// identifiers: variable and parameter
+var x1: number;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 3, 3))
+
+x1 **= value;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 3, 3))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+
+function fn1(x2: number) {
+>fn1 : Symbol(fn1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 4, 13))
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 6, 13))
+
+    x2 **= value;
+>x2 : Symbol(x2, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 6, 13))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+}
+
+// property accesses
+var x3: { a: number };
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 3))
+>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
+
+x3.a **= value;
+>x3.a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 3))
+>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+
+x3['a'] **= value;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 3))
+>'a' : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+
+// parentheses, the contained expression is reference
+(x1) **= value;
+>x1 : Symbol(x1, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 3, 3))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+
+function fn2(x4: number) {
+>fn2 : Symbol(fn2, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 17, 15))
+>x4 : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
+
+    (x4) **= value;
+>x4 : Symbol(x4, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 19, 13))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+}
+
+(x3.a) **= value;
+>x3.a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 3))
+>a : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+
+(x3['a']) **= value;
+>x3 : Symbol(x3, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 3))
+>'a' : Symbol(a, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 11, 9))
+>value : Symbol(value, Decl(compoundExponentiationAssignmentLHSIsReference.ts, 0, 3))
+
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.types b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.types
new file mode 100644
index 00000000000..35f42f4fa77
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsReference.types
@@ -0,0 +1,76 @@
+=== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsReference.ts ===
+var value;
+>value : any
+
+// identifiers: variable and parameter
+var x1: number;
+>x1 : number
+
+x1 **= value;
+>x1 **= value : number
+>x1 : number
+>value : any
+
+function fn1(x2: number) {
+>fn1 : (x2: number) => void
+>x2 : number
+
+    x2 **= value;
+>x2 **= value : number
+>x2 : number
+>value : any
+}
+
+// property accesses
+var x3: { a: number };
+>x3 : { a: number; }
+>a : number
+
+x3.a **= value;
+>x3.a **= value : number
+>x3.a : number
+>x3 : { a: number; }
+>a : number
+>value : any
+
+x3['a'] **= value;
+>x3['a'] **= value : number
+>x3['a'] : number
+>x3 : { a: number; }
+>'a' : string
+>value : any
+
+// parentheses, the contained expression is reference
+(x1) **= value;
+>(x1) **= value : number
+>(x1) : number
+>x1 : number
+>value : any
+
+function fn2(x4: number) {
+>fn2 : (x4: number) => void
+>x4 : number
+
+    (x4) **= value;
+>(x4) **= value : number
+>(x4) : number
+>x4 : number
+>value : any
+}
+
+(x3.a) **= value;
+>(x3.a) **= value : number
+>(x3.a) : number
+>x3.a : number
+>x3 : { a: number; }
+>a : number
+>value : any
+
+(x3['a']) **= value;
+>(x3['a']) **= value : number
+>(x3['a']) : number
+>x3['a'] : number
+>x3 : { a: number; }
+>'a' : string
+>value : any
+
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt
new file mode 100644
index 00000000000..bee6f75ff5c
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt
@@ -0,0 +1,199 @@
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(10,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(13,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(18,5): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(21,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(25,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(27,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(32,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(35,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(36,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(38,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(39,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(43,10): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(52,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(56,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(60,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(65,21): error TS1128: Declaration or statement expected.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(66,11): error TS1005: ';' expected.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(69,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(72,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(73,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(74,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(75,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(76,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(77,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(78,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(79,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(80,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(81,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(82,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(83,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(84,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(85,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts (37 errors) ====
+    // expected error for all the LHS of compound assignments (arithmetic and addition)
+    var value;
+    
+    // this
+    class C {
+        constructor() {
+            this **= value;
+            ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        }
+        foo() {
+            this **= value;
+            ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        }
+        static sfoo() {
+            this **= value;
+            ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        }
+    }
+    
+    function foo() {
+        this **= value;
+        ~~~~
+!!! error TS2364: Invalid left-hand side of assignment expression.
+    }
+    
+    this **= value;
+    ~~~~
+!!! error TS2364: Invalid left-hand side of assignment expression.
+    
+    // identifiers: module, class, enum, function
+    module M { export var a; }
+    M **= value;
+    ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    C **= value;
+    ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    enum E { }
+    E **= value;
+    ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    foo **= value;
+    ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    // literals
+    null **= value;
+    ~~~~
+!!! error TS2364: Invalid left-hand side of assignment expression.
+    true **= value;
+    ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    false **= value;
+    ~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    0 **= value;
+    ~
+!!! error TS2364: Invalid left-hand side of assignment expression.
+    '' **= value;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    /d+/ **= value;
+    ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    // object literals
+    { a: 0 } **= value;
+             ~~~
+!!! error TS1128: Declaration or statement expected.
+    
+    // array literals
+    ['', ''] **= value;
+    ~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    // super
+    class Derived extends C {
+        constructor() {
+            super();
+            super **= value;
+                  ~~~
+!!! error TS1034: 'super' must be followed by an argument list or member access.
+        }
+    
+        foo() {
+            super **= value;
+                  ~~~
+!!! error TS1034: 'super' must be followed by an argument list or member access.
+        }
+    
+        static sfoo() {
+            super **= value;
+                  ~~~
+!!! error TS1034: 'super' must be followed by an argument list or member access.
+        }
+    }
+    
+    // function expression
+    function bar1() { } **= value;
+                        ~~~
+!!! error TS1128: Declaration or statement expected.
+    () => { } **= value;
+              ~~~
+!!! error TS1005: ';' expected.
+    
+    // function calls
+    foo() **= value;
+    ~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    // parentheses, the containted expression is value
+    (this) **= value;
+    ~~~~~~
+!!! error TS2364: Invalid left-hand side of assignment expression.
+    (M) **= value;
+    ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (C) **= value;
+    ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (E) **= value;
+    ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (foo) **= value;
+    ~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (null) **= value;
+    ~~~~~~
+!!! error TS2364: Invalid left-hand side of assignment expression.
+    (true) **= value;
+    ~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (0) **= value;
+    ~~~
+!!! error TS2364: Invalid left-hand side of assignment expression.
+    ('') **= value;
+    ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (/d+/) **= value;
+    ~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ({}) **= value;
+    ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ([]) **= value;
+    ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (function baz1() { }) **= value;
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (foo()) **= value;
+    ~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.js b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.js
new file mode 100644
index 00000000000..f4e14e54242
--- /dev/null
+++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.js
@@ -0,0 +1,177 @@
+//// [compoundExponentiationAssignmentLHSIsValue.ts]
+// expected error for all the LHS of compound assignments (arithmetic and addition)
+var value;
+
+// this
+class C {
+    constructor() {
+        this **= value;
+    }
+    foo() {
+        this **= value;
+    }
+    static sfoo() {
+        this **= value;
+    }
+}
+
+function foo() {
+    this **= value;
+}
+
+this **= value;
+
+// identifiers: module, class, enum, function
+module M { export var a; }
+M **= value;
+
+C **= value;
+
+enum E { }
+E **= value;
+
+foo **= value;
+
+// literals
+null **= value;
+true **= value;
+false **= value;
+0 **= value;
+'' **= value;
+/d+/ **= value;
+
+// object literals
+{ a: 0 } **= value;
+
+// array literals
+['', ''] **= value;
+
+// super
+class Derived extends C {
+    constructor() {
+        super();
+        super **= value;
+    }
+
+    foo() {
+        super **= value;
+    }
+
+    static sfoo() {
+        super **= value;
+    }
+}
+
+// function expression
+function bar1() { } **= value;
+() => { } **= value;
+
+// function calls
+foo() **= value;
+
+// parentheses, the containted expression is value
+(this) **= value;
+(M) **= value;
+(C) **= value;
+(E) **= value;
+(foo) **= value;
+(null) **= value;
+(true) **= value;
+(0) **= value;
+('') **= value;
+(/d+/) **= value;
+({}) **= value;
+([]) **= value;
+(function baz1() { }) **= value;
+(foo()) **= value;
+
+//// [compoundExponentiationAssignmentLHSIsValue.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+// expected error for all the LHS of compound assignments (arithmetic and addition)
+var value;
+// this
+var C = (function () {
+    function C() {
+        this = Math.pow(this, value);
+    }
+    C.prototype.foo = function () {
+        this = Math.pow(this, value);
+    };
+    C.sfoo = function () {
+        this = Math.pow(this, value);
+    };
+    return C;
+})();
+function foo() {
+    this = Math.pow(this, value);
+}
+this = Math.pow(this, value);
+// identifiers: module, class, enum, function
+var M;
+(function (M) {
+})(M || (M = {}));
+M = Math.pow(M, value);
+C = Math.pow(C, value);
+var E;
+(function (E) {
+})(E || (E = {}));
+E = Math.pow(E, value);
+foo = Math.pow(foo, value);
+// literals
+null = Math.pow(null, value);
+true = Math.pow(true, value);
+false = Math.pow(false, value);
+0 = Math.pow(0, value);
+'' = Math.pow('', value);
+/d+/ = Math.pow(/d+/, value);
+// object literals
+{
+    a: 0;
+}
+value;
+// array literals
+['', ''] = Math.pow(['', ''], value);
+// super
+var Derived = (function (_super) {
+    __extends(Derived, _super);
+    function Derived() {
+        _super.call(this);
+        (_a = _super.prototype, _a. = Math.pow(_a., value));
+        var _a;
+    }
+    Derived.prototype.foo = function () {
+        (_a = _super.prototype, _a. = Math.pow(_a., value));
+        var _a;
+    };
+    Derived.sfoo = function () {
+        (_a = _super, _a. = Math.pow(_a., value));
+        var _a;
+    };
+    return Derived;
+})(C);
+// function expression
+function bar1() { }
+value;
+(function () { });
+value;
+// function calls
+foo() = Math.pow(foo(), value);
+// parentheses, the containted expression is value
+(this) = Math.pow((this), value);
+(M) = Math.pow((M), value);
+(C) = Math.pow((C), value);
+(E) = Math.pow((E), value);
+(foo) = Math.pow((foo), value);
+(null) = Math.pow((null), value);
+(true) = Math.pow((true), value);
+(0) = Math.pow((0), value);
+('') = Math.pow((''), value);
+(/d+/) = Math.pow((/d+/), value);
+({}) = Math.pow(({}), value);
+([]) = Math.pow(([]), value);
+(function baz1() { }) = Math.pow((function baz1() { }), value);
+(foo()) = Math.pow((foo()), value);
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
index a99a3899725..3fd0843a727 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols
@@ -17,13 +17,13 @@ var o: I = {
 
     ["" + 0](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     ["" + 1]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
index e386b8e9efa..56da1f91a5e 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols
@@ -17,13 +17,13 @@ var o: I = {
 
     ["" + 0](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     ["" + 1]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
index fcd89e032e6..20b344adfd6 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols
@@ -17,13 +17,13 @@ var o: I = {
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     [+"bar"]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
index ce6be5194c0..9412a9c8c34 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols
@@ -17,13 +17,13 @@ var o: I = {
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     [+"bar"]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
index d73c9c186d4..acc3b848ce4 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols
@@ -13,13 +13,13 @@ var o: I = {
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 5, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 5, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     [+"bar"]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
index 48e93ee62f9..0b53cf3bfe4 100644
--- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
+++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols
@@ -13,13 +13,13 @@ var o: I = {
 
     [+"foo"](y) { return y.length; },
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     [+"bar"]: y => y.length
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>y.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/concatError.symbols b/tests/baselines/reference/concatError.symbols
index 6ed5ffd468f..d4f04531fc7 100644
--- a/tests/baselines/reference/concatError.symbols
+++ b/tests/baselines/reference/concatError.symbols
@@ -14,15 +14,15 @@ var fa: number[];
 
 fa = fa.concat([0]);
 >fa : Symbol(fa, Decl(concatError.ts, 8, 3))
->fa.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fa : Symbol(fa, Decl(concatError.ts, 8, 3))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 fa = fa.concat(0);
 >fa : Symbol(fa, Decl(concatError.ts, 8, 3))
->fa.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >fa : Symbol(fa, Decl(concatError.ts, 8, 3))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 
 
diff --git a/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols
index eade67512ad..a7124d58305 100644
--- a/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols
@@ -17,7 +17,7 @@ var exprString1: string;
 
 var exprIsObject1: Object;
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsBooleanType.ts, 7, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var exprAny2: any;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsBooleanType.ts, 9, 3))
@@ -33,7 +33,7 @@ var exprString2: string;
 
 var exprIsObject2: Object;
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsBooleanType.ts, 13, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //Cond is a boolean type variable
 condBoolean ? exprAny1 : exprAny2;
diff --git a/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols
index 8ece5961636..f3816b6238e 100644
--- a/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols
@@ -17,7 +17,7 @@ var exprString1: string;
 
 var exprIsObject1: Object;
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsNumberType.ts, 7, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var exprAny2: any;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsNumberType.ts, 9, 3))
@@ -33,7 +33,7 @@ var exprString2: string;
 
 var exprIsObject2: Object;
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsNumberType.ts, 13, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //Cond is a number type variable
 condNumber ? exprAny1 : exprAny2;
@@ -107,8 +107,8 @@ var array = [1, 2, 3];
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsNumberType.ts, 10, 3))
 
 "string".length ? exprNumber1 : exprNumber2;
->"string".length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>"string".length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsNumberType.ts, 5, 3))
 >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsNumberType.ts, 11, 3))
 
@@ -207,8 +207,8 @@ var resultIsBoolean3 = 1 + 1 ? exprBoolean1 : exprBoolean2;
 
 var resultIsNumber3 = "string".length ? exprNumber1 : exprNumber2;
 >resultIsNumber3 : Symbol(resultIsNumber3, Decl(conditionalOperatorConditionIsNumberType.ts, 59, 3))
->"string".length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>"string".length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsNumberType.ts, 5, 3))
 >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsNumberType.ts, 11, 3))
 
diff --git a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
index 41f00e53b26..0867a708770 100644
--- a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols
@@ -2,7 +2,7 @@
 //Cond ? Expr1 : Expr2,  Cond is of object type, Expr1 and Expr2 have the same type
 var condObject: Object;
 >condObject : Symbol(condObject, Decl(conditionalOperatorConditionIsObjectType.ts, 1, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var exprAny1: any;
 >exprAny1 : Symbol(exprAny1, Decl(conditionalOperatorConditionIsObjectType.ts, 3, 3))
@@ -18,7 +18,7 @@ var exprString1: string;
 
 var exprIsObject1: Object;
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var exprAny2: any;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3))
@@ -34,7 +34,7 @@ var exprString2: string;
 
 var exprIsObject2: Object;
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo() { };
 >foo : Symbol(foo, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 26))
@@ -77,17 +77,17 @@ condObject ? exprString1 : exprBoolean1; // union
 //Cond is an object type literal
 ((a: string) => a.length) ? exprAny1 : exprAny2;
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2))
->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>a.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >exprAny1 : Symbol(exprAny1, Decl(conditionalOperatorConditionIsObjectType.ts, 3, 3))
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3))
 
 ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2))
->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>a.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
@@ -120,7 +120,7 @@ foo() ? exprAny1 : exprAny2;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3))
 
 new Date() ? exprBoolean1 : exprBoolean2;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
@@ -137,14 +137,14 @@ C.doIt() ? exprString1 : exprString2;
 >exprString2 : Symbol(exprString2, Decl(conditionalOperatorConditionIsObjectType.ts, 12, 3))
 
 condObject.valueOf() ? exprIsObject1 : exprIsObject2;
->condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29))
+>condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --))
 >condObject : Symbol(condObject, Decl(conditionalOperatorConditionIsObjectType.ts, 1, 3))
->valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29))
+>valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --))
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3))
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3))
 
 new Date() ? exprString1 : exprBoolean1; // union
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 
@@ -188,18 +188,18 @@ var resultIsStringOrBoolean1 = condObject ? exprString1 : exprBoolean1; // union
 var resultIsAny2 = ((a: string) => a.length) ? exprAny1 : exprAny2;
 >resultIsAny2 : Symbol(resultIsAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 3))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21))
->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>a.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >exprAny1 : Symbol(exprAny1, Decl(conditionalOperatorConditionIsObjectType.ts, 3, 3))
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3))
 
 var resultIsBoolean2 = ((a: string) => a.length) ? exprBoolean1 : exprBoolean2;
 >resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 3))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25))
->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>a.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
@@ -237,7 +237,7 @@ var resultIsAny3 = foo() ? exprAny1 : exprAny2;
 
 var resultIsBoolean3 = new Date() ? exprBoolean1 : exprBoolean2;
 >resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(conditionalOperatorConditionIsObjectType.ts, 58, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3))
 
@@ -257,9 +257,9 @@ var resultIsString3 = C.doIt() ? exprString1 : exprString2;
 
 var resultIsObject3 = condObject.valueOf() ? exprIsObject1 : exprIsObject2;
 >resultIsObject3 : Symbol(resultIsObject3, Decl(conditionalOperatorConditionIsObjectType.ts, 61, 3))
->condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29))
+>condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --))
 >condObject : Symbol(condObject, Decl(conditionalOperatorConditionIsObjectType.ts, 1, 3))
->valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29))
+>valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --))
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3))
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3))
 
diff --git a/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols b/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols
index aaaf4124eb6..c31f367b7d4 100644
--- a/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols
@@ -20,7 +20,7 @@ var exprString1: string;
 
 var exprIsObject1: Object;
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditoinIsAnyType.ts, 8, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var exprAny2: any;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditoinIsAnyType.ts, 10, 3))
@@ -36,7 +36,7 @@ var exprString2: string;
 
 var exprIsObject2: Object;
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditoinIsAnyType.ts, 14, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //Cond is an any type variable
 condAny ? exprAny1 : exprAny2;
diff --git a/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols b/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols
index 76845a80ce6..9de27f5a96b 100644
--- a/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols
+++ b/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols
@@ -17,7 +17,7 @@ var exprString1: string;
 
 var exprIsObject1: Object;
 >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditoinIsStringType.ts, 7, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var exprAny2: any;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditoinIsStringType.ts, 9, 3))
@@ -33,7 +33,7 @@ var exprString2: string;
 
 var exprIsObject2: Object;
 >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditoinIsStringType.ts, 13, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 //Cond is a string type variable
 condString ? exprAny1 : exprAny2;
@@ -104,9 +104,9 @@ typeof condString ? exprAny1 : exprAny2;
 >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditoinIsStringType.ts, 9, 3))
 
 condString.toUpperCase ? exprBoolean1 : exprBoolean2;
->condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >condString : Symbol(condString, Decl(conditionalOperatorConditoinIsStringType.ts, 1, 3))
->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditoinIsStringType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditoinIsStringType.ts, 10, 3))
 
@@ -205,9 +205,9 @@ var resultIsAny3 = typeof condString ? exprAny1 : exprAny2;
 
 var resultIsBoolean3 = condString.toUpperCase ? exprBoolean1 : exprBoolean2;
 >resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(conditionalOperatorConditoinIsStringType.ts, 58, 3))
->condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >condString : Symbol(condString, Decl(conditionalOperatorConditoinIsStringType.ts, 1, 3))
->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditoinIsStringType.ts, 4, 3))
 >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditoinIsStringType.ts, 10, 3))
 
@@ -237,9 +237,9 @@ var resultIsStringOrBoolean3 = typeof condString ? exprString1 : exprBoolean1; /
 
 var resultIsStringOrBoolean4 = condString.toUpperCase ? exprString1 : exprBoolean1; // union
 >resultIsStringOrBoolean4 : Symbol(resultIsStringOrBoolean4, Decl(conditionalOperatorConditoinIsStringType.ts, 63, 3))
->condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >condString : Symbol(condString, Decl(conditionalOperatorConditoinIsStringType.ts, 1, 3))
->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditoinIsStringType.ts, 6, 3))
 >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditoinIsStringType.ts, 4, 3))
 
diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols
index 99e11e12967..cca4cb6e12c 100644
--- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols
+++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols
@@ -5,8 +5,8 @@ class Rule {
 
     public regex: RegExp = new RegExp('');
 >regex : Symbol(regex, Decl(constDeclarationShadowedByVarDeclaration3.ts, 1, 12))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     public name: string = '';
 >name : Symbol(name, Decl(constDeclarationShadowedByVarDeclaration3.ts, 2, 42))
diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt
deleted file mode 100644
index a4d28f51878..00000000000
--- a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/file1.ts(2,1): error TS2448: Block-scoped variable 'c' used before its declaration.
-
-
-==== tests/cases/compiler/file1.ts (1 errors) ====
-    
-    c;
-    ~
-!!! error TS2448: Block-scoped variable 'c' used before its declaration.
-    
-==== tests/cases/compiler/file2.ts (0 errors) ====
-    const c = 0;
\ No newline at end of file
diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.symbols b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.symbols
new file mode 100644
index 00000000000..281ce427733
--- /dev/null
+++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.symbols
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/file1.ts ===
+
+c;
+>c : Symbol(c, Decl(file2.ts, 0, 5))
+
+=== tests/cases/compiler/file2.ts ===
+const c = 0;
+>c : Symbol(c, Decl(file2.ts, 0, 5))
+
diff --git a/tests/baselines/reference/constDeclarations-useBeforeDefinition2.types b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.types
new file mode 100644
index 00000000000..ae60fdfa477
--- /dev/null
+++ b/tests/baselines/reference/constDeclarations-useBeforeDefinition2.types
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/file1.ts ===
+
+c;
+>c : number
+
+=== tests/cases/compiler/file2.ts ===
+const c = 0;
+>c : number
+>0 : number
+
diff --git a/tests/baselines/reference/constEnumToStringNoComments.symbols b/tests/baselines/reference/constEnumToStringNoComments.symbols
index 0206e6a5d90..3f48b060f35 100644
--- a/tests/baselines/reference/constEnumToStringNoComments.symbols
+++ b/tests/baselines/reference/constEnumToStringNoComments.symbols
@@ -23,91 +23,91 @@ const enum Foo {
 
 let x0 = Foo.X.toString();
 >x0 : Symbol(x0, Decl(constEnumToStringNoComments.ts, 9, 3))
->Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.X : Symbol(Foo.X, Decl(constEnumToStringNoComments.ts, 0, 16))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >X : Symbol(Foo.X, Decl(constEnumToStringNoComments.ts, 0, 16))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let x1 = Foo["X"].toString();
 >x1 : Symbol(x1, Decl(constEnumToStringNoComments.ts, 10, 3))
->Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >"X" : Symbol(Foo.X, Decl(constEnumToStringNoComments.ts, 0, 16))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let y0 = Foo.Y.toString();
 >y0 : Symbol(y0, Decl(constEnumToStringNoComments.ts, 11, 3))
->Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.Y : Symbol(Foo.Y, Decl(constEnumToStringNoComments.ts, 1, 12))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >Y : Symbol(Foo.Y, Decl(constEnumToStringNoComments.ts, 1, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let y1 = Foo["Y"].toString();
 >y1 : Symbol(y1, Decl(constEnumToStringNoComments.ts, 12, 3))
->Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >"Y" : Symbol(Foo.Y, Decl(constEnumToStringNoComments.ts, 1, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let z0 = Foo.Z.toString();
 >z0 : Symbol(z0, Decl(constEnumToStringNoComments.ts, 13, 3))
->Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.Z : Symbol(Foo.Z, Decl(constEnumToStringNoComments.ts, 2, 12))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >Z : Symbol(Foo.Z, Decl(constEnumToStringNoComments.ts, 2, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let z1 = Foo["Z"].toString();
 >z1 : Symbol(z1, Decl(constEnumToStringNoComments.ts, 14, 3))
->Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >"Z" : Symbol(Foo.Z, Decl(constEnumToStringNoComments.ts, 2, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let a0 = Foo.A.toString();
 >a0 : Symbol(a0, Decl(constEnumToStringNoComments.ts, 15, 3))
->Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.A : Symbol(Foo.A, Decl(constEnumToStringNoComments.ts, 3, 11))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >A : Symbol(Foo.A, Decl(constEnumToStringNoComments.ts, 3, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let a1 = Foo["A"].toString();
 >a1 : Symbol(a1, Decl(constEnumToStringNoComments.ts, 16, 3))
->Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >"A" : Symbol(Foo.A, Decl(constEnumToStringNoComments.ts, 3, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let b0 = Foo.B.toString();
 >b0 : Symbol(b0, Decl(constEnumToStringNoComments.ts, 17, 3))
->Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.B : Symbol(Foo.B, Decl(constEnumToStringNoComments.ts, 4, 11))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >B : Symbol(Foo.B, Decl(constEnumToStringNoComments.ts, 4, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let b1 = Foo["B"].toString();
 >b1 : Symbol(b1, Decl(constEnumToStringNoComments.ts, 18, 3))
->Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >"B" : Symbol(Foo.B, Decl(constEnumToStringNoComments.ts, 4, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let c0 = Foo.C.toString();
 >c0 : Symbol(c0, Decl(constEnumToStringNoComments.ts, 19, 3))
->Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.C : Symbol(Foo.C, Decl(constEnumToStringNoComments.ts, 5, 13))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >C : Symbol(Foo.C, Decl(constEnumToStringNoComments.ts, 5, 13))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let c1 = Foo["C"].toString();
 >c1 : Symbol(c1, Decl(constEnumToStringNoComments.ts, 20, 3))
->Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0))
 >"C" : Symbol(Foo.C, Decl(constEnumToStringNoComments.ts, 5, 13))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/constEnumToStringWithComments.symbols b/tests/baselines/reference/constEnumToStringWithComments.symbols
index fafb7ab4611..028731a4540 100644
--- a/tests/baselines/reference/constEnumToStringWithComments.symbols
+++ b/tests/baselines/reference/constEnumToStringWithComments.symbols
@@ -23,91 +23,91 @@ const enum Foo {
 
 let x0 = Foo.X.toString();
 >x0 : Symbol(x0, Decl(constEnumToStringWithComments.ts, 9, 3))
->Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.X : Symbol(Foo.X, Decl(constEnumToStringWithComments.ts, 0, 16))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >X : Symbol(Foo.X, Decl(constEnumToStringWithComments.ts, 0, 16))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let x1 = Foo["X"].toString();
 >x1 : Symbol(x1, Decl(constEnumToStringWithComments.ts, 10, 3))
->Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >"X" : Symbol(Foo.X, Decl(constEnumToStringWithComments.ts, 0, 16))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let y0 = Foo.Y.toString();
 >y0 : Symbol(y0, Decl(constEnumToStringWithComments.ts, 11, 3))
->Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.Y : Symbol(Foo.Y, Decl(constEnumToStringWithComments.ts, 1, 12))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >Y : Symbol(Foo.Y, Decl(constEnumToStringWithComments.ts, 1, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let y1 = Foo["Y"].toString();
 >y1 : Symbol(y1, Decl(constEnumToStringWithComments.ts, 12, 3))
->Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >"Y" : Symbol(Foo.Y, Decl(constEnumToStringWithComments.ts, 1, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let z0 = Foo.Z.toString();
 >z0 : Symbol(z0, Decl(constEnumToStringWithComments.ts, 13, 3))
->Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.Z : Symbol(Foo.Z, Decl(constEnumToStringWithComments.ts, 2, 12))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >Z : Symbol(Foo.Z, Decl(constEnumToStringWithComments.ts, 2, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let z1 = Foo["Z"].toString();
 >z1 : Symbol(z1, Decl(constEnumToStringWithComments.ts, 14, 3))
->Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >"Z" : Symbol(Foo.Z, Decl(constEnumToStringWithComments.ts, 2, 12))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let a0 = Foo.A.toString();
 >a0 : Symbol(a0, Decl(constEnumToStringWithComments.ts, 15, 3))
->Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.A : Symbol(Foo.A, Decl(constEnumToStringWithComments.ts, 3, 11))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >A : Symbol(Foo.A, Decl(constEnumToStringWithComments.ts, 3, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let a1 = Foo["A"].toString();
 >a1 : Symbol(a1, Decl(constEnumToStringWithComments.ts, 16, 3))
->Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >"A" : Symbol(Foo.A, Decl(constEnumToStringWithComments.ts, 3, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let b0 = Foo.B.toString();
 >b0 : Symbol(b0, Decl(constEnumToStringWithComments.ts, 17, 3))
->Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.B : Symbol(Foo.B, Decl(constEnumToStringWithComments.ts, 4, 11))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >B : Symbol(Foo.B, Decl(constEnumToStringWithComments.ts, 4, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let b1 = Foo["B"].toString();
 >b1 : Symbol(b1, Decl(constEnumToStringWithComments.ts, 18, 3))
->Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >"B" : Symbol(Foo.B, Decl(constEnumToStringWithComments.ts, 4, 11))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let c0 = Foo.C.toString();
 >c0 : Symbol(c0, Decl(constEnumToStringWithComments.ts, 19, 3))
->Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo.C : Symbol(Foo.C, Decl(constEnumToStringWithComments.ts, 5, 13))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >C : Symbol(Foo.C, Decl(constEnumToStringWithComments.ts, 5, 13))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 let c1 = Foo["C"].toString();
 >c1 : Symbol(c1, Decl(constEnumToStringWithComments.ts, 20, 3))
->Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0))
 >"C" : Symbol(Foo.C, Decl(constEnumToStringWithComments.ts, 5, 13))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/constIndexedAccess.js b/tests/baselines/reference/constIndexedAccess.js
new file mode 100644
index 00000000000..db80441bd33
--- /dev/null
+++ b/tests/baselines/reference/constIndexedAccess.js
@@ -0,0 +1,47 @@
+//// [constIndexedAccess.ts]
+
+const enum numbers {
+    zero,
+    one
+}
+
+interface indexAccess {
+    0: string;
+    1: number;
+}
+
+let test: indexAccess;
+
+let s = test[0];
+let n = test[1];
+
+let s1 = test[numbers.zero];
+let n1 = test[numbers.one];
+
+let s2 = test[numbers["zero"]];
+let n2 = test[numbers["one"]];
+
+enum numbersNotConst {
+    zero,
+    one
+}
+
+let s3 = test[numbersNotConst.zero];
+let n3 = test[numbersNotConst.one];
+
+
+//// [constIndexedAccess.js]
+var test;
+var s = test[0];
+var n = test[1];
+var s1 = test[0 /* zero */];
+var n1 = test[1 /* one */];
+var s2 = test[0 /* "zero" */];
+var n2 = test[1 /* "one" */];
+var numbersNotConst;
+(function (numbersNotConst) {
+    numbersNotConst[numbersNotConst["zero"] = 0] = "zero";
+    numbersNotConst[numbersNotConst["one"] = 1] = "one";
+})(numbersNotConst || (numbersNotConst = {}));
+var s3 = test[numbersNotConst.zero];
+var n3 = test[numbersNotConst.one];
diff --git a/tests/baselines/reference/constIndexedAccess.symbols b/tests/baselines/reference/constIndexedAccess.symbols
new file mode 100644
index 00000000000..2ccb7f11686
--- /dev/null
+++ b/tests/baselines/reference/constIndexedAccess.symbols
@@ -0,0 +1,83 @@
+=== tests/cases/compiler/constIndexedAccess.ts ===
+
+const enum numbers {
+>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
+
+    zero,
+>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
+
+    one
+>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
+}
+
+interface indexAccess {
+>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1))
+
+    0: string;
+    1: number;
+}
+
+let test: indexAccess;
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1))
+
+let s = test[0];
+>s : Symbol(s, Decl(constIndexedAccess.ts, 13, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>0 : Symbol(indexAccess.0, Decl(constIndexedAccess.ts, 6, 23))
+
+let n = test[1];
+>n : Symbol(n, Decl(constIndexedAccess.ts, 14, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>1 : Symbol(indexAccess.1, Decl(constIndexedAccess.ts, 7, 14))
+
+let s1 = test[numbers.zero];
+>s1 : Symbol(s1, Decl(constIndexedAccess.ts, 16, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>numbers.zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
+>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
+>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
+
+let n1 = test[numbers.one];
+>n1 : Symbol(n1, Decl(constIndexedAccess.ts, 17, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>numbers.one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
+>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
+>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
+
+let s2 = test[numbers["zero"]];
+>s2 : Symbol(s2, Decl(constIndexedAccess.ts, 19, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
+>"zero" : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20))
+
+let n2 = test[numbers["one"]];
+>n2 : Symbol(n2, Decl(constIndexedAccess.ts, 20, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0))
+>"one" : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9))
+
+enum numbersNotConst {
+>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30))
+
+    zero,
+>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22))
+
+    one
+>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9))
+}
+
+let s3 = test[numbersNotConst.zero];
+>s3 : Symbol(s3, Decl(constIndexedAccess.ts, 27, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>numbersNotConst.zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22))
+>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30))
+>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22))
+
+let n3 = test[numbersNotConst.one];
+>n3 : Symbol(n3, Decl(constIndexedAccess.ts, 28, 3))
+>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
+>numbersNotConst.one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9))
+>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30))
+>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 9))
+
diff --git a/tests/baselines/reference/constIndexedAccess.types b/tests/baselines/reference/constIndexedAccess.types
new file mode 100644
index 00000000000..eb02c7bde2e
--- /dev/null
+++ b/tests/baselines/reference/constIndexedAccess.types
@@ -0,0 +1,93 @@
+=== tests/cases/compiler/constIndexedAccess.ts ===
+
+const enum numbers {
+>numbers : numbers
+
+    zero,
+>zero : numbers
+
+    one
+>one : numbers
+}
+
+interface indexAccess {
+>indexAccess : indexAccess
+
+    0: string;
+    1: number;
+}
+
+let test: indexAccess;
+>test : indexAccess
+>indexAccess : indexAccess
+
+let s = test[0];
+>s : string
+>test[0] : string
+>test : indexAccess
+>0 : number
+
+let n = test[1];
+>n : number
+>test[1] : number
+>test : indexAccess
+>1 : number
+
+let s1 = test[numbers.zero];
+>s1 : string
+>test[numbers.zero] : string
+>test : indexAccess
+>numbers.zero : numbers
+>numbers : typeof numbers
+>zero : numbers
+
+let n1 = test[numbers.one];
+>n1 : number
+>test[numbers.one] : number
+>test : indexAccess
+>numbers.one : numbers
+>numbers : typeof numbers
+>one : numbers
+
+let s2 = test[numbers["zero"]];
+>s2 : string
+>test[numbers["zero"]] : string
+>test : indexAccess
+>numbers["zero"] : numbers
+>numbers : typeof numbers
+>"zero" : string
+
+let n2 = test[numbers["one"]];
+>n2 : number
+>test[numbers["one"]] : number
+>test : indexAccess
+>numbers["one"] : numbers
+>numbers : typeof numbers
+>"one" : string
+
+enum numbersNotConst {
+>numbersNotConst : numbersNotConst
+
+    zero,
+>zero : numbersNotConst
+
+    one
+>one : numbersNotConst
+}
+
+let s3 = test[numbersNotConst.zero];
+>s3 : any
+>test[numbersNotConst.zero] : any
+>test : indexAccess
+>numbersNotConst.zero : numbersNotConst
+>numbersNotConst : typeof numbersNotConst
+>zero : numbersNotConst
+
+let n3 = test[numbersNotConst.one];
+>n3 : any
+>test[numbersNotConst.one] : any
+>test : indexAccess
+>numbersNotConst.one : numbersNotConst
+>numbersNotConst : typeof numbersNotConst
+>one : numbersNotConst
+
diff --git a/tests/baselines/reference/constraintSatisfactionWithAny.symbols b/tests/baselines/reference/constraintSatisfactionWithAny.symbols
index fdf1bdce7e8..52cfe211cff 100644
--- a/tests/baselines/reference/constraintSatisfactionWithAny.symbols
+++ b/tests/baselines/reference/constraintSatisfactionWithAny.symbols
@@ -4,7 +4,7 @@
 function foo<T extends String>(x: T): T { return null; }
 >foo : Symbol(foo, Decl(constraintSatisfactionWithAny.ts, 0, 0))
 >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 2, 13))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(constraintSatisfactionWithAny.ts, 2, 31))
 >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 2, 13))
 >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 2, 13))
@@ -67,7 +67,7 @@ foo4<any>(b);
 class C<T extends String> {
 >C : Symbol(C, Decl(constraintSatisfactionWithAny.ts, 16, 13))
 >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 22, 8))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(public x: T) { }
 >x : Symbol(x, Decl(constraintSatisfactionWithAny.ts, 23, 16))
diff --git a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
index fd5aae69b86..d53e51b6623 100644
--- a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
+++ b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols
@@ -5,7 +5,7 @@
 function foo<T extends Object>(x: T) { }
 >foo : Symbol(foo, Decl(constraintSatisfactionWithEmptyObject.ts, 0, 0))
 >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 3, 13))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(constraintSatisfactionWithEmptyObject.ts, 3, 31))
 >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 3, 13))
 
@@ -23,7 +23,7 @@ var r = foo({});
 class C<T extends Object> {
 >C : Symbol(C, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 16))
 >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 8, 8))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(public x: T) { }
 >x : Symbol(x, Decl(constraintSatisfactionWithEmptyObject.ts, 9, 16))
@@ -37,7 +37,7 @@ var r2 = new C({});
 interface I<T extends Object> {
 >I : Symbol(I, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 19))
 >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 14, 12))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     x: T;
 >x : Symbol(x, Decl(constraintSatisfactionWithEmptyObject.ts, 14, 31))
diff --git a/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols b/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols
index b85ae3e90d8..8a6ec113423 100644
--- a/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols
+++ b/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols
@@ -110,23 +110,23 @@ interface A { // T
     a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance2.ts, 19, 75))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 20, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 20, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(constructSignatureAssignabilityInInheritance2.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27))
 
     a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance2.ts, 20, 68))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 21, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 21, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27))
 
     a14: new (x: { a: string; b: number }) => Object;
@@ -134,7 +134,7 @@ interface A { // T
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 14))
 >a : Symbol(a, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 18))
 >b : Symbol(b, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 29))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     a15: {
 >a15 : Symbol(a15, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 53))
@@ -195,8 +195,8 @@ interface A { // T
 
             new (a: Date): Date;
 >a : Symbol(a, Decl(constructSignatureAssignabilityInInheritance2.ts, 42, 17))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         }): any[];
     };
@@ -332,23 +332,23 @@ interface I extends A {
     a12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance2.ts, 60, 47))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 37))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 52))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27))
 
     a13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 77))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 40))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 55))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 14))
diff --git a/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols b/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols
index 2be72546bee..1b35cd0c896 100644
--- a/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols
+++ b/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols
@@ -111,23 +111,23 @@ interface A { // T
     a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance5.ts, 20, 75))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 21, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 21, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(constructSignatureAssignabilityInInheritance5.ts, 4, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27))
 
     a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance5.ts, 21, 68))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 22, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 22, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27))
 
     a14: new (x: { a: string; b: number }) => Object;
@@ -135,7 +135,7 @@ interface A { // T
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 23, 14))
 >a : Symbol(a, Decl(constructSignatureAssignabilityInInheritance5.ts, 23, 18))
 >b : Symbol(b, Decl(constructSignatureAssignabilityInInheritance5.ts, 23, 29))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface B extends A {
@@ -280,23 +280,23 @@ interface I extends B {
     a12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance5.ts, 43, 47))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 37))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 52))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27))
 
     a13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 77))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27))
 >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 40))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0))
 >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 55))
 >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 14))
diff --git a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols
index 8ca8fb6a5d8..f0ee9f0d32e 100644
--- a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols
+++ b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols
@@ -7,7 +7,7 @@ class Base {
 
         bar: Object;
 >bar : Symbol(bar, Decl(constructorFunctionTypeIsAssignableToBaseType.ts, 1, 17))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols
index e915b6e705d..39e415e8a5d 100644
--- a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols
+++ b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols
@@ -9,11 +9,11 @@ class Base {
 
         bar: Object;
 >bar : Symbol(bar, Decl(constructorFunctionTypeIsAssignableToBaseType2.ts, 3, 17))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
     constructor(x: Object) {
 >x : Symbol(x, Decl(constructorFunctionTypeIsAssignableToBaseType2.ts, 6, 16))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols b/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols
index 384aa692da6..a96e053132e 100644
--- a/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols
+++ b/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols
@@ -34,7 +34,7 @@ class D<T> {
 class E<T extends Date> {
 >E : Symbol(E, Decl(constructorImplementationWithDefaultValues.ts, 12, 1))
 >T : Symbol(T, Decl(constructorImplementationWithDefaultValues.ts, 14, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x);
 >x : Symbol(x, Decl(constructorImplementationWithDefaultValues.ts, 15, 16))
diff --git a/tests/baselines/reference/contextualSignatureInstantiation1.symbols b/tests/baselines/reference/contextualSignatureInstantiation1.symbols
index e56e997cffc..80c53b07075 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation1.symbols
+++ b/tests/baselines/reference/contextualSignatureInstantiation1.symbols
@@ -17,9 +17,9 @@ var e = <K>(x: string, y?: K) => x.length;
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 1, 12))
 >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 1, 22))
 >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 1, 9))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 1, 12))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
 var r99 = map(e); // should be {}[] for S since a generic lambda is not inferentially typed
 >r99 : Symbol(r99, Decl(contextualSignatureInstantiation1.ts, 2, 3))
@@ -45,9 +45,9 @@ var e2 = <K>(x: string, y?: K) => x.length;
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 5, 13))
 >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 5, 23))
 >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 5, 10))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 5, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
 var r100 = map2(e2); // type arg inference should fail for S since a generic lambda is not inferentially typed. Falls back to { length: number }
 >r100 : Symbol(r100, Decl(contextualSignatureInstantiation1.ts, 6, 3))
diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.symbols b/tests/baselines/reference/contextualSignatureInstantiation3.symbols
index 7e90c6390ca..6d480a7aef4 100644
--- a/tests/baselines/reference/contextualSignatureInstantiation3.symbols
+++ b/tests/baselines/reference/contextualSignatureInstantiation3.symbols
@@ -12,9 +12,9 @@ function map<T, U>(items: T[], f: (x: T) => U): U[]{
 >U : Symbol(U, Decl(contextualSignatureInstantiation3.ts, 0, 15))
 
     return items.map(f);
->items.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>items.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >items : Symbol(items, Decl(contextualSignatureInstantiation3.ts, 0, 19))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >f : Symbol(f, Decl(contextualSignatureInstantiation3.ts, 0, 30))
 }
 
@@ -47,9 +47,9 @@ var v1: number[];
 
 var v1 = xs.map(identity);      // Error if not number[]
 >v1 : Symbol(v1, Decl(contextualSignatureInstantiation3.ts, 15, 3), Decl(contextualSignatureInstantiation3.ts, 16, 3), Decl(contextualSignatureInstantiation3.ts, 17, 3))
->xs.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >identity : Symbol(identity, Decl(contextualSignatureInstantiation3.ts, 2, 1))
 
 var v1 = map(xs, identity);     // Error if not number[]
@@ -63,9 +63,9 @@ var v2: number[][];
 
 var v2 = xs.map(singleton);     // Error if not number[][]
 >v2 : Symbol(v2, Decl(contextualSignatureInstantiation3.ts, 19, 3), Decl(contextualSignatureInstantiation3.ts, 20, 3), Decl(contextualSignatureInstantiation3.ts, 21, 3))
->xs.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >singleton : Symbol(singleton, Decl(contextualSignatureInstantiation3.ts, 6, 1))
 
 var v2 = map(xs, singleton);    // Error if not number[][]
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
index 3e23a7812f5..13f95623fd5 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols
@@ -47,9 +47,9 @@ var x: IWithNoCallSignatures | IWithCallSignatures = a => a.toString();
 >IWithNoCallSignatures : Symbol(IWithNoCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 0, 0))
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 // With call signatures with different return type
 var x2: IWithCallSignatures | IWithCallSignatures2 = a => a.toString(); // Like iWithCallSignatures
@@ -57,9 +57,9 @@ var x2: IWithCallSignatures | IWithCallSignatures2 = a => a.toString(); // Like
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures2 : Symbol(IWithCallSignatures2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 12, 1))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 var x2: IWithCallSignatures | IWithCallSignatures2 = a => a; // Like iWithCallSignatures2
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 3), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 3))
@@ -82,7 +82,7 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
index c381377e523..14b595f8b33 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols
@@ -93,9 +93,9 @@ var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a.to
 >IWithStringIndexSignature2 : Symbol(IWithStringIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 17, 1))
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 67))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a }; // a should be number
 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 3))
@@ -133,9 +133,9 @@ var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a.to
 >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1))
 >IWithNumberIndexSignature2 : Symbol(IWithNumberIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 23, 1))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a }; // a should be number
 >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 3))
diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
index 3d7b8bf5a18..5a0891c3b88 100644
--- a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
+++ b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols
@@ -164,7 +164,7 @@ var i1Ori2: I1<number> | I2<number> = { // Like i1 and i2 both
 
 var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 >arrayI1OrI2 : Symbol(arrayI1OrI2, Decl(contextualTypeWithUnionTypeMembers.ts, 51, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0))
 >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1))
 >i1 : Symbol(i1, Decl(contextualTypeWithUnionTypeMembers.ts, 21, 3))
@@ -301,9 +301,9 @@ var i11Ori21: I11 | I21 = {
 
         var z = a.charAt(b);
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 91, 11))
->a.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>a.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 38))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 40))
 
         return z;  
@@ -327,9 +327,9 @@ var i11Ori21: I11 | I21 = {
 
         var z = a.charCodeAt(b);
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 99, 11))
->a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32))
+>a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 38))
->charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32))
+>charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 40))
 
         return z;
@@ -342,7 +342,7 @@ var i11Ori21: I11 | I21 = {
 };
 var arrayOrI11OrI21: Array<I11 | I21> = [i11, i21, i11 || i21, { 
 >arrayOrI11OrI21 : Symbol(arrayOrI11OrI21, Decl(contextualTypeWithUnionTypeMembers.ts, 104, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >I11 : Symbol(I11, Decl(contextualTypeWithUnionTypeMembers.ts, 74, 7))
 >I21 : Symbol(I21, Decl(contextualTypeWithUnionTypeMembers.ts, 79, 1))
 >i11 : Symbol(i11, Decl(contextualTypeWithUnionTypeMembers.ts, 84, 3))
@@ -358,9 +358,9 @@ var arrayOrI11OrI21: Array<I11 | I21> = [i11, i21, i11 || i21, {
 
             var z = a.charAt(b);
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 107, 15))
->a.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>a.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 42))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 44))
 
             return z;
@@ -379,9 +379,9 @@ var arrayOrI11OrI21: Array<I11 | I21> = [i11, i21, i11 || i21, {
 
             var z = a.charCodeAt(b);
 >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 114, 15))
->a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32))
+>a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 42))
->charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32))
+>charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 44))
 
             return z;
diff --git a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
index 56c3abe0627..1f8ad9f9c68 100644
--- a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
+++ b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols
@@ -3,13 +3,13 @@ var x: (a: number) => void = true ? (a) => a.toExponential() : (b) => b.toFixed(
 >x : Symbol(x, Decl(contextualTypingOfConditionalExpression.ts, 0, 3))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 8))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37))
->a.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>a.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37))
->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64))
->b.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>b.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
 class A {
 >A : Symbol(A, Decl(contextualTypingOfConditionalExpression.ts, 0, 82))
diff --git a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
index 810f407e1b2..e6719960b31 100644
--- a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
+++ b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols
@@ -13,9 +13,9 @@ foo((y): (y2: number) => void => {
 
     var z = y.charAt(0); // Should be string
 >z : Symbol(z, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 4, 7))
->y.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>y.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 5))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
     return null;
 });
@@ -29,9 +29,9 @@ foo((y: string) => {
 
         var z = y2.toFixed(); // Should be string
 >z : Symbol(z, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 10, 11))
->y2.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>y2.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >y2 : Symbol(y2, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 9, 10))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
         return 0;
     };
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator.symbols b/tests/baselines/reference/contextuallyTypingOrOperator.symbols
index 18019aea7cb..1ceb9b76ad3 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator.symbols
+++ b/tests/baselines/reference/contextuallyTypingOrOperator.symbols
@@ -5,34 +5,34 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >_ : Symbol(_, Decl(contextuallyTypingOrOperator.ts, 0, 13))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 39))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 63))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 66))
 
 var v2 = (s: string) => s.length || function (s) { s.length };
 >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator.ts, 2, 3))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46))
 
 var v3 = (s: string) => s.length || function (s: number) { return 1 };
 >v3 : Symbol(v3, Decl(contextuallyTypingOrOperator.ts, 4, 3))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 46))
 
 var v4 = (s: number) => 1 || function (s: string) { return s.length };
 >v4 : Symbol(v4, Decl(contextuallyTypingOrOperator.ts, 5, 3))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 10))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
index 99e328fd64a..40dc6190b04 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
+++ b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols
@@ -5,18 +5,18 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >_ : Symbol(_, Decl(contextuallyTypingOrOperator2.ts, 0, 13))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 39))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 63))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 66))
 
 var v2 = (s: string) => s.length || function (s) { s.aaa };
 >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator2.ts, 2, 3))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46))
 >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46))
 
diff --git a/tests/baselines/reference/declFileConstructors.symbols b/tests/baselines/reference/declFileConstructors.symbols
index bc8f349bb82..1190c889dbf 100644
--- a/tests/baselines/reference/declFileConstructors.symbols
+++ b/tests/baselines/reference/declFileConstructors.symbols
@@ -33,9 +33,9 @@ export class ConstructorWithRestParamters {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileConstructors_0.ts, 16, 16))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileConstructors_0.ts, 16, 26))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
 }
 
@@ -119,9 +119,9 @@ class GlobalConstructorWithRestParamters {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileConstructors_1.ts, 15, 16))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileConstructors_1.ts, 15, 26))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/declFileEnums.symbols b/tests/baselines/reference/declFileEnums.symbols
index 22d5ee6bb63..bea118ea967 100644
--- a/tests/baselines/reference/declFileEnums.symbols
+++ b/tests/baselines/reference/declFileEnums.symbols
@@ -35,9 +35,9 @@ enum e3 {
 
     b = Math.PI,
 >b : Symbol(e3.b, Decl(declFileEnums.ts, 14, 11))
->Math.PI : Symbol(Math.PI, Decl(lib.d.ts, 534, 19))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->PI : Symbol(Math.PI, Decl(lib.d.ts, 534, 19))
+>Math.PI : Symbol(Math.PI, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>PI : Symbol(Math.PI, Decl(lib.d.ts, --, --))
 
     c = a + 3
 >c : Symbol(e3.c, Decl(declFileEnums.ts, 15, 16))
diff --git a/tests/baselines/reference/declFileFunctions.symbols b/tests/baselines/reference/declFileFunctions.symbols
index 1853da94a46..9ee1a3603bd 100644
--- a/tests/baselines/reference/declFileFunctions.symbols
+++ b/tests/baselines/reference/declFileFunctions.symbols
@@ -24,9 +24,9 @@ export function fooWithRestParameters(a: string, ...rests: string[]) {
 
     return a + rests.join("");
 >a : Symbol(a, Decl(declFileFunctions_0.ts, 10, 38))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileFunctions_0.ts, 10, 48))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 }
 
 export function fooWithOverloads(a: string): string;
@@ -115,9 +115,9 @@ function nonExportedFooWithRestParameters(a: string, ...rests: string[]) {
 
     return a + rests.join("");
 >a : Symbol(a, Decl(declFileFunctions_0.ts, 47, 42))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileFunctions_0.ts, 47, 52))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 }
 
 function nonExportedFooWithOverloads(a: string): string;
@@ -161,9 +161,9 @@ function globalfooWithRestParameters(a: string, ...rests: string[]) {
 
     return a + rests.join("");
 >a : Symbol(a, Decl(declFileFunctions_1.ts, 9, 37))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileFunctions_1.ts, 9, 47))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 }
 function globalfooWithOverloads(a: string): string;
 >globalfooWithOverloads : Symbol(globalfooWithOverloads, Decl(declFileFunctions_1.ts, 11, 1), Decl(declFileFunctions_1.ts, 12, 51), Decl(declFileFunctions_1.ts, 13, 51))
diff --git a/tests/baselines/reference/declFileGenericType.symbols b/tests/baselines/reference/declFileGenericType.symbols
index 38460fcb143..b98e0df59ac 100644
--- a/tests/baselines/reference/declFileGenericType.symbols
+++ b/tests/baselines/reference/declFileGenericType.symbols
@@ -44,7 +44,7 @@ export module C {
 >B : Symbol(B, Decl(declFileGenericType.ts, 1, 24))
 >x : Symbol(x, Decl(declFileGenericType.ts, 7, 39))
 >T : Symbol(T, Decl(declFileGenericType.ts, 7, 23))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >C : Symbol(C, Decl(declFileGenericType.ts, 0, 0))
 >A : Symbol(A, Decl(declFileGenericType.ts, 0, 17))
 >C : Symbol(C, Decl(declFileGenericType.ts, 0, 0))
diff --git a/tests/baselines/reference/declFileMethods.symbols b/tests/baselines/reference/declFileMethods.symbols
index f0426e46026..845f3044dae 100644
--- a/tests/baselines/reference/declFileMethods.symbols
+++ b/tests/baselines/reference/declFileMethods.symbols
@@ -27,9 +27,9 @@ export class c1 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_0.ts, 11, 33))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_0.ts, 11, 43))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
 
     public fooWithOverloads(a: string): string;
@@ -73,9 +73,9 @@ export class c1 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_0.ts, 31, 41))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_0.ts, 31, 51))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
     private privateFooWithOverloads(a: string): string;
 >privateFooWithOverloads : Symbol(privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55))
@@ -118,9 +118,9 @@ export class c1 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_0.ts, 50, 39))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_0.ts, 50, 49))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
     static staticFooWithOverloads(a: string): string;
 >staticFooWithOverloads : Symbol(c1.staticFooWithOverloads, Decl(declFileMethods_0.ts, 52, 5), Decl(declFileMethods_0.ts, 53, 53), Decl(declFileMethods_0.ts, 54, 53))
@@ -163,9 +163,9 @@ export class c1 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_0.ts, 69, 54))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_0.ts, 69, 64))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
     private static privateStaticFooWithOverloads(a: string): string;
 >privateStaticFooWithOverloads : Symbol(c1.privateStaticFooWithOverloads, Decl(declFileMethods_0.ts, 71, 5), Decl(declFileMethods_0.ts, 72, 68), Decl(declFileMethods_0.ts, 73, 68))
@@ -242,9 +242,9 @@ class c2 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_1.ts, 10, 33))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_1.ts, 10, 43))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
 
     public fooWithOverloads(a: string): string;
@@ -288,9 +288,9 @@ class c2 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_1.ts, 30, 41))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_1.ts, 30, 51))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
     private privateFooWithOverloads(a: string): string;
 >privateFooWithOverloads : Symbol(privateFooWithOverloads, Decl(declFileMethods_1.ts, 32, 5), Decl(declFileMethods_1.ts, 33, 55), Decl(declFileMethods_1.ts, 34, 55))
@@ -333,9 +333,9 @@ class c2 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_1.ts, 49, 39))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_1.ts, 49, 49))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
     static staticFooWithOverloads(a: string): string;
 >staticFooWithOverloads : Symbol(c2.staticFooWithOverloads, Decl(declFileMethods_1.ts, 51, 5), Decl(declFileMethods_1.ts, 52, 53), Decl(declFileMethods_1.ts, 53, 53))
@@ -378,9 +378,9 @@ class c2 {
 
         return a + rests.join("");
 >a : Symbol(a, Decl(declFileMethods_1.ts, 68, 54))
->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
 >rests : Symbol(rests, Decl(declFileMethods_1.ts, 68, 64))
->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
     }
     private static privateStaticFooWithOverloads(a: string): string;
 >privateStaticFooWithOverloads : Symbol(c2.privateStaticFooWithOverloads, Decl(declFileMethods_1.ts, 70, 5), Decl(declFileMethods_1.ts, 71, 68), Decl(declFileMethods_1.ts, 72, 68))
diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols
index 4f02212d79e..becc01438c2 100644
--- a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols
+++ b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols
@@ -20,7 +20,7 @@ class c1 {
     private _forEachBindingContext(bindingContextArray: Array<IContext>, fn: (bindingContext: IContext) => void);
 >_forEachBindingContext : Symbol(_forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113))
 >bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 6, 35))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0))
 >fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 6, 72))
 >bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 6, 78))
@@ -44,7 +44,7 @@ class c1 {
     private overloadWithArityDifference(bindingContextArray: Array<IContext>, fn: (bindingContext: IContext) => void);
 >overloadWithArityDifference : Symbol(overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118))
 >bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 12, 40))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >IContext : Symbol(IContext, Decl(declFilePrivateMethodOverloads.ts, 0, 0))
 >fn : Symbol(fn, Decl(declFilePrivateMethodOverloads.ts, 12, 77))
 >bindingContext : Symbol(bindingContext, Decl(declFilePrivateMethodOverloads.ts, 12, 83))
diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols
index 7250567039a..f48ced073d5 100644
--- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols
+++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols
@@ -20,9 +20,9 @@ function foo(a: string): string | number {
 >a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13))
 
         return a.length;
->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>a.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
 
     return a;
diff --git a/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols b/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols
index 4f79e47277b..9c9e757afb9 100644
--- a/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols
+++ b/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols
@@ -1,5 +1,5 @@
 === tests/cases/compiler/declarationEmit_array-types-from-generic-array-usage.ts ===
 interface A extends Array<string> { }
 >A : Symbol(A, Decl(declarationEmit_array-types-from-generic-array-usage.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols b/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols
index 881728ce641..0b1b06cc99e 100644
--- a/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols
+++ b/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols
@@ -23,10 +23,10 @@ declare module "express" {
             post(path: RegExp, handler: (req: Function) => void ): void;
 >post : Symbol(post, Decl(declareExternalModuleWithExportAssignedFundule.ts, 10, 48))
 >path : Symbol(path, Decl(declareExternalModuleWithExportAssignedFundule.ts, 12, 17))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >handler : Symbol(handler, Decl(declareExternalModuleWithExportAssignedFundule.ts, 12, 30))
 >req : Symbol(req, Decl(declareExternalModuleWithExportAssignedFundule.ts, 12, 41))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         }
 
diff --git a/tests/baselines/reference/decoratorCallGeneric.errors.txt b/tests/baselines/reference/decoratorCallGeneric.errors.txt
new file mode 100644
index 00000000000..c8443420740
--- /dev/null
+++ b/tests/baselines/reference/decoratorCallGeneric.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/conformance/decorators/decoratorCallGeneric.ts(7,2): error TS1238: Unable to resolve signature of class decorator when called as an expression.
+  The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+    Type argument candidate 'C' is not a valid type argument because it is not a supertype of candidate 'void'.
+
+
+==== tests/cases/conformance/decorators/decoratorCallGeneric.ts (1 errors) ====
+    interface I<T> {
+        prototype: T,
+        m: () => T
+    }
+    function dec<T>(c: I<T>) { }
+    
+    @dec
+     ~~~
+!!! error TS1238: Unable to resolve signature of class decorator when called as an expression.
+!!! error TS1238:   The type argument for type parameter 'T' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
+!!! error TS1238:     Type argument candidate 'C' is not a valid type argument because it is not a supertype of candidate 'void'.
+    class C {
+        _brand: any;
+        static m() {}
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/decoratorCallGeneric.js b/tests/baselines/reference/decoratorCallGeneric.js
new file mode 100644
index 00000000000..8c141d5a131
--- /dev/null
+++ b/tests/baselines/reference/decoratorCallGeneric.js
@@ -0,0 +1,31 @@
+//// [decoratorCallGeneric.ts]
+interface I<T> {
+    prototype: T,
+    m: () => T
+}
+function dec<T>(c: I<T>) { }
+
+@dec
+class C {
+    _brand: any;
+    static m() {}
+}
+
+
+//// [decoratorCallGeneric.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+function dec(c) { }
+var C = (function () {
+    function C() {
+    }
+    C.m = function () { };
+    C = __decorate([
+        dec
+    ], C);
+    return C;
+})();
diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols
index e1507c75e94..09530f9cecf 100644
--- a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols
+++ b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols
@@ -21,7 +21,7 @@ class A {
 function decorator(target: Object, propertyKey: string) {
 >decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 7, 1))
 >target : Symbol(target, Decl(decoratorMetadataOnInferredType.ts, 9, 19))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >propertyKey : Symbol(propertyKey, Decl(decoratorMetadataOnInferredType.ts, 9, 34))
 }
 
diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols
index 57221f0d139..db1c388f206 100644
--- a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols
+++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols
@@ -21,7 +21,7 @@ class A {
 function decorator(target: Object, propertyKey: string) {
 >decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 7, 1))
 >target : Symbol(target, Decl(decoratorMetadataWithConstructorType.ts, 9, 19))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >propertyKey : Symbol(propertyKey, Decl(decoratorMetadataWithConstructorType.ts, 9, 34))
 }
 
diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.symbols b/tests/baselines/reference/decoratorOnClassAccessor1.symbols
index 933dff1b4c5..6b8e3a16c18 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor1.symbols
+++ b/tests/baselines/reference/decoratorOnClassAccessor1.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassAccessor1.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor1.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor1.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor1.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor1.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassAccessor2.symbols b/tests/baselines/reference/decoratorOnClassAccessor2.symbols
index 5738bb50bb8..936afa14de9 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor2.symbols
+++ b/tests/baselines/reference/decoratorOnClassAccessor2.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassAccessor2.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor2.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor2.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor2.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor2.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassAccessor4.symbols b/tests/baselines/reference/decoratorOnClassAccessor4.symbols
index 1100df1c081..0acd491abed 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor4.symbols
+++ b/tests/baselines/reference/decoratorOnClassAccessor4.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassAccessor4.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor4.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor4.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor4.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor4.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassAccessor5.symbols b/tests/baselines/reference/decoratorOnClassAccessor5.symbols
index 8d9927776c2..0585cff96b6 100644
--- a/tests/baselines/reference/decoratorOnClassAccessor5.symbols
+++ b/tests/baselines/reference/decoratorOnClassAccessor5.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassAccessor5.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor5.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor5.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor5.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassAccessor5.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols b/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols
index a863f74e2ff..2349029421c 100644
--- a/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols
+++ b/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols
@@ -2,7 +2,7 @@
 declare function dec(target: Function, propertyKey: string | symbol, parameterIndex: number): void;
 >dec : Symbol(dec, Decl(decoratorOnClassConstructorParameter1.ts, 0, 0))
 >target : Symbol(target, Decl(decoratorOnClassConstructorParameter1.ts, 0, 21))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassConstructorParameter1.ts, 0, 38))
 >parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassConstructorParameter1.ts, 0, 68))
 
diff --git a/tests/baselines/reference/decoratorOnClassMethod1.symbols b/tests/baselines/reference/decoratorOnClassMethod1.symbols
index f1463115f49..8a92ad7b01b 100644
--- a/tests/baselines/reference/decoratorOnClassMethod1.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod1.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod1.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod1.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod1.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod1.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod1.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod13.symbols b/tests/baselines/reference/decoratorOnClassMethod13.symbols
index 42f44d885ee..6dfcd15d040 100644
--- a/tests/baselines/reference/decoratorOnClassMethod13.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod13.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod13.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod13.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod13.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod2.symbols b/tests/baselines/reference/decoratorOnClassMethod2.symbols
index e7942d3ae45..ebab8905469 100644
--- a/tests/baselines/reference/decoratorOnClassMethod2.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod2.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod2.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod2.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod2.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod2.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod2.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod4.symbols b/tests/baselines/reference/decoratorOnClassMethod4.symbols
index 688bc03775a..745fb8c4ce7 100644
--- a/tests/baselines/reference/decoratorOnClassMethod4.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod4.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod4.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod4.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod4.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod4.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod4.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod5.symbols b/tests/baselines/reference/decoratorOnClassMethod5.symbols
index 6356ca35449..124ace783fe 100644
--- a/tests/baselines/reference/decoratorOnClassMethod5.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod5.symbols
@@ -5,9 +5,9 @@ declare function dec(): <T>(target: any, propertyKey: string, descriptor: TypedP
 >target : Symbol(target, Decl(decoratorOnClassMethod5.ts, 0, 28))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod5.ts, 0, 40))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod5.ts, 0, 61))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod5.ts, 0, 25))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod5.ts, 0, 25))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethod7.symbols b/tests/baselines/reference/decoratorOnClassMethod7.symbols
index 75c3bee294d..e870a798559 100644
--- a/tests/baselines/reference/decoratorOnClassMethod7.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethod7.symbols
@@ -5,9 +5,9 @@ declare function dec<T>(target: any, propertyKey: string, descriptor: TypedPrope
 >target : Symbol(target, Decl(decoratorOnClassMethod7.ts, 0, 24))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod7.ts, 0, 36))
 >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod7.ts, 0, 57))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod7.ts, 0, 21))
->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36))
+>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(decoratorOnClassMethod7.ts, 0, 21))
 
 class C {
diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols b/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols
index 47c5999ff47..1358343a9c5 100644
--- a/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols
+++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols
@@ -2,7 +2,7 @@
 declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void;
 >dec : Symbol(dec, Decl(decoratorOnClassMethodParameter1.ts, 0, 0))
 >target : Symbol(target, Decl(decoratorOnClassMethodParameter1.ts, 0, 21))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethodParameter1.ts, 0, 36))
 >parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassMethodParameter1.ts, 0, 66))
 
diff --git a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
index 31213ce2fd4..46e5515633a 100644
--- a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
@@ -36,15 +36,21 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(60,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(63,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(65,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(67,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(68,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(70,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(71,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(72,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(67,7): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(67,9): error TS1109: Expression expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(68,7): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(68,9): error TS1109: Expression expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,7): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,9): error TS1109: Expression expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(70,10): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(70,12): error TS1109: Expression expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(71,10): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(71,12): error TS1109: Expression expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(72,10): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts(72,12): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts (44 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithAnyOtherTypeInvalidOperations.ts (50 errors) ====
     // -- operator on any type
     var ANY1;
     var ANY2: any[] = ["", ""];
@@ -188,20 +194,32 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     
     --ANY1--;
-      ~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+          ~~
+!!! error TS1005: ';' expected.
+            ~
+!!! error TS1109: Expression expected.
     --ANY1++;
-      ~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+          ~~
+!!! error TS1005: ';' expected.
+            ~
+!!! error TS1109: Expression expected.
     ++ANY1--;
-      ~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+          ~~
+!!! error TS1005: ';' expected.
+            ~
+!!! error TS1109: Expression expected.
     --ANY2[0]--;
-      ~~~~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+             ~~
+!!! error TS1005: ';' expected.
+               ~
+!!! error TS1109: Expression expected.
     --ANY2[0]++;
-      ~~~~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+             ~~
+!!! error TS1005: ';' expected.
+               ~
+!!! error TS1109: Expression expected.
     ++ANY2[0]--;
-      ~~~~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
\ No newline at end of file
+             ~~
+!!! error TS1005: ';' expected.
+               ~
+!!! error TS1109: Expression expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.js b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.js
index 5b717d0669c..f8021a713c4 100644
--- a/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.js
+++ b/tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.js
@@ -131,9 +131,15 @@ var ResultIsNumber30 = obj1.y--;
 // miss assignment operators
 --ANY2;
 ANY2--;
---ANY1--;
---ANY1++;
-++ANY1--;
---ANY2[0]--;
---ANY2[0]++;
-++ANY2[0]--;
+--ANY1;
+--;
+--ANY1;
+++;
+++ANY1;
+--;
+--ANY2[0];
+--;
+--ANY2[0];
+++;
+++ANY2[0];
+--;
diff --git a/tests/baselines/reference/defaultExportWithOverloads01.js b/tests/baselines/reference/defaultExportWithOverloads01.js
new file mode 100644
index 00000000000..9ec8cccf5bf
--- /dev/null
+++ b/tests/baselines/reference/defaultExportWithOverloads01.js
@@ -0,0 +1,16 @@
+//// [defaultExportWithOverloads01.ts]
+
+export default function f();
+export default function f(x: string);
+export default function f(...args: any[]) {
+}
+
+//// [defaultExportWithOverloads01.js]
+function f() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i - 0] = arguments[_i];
+    }
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = f;
diff --git a/tests/baselines/reference/defaultExportWithOverloads01.symbols b/tests/baselines/reference/defaultExportWithOverloads01.symbols
new file mode 100644
index 00000000000..a5ff0df5262
--- /dev/null
+++ b/tests/baselines/reference/defaultExportWithOverloads01.symbols
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts ===
+
+export default function f();
+>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37))
+
+export default function f(x: string);
+>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37))
+>x : Symbol(x, Decl(defaultExportWithOverloads01.ts, 2, 26))
+
+export default function f(...args: any[]) {
+>f : Symbol(f, Decl(defaultExportWithOverloads01.ts, 0, 0), Decl(defaultExportWithOverloads01.ts, 1, 28), Decl(defaultExportWithOverloads01.ts, 2, 37))
+>args : Symbol(args, Decl(defaultExportWithOverloads01.ts, 3, 26))
+}
diff --git a/tests/baselines/reference/defaultExportWithOverloads01.types b/tests/baselines/reference/defaultExportWithOverloads01.types
new file mode 100644
index 00000000000..c006083b4ba
--- /dev/null
+++ b/tests/baselines/reference/defaultExportWithOverloads01.types
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts ===
+
+export default function f();
+>f : { (): any; (x: string): any; }
+
+export default function f(x: string);
+>f : { (): any; (x: string): any; }
+>x : string
+
+export default function f(...args: any[]) {
+>f : { (): any; (x: string): any; }
+>args : any[]
+}
diff --git a/tests/baselines/reference/deleteOperatorWithStringType.symbols b/tests/baselines/reference/deleteOperatorWithStringType.symbols
index a13ddd5fa39..204aac0123b 100644
--- a/tests/baselines/reference/deleteOperatorWithStringType.symbols
+++ b/tests/baselines/reference/deleteOperatorWithStringType.symbols
@@ -88,9 +88,9 @@ var ResultIsBoolean11 = delete (STRING + STRING);
 
 var ResultIsBoolean12 = delete STRING.charAt(0);
 >ResultIsBoolean12 : Symbol(ResultIsBoolean12, Decl(deleteOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(deleteOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 // multiple delete  operator
 var ResultIsBoolean13 = delete delete STRING;
diff --git a/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols b/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols
index dd384838694..17fb21e867d 100644
--- a/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols
+++ b/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols
@@ -4,7 +4,7 @@ class Base {
 
     [x: string]: Object;
 >x : Symbol(x, Decl(derivedClassOverridesIndexersWithAssignmentCompatibility.ts, 1, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 // ok, use assignment compatibility
@@ -21,7 +21,7 @@ class Base2 {
 
     [x: number]: Object;
 >x : Symbol(x, Decl(derivedClassOverridesIndexersWithAssignmentCompatibility.ts, 10, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 // ok, use assignment compatibility
diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols b/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols
index 59d062f459c..b1160328160 100644
--- a/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols
+++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols
@@ -193,7 +193,7 @@ class Base2 {
 
     [i: string]: Object;
 >i : Symbol(i, Decl(derivedClassOverridesProtectedMembers2.ts, 49, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [i: number]: typeof x;
 >i : Symbol(i, Decl(derivedClassOverridesProtectedMembers2.ts, 50, 5))
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
index c2130f060ab..c4dc8fd0f79 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
@@ -8,19 +8,19 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function a1(...x: (number|string)[]) { }
 >a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 9, 45))
@@ -33,8 +33,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36))
@@ -122,7 +122,7 @@ const enum E1 { a, b }
 function foo1<T extends Number>(...a: T[]) { }
 >foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 40, 32))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14))
 
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
index 976c402d2b0..46682802e2a 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
@@ -8,19 +8,19 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function a1(...x: (number|string)[]) { }
 >a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 9, 45))
@@ -33,8 +33,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36))
@@ -122,7 +122,7 @@ const enum E1 { a, b }
 function foo1<T extends Number>(...a: T[]) { }
 >foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 40, 32))
 >T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14))
 
diff --git a/tests/baselines/reference/destructuringWithGenericParameter.symbols b/tests/baselines/reference/destructuringWithGenericParameter.symbols
index 941cb0bf237..0c489cf1ef2 100644
--- a/tests/baselines/reference/destructuringWithGenericParameter.symbols
+++ b/tests/baselines/reference/destructuringWithGenericParameter.symbols
@@ -37,9 +37,9 @@ genericFunction(genericObject, ({greeting}) => {
 
     var s = greeting.toLocaleLowerCase();  // Greeting should be of type string
 >s : Symbol(s, Decl(destructuringWithGenericParameter.ts, 11, 7))
->greeting.toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, 402, 26))
+>greeting.toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, --, --))
 >greeting : Symbol(greeting, Decl(destructuringWithGenericParameter.ts, 10, 33))
->toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, 402, 26))
+>toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, --, --))
 
 });
 
diff --git a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
index 41916162553..a1c083fbc15 100644
--- a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
+++ b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols
@@ -1,36 +1,36 @@
 === tests/cases/compiler/duplicateOverloadInTypeAugmentation1.ts ===
 interface Array<T> {
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 
     reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T,
->reduce : Symbol(reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>reduce : Symbol(reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >callbackfn : Symbol(callbackfn, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 11))
 >previousValue : Symbol(previousValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 24))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 >currentValue : Symbol(currentValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 41))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 >currentIndex : Symbol(currentIndex, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 58))
 >array : Symbol(array, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 80))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 
         initialValue?: T): T;
 >initialValue : Symbol(initialValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 98))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 
     reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U,
->reduce : Symbol(reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>reduce : Symbol(reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >U : Symbol(U, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 11))
 >callbackfn : Symbol(callbackfn, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 14))
 >previousValue : Symbol(previousValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 27))
 >U : Symbol(U, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 11))
 >currentValue : Symbol(currentValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 44))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 >currentIndex : Symbol(currentIndex, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 61))
 >array : Symbol(array, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 83))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16))
 >U : Symbol(U, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 11))
 
         initialValue: U): U;
@@ -40,13 +40,13 @@ interface Array<T> {
 }
 var a: Array<string>;
 >a : Symbol(a, Decl(duplicateOverloadInTypeAugmentation1.ts, 6, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0))
 
 var r5 = a.reduce((x, y) => x + y);
 >r5 : Symbol(r5, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 3))
->a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >a : Symbol(a, Decl(duplicateOverloadInTypeAugmentation1.ts, 6, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))
 >y : Symbol(y, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 21))
 >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index 3e7770ccdda..f5846be3738 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -4,9 +4,9 @@ function f() {
 >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 0, 0))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 
         let arguments = 100;
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 3, 11))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index c0ea901fbbf..648f04b0814 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -7,9 +7,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 2, 7))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 
         const arguments = 100;
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 4, 13))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index 3d09056c8c3..bc9fcbfa159 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -7,9 +7,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 
         return () => arguments[0];
 >arguments : Symbol(arguments)
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index 22431e495cc..65f4e121d10 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -8,9 +8,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 25))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 
         return () => arguments[0];
 >arguments : Symbol(arguments)
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index 6dbbe9501d0..a15a10c29d8 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -9,9 +9,9 @@ function f() {
 >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31))
 
     if (Math.random()) {
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 
         return () => arguments;
 >arguments : Symbol(arguments)
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js
new file mode 100644
index 00000000000..3b9db4c6998
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js
@@ -0,0 +1,32 @@
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts]
+
+var array0 = [1, 2, 3]
+var i0 = 0;
+array0[++i0] **= 2;
+
+var array1 = [1, 2, 3]
+var i1 = 0;
+array1[++i1] **= array1[++i1] **= 2;
+
+var array2 = [1, 2, 3]
+var i2 = 0;
+array2[++i2] **= array2[++i2] ** 2;
+
+var array3 = [2, 2, 3];
+var j0 = 0, j1 = 1;
+array3[j0++] **= array3[j1++] **= array3[j0++] **= 1;
+
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS1.js]
+var array0 = [1, 2, 3];
+var i0 = 0;
+(_a = array0, _i = ++i0, _a[_i] = Math.pow(_a[_i], 2));
+var array1 = [1, 2, 3];
+var i1 = 0;
+(_b = array1, _c = ++i1, _b[_c] = Math.pow(_b[_c], (_d = array1, _e = ++i1, _d[_e] = Math.pow(_d[_e], 2))));
+var array2 = [1, 2, 3];
+var i2 = 0;
+(_f = array2, _g = ++i2, _f[_g] = Math.pow(_f[_g], Math.pow(array2[++i2], 2)));
+var array3 = [2, 2, 3];
+var j0 = 0, j1 = 1;
+(_h = array3, _j = j0++, _h[_j] = Math.pow(_h[_j], (_k = array3, _l = j1++, _k[_l] = Math.pow(_k[_l], (_m = array3, _o = j0++, _m[_o] = Math.pow(_m[_o], 1))))));
+var _a, _i, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols
new file mode 100644
index 00000000000..83f71871ec0
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.symbols
@@ -0,0 +1,51 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts ===
+
+var array0 = [1, 2, 3]
+>array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3))
+
+var i0 = 0;
+>i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 2, 3))
+
+array0[++i0] **= 2;
+>array0 : Symbol(array0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 1, 3))
+>i0 : Symbol(i0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 2, 3))
+
+var array1 = [1, 2, 3]
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3))
+
+var i1 = 0;
+>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3))
+
+array1[++i1] **= array1[++i1] **= 2;
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3))
+>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 5, 3))
+>i1 : Symbol(i1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 6, 3))
+
+var array2 = [1, 2, 3]
+>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3))
+
+var i2 = 0;
+>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3))
+
+array2[++i2] **= array2[++i2] ** 2;
+>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3))
+>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3))
+>array2 : Symbol(array2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 9, 3))
+>i2 : Symbol(i2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 10, 3))
+
+var array3 = [2, 2, 3];
+>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3))
+
+var j0 = 0, j1 = 1;
+>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3))
+>j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 11))
+
+array3[j0++] **= array3[j1++] **= array3[j0++] **= 1;
+>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3))
+>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3))
+>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3))
+>j1 : Symbol(j1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 11))
+>array3 : Symbol(array3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 13, 3))
+>j0 : Symbol(j0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts, 14, 3))
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types
new file mode 100644
index 00000000000..393499a931f
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.types
@@ -0,0 +1,100 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts ===
+
+var array0 = [1, 2, 3]
+>array0 : number[]
+>[1, 2, 3] : number[]
+>1 : number
+>2 : number
+>3 : number
+
+var i0 = 0;
+>i0 : number
+>0 : number
+
+array0[++i0] **= 2;
+>array0[++i0] **= 2 : number
+>array0[++i0] : number
+>array0 : number[]
+>++i0 : number
+>i0 : number
+>2 : number
+
+var array1 = [1, 2, 3]
+>array1 : number[]
+>[1, 2, 3] : number[]
+>1 : number
+>2 : number
+>3 : number
+
+var i1 = 0;
+>i1 : number
+>0 : number
+
+array1[++i1] **= array1[++i1] **= 2;
+>array1[++i1] **= array1[++i1] **= 2 : number
+>array1[++i1] : number
+>array1 : number[]
+>++i1 : number
+>i1 : number
+>array1[++i1] **= 2 : number
+>array1[++i1] : number
+>array1 : number[]
+>++i1 : number
+>i1 : number
+>2 : number
+
+var array2 = [1, 2, 3]
+>array2 : number[]
+>[1, 2, 3] : number[]
+>1 : number
+>2 : number
+>3 : number
+
+var i2 = 0;
+>i2 : number
+>0 : number
+
+array2[++i2] **= array2[++i2] ** 2;
+>array2[++i2] **= array2[++i2] ** 2 : number
+>array2[++i2] : number
+>array2 : number[]
+>++i2 : number
+>i2 : number
+>array2[++i2] ** 2 : number
+>array2[++i2] : number
+>array2 : number[]
+>++i2 : number
+>i2 : number
+>2 : number
+
+var array3 = [2, 2, 3];
+>array3 : number[]
+>[2, 2, 3] : number[]
+>2 : number
+>2 : number
+>3 : number
+
+var j0 = 0, j1 = 1;
+>j0 : number
+>0 : number
+>j1 : number
+>1 : number
+
+array3[j0++] **= array3[j1++] **= array3[j0++] **= 1;
+>array3[j0++] **= array3[j1++] **= array3[j0++] **= 1 : number
+>array3[j0++] : number
+>array3 : number[]
+>j0++ : number
+>j0 : number
+>array3[j1++] **= array3[j0++] **= 1 : number
+>array3[j1++] : number
+>array3 : number[]
+>j1++ : number
+>j1 : number
+>array3[j0++] **= 1 : number
+>array3[j0++] : number
+>array3 : number[]
+>j0++ : number
+>j0 : number
+>1 : number
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.js
new file mode 100644
index 00000000000..83e0b2473e8
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.js
@@ -0,0 +1,26 @@
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts]
+var globalCounter = 0;
+function foo() {
+    globalCounter += 1;
+    return { 0: 2 };
+}
+foo()[0] **= foo()[0];
+var result_foo1 = foo()[0] **= foo()[0];
+foo()[0] **= foo()[0] **= 2;
+var result_foo2 = foo()[0] **= foo()[0] **= 2;
+foo()[0] **= foo()[0] ** 2;
+var result_foo3 = foo()[0] **= foo()[0] ** 2;
+
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS2.js]
+var globalCounter = 0;
+function foo() {
+    globalCounter += 1;
+    return { 0: 2 };
+}
+(_a = foo(), _a[0] = Math.pow(_a[0], foo()[0]));
+var result_foo1 = (_b = foo(), _b[0] = Math.pow(_b[0], foo()[0]));
+(_c = foo(), _c[0] = Math.pow(_c[0], (_d = foo(), _d[0] = Math.pow(_d[0], 2))));
+var result_foo2 = (_e = foo(), _e[0] = Math.pow(_e[0], (_f = foo(), _f[0] = Math.pow(_f[0], 2))));
+(_g = foo(), _g[0] = Math.pow(_g[0], Math.pow(foo()[0], 2)));
+var result_foo3 = (_h = foo(), _h[0] = Math.pow(_h[0], Math.pow(foo()[0], 2)));
+var _a, _b, _c, _d, _e, _f, _g, _h;
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.symbols
new file mode 100644
index 00000000000..923c0bac1ef
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.symbols
@@ -0,0 +1,51 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts ===
+var globalCounter = 0;
+>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 3))
+
+function foo() {
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+
+    globalCounter += 1;
+>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 3))
+
+    return { 0: 2 };
+}
+foo()[0] **= foo()[0];
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+
+var result_foo1 = foo()[0] **= foo()[0];
+>result_foo1 : Symbol(result_foo1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 6, 3))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+
+foo()[0] **= foo()[0] **= 2;
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+
+var result_foo2 = foo()[0] **= foo()[0] **= 2;
+>result_foo2 : Symbol(result_foo2, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 8, 3))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+
+foo()[0] **= foo()[0] ** 2;
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+
+var result_foo3 = foo()[0] **= foo()[0] ** 2;
+>result_foo3 : Symbol(result_foo3, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 10, 3))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 0, 22))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts, 3, 12))
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.types
new file mode 100644
index 00000000000..c47f539baf2
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.types
@@ -0,0 +1,94 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts ===
+var globalCounter = 0;
+>globalCounter : number
+>0 : number
+
+function foo() {
+>foo : () => { 0: number; }
+
+    globalCounter += 1;
+>globalCounter += 1 : number
+>globalCounter : number
+>1 : number
+
+    return { 0: 2 };
+>{ 0: 2 } : { 0: number; }
+>2 : number
+}
+foo()[0] **= foo()[0];
+>foo()[0] **= foo()[0] : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+
+var result_foo1 = foo()[0] **= foo()[0];
+>result_foo1 : number
+>foo()[0] **= foo()[0] : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+
+foo()[0] **= foo()[0] **= 2;
+>foo()[0] **= foo()[0] **= 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>foo()[0] **= 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>2 : number
+
+var result_foo2 = foo()[0] **= foo()[0] **= 2;
+>result_foo2 : number
+>foo()[0] **= foo()[0] **= 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>foo()[0] **= 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>2 : number
+
+foo()[0] **= foo()[0] ** 2;
+>foo()[0] **= foo()[0] ** 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>foo()[0] ** 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>2 : number
+
+var result_foo3 = foo()[0] **= foo()[0] ** 2;
+>result_foo3 : number
+>foo()[0] **= foo()[0] ** 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>foo()[0] ** 2 : number
+>foo()[0] : number
+>foo() : { 0: number; }
+>foo : () => { 0: number; }
+>0 : number
+>2 : number
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js
new file mode 100644
index 00000000000..797ccccc331
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js
@@ -0,0 +1,29 @@
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts]
+
+var object = {
+    _0: 2,
+    get 0() {
+        return this._0;
+    },
+    set 0(x: number) {
+        this._0 = x;
+    },
+}
+object[0] **= object[0];
+object[0] **= object[0] **= 2;
+object[0] **= object[0] ** 2;
+
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js]
+var object = {
+    _0: 2,
+    get 0() {
+        return this._0;
+    },
+    set 0(x) {
+        this._0 = x;
+    },
+};
+(_a = object, _a[0] = Math.pow(_a[0], object[0]));
+(_b = object, _b[0] = Math.pow(_b[0], (_c = object, _c[0] = Math.pow(_c[0], 2))));
+(_d = object, _d[0] = Math.pow(_d[0], Math.pow(object[0], 2)));
+var _a, _b, _c, _d;
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols
new file mode 100644
index 00000000000..dbd5aa150dc
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.symbols
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts ===
+
+var object = {
+>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3))
+
+    _0: 2,
+>_0 : Symbol(_0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 14))
+
+    get 0() {
+        return this._0;
+    },
+    set 0(x: number) {
+>x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 6, 10))
+
+        this._0 = x;
+>x : Symbol(x, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 6, 10))
+
+    },
+}
+object[0] **= object[0];
+>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6))
+>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6))
+
+object[0] **= object[0] **= 2;
+>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6))
+>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6))
+
+object[0] **= object[0] ** 2;
+>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6))
+>object : Symbol(object, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 1, 3))
+>0 : Symbol(0, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 2, 10), Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts, 5, 6))
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types
new file mode 100644
index 00000000000..1877f391207
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.types
@@ -0,0 +1,60 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts ===
+
+var object = {
+>object : { 0: number; _0: number; }
+>{    _0: 2,    get 0() {        return this._0;    },    set 0(x: number) {        this._0 = x;    },} : { 0: number; _0: number; }
+
+    _0: 2,
+>_0 : number
+>2 : number
+
+    get 0() {
+        return this._0;
+>this._0 : any
+>this : any
+>_0 : any
+
+    },
+    set 0(x: number) {
+>x : number
+
+        this._0 = x;
+>this._0 = x : number
+>this._0 : any
+>this : any
+>_0 : any
+>x : number
+
+    },
+}
+object[0] **= object[0];
+>object[0] **= object[0] : number
+>object[0] : number
+>object : { 0: number; _0: number; }
+>0 : number
+>object[0] : number
+>object : { 0: number; _0: number; }
+>0 : number
+
+object[0] **= object[0] **= 2;
+>object[0] **= object[0] **= 2 : number
+>object[0] : number
+>object : { 0: number; _0: number; }
+>0 : number
+>object[0] **= 2 : number
+>object[0] : number
+>object : { 0: number; _0: number; }
+>0 : number
+>2 : number
+
+object[0] **= object[0] ** 2;
+>object[0] **= object[0] ** 2 : number
+>object[0] : number
+>object : { 0: number; _0: number; }
+>0 : number
+>object[0] ** 2 : number
+>object[0] : number
+>object : { 0: number; _0: number; }
+>0 : number
+>2 : number
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js
new file mode 100644
index 00000000000..f61693f192c
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js
@@ -0,0 +1,29 @@
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts]
+
+var globalCounter = 0;
+function incrementIdx(max: number) {
+    globalCounter += 1;
+    let idx = Math.floor(Math.random() * max);
+    return idx;
+}
+
+var array1 = [1, 2, 3, 4, 5];
+
+array1[incrementIdx(array1.length)] **= 3;
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] **= 2;
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] ** 2;
+
+//// [emitCompoundExponentiationAssignmentWithIndexingOnLHS4.js]
+var globalCounter = 0;
+function incrementIdx(max) {
+    globalCounter += 1;
+    var idx = Math.floor(Math.random() * max);
+    return idx;
+}
+var array1 = [1, 2, 3, 4, 5];
+(_a = array1, _i = incrementIdx(array1.length), _a[_i] = Math.pow(_a[_i], 3));
+(_b = array1, _c = incrementIdx(array1.length), _b[_c] = Math.pow(_b[_c], (_d = array1, _e = incrementIdx(array1.length), _d[_e] = Math.pow(_d[_e], 2))));
+(_f = array1, _g = incrementIdx(array1.length), _f[_g] = Math.pow(_f[_g], Math.pow(array1[incrementIdx(array1.length)], 2)));
+var _a, _i, _b, _c, _d, _e, _f, _g;
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols
new file mode 100644
index 00000000000..19a9805a0c2
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.symbols
@@ -0,0 +1,60 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts ===
+
+var globalCounter = 0;
+>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 3))
+
+function incrementIdx(max: number) {
+>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22))
+>max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 2, 22))
+
+    globalCounter += 1;
+>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 3))
+
+    let idx = Math.floor(Math.random() * max);
+>idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 4, 7))
+>Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>max : Symbol(max, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 2, 22))
+
+    return idx;
+>idx : Symbol(idx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 4, 7))
+}
+
+var array1 = [1, 2, 3, 4, 5];
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+
+array1[incrementIdx(array1.length)] **= 3;
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22))
+>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] **= 2;
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22))
+>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22))
+>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] ** 2;
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22))
+>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>incrementIdx : Symbol(incrementIdx, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 1, 22))
+>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array1 : Symbol(array1, Decl(emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts, 8, 3))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types
new file mode 100644
index 00000000000..abfc69d7ca6
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.types
@@ -0,0 +1,90 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts ===
+
+var globalCounter = 0;
+>globalCounter : number
+>0 : number
+
+function incrementIdx(max: number) {
+>incrementIdx : (max: number) => number
+>max : number
+
+    globalCounter += 1;
+>globalCounter += 1 : number
+>globalCounter : number
+>1 : number
+
+    let idx = Math.floor(Math.random() * max);
+>idx : number
+>Math.floor(Math.random() * max) : number
+>Math.floor : (x: number) => number
+>Math : Math
+>floor : (x: number) => number
+>Math.random() * max : number
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>max : number
+
+    return idx;
+>idx : number
+}
+
+var array1 = [1, 2, 3, 4, 5];
+>array1 : number[]
+>[1, 2, 3, 4, 5] : number[]
+>1 : number
+>2 : number
+>3 : number
+>4 : number
+>5 : number
+
+array1[incrementIdx(array1.length)] **= 3;
+>array1[incrementIdx(array1.length)] **= 3 : number
+>array1[incrementIdx(array1.length)] : number
+>array1 : number[]
+>incrementIdx(array1.length) : number
+>incrementIdx : (max: number) => number
+>array1.length : number
+>array1 : number[]
+>length : number
+>3 : number
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] **= 2;
+>array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] **= 2 : number
+>array1[incrementIdx(array1.length)] : number
+>array1 : number[]
+>incrementIdx(array1.length) : number
+>incrementIdx : (max: number) => number
+>array1.length : number
+>array1 : number[]
+>length : number
+>array1[incrementIdx(array1.length)] **= 2 : number
+>array1[incrementIdx(array1.length)] : number
+>array1 : number[]
+>incrementIdx(array1.length) : number
+>incrementIdx : (max: number) => number
+>array1.length : number
+>array1 : number[]
+>length : number
+>2 : number
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] ** 2;
+>array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] ** 2 : number
+>array1[incrementIdx(array1.length)] : number
+>array1 : number[]
+>incrementIdx(array1.length) : number
+>incrementIdx : (max: number) => number
+>array1.length : number
+>array1 : number[]
+>length : number
+>array1[incrementIdx(array1.length)] ** 2 : number
+>array1[incrementIdx(array1.length)] : number
+>array1 : number[]
+>incrementIdx(array1.length) : number
+>incrementIdx : (max: number) => number
+>array1.length : number
+>array1 : number[]
+>length : number
+>2 : number
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js
new file mode 100644
index 00000000000..99204e6362c
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js
@@ -0,0 +1,27 @@
+//// [emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts]
+
+var globalCounter = 0;
+function foo() {
+    globalCounter += 1;
+    return { prop: 2 };
+}
+foo().prop **= 2;
+var result0 = foo().prop **= 2;
+foo().prop **= foo().prop **= 2;
+var result1 = foo().prop **= foo().prop **= 2;
+foo().prop **= foo().prop ** 2;
+var result2 = foo().prop **= foo().prop ** 2;
+
+//// [emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.js]
+var globalCounter = 0;
+function foo() {
+    globalCounter += 1;
+    return { prop: 2 };
+}
+(_a = foo(), _a.prop = Math.pow(_a.prop, 2));
+var result0 = (_b = foo(), _b.prop = Math.pow(_b.prop, 2));
+(_c = foo(), _c.prop = Math.pow(_c.prop, (_d = foo(), _d.prop = Math.pow(_d.prop, 2))));
+var result1 = (_e = foo(), _e.prop = Math.pow(_e.prop, (_f = foo(), _f.prop = Math.pow(_f.prop, 2))));
+(_g = foo(), _g.prop = Math.pow(_g.prop, Math.pow(foo().prop, 2)));
+var result2 = (_h = foo(), _h.prop = Math.pow(_h.prop, Math.pow(foo().prop, 2)));
+var _a, _b, _c, _d, _e, _f, _g, _h;
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols
new file mode 100644
index 00000000000..6bdf5f331fb
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.symbols
@@ -0,0 +1,59 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts ===
+
+var globalCounter = 0;
+>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 3))
+
+function foo() {
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+
+    globalCounter += 1;
+>globalCounter : Symbol(globalCounter, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 3))
+
+    return { prop: 2 };
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+}
+foo().prop **= 2;
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+
+var result0 = foo().prop **= 2;
+>result0 : Symbol(result0, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 7, 3))
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+
+foo().prop **= foo().prop **= 2;
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+
+var result1 = foo().prop **= foo().prop **= 2;
+>result1 : Symbol(result1, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 9, 3))
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+
+foo().prop **= foo().prop ** 2;
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+
+var result2 = foo().prop **= foo().prop ** 2;
+>result2 : Symbol(result2, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 11, 3))
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo().prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+>foo : Symbol(foo, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 1, 22))
+>prop : Symbol(prop, Decl(emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts, 4, 12))
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types
new file mode 100644
index 00000000000..b57878e9443
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.types
@@ -0,0 +1,90 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts ===
+
+var globalCounter = 0;
+>globalCounter : number
+>0 : number
+
+function foo() {
+>foo : () => { prop: number; }
+
+    globalCounter += 1;
+>globalCounter += 1 : number
+>globalCounter : number
+>1 : number
+
+    return { prop: 2 };
+>{ prop: 2 } : { prop: number; }
+>prop : number
+>2 : number
+}
+foo().prop **= 2;
+>foo().prop **= 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>2 : number
+
+var result0 = foo().prop **= 2;
+>result0 : number
+>foo().prop **= 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>2 : number
+
+foo().prop **= foo().prop **= 2;
+>foo().prop **= foo().prop **= 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>foo().prop **= 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>2 : number
+
+var result1 = foo().prop **= foo().prop **= 2;
+>result1 : number
+>foo().prop **= foo().prop **= 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>foo().prop **= 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>2 : number
+
+foo().prop **= foo().prop ** 2;
+>foo().prop **= foo().prop ** 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>foo().prop ** 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>2 : number
+
+var result2 = foo().prop **= foo().prop ** 2;
+>result2 : number
+>foo().prop **= foo().prop ** 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>foo().prop ** 2 : number
+>foo().prop : number
+>foo() : { prop: number; }
+>foo : () => { prop: number; }
+>prop : number
+>2 : number
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.js b/tests/baselines/reference/emitCompoundExponentiationOperator1.js
new file mode 100644
index 00000000000..cf72ce1d39f
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.js
@@ -0,0 +1,43 @@
+//// [emitCompoundExponentiationOperator1.ts]
+
+var comp: number;
+
+comp **= 1;
+comp **= comp ** comp;
+comp **= comp ** comp ** 2;
+comp **= comp ** comp + 2;
+comp **= comp ** comp - 2;
+comp **= comp ** comp * 2;
+comp **= comp ** comp / 2;
+comp **= comp ** comp % 2;
+comp **= (comp - 2) ** 5;
+comp **= (comp + 2) ** 5;
+comp **= (comp * 2) ** 5;
+comp **= (comp / 2) ** 5;
+comp **= (comp % 2) ** 5;
+comp **= comp ** (5 + 2);
+comp **= comp ** (5 - 2);
+comp **= comp ** (5 * 2);
+comp **= comp ** (5 / 2);
+comp **= comp ** (5 % 2);
+
+//// [emitCompoundExponentiationOperator1.js]
+var comp;
+comp = Math.pow(comp, 1);
+comp = Math.pow(comp, Math.pow(comp, comp));
+comp = Math.pow(comp, Math.pow(comp, Math.pow(comp, 2)));
+comp = Math.pow(comp, Math.pow(comp, comp) + 2);
+comp = Math.pow(comp, Math.pow(comp, comp) - 2);
+comp = Math.pow(comp, Math.pow(comp, comp) * 2);
+comp = Math.pow(comp, Math.pow(comp, comp) / 2);
+comp = Math.pow(comp, Math.pow(comp, comp) % 2);
+comp = Math.pow(comp, Math.pow((comp - 2), 5));
+comp = Math.pow(comp, Math.pow((comp + 2), 5));
+comp = Math.pow(comp, Math.pow((comp * 2), 5));
+comp = Math.pow(comp, Math.pow((comp / 2), 5));
+comp = Math.pow(comp, Math.pow((comp % 2), 5));
+comp = Math.pow(comp, Math.pow(comp, (5 + 2)));
+comp = Math.pow(comp, Math.pow(comp, (5 - 2)));
+comp = Math.pow(comp, Math.pow(comp, (5 * 2)));
+comp = Math.pow(comp, Math.pow(comp, (5 / 2)));
+comp = Math.pow(comp, Math.pow(comp, (5 % 2)));
diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols b/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols
new file mode 100644
index 00000000000..a6a57c6fb88
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.symbols
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts ===
+
+var comp: number;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= 1;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** comp;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** comp ** 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** comp + 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** comp - 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** comp * 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** comp / 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** comp % 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= (comp - 2) ** 5;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= (comp + 2) ** 5;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= (comp * 2) ** 5;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= (comp / 2) ** 5;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= (comp % 2) ** 5;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** (5 + 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** (5 - 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** (5 * 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** (5 / 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
+comp **= comp ** (5 % 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator1.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator1.types b/tests/baselines/reference/emitCompoundExponentiationOperator1.types
new file mode 100644
index 00000000000..a1c986dbb78
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationOperator1.types
@@ -0,0 +1,171 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts ===
+
+var comp: number;
+>comp : number
+
+comp **= 1;
+>comp **= 1 : number
+>comp : number
+>1 : number
+
+comp **= comp ** comp;
+>comp **= comp ** comp : number
+>comp : number
+>comp ** comp : number
+>comp : number
+>comp : number
+
+comp **= comp ** comp ** 2;
+>comp **= comp ** comp ** 2 : number
+>comp : number
+>comp ** comp ** 2 : number
+>comp : number
+>comp ** 2 : number
+>comp : number
+>2 : number
+
+comp **= comp ** comp + 2;
+>comp **= comp ** comp + 2 : number
+>comp : number
+>comp ** comp + 2 : number
+>comp ** comp : number
+>comp : number
+>comp : number
+>2 : number
+
+comp **= comp ** comp - 2;
+>comp **= comp ** comp - 2 : number
+>comp : number
+>comp ** comp - 2 : number
+>comp ** comp : number
+>comp : number
+>comp : number
+>2 : number
+
+comp **= comp ** comp * 2;
+>comp **= comp ** comp * 2 : number
+>comp : number
+>comp ** comp * 2 : number
+>comp ** comp : number
+>comp : number
+>comp : number
+>2 : number
+
+comp **= comp ** comp / 2;
+>comp **= comp ** comp / 2 : number
+>comp : number
+>comp ** comp / 2 : number
+>comp ** comp : number
+>comp : number
+>comp : number
+>2 : number
+
+comp **= comp ** comp % 2;
+>comp **= comp ** comp % 2 : number
+>comp : number
+>comp ** comp % 2 : number
+>comp ** comp : number
+>comp : number
+>comp : number
+>2 : number
+
+comp **= (comp - 2) ** 5;
+>comp **= (comp - 2) ** 5 : number
+>comp : number
+>(comp - 2) ** 5 : number
+>(comp - 2) : number
+>comp - 2 : number
+>comp : number
+>2 : number
+>5 : number
+
+comp **= (comp + 2) ** 5;
+>comp **= (comp + 2) ** 5 : number
+>comp : number
+>(comp + 2) ** 5 : number
+>(comp + 2) : number
+>comp + 2 : number
+>comp : number
+>2 : number
+>5 : number
+
+comp **= (comp * 2) ** 5;
+>comp **= (comp * 2) ** 5 : number
+>comp : number
+>(comp * 2) ** 5 : number
+>(comp * 2) : number
+>comp * 2 : number
+>comp : number
+>2 : number
+>5 : number
+
+comp **= (comp / 2) ** 5;
+>comp **= (comp / 2) ** 5 : number
+>comp : number
+>(comp / 2) ** 5 : number
+>(comp / 2) : number
+>comp / 2 : number
+>comp : number
+>2 : number
+>5 : number
+
+comp **= (comp % 2) ** 5;
+>comp **= (comp % 2) ** 5 : number
+>comp : number
+>(comp % 2) ** 5 : number
+>(comp % 2) : number
+>comp % 2 : number
+>comp : number
+>2 : number
+>5 : number
+
+comp **= comp ** (5 + 2);
+>comp **= comp ** (5 + 2) : number
+>comp : number
+>comp ** (5 + 2) : number
+>comp : number
+>(5 + 2) : number
+>5 + 2 : number
+>5 : number
+>2 : number
+
+comp **= comp ** (5 - 2);
+>comp **= comp ** (5 - 2) : number
+>comp : number
+>comp ** (5 - 2) : number
+>comp : number
+>(5 - 2) : number
+>5 - 2 : number
+>5 : number
+>2 : number
+
+comp **= comp ** (5 * 2);
+>comp **= comp ** (5 * 2) : number
+>comp : number
+>comp ** (5 * 2) : number
+>comp : number
+>(5 * 2) : number
+>5 * 2 : number
+>5 : number
+>2 : number
+
+comp **= comp ** (5 / 2);
+>comp **= comp ** (5 / 2) : number
+>comp : number
+>comp ** (5 / 2) : number
+>comp : number
+>(5 / 2) : number
+>5 / 2 : number
+>5 : number
+>2 : number
+
+comp **= comp ** (5 % 2);
+>comp **= comp ** (5 % 2) : number
+>comp : number
+>comp ** (5 % 2) : number
+>comp : number
+>(5 % 2) : number
+>5 % 2 : number
+>5 : number
+>2 : number
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.js b/tests/baselines/reference/emitCompoundExponentiationOperator2.js
new file mode 100644
index 00000000000..91b988423ac
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.js
@@ -0,0 +1,47 @@
+//// [emitCompoundExponentiationOperator2.ts]
+
+var comp: number;
+
+comp **= 1;
+comp **= comp **= 1;
+comp **= comp **= 1 + 2;
+comp **= comp **= 1 - 2;
+comp **= comp **= 1 * 2;
+comp **= comp **= 1 / 2;
+
+comp **= comp **= (1 + 2);
+comp **= comp **= (1 - 2);
+comp **= comp **= (1 * 2);
+comp **= comp **= (1 / 2);
+
+comp **= comp **= 1 + 2 ** 3;
+comp **= comp **= 1 - 2 ** 4;
+comp **= comp **= 1 * 2 ** 5;
+comp **= comp **= 1 / 2 ** 6;
+
+comp **= comp **= (1 + 2) ** 3;
+comp **= comp **= (1 - 2) ** 4;
+comp **= comp **= (1 * 2) ** 5;
+comp **= comp **= (1 / 2) ** 6;
+
+
+//// [emitCompoundExponentiationOperator2.js]
+var comp;
+comp = Math.pow(comp, 1);
+comp = Math.pow(comp, comp = Math.pow(comp, 1));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 + 2));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 - 2));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 * 2));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 / 2));
+comp = Math.pow(comp, comp = Math.pow(comp, (1 + 2)));
+comp = Math.pow(comp, comp = Math.pow(comp, (1 - 2)));
+comp = Math.pow(comp, comp = Math.pow(comp, (1 * 2)));
+comp = Math.pow(comp, comp = Math.pow(comp, (1 / 2)));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 + Math.pow(2, 3)));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 - Math.pow(2, 4)));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 * Math.pow(2, 5)));
+comp = Math.pow(comp, comp = Math.pow(comp, 1 / Math.pow(2, 6)));
+comp = Math.pow(comp, comp = Math.pow(comp, Math.pow((1 + 2), 3)));
+comp = Math.pow(comp, comp = Math.pow(comp, Math.pow((1 - 2), 4)));
+comp = Math.pow(comp, comp = Math.pow(comp, Math.pow((1 * 2), 5)));
+comp = Math.pow(comp, comp = Math.pow(comp, Math.pow((1 / 2), 6)));
diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols b/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols
new file mode 100644
index 00000000000..04a22b2782c
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.symbols
@@ -0,0 +1,76 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts ===
+
+var comp: number;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= 1;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 + 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 - 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 * 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 / 2;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 + 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 - 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 * 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 / 2);
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 + 2 ** 3;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 - 2 ** 4;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 * 2 ** 5;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= 1 / 2 ** 6;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 + 2) ** 3;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 - 2) ** 4;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 * 2) ** 5;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
+comp **= comp **= (1 / 2) ** 6;
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+>comp : Symbol(comp, Decl(emitCompoundExponentiationOperator2.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitCompoundExponentiationOperator2.types b/tests/baselines/reference/emitCompoundExponentiationOperator2.types
new file mode 100644
index 00000000000..03ca9b06626
--- /dev/null
+++ b/tests/baselines/reference/emitCompoundExponentiationOperator2.types
@@ -0,0 +1,185 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts ===
+
+var comp: number;
+>comp : number
+
+comp **= 1;
+>comp **= 1 : number
+>comp : number
+>1 : number
+
+comp **= comp **= 1;
+>comp **= comp **= 1 : number
+>comp : number
+>comp **= 1 : number
+>comp : number
+>1 : number
+
+comp **= comp **= 1 + 2;
+>comp **= comp **= 1 + 2 : number
+>comp : number
+>comp **= 1 + 2 : number
+>comp : number
+>1 + 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= 1 - 2;
+>comp **= comp **= 1 - 2 : number
+>comp : number
+>comp **= 1 - 2 : number
+>comp : number
+>1 - 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= 1 * 2;
+>comp **= comp **= 1 * 2 : number
+>comp : number
+>comp **= 1 * 2 : number
+>comp : number
+>1 * 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= 1 / 2;
+>comp **= comp **= 1 / 2 : number
+>comp : number
+>comp **= 1 / 2 : number
+>comp : number
+>1 / 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= (1 + 2);
+>comp **= comp **= (1 + 2) : number
+>comp : number
+>comp **= (1 + 2) : number
+>comp : number
+>(1 + 2) : number
+>1 + 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= (1 - 2);
+>comp **= comp **= (1 - 2) : number
+>comp : number
+>comp **= (1 - 2) : number
+>comp : number
+>(1 - 2) : number
+>1 - 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= (1 * 2);
+>comp **= comp **= (1 * 2) : number
+>comp : number
+>comp **= (1 * 2) : number
+>comp : number
+>(1 * 2) : number
+>1 * 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= (1 / 2);
+>comp **= comp **= (1 / 2) : number
+>comp : number
+>comp **= (1 / 2) : number
+>comp : number
+>(1 / 2) : number
+>1 / 2 : number
+>1 : number
+>2 : number
+
+comp **= comp **= 1 + 2 ** 3;
+>comp **= comp **= 1 + 2 ** 3 : number
+>comp : number
+>comp **= 1 + 2 ** 3 : number
+>comp : number
+>1 + 2 ** 3 : number
+>1 : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+comp **= comp **= 1 - 2 ** 4;
+>comp **= comp **= 1 - 2 ** 4 : number
+>comp : number
+>comp **= 1 - 2 ** 4 : number
+>comp : number
+>1 - 2 ** 4 : number
+>1 : number
+>2 ** 4 : number
+>2 : number
+>4 : number
+
+comp **= comp **= 1 * 2 ** 5;
+>comp **= comp **= 1 * 2 ** 5 : number
+>comp : number
+>comp **= 1 * 2 ** 5 : number
+>comp : number
+>1 * 2 ** 5 : number
+>1 : number
+>2 ** 5 : number
+>2 : number
+>5 : number
+
+comp **= comp **= 1 / 2 ** 6;
+>comp **= comp **= 1 / 2 ** 6 : number
+>comp : number
+>comp **= 1 / 2 ** 6 : number
+>comp : number
+>1 / 2 ** 6 : number
+>1 : number
+>2 ** 6 : number
+>2 : number
+>6 : number
+
+comp **= comp **= (1 + 2) ** 3;
+>comp **= comp **= (1 + 2) ** 3 : number
+>comp : number
+>comp **= (1 + 2) ** 3 : number
+>comp : number
+>(1 + 2) ** 3 : number
+>(1 + 2) : number
+>1 + 2 : number
+>1 : number
+>2 : number
+>3 : number
+
+comp **= comp **= (1 - 2) ** 4;
+>comp **= comp **= (1 - 2) ** 4 : number
+>comp : number
+>comp **= (1 - 2) ** 4 : number
+>comp : number
+>(1 - 2) ** 4 : number
+>(1 - 2) : number
+>1 - 2 : number
+>1 : number
+>2 : number
+>4 : number
+
+comp **= comp **= (1 * 2) ** 5;
+>comp **= comp **= (1 * 2) ** 5 : number
+>comp : number
+>comp **= (1 * 2) ** 5 : number
+>comp : number
+>(1 * 2) ** 5 : number
+>(1 * 2) : number
+>1 * 2 : number
+>1 : number
+>2 : number
+>5 : number
+
+comp **= comp **= (1 / 2) ** 6;
+>comp **= comp **= (1 / 2) ** 6 : number
+>comp : number
+>comp **= (1 / 2) ** 6 : number
+>comp : number
+>(1 / 2) ** 6 : number
+>(1 / 2) : number
+>1 / 2 : number
+>1 : number
+>2 : number
+>6 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperator1.js b/tests/baselines/reference/emitExponentiationOperator1.js
new file mode 100644
index 00000000000..2b270ef708b
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator1.js
@@ -0,0 +1,62 @@
+//// [emitExponentiationOperator1.ts]
+
+1 ** -2;
+1 ** 2;
+(-1) ** 2
+1 ** 2 ** 3;
+1 ** 2 ** -3;
+1 ** -(2 ** 3);
+(-(1 ** 2)) ** 3;
+(-(1 ** 2)) ** -3;
+
+1 ** 2 + 3;
+1 ** 2 - 3;
+1 ** 2 * 3;
+1 ** 2 / 3;
+1 ** 2 % 3;
+
+1 ** -2 + 3;
+1 ** -2 - 3;
+1 ** -2 * 3;
+1 ** -2 / 3;
+1 ** -2 % 3;
+
+2 + 3 ** 3;
+2 - 3 ** 3;
+2 * 3 ** 3;
+2 / 3 ** 3;
+2 % 3 ** 3;
+
+(2 + 3) ** 4;
+(2 - 3) ** 4;
+(2 * 3) ** 4;
+(2 / 3) ** 4;
+
+//// [emitExponentiationOperator1.js]
+Math.pow(1, -2);
+Math.pow(1, 2);
+Math.pow((-1), 2);
+Math.pow(1, Math.pow(2, 3));
+Math.pow(1, Math.pow(2, -3));
+Math.pow(1, -(Math.pow(2, 3)));
+Math.pow((-(Math.pow(1, 2))), 3);
+Math.pow((-(Math.pow(1, 2))), -3);
+Math.pow(1, 2) + 3;
+Math.pow(1, 2) - 3;
+Math.pow(1, 2) * 3;
+Math.pow(1, 2) / 3;
+Math.pow(1, 2) % 3;
+Math.pow(1, -2) + 3;
+Math.pow(1, -2) - 3;
+Math.pow(1, -2) * 3;
+Math.pow(1, -2) / 3;
+Math.pow(1, -2) % 3;
+2 + Math.pow(3, 3);
+2 - Math.pow(3, 3);
+2 * Math.pow(3, 3);
+2 / Math.pow(3, 3);
+2 % Math.pow(3, 3);
+Math.pow((2 + 3), 4);
+Math.pow((2 - 3), 4);
+Math.pow((2 * 3), 4);
+Math.pow((2 / 3), 4);
diff --git a/tests/baselines/reference/emitExponentiationOperator1.symbols b/tests/baselines/reference/emitExponentiationOperator1.symbols
new file mode 100644
index 00000000000..5fb3419d419
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator1.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts ===
+
+No type information for this code.1 ** -2;
+No type information for this code.1 ** 2;
+No type information for this code.(-1) ** 2
+No type information for this code.1 ** 2 ** 3;
+No type information for this code.1 ** 2 ** -3;
+No type information for this code.1 ** -(2 ** 3);
+No type information for this code.(-(1 ** 2)) ** 3;
+No type information for this code.(-(1 ** 2)) ** -3;
+No type information for this code.
+No type information for this code.1 ** 2 + 3;
+No type information for this code.1 ** 2 - 3;
+No type information for this code.1 ** 2 * 3;
+No type information for this code.1 ** 2 / 3;
+No type information for this code.1 ** 2 % 3;
+No type information for this code.
+No type information for this code.1 ** -2 + 3;
+No type information for this code.1 ** -2 - 3;
+No type information for this code.1 ** -2 * 3;
+No type information for this code.1 ** -2 / 3;
+No type information for this code.1 ** -2 % 3;
+No type information for this code.
+No type information for this code.2 + 3 ** 3;
+No type information for this code.2 - 3 ** 3;
+No type information for this code.2 * 3 ** 3;
+No type information for this code.2 / 3 ** 3;
+No type information for this code.2 % 3 ** 3;
+No type information for this code.
+No type information for this code.(2 + 3) ** 4;
+No type information for this code.(2 - 3) ** 4;
+No type information for this code.(2 * 3) ** 4;
+No type information for this code.(2 / 3) ** 4;
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/emitExponentiationOperator1.types b/tests/baselines/reference/emitExponentiationOperator1.types
new file mode 100644
index 00000000000..a2dc4f16901
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator1.types
@@ -0,0 +1,207 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts ===
+
+1 ** -2;
+>1 ** -2 : number
+>1 : number
+>-2 : number
+>2 : number
+
+1 ** 2;
+>1 ** 2 : number
+>1 : number
+>2 : number
+
+(-1) ** 2
+>(-1) ** 2 : number
+>(-1) : number
+>-1 : number
+>1 : number
+>2 : number
+
+1 ** 2 ** 3;
+>1 ** 2 ** 3 : number
+>1 : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+1 ** 2 ** -3;
+>1 ** 2 ** -3 : number
+>1 : number
+>2 ** -3 : number
+>2 : number
+>-3 : number
+>3 : number
+
+1 ** -(2 ** 3);
+>1 ** -(2 ** 3) : number
+>1 : number
+>-(2 ** 3) : number
+>(2 ** 3) : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+(-(1 ** 2)) ** 3;
+>(-(1 ** 2)) ** 3 : number
+>(-(1 ** 2)) : number
+>-(1 ** 2) : number
+>(1 ** 2) : number
+>1 ** 2 : number
+>1 : number
+>2 : number
+>3 : number
+
+(-(1 ** 2)) ** -3;
+>(-(1 ** 2)) ** -3 : number
+>(-(1 ** 2)) : number
+>-(1 ** 2) : number
+>(1 ** 2) : number
+>1 ** 2 : number
+>1 : number
+>2 : number
+>-3 : number
+>3 : number
+
+1 ** 2 + 3;
+>1 ** 2 + 3 : number
+>1 ** 2 : number
+>1 : number
+>2 : number
+>3 : number
+
+1 ** 2 - 3;
+>1 ** 2 - 3 : number
+>1 ** 2 : number
+>1 : number
+>2 : number
+>3 : number
+
+1 ** 2 * 3;
+>1 ** 2 * 3 : number
+>1 ** 2 : number
+>1 : number
+>2 : number
+>3 : number
+
+1 ** 2 / 3;
+>1 ** 2 / 3 : number
+>1 ** 2 : number
+>1 : number
+>2 : number
+>3 : number
+
+1 ** 2 % 3;
+>1 ** 2 % 3 : number
+>1 ** 2 : number
+>1 : number
+>2 : number
+>3 : number
+
+1 ** -2 + 3;
+>1 ** -2 + 3 : number
+>1 ** -2 : number
+>1 : number
+>-2 : number
+>2 : number
+>3 : number
+
+1 ** -2 - 3;
+>1 ** -2 - 3 : number
+>1 ** -2 : number
+>1 : number
+>-2 : number
+>2 : number
+>3 : number
+
+1 ** -2 * 3;
+>1 ** -2 * 3 : number
+>1 ** -2 : number
+>1 : number
+>-2 : number
+>2 : number
+>3 : number
+
+1 ** -2 / 3;
+>1 ** -2 / 3 : number
+>1 ** -2 : number
+>1 : number
+>-2 : number
+>2 : number
+>3 : number
+
+1 ** -2 % 3;
+>1 ** -2 % 3 : number
+>1 ** -2 : number
+>1 : number
+>-2 : number
+>2 : number
+>3 : number
+
+2 + 3 ** 3;
+>2 + 3 ** 3 : number
+>2 : number
+>3 ** 3 : number
+>3 : number
+>3 : number
+
+2 - 3 ** 3;
+>2 - 3 ** 3 : number
+>2 : number
+>3 ** 3 : number
+>3 : number
+>3 : number
+
+2 * 3 ** 3;
+>2 * 3 ** 3 : number
+>2 : number
+>3 ** 3 : number
+>3 : number
+>3 : number
+
+2 / 3 ** 3;
+>2 / 3 ** 3 : number
+>2 : number
+>3 ** 3 : number
+>3 : number
+>3 : number
+
+2 % 3 ** 3;
+>2 % 3 ** 3 : number
+>2 : number
+>3 ** 3 : number
+>3 : number
+>3 : number
+
+(2 + 3) ** 4;
+>(2 + 3) ** 4 : number
+>(2 + 3) : number
+>2 + 3 : number
+>2 : number
+>3 : number
+>4 : number
+
+(2 - 3) ** 4;
+>(2 - 3) ** 4 : number
+>(2 - 3) : number
+>2 - 3 : number
+>2 : number
+>3 : number
+>4 : number
+
+(2 * 3) ** 4;
+>(2 * 3) ** 4 : number
+>(2 * 3) : number
+>2 * 3 : number
+>2 : number
+>3 : number
+>4 : number
+
+(2 / 3) ** 4;
+>(2 / 3) ** 4 : number
+>(2 / 3) : number
+>2 / 3 : number
+>2 : number
+>3 : number
+>4 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperator2.js b/tests/baselines/reference/emitExponentiationOperator2.js
new file mode 100644
index 00000000000..46f80b44bba
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator2.js
@@ -0,0 +1,104 @@
+//// [emitExponentiationOperator2.ts]
+
+var temp = 10;
+
+++temp ** 3;
+--temp ** 3;
+temp++ ** 3;
+temp-- ** 3;
+--temp + temp ** 3;
+--temp - temp ** 3;
+--temp * temp ** 3;
+--temp / temp ** 3;
+--temp % temp ** 3;
+temp-- ** 3;
+temp++ ** 3;
+temp-- ** -temp;
+temp++ ** +temp;
+
+temp-- + temp ** 3;
+temp-- - temp ** 3;
+temp-- * temp ** 3;
+temp-- / temp ** 3;
+temp-- % temp ** 3;
+
+--temp + 2 ** 3;
+--temp - 2 ** 3;
+--temp * 2 ** 3;
+--temp / 2 ** 3;
+--temp % 2 ** 3;
+
+++temp + 2 ** 3;
+++temp - 2 ** 3;
+++temp * 2 ** 3;
+++temp / 2 ** 3;
+
+3 ** ++temp;
+3 ** --temp;
+3 ** temp++;
+3 ** temp--;
+
+3 ** ++temp ** 2;
+3 ** --temp ** 2;
+3 ** temp++ ** 2;
+3 ** temp-- ** 2;
+
+3 ** ++temp + 2;
+3 ** ++temp - 2;
+3 ** ++temp * 2;
+3 ** ++temp / 2;
+3 ** ++temp % 2;
+
+3 ** --temp + 2;
+3 ** --temp - 2;
+3 ** --temp * 2;
+3 ** --temp / 2;
+3 ** --temp % 2;
+
+//// [emitExponentiationOperator2.js]
+var temp = 10;
+Math.pow(++temp, 3);
+Math.pow(--temp, 3);
+Math.pow(temp++, 3);
+Math.pow(temp--, 3);
+--temp + Math.pow(temp, 3);
+--temp - Math.pow(temp, 3);
+--temp * Math.pow(temp, 3);
+--temp / Math.pow(temp, 3);
+--temp % Math.pow(temp, 3);
+Math.pow(temp--, 3);
+Math.pow(temp++, 3);
+Math.pow(temp--, -temp);
+Math.pow(temp++, +temp);
+temp-- + Math.pow(temp, 3);
+temp-- - Math.pow(temp, 3);
+temp-- * Math.pow(temp, 3);
+temp-- / Math.pow(temp, 3);
+temp-- % Math.pow(temp, 3);
+--temp + Math.pow(2, 3);
+--temp - Math.pow(2, 3);
+--temp * Math.pow(2, 3);
+--temp / Math.pow(2, 3);
+--temp % Math.pow(2, 3);
+++temp + Math.pow(2, 3);
+++temp - Math.pow(2, 3);
+++temp * Math.pow(2, 3);
+++temp / Math.pow(2, 3);
+Math.pow(3, ++temp);
+Math.pow(3, --temp);
+Math.pow(3, temp++);
+Math.pow(3, temp--);
+Math.pow(3, Math.pow(++temp, 2));
+Math.pow(3, Math.pow(--temp, 2));
+Math.pow(3, Math.pow(temp++, 2));
+Math.pow(3, Math.pow(temp--, 2));
+Math.pow(3, ++temp) + 2;
+Math.pow(3, ++temp) - 2;
+Math.pow(3, ++temp) * 2;
+Math.pow(3, ++temp) / 2;
+Math.pow(3, ++temp) % 2;
+Math.pow(3, --temp) + 2;
+Math.pow(3, --temp) - 2;
+Math.pow(3, --temp) * 2;
+Math.pow(3, --temp) / 2;
+Math.pow(3, --temp) % 2;
diff --git a/tests/baselines/reference/emitExponentiationOperator2.symbols b/tests/baselines/reference/emitExponentiationOperator2.symbols
new file mode 100644
index 00000000000..c3d9e4b25df
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator2.symbols
@@ -0,0 +1,152 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts ===
+
+var temp = 10;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+++temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp++ ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp + temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp - temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp * temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp / temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp % temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp++ ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- ** -temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp++ ** +temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- + temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- - temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- * temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- / temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+temp-- % temp ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp + 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp - 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp * 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp / 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+--temp % 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+++temp + 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+++temp - 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+++temp * 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+++temp / 2 ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** ++temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** --temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** temp++;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** temp--;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** ++temp ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** --temp ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** temp++ ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** temp-- ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** ++temp + 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** ++temp - 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** ++temp * 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** ++temp / 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** ++temp % 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** --temp + 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** --temp - 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** --temp * 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** --temp / 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
+3 ** --temp % 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator2.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperator2.types b/tests/baselines/reference/emitExponentiationOperator2.types
new file mode 100644
index 00000000000..cd8773624a7
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator2.types
@@ -0,0 +1,344 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts ===
+
+var temp = 10;
+>temp : number
+>10 : number
+
+++temp ** 3;
+>++temp ** 3 : number
+>++temp : number
+>temp : number
+>3 : number
+
+--temp ** 3;
+>--temp ** 3 : number
+>--temp : number
+>temp : number
+>3 : number
+
+temp++ ** 3;
+>temp++ ** 3 : number
+>temp++ : number
+>temp : number
+>3 : number
+
+temp-- ** 3;
+>temp-- ** 3 : number
+>temp-- : number
+>temp : number
+>3 : number
+
+--temp + temp ** 3;
+>--temp + temp ** 3 : number
+>--temp : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+--temp - temp ** 3;
+>--temp - temp ** 3 : number
+>--temp : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+--temp * temp ** 3;
+>--temp * temp ** 3 : number
+>--temp : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+--temp / temp ** 3;
+>--temp / temp ** 3 : number
+>--temp : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+--temp % temp ** 3;
+>--temp % temp ** 3 : number
+>--temp : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+temp-- ** 3;
+>temp-- ** 3 : number
+>temp-- : number
+>temp : number
+>3 : number
+
+temp++ ** 3;
+>temp++ ** 3 : number
+>temp++ : number
+>temp : number
+>3 : number
+
+temp-- ** -temp;
+>temp-- ** -temp : number
+>temp-- : number
+>temp : number
+>-temp : number
+>temp : number
+
+temp++ ** +temp;
+>temp++ ** +temp : number
+>temp++ : number
+>temp : number
+>+temp : number
+>temp : number
+
+temp-- + temp ** 3;
+>temp-- + temp ** 3 : number
+>temp-- : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+temp-- - temp ** 3;
+>temp-- - temp ** 3 : number
+>temp-- : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+temp-- * temp ** 3;
+>temp-- * temp ** 3 : number
+>temp-- : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+temp-- / temp ** 3;
+>temp-- / temp ** 3 : number
+>temp-- : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+temp-- % temp ** 3;
+>temp-- % temp ** 3 : number
+>temp-- : number
+>temp : number
+>temp ** 3 : number
+>temp : number
+>3 : number
+
+--temp + 2 ** 3;
+>--temp + 2 ** 3 : number
+>--temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+--temp - 2 ** 3;
+>--temp - 2 ** 3 : number
+>--temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+--temp * 2 ** 3;
+>--temp * 2 ** 3 : number
+>--temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+--temp / 2 ** 3;
+>--temp / 2 ** 3 : number
+>--temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+--temp % 2 ** 3;
+>--temp % 2 ** 3 : number
+>--temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+++temp + 2 ** 3;
+>++temp + 2 ** 3 : number
+>++temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+++temp - 2 ** 3;
+>++temp - 2 ** 3 : number
+>++temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+++temp * 2 ** 3;
+>++temp * 2 ** 3 : number
+>++temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+++temp / 2 ** 3;
+>++temp / 2 ** 3 : number
+>++temp : number
+>temp : number
+>2 ** 3 : number
+>2 : number
+>3 : number
+
+3 ** ++temp;
+>3 ** ++temp : number
+>3 : number
+>++temp : number
+>temp : number
+
+3 ** --temp;
+>3 ** --temp : number
+>3 : number
+>--temp : number
+>temp : number
+
+3 ** temp++;
+>3 ** temp++ : number
+>3 : number
+>temp++ : number
+>temp : number
+
+3 ** temp--;
+>3 ** temp-- : number
+>3 : number
+>temp-- : number
+>temp : number
+
+3 ** ++temp ** 2;
+>3 ** ++temp ** 2 : number
+>3 : number
+>++temp ** 2 : number
+>++temp : number
+>temp : number
+>2 : number
+
+3 ** --temp ** 2;
+>3 ** --temp ** 2 : number
+>3 : number
+>--temp ** 2 : number
+>--temp : number
+>temp : number
+>2 : number
+
+3 ** temp++ ** 2;
+>3 ** temp++ ** 2 : number
+>3 : number
+>temp++ ** 2 : number
+>temp++ : number
+>temp : number
+>2 : number
+
+3 ** temp-- ** 2;
+>3 ** temp-- ** 2 : number
+>3 : number
+>temp-- ** 2 : number
+>temp-- : number
+>temp : number
+>2 : number
+
+3 ** ++temp + 2;
+>3 ** ++temp + 2 : number
+>3 ** ++temp : number
+>3 : number
+>++temp : number
+>temp : number
+>2 : number
+
+3 ** ++temp - 2;
+>3 ** ++temp - 2 : number
+>3 ** ++temp : number
+>3 : number
+>++temp : number
+>temp : number
+>2 : number
+
+3 ** ++temp * 2;
+>3 ** ++temp * 2 : number
+>3 ** ++temp : number
+>3 : number
+>++temp : number
+>temp : number
+>2 : number
+
+3 ** ++temp / 2;
+>3 ** ++temp / 2 : number
+>3 ** ++temp : number
+>3 : number
+>++temp : number
+>temp : number
+>2 : number
+
+3 ** ++temp % 2;
+>3 ** ++temp % 2 : number
+>3 ** ++temp : number
+>3 : number
+>++temp : number
+>temp : number
+>2 : number
+
+3 ** --temp + 2;
+>3 ** --temp + 2 : number
+>3 ** --temp : number
+>3 : number
+>--temp : number
+>temp : number
+>2 : number
+
+3 ** --temp - 2;
+>3 ** --temp - 2 : number
+>3 ** --temp : number
+>3 : number
+>--temp : number
+>temp : number
+>2 : number
+
+3 ** --temp * 2;
+>3 ** --temp * 2 : number
+>3 ** --temp : number
+>3 : number
+>--temp : number
+>temp : number
+>2 : number
+
+3 ** --temp / 2;
+>3 ** --temp / 2 : number
+>3 ** --temp : number
+>3 : number
+>--temp : number
+>temp : number
+>2 : number
+
+3 ** --temp % 2;
+>3 ** --temp % 2 : number
+>3 ** --temp : number
+>3 : number
+>--temp : number
+>temp : number
+>2 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperator3.js b/tests/baselines/reference/emitExponentiationOperator3.js
new file mode 100644
index 00000000000..ceb08c868db
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator3.js
@@ -0,0 +1,78 @@
+//// [emitExponentiationOperator3.ts]
+
+var temp = 10;
+
+(-++temp) ** 3;
+(+--temp) ** 3;
+(-temp++) ** 3;
+(+temp--) ** 3;
+(-(1 ** ++temp)) ** 3;
+(-(1 ** --temp)) ** 3;
+(-(1 ** temp++)) ** 3;
+(-(1 ** temp--)) ** 3;
+
+(-3) ** temp++;
+(-3) ** temp--;
+(-3) ** ++temp;
+(-3) ** --temp;
+(+3) ** temp++;
+(+3) ** temp--;
+(+3) ** ++temp;
+(+3) ** --temp;
+(-3) ** temp++ ** 2;
+(-3) ** temp-- ** 2;
+(-3) ** ++temp ** 2;
+(-3) ** --temp ** 2;
+(+3) ** temp++ ** 2;
+(+3) ** temp-- ** 2;
+(+3) ** ++temp ** 2;
+(+3) ** --temp ** 2;
+
+3 ** -temp++;
+3 ** -temp--;
+3 ** -++temp;
+3 ** +--temp;
+3 ** (-temp++) ** 2;
+3 ** (-temp--) ** 2;
+3 ** (+temp++) ** 2;
+3 ** (+temp--) ** 2;
+3 ** (-++temp) ** 2;
+3 ** (+--temp) ** 2;
+
+
+//// [emitExponentiationOperator3.js]
+var temp = 10;
+Math.pow((-++temp), 3);
+Math.pow((+--temp), 3);
+Math.pow((-temp++), 3);
+Math.pow((+temp--), 3);
+Math.pow((-(Math.pow(1, ++temp))), 3);
+Math.pow((-(Math.pow(1, --temp))), 3);
+Math.pow((-(Math.pow(1, temp++))), 3);
+Math.pow((-(Math.pow(1, temp--))), 3);
+Math.pow((-3), temp++);
+Math.pow((-3), temp--);
+Math.pow((-3), ++temp);
+Math.pow((-3), --temp);
+Math.pow((+3), temp++);
+Math.pow((+3), temp--);
+Math.pow((+3), ++temp);
+Math.pow((+3), --temp);
+Math.pow((-3), Math.pow(temp++, 2));
+Math.pow((-3), Math.pow(temp--, 2));
+Math.pow((-3), Math.pow(++temp, 2));
+Math.pow((-3), Math.pow(--temp, 2));
+Math.pow((+3), Math.pow(temp++, 2));
+Math.pow((+3), Math.pow(temp--, 2));
+Math.pow((+3), Math.pow(++temp, 2));
+Math.pow((+3), Math.pow(--temp, 2));
+Math.pow(3, -temp++);
+Math.pow(3, -temp--);
+Math.pow(3, -++temp);
+Math.pow(3, +--temp);
+Math.pow(3, Math.pow((-temp++), 2));
+Math.pow(3, Math.pow((-temp--), 2));
+Math.pow(3, Math.pow((+temp++), 2));
+Math.pow(3, Math.pow((+temp--), 2));
+Math.pow(3, Math.pow((-++temp), 2));
+Math.pow(3, Math.pow((+--temp), 2));
diff --git a/tests/baselines/reference/emitExponentiationOperator3.symbols b/tests/baselines/reference/emitExponentiationOperator3.symbols
new file mode 100644
index 00000000000..23111743855
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator3.symbols
@@ -0,0 +1,107 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts ===
+
+var temp = 10;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-++temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+--temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-temp++) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+temp--) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-(1 ** ++temp)) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-(1 ** --temp)) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-(1 ** temp++)) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-(1 ** temp--)) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** temp++;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** temp--;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** ++temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** --temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** temp++;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** temp--;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** ++temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** --temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** temp++ ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** temp-- ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** ++temp ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(-3) ** --temp ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** temp++ ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** temp-- ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** ++temp ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+(+3) ** --temp ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** -temp++;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** -temp--;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** -++temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** +--temp;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** (-temp++) ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** (-temp--) ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** (+temp++) ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** (+temp--) ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** (-++temp) ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
+3 ** (+--temp) ** 2;
+>temp : Symbol(temp, Decl(emitExponentiationOperator3.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperator3.types b/tests/baselines/reference/emitExponentiationOperator3.types
new file mode 100644
index 00000000000..cc4c5374d05
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator3.types
@@ -0,0 +1,314 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts ===
+
+var temp = 10;
+>temp : number
+>10 : number
+
+(-++temp) ** 3;
+>(-++temp) ** 3 : number
+>(-++temp) : number
+>-++temp : number
+>++temp : number
+>temp : number
+>3 : number
+
+(+--temp) ** 3;
+>(+--temp) ** 3 : number
+>(+--temp) : number
+>+--temp : number
+>--temp : number
+>temp : number
+>3 : number
+
+(-temp++) ** 3;
+>(-temp++) ** 3 : number
+>(-temp++) : number
+>-temp++ : number
+>temp++ : number
+>temp : number
+>3 : number
+
+(+temp--) ** 3;
+>(+temp--) ** 3 : number
+>(+temp--) : number
+>+temp-- : number
+>temp-- : number
+>temp : number
+>3 : number
+
+(-(1 ** ++temp)) ** 3;
+>(-(1 ** ++temp)) ** 3 : number
+>(-(1 ** ++temp)) : number
+>-(1 ** ++temp) : number
+>(1 ** ++temp) : number
+>1 ** ++temp : number
+>1 : number
+>++temp : number
+>temp : number
+>3 : number
+
+(-(1 ** --temp)) ** 3;
+>(-(1 ** --temp)) ** 3 : number
+>(-(1 ** --temp)) : number
+>-(1 ** --temp) : number
+>(1 ** --temp) : number
+>1 ** --temp : number
+>1 : number
+>--temp : number
+>temp : number
+>3 : number
+
+(-(1 ** temp++)) ** 3;
+>(-(1 ** temp++)) ** 3 : number
+>(-(1 ** temp++)) : number
+>-(1 ** temp++) : number
+>(1 ** temp++) : number
+>1 ** temp++ : number
+>1 : number
+>temp++ : number
+>temp : number
+>3 : number
+
+(-(1 ** temp--)) ** 3;
+>(-(1 ** temp--)) ** 3 : number
+>(-(1 ** temp--)) : number
+>-(1 ** temp--) : number
+>(1 ** temp--) : number
+>1 ** temp-- : number
+>1 : number
+>temp-- : number
+>temp : number
+>3 : number
+
+(-3) ** temp++;
+>(-3) ** temp++ : number
+>(-3) : number
+>-3 : number
+>3 : number
+>temp++ : number
+>temp : number
+
+(-3) ** temp--;
+>(-3) ** temp-- : number
+>(-3) : number
+>-3 : number
+>3 : number
+>temp-- : number
+>temp : number
+
+(-3) ** ++temp;
+>(-3) ** ++temp : number
+>(-3) : number
+>-3 : number
+>3 : number
+>++temp : number
+>temp : number
+
+(-3) ** --temp;
+>(-3) ** --temp : number
+>(-3) : number
+>-3 : number
+>3 : number
+>--temp : number
+>temp : number
+
+(+3) ** temp++;
+>(+3) ** temp++ : number
+>(+3) : number
+>+3 : number
+>3 : number
+>temp++ : number
+>temp : number
+
+(+3) ** temp--;
+>(+3) ** temp-- : number
+>(+3) : number
+>+3 : number
+>3 : number
+>temp-- : number
+>temp : number
+
+(+3) ** ++temp;
+>(+3) ** ++temp : number
+>(+3) : number
+>+3 : number
+>3 : number
+>++temp : number
+>temp : number
+
+(+3) ** --temp;
+>(+3) ** --temp : number
+>(+3) : number
+>+3 : number
+>3 : number
+>--temp : number
+>temp : number
+
+(-3) ** temp++ ** 2;
+>(-3) ** temp++ ** 2 : number
+>(-3) : number
+>-3 : number
+>3 : number
+>temp++ ** 2 : number
+>temp++ : number
+>temp : number
+>2 : number
+
+(-3) ** temp-- ** 2;
+>(-3) ** temp-- ** 2 : number
+>(-3) : number
+>-3 : number
+>3 : number
+>temp-- ** 2 : number
+>temp-- : number
+>temp : number
+>2 : number
+
+(-3) ** ++temp ** 2;
+>(-3) ** ++temp ** 2 : number
+>(-3) : number
+>-3 : number
+>3 : number
+>++temp ** 2 : number
+>++temp : number
+>temp : number
+>2 : number
+
+(-3) ** --temp ** 2;
+>(-3) ** --temp ** 2 : number
+>(-3) : number
+>-3 : number
+>3 : number
+>--temp ** 2 : number
+>--temp : number
+>temp : number
+>2 : number
+
+(+3) ** temp++ ** 2;
+>(+3) ** temp++ ** 2 : number
+>(+3) : number
+>+3 : number
+>3 : number
+>temp++ ** 2 : number
+>temp++ : number
+>temp : number
+>2 : number
+
+(+3) ** temp-- ** 2;
+>(+3) ** temp-- ** 2 : number
+>(+3) : number
+>+3 : number
+>3 : number
+>temp-- ** 2 : number
+>temp-- : number
+>temp : number
+>2 : number
+
+(+3) ** ++temp ** 2;
+>(+3) ** ++temp ** 2 : number
+>(+3) : number
+>+3 : number
+>3 : number
+>++temp ** 2 : number
+>++temp : number
+>temp : number
+>2 : number
+
+(+3) ** --temp ** 2;
+>(+3) ** --temp ** 2 : number
+>(+3) : number
+>+3 : number
+>3 : number
+>--temp ** 2 : number
+>--temp : number
+>temp : number
+>2 : number
+
+3 ** -temp++;
+>3 ** -temp++ : number
+>3 : number
+>-temp++ : number
+>temp++ : number
+>temp : number
+
+3 ** -temp--;
+>3 ** -temp-- : number
+>3 : number
+>-temp-- : number
+>temp-- : number
+>temp : number
+
+3 ** -++temp;
+>3 ** -++temp : number
+>3 : number
+>-++temp : number
+>++temp : number
+>temp : number
+
+3 ** +--temp;
+>3 ** +--temp : number
+>3 : number
+>+--temp : number
+>--temp : number
+>temp : number
+
+3 ** (-temp++) ** 2;
+>3 ** (-temp++) ** 2 : number
+>3 : number
+>(-temp++) ** 2 : number
+>(-temp++) : number
+>-temp++ : number
+>temp++ : number
+>temp : number
+>2 : number
+
+3 ** (-temp--) ** 2;
+>3 ** (-temp--) ** 2 : number
+>3 : number
+>(-temp--) ** 2 : number
+>(-temp--) : number
+>-temp-- : number
+>temp-- : number
+>temp : number
+>2 : number
+
+3 ** (+temp++) ** 2;
+>3 ** (+temp++) ** 2 : number
+>3 : number
+>(+temp++) ** 2 : number
+>(+temp++) : number
+>+temp++ : number
+>temp++ : number
+>temp : number
+>2 : number
+
+3 ** (+temp--) ** 2;
+>3 ** (+temp--) ** 2 : number
+>3 : number
+>(+temp--) ** 2 : number
+>(+temp--) : number
+>+temp-- : number
+>temp-- : number
+>temp : number
+>2 : number
+
+3 ** (-++temp) ** 2;
+>3 ** (-++temp) ** 2 : number
+>3 : number
+>(-++temp) ** 2 : number
+>(-++temp) : number
+>-++temp : number
+>++temp : number
+>temp : number
+>2 : number
+
+3 ** (+--temp) ** 2;
+>3 ** (+--temp) ** 2 : number
+>3 : number
+>(+--temp) ** 2 : number
+>(+--temp) : number
+>+--temp : number
+>--temp : number
+>temp : number
+>2 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperator4.js b/tests/baselines/reference/emitExponentiationOperator4.js
new file mode 100644
index 00000000000..7bed614b664
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator4.js
@@ -0,0 +1,70 @@
+//// [emitExponentiationOperator4.ts]
+var temp: any;
+
+(<number>temp) ** 3;
+(<number>--temp) ** 3;
+(<number>++temp) ** 3;
+(<number>temp--) ** 3;
+(<number>temp++) ** 3;
+
+1 ** (<number>--temp) ** 3;
+1 ** (<number>++temp) ** 3;
+1 ** (<number>temp--) ** 3;
+1 ** (<number>temp++) ** 3;
+
+(void --temp) ** 3;
+(void temp--) ** 3;
+(void 3) ** 4;
+(void temp++) ** 4;
+(void temp--) ** 4;
+
+
+1 ** (void --temp) ** 3;
+1 ** (void temp--) ** 3;
+1 ** (void 3) ** 4;
+1 ** (void temp++) ** 4;
+1 ** (void temp--) ** 4;
+
+(~ --temp) ** 3;
+(~ temp--) ** 3;
+(~ 3) ** 4;
+(~ temp++) ** 4;
+(~ temp--) ** 4;
+
+1 ** (~ --temp) ** 3;
+1 ** (~ temp--) ** 3;
+1 ** (~ 3) ** 4;
+1 ** (~ temp++) ** 4;
+1 ** (~ temp--) ** 4;
+
+//// [emitExponentiationOperator4.js]
+var temp;
+Math.pow(temp, 3);
+Math.pow((--temp), 3);
+Math.pow((++temp), 3);
+Math.pow((temp--), 3);
+Math.pow((temp++), 3);
+Math.pow(1, Math.pow((--temp), 3));
+Math.pow(1, Math.pow((++temp), 3));
+Math.pow(1, Math.pow((temp--), 3));
+Math.pow(1, Math.pow((temp++), 3));
+Math.pow((void --temp), 3);
+Math.pow((void temp--), 3);
+Math.pow((void 3), 4);
+Math.pow((void temp++), 4);
+Math.pow((void temp--), 4);
+Math.pow(1, Math.pow((void --temp), 3));
+Math.pow(1, Math.pow((void temp--), 3));
+Math.pow(1, Math.pow((void 3), 4));
+Math.pow(1, Math.pow((void temp++), 4));
+Math.pow(1, Math.pow((void temp--), 4));
+Math.pow((~--temp), 3);
+Math.pow((~temp--), 3);
+Math.pow((~3), 4);
+Math.pow((~temp++), 4);
+Math.pow((~temp--), 4);
+Math.pow(1, Math.pow((~--temp), 3));
+Math.pow(1, Math.pow((~temp--), 3));
+Math.pow(1, Math.pow((~3), 4));
+Math.pow(1, Math.pow((~temp++), 4));
+Math.pow(1, Math.pow((~temp--), 4));
diff --git a/tests/baselines/reference/emitExponentiationOperator4.symbols b/tests/baselines/reference/emitExponentiationOperator4.symbols
new file mode 100644
index 00000000000..45b73afbce8
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator4.symbols
@@ -0,0 +1,84 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts ===
+var temp: any;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(<number>temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(<number>--temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(<number>++temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(<number>temp--) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(<number>temp++) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (<number>--temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (<number>++temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (<number>temp--) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (<number>temp++) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(void --temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(void temp--) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(void 3) ** 4;
+(void temp++) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(void temp--) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+
+1 ** (void --temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (void temp--) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (void 3) ** 4;
+1 ** (void temp++) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (void temp--) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(~ --temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(~ temp--) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(~ 3) ** 4;
+(~ temp++) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+(~ temp--) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (~ --temp) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (~ temp--) ** 3;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (~ 3) ** 4;
+1 ** (~ temp++) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
+1 ** (~ temp--) ** 4;
+>temp : Symbol(temp, Decl(emitExponentiationOperator4.ts, 0, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperator4.types b/tests/baselines/reference/emitExponentiationOperator4.types
new file mode 100644
index 00000000000..36da1c32b4c
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperator4.types
@@ -0,0 +1,260 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts ===
+var temp: any;
+>temp : any
+
+(<number>temp) ** 3;
+>(<number>temp) ** 3 : number
+>(<number>temp) : number
+><number>temp : number
+>temp : any
+>3 : number
+
+(<number>--temp) ** 3;
+>(<number>--temp) ** 3 : number
+>(<number>--temp) : number
+><number>--temp : number
+>--temp : number
+>temp : any
+>3 : number
+
+(<number>++temp) ** 3;
+>(<number>++temp) ** 3 : number
+>(<number>++temp) : number
+><number>++temp : number
+>++temp : number
+>temp : any
+>3 : number
+
+(<number>temp--) ** 3;
+>(<number>temp--) ** 3 : number
+>(<number>temp--) : number
+><number>temp-- : number
+>temp-- : number
+>temp : any
+>3 : number
+
+(<number>temp++) ** 3;
+>(<number>temp++) ** 3 : number
+>(<number>temp++) : number
+><number>temp++ : number
+>temp++ : number
+>temp : any
+>3 : number
+
+1 ** (<number>--temp) ** 3;
+>1 ** (<number>--temp) ** 3 : number
+>1 : number
+>(<number>--temp) ** 3 : number
+>(<number>--temp) : number
+><number>--temp : number
+>--temp : number
+>temp : any
+>3 : number
+
+1 ** (<number>++temp) ** 3;
+>1 ** (<number>++temp) ** 3 : number
+>1 : number
+>(<number>++temp) ** 3 : number
+>(<number>++temp) : number
+><number>++temp : number
+>++temp : number
+>temp : any
+>3 : number
+
+1 ** (<number>temp--) ** 3;
+>1 ** (<number>temp--) ** 3 : number
+>1 : number
+>(<number>temp--) ** 3 : number
+>(<number>temp--) : number
+><number>temp-- : number
+>temp-- : number
+>temp : any
+>3 : number
+
+1 ** (<number>temp++) ** 3;
+>1 ** (<number>temp++) ** 3 : number
+>1 : number
+>(<number>temp++) ** 3 : number
+>(<number>temp++) : number
+><number>temp++ : number
+>temp++ : number
+>temp : any
+>3 : number
+
+(void --temp) ** 3;
+>(void --temp) ** 3 : number
+>(void --temp) : undefined
+>void --temp : undefined
+>--temp : number
+>temp : any
+>3 : number
+
+(void temp--) ** 3;
+>(void temp--) ** 3 : number
+>(void temp--) : undefined
+>void temp-- : undefined
+>temp-- : number
+>temp : any
+>3 : number
+
+(void 3) ** 4;
+>(void 3) ** 4 : number
+>(void 3) : undefined
+>void 3 : undefined
+>3 : number
+>4 : number
+
+(void temp++) ** 4;
+>(void temp++) ** 4 : number
+>(void temp++) : undefined
+>void temp++ : undefined
+>temp++ : number
+>temp : any
+>4 : number
+
+(void temp--) ** 4;
+>(void temp--) ** 4 : number
+>(void temp--) : undefined
+>void temp-- : undefined
+>temp-- : number
+>temp : any
+>4 : number
+
+
+1 ** (void --temp) ** 3;
+>1 ** (void --temp) ** 3 : number
+>1 : number
+>(void --temp) ** 3 : number
+>(void --temp) : undefined
+>void --temp : undefined
+>--temp : number
+>temp : any
+>3 : number
+
+1 ** (void temp--) ** 3;
+>1 ** (void temp--) ** 3 : number
+>1 : number
+>(void temp--) ** 3 : number
+>(void temp--) : undefined
+>void temp-- : undefined
+>temp-- : number
+>temp : any
+>3 : number
+
+1 ** (void 3) ** 4;
+>1 ** (void 3) ** 4 : number
+>1 : number
+>(void 3) ** 4 : number
+>(void 3) : undefined
+>void 3 : undefined
+>3 : number
+>4 : number
+
+1 ** (void temp++) ** 4;
+>1 ** (void temp++) ** 4 : number
+>1 : number
+>(void temp++) ** 4 : number
+>(void temp++) : undefined
+>void temp++ : undefined
+>temp++ : number
+>temp : any
+>4 : number
+
+1 ** (void temp--) ** 4;
+>1 ** (void temp--) ** 4 : number
+>1 : number
+>(void temp--) ** 4 : number
+>(void temp--) : undefined
+>void temp-- : undefined
+>temp-- : number
+>temp : any
+>4 : number
+
+(~ --temp) ** 3;
+>(~ --temp) ** 3 : number
+>(~ --temp) : number
+>~ --temp : number
+>--temp : number
+>temp : any
+>3 : number
+
+(~ temp--) ** 3;
+>(~ temp--) ** 3 : number
+>(~ temp--) : number
+>~ temp-- : number
+>temp-- : number
+>temp : any
+>3 : number
+
+(~ 3) ** 4;
+>(~ 3) ** 4 : number
+>(~ 3) : number
+>~ 3 : number
+>3 : number
+>4 : number
+
+(~ temp++) ** 4;
+>(~ temp++) ** 4 : number
+>(~ temp++) : number
+>~ temp++ : number
+>temp++ : number
+>temp : any
+>4 : number
+
+(~ temp--) ** 4;
+>(~ temp--) ** 4 : number
+>(~ temp--) : number
+>~ temp-- : number
+>temp-- : number
+>temp : any
+>4 : number
+
+1 ** (~ --temp) ** 3;
+>1 ** (~ --temp) ** 3 : number
+>1 : number
+>(~ --temp) ** 3 : number
+>(~ --temp) : number
+>~ --temp : number
+>--temp : number
+>temp : any
+>3 : number
+
+1 ** (~ temp--) ** 3;
+>1 ** (~ temp--) ** 3 : number
+>1 : number
+>(~ temp--) ** 3 : number
+>(~ temp--) : number
+>~ temp-- : number
+>temp-- : number
+>temp : any
+>3 : number
+
+1 ** (~ 3) ** 4;
+>1 ** (~ 3) ** 4 : number
+>1 : number
+>(~ 3) ** 4 : number
+>(~ 3) : number
+>~ 3 : number
+>3 : number
+>4 : number
+
+1 ** (~ temp++) ** 4;
+>1 ** (~ temp++) ** 4 : number
+>1 : number
+>(~ temp++) ** 4 : number
+>(~ temp++) : number
+>~ temp++ : number
+>temp++ : number
+>temp : any
+>4 : number
+
+1 ** (~ temp--) ** 4;
+>1 ** (~ temp--) ** 4 : number
+>1 : number
+>(~ temp--) ** 4 : number
+>(~ temp--) : number
+>~ temp-- : number
+>temp-- : number
+>temp : any
+>4 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js
new file mode 100644
index 00000000000..433cd764726
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.js
@@ -0,0 +1,53 @@
+//// [emitExponentiationOperatorInTempalteString4.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+`${(-t1) ** t2 - t1} world`;
+`${(-++t1) ** t2 - t1} world`;
+`${(-t1++) ** t2 - t1} world`;
+`${(~t1) ** t2 ** --t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+`hello ${(-++t1) ** t2 - t1}`;
+`hello ${(-t1++) ** t2 - t1}`;
+`hello ${(~t1) ** t2 ** --t1 }`;
+`hello ${typeof (t1 ** t2 ** t1)}`;
+
+//// [emitExponentiationOperatorInTempalteString4.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// With TemplateTail
+(Math.pow(t1, -t2)) + " world";
+(Math.pow((-t1), t2) - t1) + " world";
+(Math.pow((-++t1), t2) - t1) + " world";
+(Math.pow((-t1++), t2) - t1) + " world";
+(Math.pow((~t1), Math.pow(t2, --t1))) + " world";
+typeof (Math.pow(t1, Math.pow(t2, t1))) + " world";
+// TempateHead & TemplateTail are empt
+(Math.pow(t1, -t2)) + " hello world " + (Math.pow(t1, -t2));
+(Math.pow((-t1), t2) - t1) + " hello world " + (Math.pow((-t1), t2) - t1);
+(Math.pow((-++t1), t2) - t1) + " hello world " + (Math.pow(t1, Math.pow((-++t1), -t1)));
+(Math.pow((-t1++), t2) - t1) + " hello world " + (Math.pow(t2, Math.pow((-t1++), -t1)));
+(Math.pow((~t1), Math.pow(t2, --t1))) + " hello world " + (Math.pow((~t1), Math.pow(t2, --t1)));
+typeof (Math.pow(t1, Math.pow(t2, t1))) + " hello world " + typeof (Math.pow(t1, Math.pow(t2, t1)));
+// With templateHead
+"hello " + (Math.pow((-t1), t2) - t1);
+"hello " + (Math.pow((-++t1), t2) - t1);
+"hello " + (Math.pow((-t1++), t2) - t1);
+"hello " + (Math.pow((~t1), Math.pow(t2, --t1)));
+"hello " + typeof (Math.pow(t1, Math.pow(t2, t1)));
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols
new file mode 100644
index 00000000000..7892323ef1d
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.symbols
@@ -0,0 +1,114 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4.ts, 3, 3))
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+
+`${(-t1) ** t2 - t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${(-++t1) ** t2 - t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${(-t1++) ** t2 - t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${(~t1) ** t2 ** --t1 } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`hello ${(-++t1) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`hello ${(-t1++) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`hello ${(~t1) ** t2 ** --t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1)}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types
new file mode 100644
index 00000000000..b4d1aebd4f6
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4.types
@@ -0,0 +1,233 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+>`${t1 ** -t2} world` : string
+>t1 ** -t2 : number
+>t1 : number
+>-t2 : number
+>t2 : number
+
+`${(-t1) ** t2 - t1} world`;
+>`${(-t1) ** t2 - t1} world` : string
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(-++t1) ** t2 - t1} world`;
+>`${(-++t1) ** t2 - t1} world` : string
+>(-++t1) ** t2 - t1 : number
+>(-++t1) ** t2 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(-t1++) ** t2 - t1} world`;
+>`${(-t1++) ** t2 - t1} world` : string
+>(-t1++) ** t2 - t1 : number
+>(-t1++) ** t2 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(~t1) ** t2 ** --t1 } world`;
+>`${(~t1) ** t2 ** --t1 } world` : string
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>`${typeof (t1 ** t2 ** t1) } world` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+>`${t1 ** -t2} hello world ${t1 ** -t2}` : string
+>t1 ** -t2 : number
+>t1 : number
+>-t2 : number
+>t2 : number
+>t1 ** -t2 : number
+>t1 : number
+>-t2 : number
+>t2 : number
+
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+>`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}` : string
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+>`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}` : string
+>(-++t1) ** t2 - t1 : number
+>(-++t1) ** t2 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** (-++t1) **- t1 : number
+>t1 : number
+>(-++t1) **- t1 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>- t1 : number
+>t1 : number
+
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+>`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}` : string
+>(-t1++) ** t2 - t1 : number
+>(-t1++) ** t2 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t2 ** (-t1++) **  - t1 : number
+>t2 : number
+>(-t1++) **  - t1 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>- t1 : number
+>t1 : number
+
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+>`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }` : string
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+>`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+>`hello ${(-t1) ** t2 - t1}` : string
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${(-++t1) ** t2 - t1}`;
+>`hello ${(-++t1) ** t2 - t1}` : string
+>(-++t1) ** t2 - t1 : number
+>(-++t1) ** t2 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${(-t1++) ** t2 - t1}`;
+>`hello ${(-t1++) ** t2 - t1}` : string
+>(-t1++) ** t2 - t1 : number
+>(-t1++) ** t2 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${(~t1) ** t2 ** --t1 }`;
+>`hello ${(~t1) ** t2 ** --t1 }` : string
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1)}`;
+>`hello ${typeof (t1 ** t2 ** t1)}` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js
new file mode 100644
index 00000000000..bda3f8be251
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.js
@@ -0,0 +1,53 @@
+//// [emitExponentiationOperatorInTempalteString4ES6.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+`${(-t1) ** t2 - t1} world`;
+`${(-++t1) ** t2 - t1} world`;
+`${(-t1++) ** t2 - t1} world`;
+`${(~t1) ** t2 ** --t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+`hello ${(-++t1) ** t2 - t1}`;
+`hello ${(-t1++) ** t2 - t1}`;
+`hello ${(~t1) ** t2 ** --t1 }`;
+`hello ${typeof (t1 ** t2 ** t1)}`;
+
+//// [emitExponentiationOperatorInTempalteString4ES6.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// With TemplateTail
+`${Math.pow(t1, -t2)} world`;
+`${Math.pow((-t1), t2) - t1} world`;
+`${Math.pow((-++t1), t2) - t1} world`;
+`${Math.pow((-t1++), t2) - t1} world`;
+`${Math.pow((~t1), Math.pow(t2, --t1))} world`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))} world`;
+// TempateHead & TemplateTail are empt
+`${Math.pow(t1, -t2)} hello world ${Math.pow(t1, -t2)}`;
+`${Math.pow((-t1), t2) - t1} hello world ${Math.pow((-t1), t2) - t1}`;
+`${Math.pow((-++t1), t2) - t1} hello world ${Math.pow(t1, Math.pow((-++t1), -t1))}`;
+`${Math.pow((-t1++), t2) - t1} hello world ${Math.pow(t2, Math.pow((-t1++), -t1))}`;
+`${Math.pow((~t1), Math.pow(t2, --t1))} hello world ${Math.pow((~t1), Math.pow(t2, --t1))}`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))} hello world ${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
+// With templateHead
+`hello ${Math.pow((-t1), t2) - t1}`;
+`hello ${Math.pow((-++t1), t2) - t1}`;
+`hello ${Math.pow((-t1++), t2) - t1}`;
+`hello ${Math.pow((~t1), Math.pow(t2, --t1))}`;
+`hello ${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols
new file mode 100644
index 00000000000..1f4cd74502b
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.symbols
@@ -0,0 +1,114 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 3, 3))
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+
+`${(-t1) ** t2 - t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${(-++t1) ** t2 - t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${(-t1++) ** t2 - t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${(~t1) ** t2 ** --t1 } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`hello ${(-++t1) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`hello ${(-t1++) ** t2 - t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`hello ${(~t1) ** t2 ** --t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1)}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTempalteString4ES6.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types
new file mode 100644
index 00000000000..ed2f4b522e9
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTempalteString4ES6.types
@@ -0,0 +1,233 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+>`${t1 ** -t2} world` : string
+>t1 ** -t2 : number
+>t1 : number
+>-t2 : number
+>t2 : number
+
+`${(-t1) ** t2 - t1} world`;
+>`${(-t1) ** t2 - t1} world` : string
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(-++t1) ** t2 - t1} world`;
+>`${(-++t1) ** t2 - t1} world` : string
+>(-++t1) ** t2 - t1 : number
+>(-++t1) ** t2 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(-t1++) ** t2 - t1} world`;
+>`${(-t1++) ** t2 - t1} world` : string
+>(-t1++) ** t2 - t1 : number
+>(-t1++) ** t2 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(~t1) ** t2 ** --t1 } world`;
+>`${(~t1) ** t2 ** --t1 } world` : string
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>`${typeof (t1 ** t2 ** t1) } world` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+>`${t1 ** -t2} hello world ${t1 ** -t2}` : string
+>t1 ** -t2 : number
+>t1 : number
+>-t2 : number
+>t2 : number
+>t1 ** -t2 : number
+>t1 : number
+>-t2 : number
+>t2 : number
+
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+>`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}` : string
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+>`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}` : string
+>(-++t1) ** t2 - t1 : number
+>(-++t1) ** t2 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** (-++t1) **- t1 : number
+>t1 : number
+>(-++t1) **- t1 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>- t1 : number
+>t1 : number
+
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+>`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}` : string
+>(-t1++) ** t2 - t1 : number
+>(-t1++) ** t2 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t2 ** (-t1++) **  - t1 : number
+>t2 : number
+>(-t1++) **  - t1 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>- t1 : number
+>t1 : number
+
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+>`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }` : string
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+>`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+>`hello ${(-t1) ** t2 - t1}` : string
+>(-t1) ** t2 - t1 : number
+>(-t1) ** t2 : number
+>(-t1) : number
+>-t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${(-++t1) ** t2 - t1}`;
+>`hello ${(-++t1) ** t2 - t1}` : string
+>(-++t1) ** t2 - t1 : number
+>(-++t1) ** t2 : number
+>(-++t1) : number
+>-++t1 : number
+>++t1 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${(-t1++) ** t2 - t1}`;
+>`hello ${(-t1++) ** t2 - t1}` : string
+>(-t1++) ** t2 - t1 : number
+>(-t1++) ** t2 : number
+>(-t1++) : number
+>-t1++ : number
+>t1++ : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${(~t1) ** t2 ** --t1 }`;
+>`hello ${(~t1) ** t2 ** --t1 }` : string
+>(~t1) ** t2 ** --t1 : number
+>(~t1) : number
+>~t1 : number
+>t1 : number
+>t2 ** --t1 : number
+>t2 : number
+>--t1 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1)}`;
+>`hello ${typeof (t1 ** t2 ** t1)}` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js
new file mode 100644
index 00000000000..eb879cce6a5
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.js
@@ -0,0 +1,53 @@
+//// [emitExponentiationOperatorInTemplateString1.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+`${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1 }`;
+`${typeof (t1 ** t2 ** t1) }`;
+`${1 + typeof (t1 ** t2 ** t1) }`;
+
+`${t1 ** t2}${t1 ** t2}`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+
+//// [emitExponentiationOperatorInTemplateString1.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// TempateHead & TemplateTail are empty
+"" + (Math.pow(t1, t2));
+"" + (Math.pow(t1, Math.pow(t2, t1)));
+"" + (t1 + Math.pow(t2, t1));
+"" + (Math.pow(t1, t2) + t1);
+"" + (t1 + Math.pow(t2, t2) + t1);
+"" + typeof (Math.pow(t1, Math.pow(t2, t1)));
+"" + (1 + typeof (Math.pow(t1, Math.pow(t2, t1))));
+"" + (Math.pow(t1, t2)) + (Math.pow(t1, t2));
+"" + (Math.pow(t1, Math.pow(t2, t1))) + (Math.pow(t1, Math.pow(t2, t1)));
+"" + (t1 + Math.pow(t2, t1)) + (t1 + Math.pow(t2, t1));
+"" + (Math.pow(t1, t2) + t1) + (Math.pow(t1, t2) + t1);
+"" + (t1 + Math.pow(t2, t2) + t1) + (t1 + Math.pow(t2, t2) + t1);
+"" + typeof (Math.pow(t1, Math.pow(t2, t1))) + typeof (Math.pow(t1, Math.pow(t2, t1)));
+(Math.pow(t1, t2)) + " hello world " + (Math.pow(t1, t2));
+(Math.pow(t1, Math.pow(t2, t1))) + " hello world " + (Math.pow(t1, Math.pow(t2, t1)));
+(t1 + Math.pow(t2, t1)) + " hello world " + (t1 + Math.pow(t2, t1));
+(Math.pow(t1, t2) + t1) + " hello world " + (Math.pow(t1, t2) + t1);
+(t1 + Math.pow(t2, t2) + t1) + " hello world " + (t1 + Math.pow(t2, t2) + t1);
+typeof (Math.pow(t1, Math.pow(t2, t1))) + " hello world " + typeof (Math.pow(t1, Math.pow(t2, t1)));
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols
new file mode 100644
index 00000000000..8830135987e
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.symbols
@@ -0,0 +1,143 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1.ts, 3, 3))
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+
+`${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${1 + typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 ** t2}${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types
new file mode 100644
index 00000000000..02ae523c168
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1.types
@@ -0,0 +1,240 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+>`${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1}`;
+>`${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1}`;
+>`${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1}`;
+>`${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1 }`;
+>`${t1 + t2 ** t2 + t1 }` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) }`;
+>`${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${1 + typeof (t1 ** t2 ** t1) }`;
+>`${1 + typeof (t1 ** t2 ** t1) }` : string
+>1 + typeof (t1 ** t2 ** t1) : string
+>1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2}${t1 ** t2}`;
+>`${t1 ** t2}${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>`${t1 ** t2 ** t1}${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>`${t1 + t2 ** t1}${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>`${t1 ** t2 + t1}${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+>`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+>`${t1 ** t2} hello world ${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js
new file mode 100644
index 00000000000..d32caf45106
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.js
@@ -0,0 +1,53 @@
+//// [emitExponentiationOperatorInTemplateString1ES6.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+`${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1 }`;
+`${typeof (t1 ** t2 ** t1) }`;
+`${1 + typeof (t1 ** t2 ** t1) }`;
+
+`${t1 ** t2}${t1 ** t2}`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+
+//// [emitExponentiationOperatorInTemplateString1ES6.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// TempateHead & TemplateTail are empty
+`${Math.pow(t1, t2)}`;
+`${Math.pow(t1, Math.pow(t2, t1))}`;
+`${t1 + Math.pow(t2, t1)}`;
+`${Math.pow(t1, t2) + t1}`;
+`${t1 + Math.pow(t2, t2) + t1}`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
+`${1 + typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
+`${Math.pow(t1, t2)}${Math.pow(t1, t2)}`;
+`${Math.pow(t1, Math.pow(t2, t1))}${Math.pow(t1, Math.pow(t2, t1))}`;
+`${t1 + Math.pow(t2, t1)}${t1 + Math.pow(t2, t1)}`;
+`${Math.pow(t1, t2) + t1}${Math.pow(t1, t2) + t1}`;
+`${t1 + Math.pow(t2, t2) + t1}${t1 + Math.pow(t2, t2) + t1}`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))}${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
+`${Math.pow(t1, t2)} hello world ${Math.pow(t1, t2)}`;
+`${Math.pow(t1, Math.pow(t2, t1))} hello world ${Math.pow(t1, Math.pow(t2, t1))}`;
+`${t1 + Math.pow(t2, t1)} hello world ${t1 + Math.pow(t2, t1)}`;
+`${Math.pow(t1, t2) + t1} hello world ${Math.pow(t1, t2) + t1}`;
+`${t1 + Math.pow(t2, t2) + t1} hello world ${t1 + Math.pow(t2, t2) + t1}`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))} hello world ${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols
new file mode 100644
index 00000000000..7b07fa26bba
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.symbols
@@ -0,0 +1,143 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 3, 3))
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+
+`${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${1 + typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 ** t2}${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString1ES6.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types
new file mode 100644
index 00000000000..c2ee01ff23f
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString1ES6.types
@@ -0,0 +1,240 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+>`${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1}`;
+>`${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1}`;
+>`${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1}`;
+>`${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1 }`;
+>`${t1 + t2 ** t2 + t1 }` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) }`;
+>`${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${1 + typeof (t1 ** t2 ** t1) }`;
+>`${1 + typeof (t1 ** t2 ** t1) }` : string
+>1 + typeof (t1 ** t2 ** t1) : string
+>1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2}${t1 ** t2}`;
+>`${t1 ** t2}${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>`${t1 ** t2 ** t1}${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>`${t1 + t2 ** t1}${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>`${t1 ** t2 + t1}${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+>`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+>`${t1 ** t2} hello world ${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js
new file mode 100644
index 00000000000..73384762706
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.js
@@ -0,0 +1,53 @@
+//// [emitExponentiationOperatorInTemplateString2.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With templateHead
+`hello ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1 }`;
+`hello ${typeof (t1 ** t2 ** t1) }`;
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+
+//// [emitExponentiationOperatorInTemplateString2.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// With templateHead
+"hello " + (Math.pow(t1, t2));
+"hello " + (Math.pow(t1, Math.pow(t2, t1)));
+"hello " + (t1 + Math.pow(t2, t1));
+"hello " + (Math.pow(t1, t2) + t1);
+"hello " + (t1 + Math.pow(t2, t2) + t1);
+"hello " + typeof (Math.pow(t1, Math.pow(t2, t1)));
+"hello " + (1 + typeof (Math.pow(t1, Math.pow(t2, t1))));
+"hello " + (Math.pow(t1, t2)) + (Math.pow(t1, t2));
+"hello " + (Math.pow(t1, Math.pow(t2, t1))) + (Math.pow(t1, Math.pow(t2, t1)));
+"hello " + (t1 + Math.pow(t2, t1)) + (t1 + Math.pow(t2, t1));
+"hello " + (Math.pow(t1, t2) + t1) + (Math.pow(t1, t2) + t1);
+"hello " + (t1 + Math.pow(t2, t2) + t1) + (t1 + Math.pow(t2, t2) + t1);
+"hello " + typeof (Math.pow(t1, Math.pow(t2, t1))) + typeof (Math.pow(t1, Math.pow(t2, t1)));
+"hello " + (Math.pow(t1, t2)) + " hello world " + (Math.pow(t1, t2));
+"hello " + (Math.pow(t1, Math.pow(t2, t1))) + " hello world " + (Math.pow(t1, Math.pow(t2, t1)));
+"hello " + (t1 + Math.pow(t2, t1)) + " hello world " + (t1 + Math.pow(t2, t1));
+"hello " + (Math.pow(t1, t2) + t1) + " hello world " + (Math.pow(t1, t2) + t1);
+"hello " + (t1 + Math.pow(t2, t2) + t1) + " hello world " + (t1 + Math.pow(t2, t2) + t1);
+"hello " + typeof (Math.pow(t1, Math.pow(t2, t1))) + " hello world " + typeof (Math.pow(t1, Math.pow(t2, t1)));
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols
new file mode 100644
index 00000000000..224499c1289
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.symbols
@@ -0,0 +1,143 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2.ts, 3, 3))
+
+// With templateHead
+`hello ${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+
+`hello ${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 + t2 ** t2 + t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types
new file mode 100644
index 00000000000..05816e94c6c
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2.types
@@ -0,0 +1,240 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// With templateHead
+`hello ${t1 ** t2}`;
+>`hello ${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`hello ${t1 ** t2 ** t1}`;
+>`hello ${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t1}`;
+>`hello ${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2 + t1}`;
+>`hello ${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t2 + t1 }`;
+>`hello ${t1 + t2 ** t2 + t1 }` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1) }`;
+>`hello ${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+>`hello ${1 + typeof (t1 ** t2 ** t1) }` : string
+>1 + typeof (t1 ** t2 ** t1) : string
+>1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+>`hello ${t1 ** t2}${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+>`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+>`hello ${t1 ** t2} hello world ${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js
new file mode 100644
index 00000000000..ac92b4598aa
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.js
@@ -0,0 +1,53 @@
+//// [emitExponentiationOperatorInTemplateString2ES6.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With templateHead
+`hello ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1 }`;
+`hello ${typeof (t1 ** t2 ** t1) }`;
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+
+//// [emitExponentiationOperatorInTemplateString2ES6.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// With templateHead
+`hello ${Math.pow(t1, t2)}`;
+`hello ${Math.pow(t1, Math.pow(t2, t1))}`;
+`hello ${t1 + Math.pow(t2, t1)}`;
+`hello ${Math.pow(t1, t2) + t1}`;
+`hello ${t1 + Math.pow(t2, t2) + t1}`;
+`hello ${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
+`hello ${1 + typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
+`hello ${Math.pow(t1, t2)}${Math.pow(t1, t2)}`;
+`hello ${Math.pow(t1, Math.pow(t2, t1))}${Math.pow(t1, Math.pow(t2, t1))}`;
+`hello ${t1 + Math.pow(t2, t1)}${t1 + Math.pow(t2, t1)}`;
+`hello ${Math.pow(t1, t2) + t1}${Math.pow(t1, t2) + t1}`;
+`hello ${t1 + Math.pow(t2, t2) + t1}${t1 + Math.pow(t2, t2) + t1}`;
+`hello ${typeof (Math.pow(t1, Math.pow(t2, t1)))}${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
+`hello ${Math.pow(t1, t2)} hello world ${Math.pow(t1, t2)}`;
+`hello ${Math.pow(t1, Math.pow(t2, t1))} hello world ${Math.pow(t1, Math.pow(t2, t1))}`;
+`hello ${t1 + Math.pow(t2, t1)} hello world ${t1 + Math.pow(t2, t1)}`;
+`hello ${Math.pow(t1, t2) + t1} hello world ${Math.pow(t1, t2) + t1}`;
+`hello ${t1 + Math.pow(t2, t2) + t1} hello world ${t1 + Math.pow(t2, t2) + t1}`;
+`hello ${typeof (Math.pow(t1, Math.pow(t2, t1)))} hello world ${typeof (Math.pow(t1, Math.pow(t2, t1)))}`;
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols
new file mode 100644
index 00000000000..fd674b21d33
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.symbols
@@ -0,0 +1,143 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 3, 3))
+
+// With templateHead
+`hello ${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+
+`hello ${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 + t2 ** t2 + t1 }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString2ES6.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types
new file mode 100644
index 00000000000..b77e38587c2
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString2ES6.types
@@ -0,0 +1,240 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// With templateHead
+`hello ${t1 ** t2}`;
+>`hello ${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`hello ${t1 ** t2 ** t1}`;
+>`hello ${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t1}`;
+>`hello ${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2 + t1}`;
+>`hello ${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t2 + t1 }`;
+>`hello ${t1 + t2 ** t2 + t1 }` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1) }`;
+>`hello ${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+>`hello ${1 + typeof (t1 ** t2 ** t1) }` : string
+>1 + typeof (t1 ** t2 ** t1) : string
+>1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+>`hello ${t1 ** t2}${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+>`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+>`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+>`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+>`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+>`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+>`hello ${t1 ** t2} hello world ${t1 ** t2}` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+>`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+>`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+>`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+>`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
+>`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js
new file mode 100644
index 00000000000..9c3b937d94b
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.js
@@ -0,0 +1,54 @@
+//// [emitExponentiationOperatorInTemplateString3.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** t2} world`;
+`${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2}${t1 ** t2} world`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
+
+
+//// [emitExponentiationOperatorInTemplateString3.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// With TemplateTail
+(Math.pow(t1, t2)) + " world";
+(Math.pow(t1, Math.pow(t2, t1))) + " world";
+(t1 + Math.pow(t2, t1)) + " world";
+(Math.pow(t1, t2) + t1) + " world";
+(t1 + Math.pow(t2, t2) + t1) + " world";
+typeof (Math.pow(t1, Math.pow(t2, t1))) + " world";
+(1 + typeof (Math.pow(t1, Math.pow(t2, t1)))) + " world";
+"" + (Math.pow(t1, t2)) + (Math.pow(t1, t2)) + " world";
+"" + (Math.pow(t1, Math.pow(t2, t1))) + (Math.pow(t1, Math.pow(t2, t1))) + " world";
+"" + (t1 + Math.pow(t2, t1)) + (t1 + Math.pow(t2, t1)) + " world";
+"" + (Math.pow(t1, t2) + t1) + (Math.pow(t1, t2) + t1) + " world";
+"" + (t1 + Math.pow(t2, t2) + t1) + (t1 + Math.pow(t2, t2) + t1) + " world";
+"" + typeof (Math.pow(t1, Math.pow(t2, t1))) + typeof (Math.pow(t1, Math.pow(t2, t1))) + " world";
+(Math.pow(t1, t2)) + " hello world " + (Math.pow(t1, t2)) + " !!";
+(Math.pow(t1, Math.pow(t2, t1))) + " hello world " + (Math.pow(t1, Math.pow(t2, t1))) + " !!";
+(t1 + Math.pow(t2, t1)) + " hello world " + (t1 + Math.pow(t2, t1)) + " !!";
+(Math.pow(t1, t2) + t1) + " hello world " + (Math.pow(t1, t2) + t1) + " !!";
+(t1 + Math.pow(t2, t2) + t1) + " hello world " + (t1 + Math.pow(t2, t2) + t1) + " !!";
+typeof (Math.pow(t1, Math.pow(t2, t1))) + " hello world " + typeof (Math.pow(t1, Math.pow(t2, t1))) + " !!";
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols
new file mode 100644
index 00000000000..758a0e2956b
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.symbols
@@ -0,0 +1,143 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3.ts, 3, 3))
+
+// With TemplateTail
+`${t1 ** t2} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+
+`${t1 ** t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 + t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 ** t2 + t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1 } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 ** t2}${t1 ** t2} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types
new file mode 100644
index 00000000000..88c23ee8a0b
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3.types
@@ -0,0 +1,240 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// With TemplateTail
+`${t1 ** t2} world`;
+>`${t1 ** t2} world` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1} world`;
+>`${t1 ** t2 ** t1} world` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1} world`;
+>`${t1 + t2 ** t1} world` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1} world`;
+>`${t1 ** t2 + t1} world` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1 } world`;
+>`${t1 + t2 ** t2 + t1 } world` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>`${typeof (t1 ** t2 ** t1) } world` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+>`${1 + typeof (t1 ** t2 ** t1) } world` : string
+>1 + typeof (t1 ** t2 ** t1) : string
+>1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2}${t1 ** t2} world`;
+>`${t1 ** t2}${t1 ** t2} world` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+>`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+>`${t1 + t2 ** t1}${t1 + t2 ** t1} world` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+>`${t1 ** t2 + t1}${t1 ** t2 + t1} world` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+>`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+>`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+>`${t1 ** t2} hello world ${t1 ** t2} !!` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+>`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+>`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+>`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+>`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
+>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js
new file mode 100644
index 00000000000..ec037dd2150
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.js
@@ -0,0 +1,54 @@
+//// [emitExponentiationOperatorInTemplateString3ES6.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** t2} world`;
+`${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2}${t1 ** t2} world`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
+
+
+//// [emitExponentiationOperatorInTemplateString3ES6.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// With TemplateTail
+`${Math.pow(t1, t2)} world`;
+`${Math.pow(t1, Math.pow(t2, t1))} world`;
+`${t1 + Math.pow(t2, t1)} world`;
+`${Math.pow(t1, t2) + t1} world`;
+`${t1 + Math.pow(t2, t2) + t1} world`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))} world`;
+`${1 + typeof (Math.pow(t1, Math.pow(t2, t1)))} world`;
+`${Math.pow(t1, t2)}${Math.pow(t1, t2)} world`;
+`${Math.pow(t1, Math.pow(t2, t1))}${Math.pow(t1, Math.pow(t2, t1))} world`;
+`${t1 + Math.pow(t2, t1)}${t1 + Math.pow(t2, t1)} world`;
+`${Math.pow(t1, t2) + t1}${Math.pow(t1, t2) + t1} world`;
+`${t1 + Math.pow(t2, t2) + t1}${t1 + Math.pow(t2, t2) + t1} world`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))}${typeof (Math.pow(t1, Math.pow(t2, t1)))} world`;
+`${Math.pow(t1, t2)} hello world ${Math.pow(t1, t2)} !!`;
+`${Math.pow(t1, Math.pow(t2, t1))} hello world ${Math.pow(t1, Math.pow(t2, t1))} !!`;
+`${t1 + Math.pow(t2, t1)} hello world ${t1 + Math.pow(t2, t1)} !!`;
+`${Math.pow(t1, t2) + t1} hello world ${Math.pow(t1, t2) + t1} !!`;
+`${t1 + Math.pow(t2, t2) + t1} hello world ${t1 + Math.pow(t2, t2) + t1} !!`;
+`${typeof (Math.pow(t1, Math.pow(t2, t1)))} hello world ${typeof (Math.pow(t1, Math.pow(t2, t1)))} !!`;
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols
new file mode 100644
index 00000000000..a6062348432
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.symbols
@@ -0,0 +1,143 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts ===
+
+var t1 = 10;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+var t2 = 10;
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+
+var s;
+>s : Symbol(s, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 3, 3))
+
+// With TemplateTail
+`${t1 ** t2} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+
+`${t1 ** t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 + t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 ** t2 + t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1 } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 ** t2}${t1 ** t2} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+>t2 : Symbol(t2, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 2, 3))
+>t1 : Symbol(t1, Decl(emitExponentiationOperatorInTemplateString3ES6.ts, 1, 3))
+
diff --git a/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types
new file mode 100644
index 00000000000..e0d59cc1319
--- /dev/null
+++ b/tests/baselines/reference/emitExponentiationOperatorInTemplateString3ES6.types
@@ -0,0 +1,240 @@
+=== tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts ===
+
+var t1 = 10;
+>t1 : number
+>10 : number
+
+var t2 = 10;
+>t2 : number
+>10 : number
+
+var s;
+>s : any
+
+// With TemplateTail
+`${t1 ** t2} world`;
+>`${t1 ** t2} world` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1} world`;
+>`${t1 ** t2 ** t1} world` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1} world`;
+>`${t1 + t2 ** t1} world` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1} world`;
+>`${t1 ** t2 + t1} world` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1 } world`;
+>`${t1 + t2 ** t2 + t1 } world` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } world`;
+>`${typeof (t1 ** t2 ** t1) } world` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+>`${1 + typeof (t1 ** t2 ** t1) } world` : string
+>1 + typeof (t1 ** t2 ** t1) : string
+>1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2}${t1 ** t2} world`;
+>`${t1 ** t2}${t1 ** t2} world` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+>`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+>`${t1 + t2 ** t1}${t1 + t2 ** t1} world` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+>`${t1 ** t2 + t1}${t1 ** t2 + t1} world` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+>`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+>`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+>`${t1 ** t2} hello world ${t1 ** t2} !!` : string
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+>`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!` : string
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+>`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!` : string
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+>`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!` : string
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+>t1 ** t2 + t1 : number
+>t1 ** t2 : number
+>t1 : number
+>t2 : number
+>t1 : number
+
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+>`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!` : string
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+>t1 + t2 ** t2 + t1 : number
+>t1 + t2 ** t2 : number
+>t1 : number
+>t2 ** t2 : number
+>t2 : number
+>t2 : number
+>t1 : number
+
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
+>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!` : string
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+>typeof (t1 ** t2 ** t1) : string
+>(t1 ** t2 ** t1) : number
+>t1 ** t2 ** t1 : number
+>t1 : number
+>t2 ** t1 : number
+>t2 : number
+>t1 : number
+
diff --git a/tests/baselines/reference/enumBasics.symbols b/tests/baselines/reference/enumBasics.symbols
index 32bbfc3124e..23f2a400741 100644
--- a/tests/baselines/reference/enumBasics.symbols
+++ b/tests/baselines/reference/enumBasics.symbols
@@ -76,8 +76,8 @@ enum E3 {
 
     X = 'foo'.length, Y = 4 + 3, Z = +'foo'
 >X : Symbol(E3.X, Decl(enumBasics.ts, 31, 9))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >Y : Symbol(E3.Y, Decl(enumBasics.ts, 32, 21))
 >Z : Symbol(E3.Z, Decl(enumBasics.ts, 32, 32))
 }
@@ -90,8 +90,8 @@ enum E4 {
 >X : Symbol(E4.X, Decl(enumBasics.ts, 36, 9))
 >Y : Symbol(E4.Y, Decl(enumBasics.ts, 37, 10))
 >Z : Symbol(E4.Z, Decl(enumBasics.ts, 37, 13))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
 
 // Enum with > 2 constant members with no initializer for first member, non zero initializer for second element
diff --git a/tests/baselines/reference/enumIndexer.symbols b/tests/baselines/reference/enumIndexer.symbols
index 3f65044c2ec..59191a73276 100644
--- a/tests/baselines/reference/enumIndexer.symbols
+++ b/tests/baselines/reference/enumIndexer.symbols
@@ -19,9 +19,9 @@ var enumValue = MyEnumType.foo;
 
 var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type
 >x : Symbol(x, Decl(enumIndexer.ts, 5, 3))
->_arr.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>_arr.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >o : Symbol(o, Decl(enumIndexer.ts, 5, 17))
 >MyEnumType : Symbol(MyEnumType, Decl(enumIndexer.ts, 0, 0))
 >o.key : Symbol(key, Decl(enumIndexer.ts, 3, 13))
diff --git a/tests/baselines/reference/enumMerging.symbols b/tests/baselines/reference/enumMerging.symbols
index 414dd839952..7b94cb49b29 100644
--- a/tests/baselines/reference/enumMerging.symbols
+++ b/tests/baselines/reference/enumMerging.symbols
@@ -71,14 +71,14 @@ module M2 {
 
         A = 'foo'.length, B = 'foo'.length, C = 'foo'.length
 >A : Symbol(EComp2.A, Decl(enumMerging.ts, 24, 24))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >B : Symbol(EComp2.B, Decl(enumMerging.ts, 25, 25))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >C : Symbol(EComp2.C, Decl(enumMerging.ts, 25, 43))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
 
     export enum EComp2 {
@@ -86,14 +86,14 @@ module M2 {
 
         D = 'foo'.length, E = 'foo'.length, F = 'foo'.length
 >D : Symbol(EComp2.D, Decl(enumMerging.ts, 28, 24))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >E : Symbol(EComp2.E, Decl(enumMerging.ts, 29, 25))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >F : Symbol(EComp2.F, Decl(enumMerging.ts, 29, 43))
->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
 
     var x = [EComp2.A, EComp2.B, EComp2.C, EComp2.D, EComp2.E, EComp2.F];
diff --git a/tests/baselines/reference/enumNumbering1.symbols b/tests/baselines/reference/enumNumbering1.symbols
index 7722b5bad78..274798f6aad 100644
--- a/tests/baselines/reference/enumNumbering1.symbols
+++ b/tests/baselines/reference/enumNumbering1.symbols
@@ -10,12 +10,12 @@ enum Test {
 
     C = Math.floor(Math.random() * 1000),
 >C : Symbol(Test.C, Decl(enumNumbering1.ts, 2, 6))
->Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 
     D = 10,
 >D : Symbol(Test.D, Decl(enumNumbering1.ts, 3, 41))
diff --git a/tests/baselines/reference/es2015modulekind.js b/tests/baselines/reference/es2015modulekind.js
new file mode 100644
index 00000000000..af638557fde
--- /dev/null
+++ b/tests/baselines/reference/es2015modulekind.js
@@ -0,0 +1,23 @@
+//// [es2015modulekind.ts]
+
+export default class A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+    {
+        return 42;
+    }
+}
+
+//// [es2015modulekind.js]
+export default class A {
+    constructor() {
+    }
+    B() {
+        return 42;
+    }
+}
diff --git a/tests/baselines/reference/es2015modulekind.symbols b/tests/baselines/reference/es2015modulekind.symbols
new file mode 100644
index 00000000000..227443ac06b
--- /dev/null
+++ b/tests/baselines/reference/es2015modulekind.symbols
@@ -0,0 +1,16 @@
+=== tests/cases/compiler/es2015modulekind.ts ===
+
+export default class A
+>A : Symbol(A, Decl(es2015modulekind.ts, 0, 0))
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+>B : Symbol(B, Decl(es2015modulekind.ts, 6, 5))
+    {
+        return 42;
+    }
+}
diff --git a/tests/baselines/reference/es2015modulekind.types b/tests/baselines/reference/es2015modulekind.types
new file mode 100644
index 00000000000..e77cf095aed
--- /dev/null
+++ b/tests/baselines/reference/es2015modulekind.types
@@ -0,0 +1,17 @@
+=== tests/cases/compiler/es2015modulekind.ts ===
+
+export default class A
+>A : A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+>B : () => number
+    {
+        return 42;
+>42 : number
+    }
+}
diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.js b/tests/baselines/reference/es2015modulekindWithES6Target.js
new file mode 100644
index 00000000000..b76ab2a02a2
--- /dev/null
+++ b/tests/baselines/reference/es2015modulekindWithES6Target.js
@@ -0,0 +1,23 @@
+//// [es2015modulekindWithES6Target.ts]
+
+export default class A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+    {
+        return 42;
+    }
+}
+
+//// [es2015modulekindWithES6Target.js]
+export default class A {
+    constructor() {
+    }
+    B() {
+        return 42;
+    }
+}
diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.symbols b/tests/baselines/reference/es2015modulekindWithES6Target.symbols
new file mode 100644
index 00000000000..2ff208ac704
--- /dev/null
+++ b/tests/baselines/reference/es2015modulekindWithES6Target.symbols
@@ -0,0 +1,16 @@
+=== tests/cases/compiler/es2015modulekindWithES6Target.ts ===
+
+export default class A
+>A : Symbol(A, Decl(es2015modulekindWithES6Target.ts, 0, 0))
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+>B : Symbol(B, Decl(es2015modulekindWithES6Target.ts, 6, 5))
+    {
+        return 42;
+    }
+}
diff --git a/tests/baselines/reference/es2015modulekindWithES6Target.types b/tests/baselines/reference/es2015modulekindWithES6Target.types
new file mode 100644
index 00000000000..50b85921b0e
--- /dev/null
+++ b/tests/baselines/reference/es2015modulekindWithES6Target.types
@@ -0,0 +1,17 @@
+=== tests/cases/compiler/es2015modulekindWithES6Target.ts ===
+
+export default class A
+>A : A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+>B : () => number
+    {
+        return 42;
+>42 : number
+    }
+}
diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols
index 907f1d71b89..3472258373e 100644
--- a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols
+++ b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols
@@ -13,7 +13,7 @@ export default function assert(value: boolean) {
 
     if (!value) throw new Error("Assertion failed!");
 >value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 === tests/cases/compiler/es3defaultAliasQuoted_file1.ts ===
diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.js b/tests/baselines/reference/es6modulekindWithES2015Target.js
new file mode 100644
index 00000000000..98808fd1c65
--- /dev/null
+++ b/tests/baselines/reference/es6modulekindWithES2015Target.js
@@ -0,0 +1,23 @@
+//// [es6modulekindWithES2015Target.ts]
+
+export default class A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+    {
+        return 42;
+    }
+}
+
+//// [es6modulekindWithES2015Target.js]
+export default class A {
+    constructor() {
+    }
+    B() {
+        return 42;
+    }
+}
diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.symbols b/tests/baselines/reference/es6modulekindWithES2015Target.symbols
new file mode 100644
index 00000000000..98b91a0411b
--- /dev/null
+++ b/tests/baselines/reference/es6modulekindWithES2015Target.symbols
@@ -0,0 +1,16 @@
+=== tests/cases/compiler/es6modulekindWithES2015Target.ts ===
+
+export default class A
+>A : Symbol(A, Decl(es6modulekindWithES2015Target.ts, 0, 0))
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+>B : Symbol(B, Decl(es6modulekindWithES2015Target.ts, 6, 5))
+    {
+        return 42;
+    }
+}
diff --git a/tests/baselines/reference/es6modulekindWithES2015Target.types b/tests/baselines/reference/es6modulekindWithES2015Target.types
new file mode 100644
index 00000000000..63acdae43d1
--- /dev/null
+++ b/tests/baselines/reference/es6modulekindWithES2015Target.types
@@ -0,0 +1,17 @@
+=== tests/cases/compiler/es6modulekindWithES2015Target.ts ===
+
+export default class A
+>A : A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+>B : () => number
+    {
+        return 42;
+>42 : number
+    }
+}
diff --git a/tests/baselines/reference/everyTypeAssignableToAny.symbols b/tests/baselines/reference/everyTypeAssignableToAny.symbols
index 275a58641d2..be88c481ece 100644
--- a/tests/baselines/reference/everyTypeAssignableToAny.symbols
+++ b/tests/baselines/reference/everyTypeAssignableToAny.symbols
@@ -41,7 +41,7 @@ var d: boolean;
 
 var e: Date;
 >e : Symbol(e, Decl(everyTypeAssignableToAny.ts, 17, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f: any;
 >f : Symbol(f, Decl(everyTypeAssignableToAny.ts, 18, 3))
@@ -51,7 +51,7 @@ var g: void;
 
 var h: Object;
 >h : Symbol(h, Decl(everyTypeAssignableToAny.ts, 20, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var i: {};
 >i : Symbol(i, Decl(everyTypeAssignableToAny.ts, 21, 3))
@@ -61,7 +61,7 @@ var j: () => {};
 
 var k: Function;
 >k : Symbol(k, Decl(everyTypeAssignableToAny.ts, 23, 3))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var l: (x: number) => string;
 >l : Symbol(l, Decl(everyTypeAssignableToAny.ts, 24, 3))
@@ -83,11 +83,11 @@ var o: <T>(x: T) => T;
 
 var p: Number;
 >p : Symbol(p, Decl(everyTypeAssignableToAny.ts, 28, 3))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var q: String;
 >q : Symbol(q, Decl(everyTypeAssignableToAny.ts, 29, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 a = b;
 >a : Symbol(a, Decl(everyTypeAssignableToAny.ts, 0, 3))
@@ -166,7 +166,7 @@ function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
 >T : Symbol(T, Decl(everyTypeAssignableToAny.ts, 50, 13))
 >U : Symbol(U, Decl(everyTypeAssignableToAny.ts, 50, 15))
 >V : Symbol(V, Decl(everyTypeAssignableToAny.ts, 50, 32))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(everyTypeAssignableToAny.ts, 50, 49))
 >T : Symbol(T, Decl(everyTypeAssignableToAny.ts, 50, 13))
 >y : Symbol(y, Decl(everyTypeAssignableToAny.ts, 50, 54))
diff --git a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
index 489903750f5..e76b3784e8a 100644
--- a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols
@@ -51,9 +51,9 @@ module M {
     export function F2(x: number): string { return x.toString(); }
 >F2 : Symbol(F2, Decl(everyTypeWithAnnotationAndInitializer.ts, 19, 5))
 >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 21, 23))
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 21, 23))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 var aNumber: number = 9.9;
@@ -64,13 +64,13 @@ var aString: string = 'this is a string';
 
 var aDate: Date = new Date(12);
 >aDate : Symbol(aDate, Decl(everyTypeWithAnnotationAndInitializer.ts, 26, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anObject: Object = new Object();
 >anObject : Symbol(anObject, Decl(everyTypeWithAnnotationAndInitializer.ts, 27, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anAny: any = null;
 >anAny : Symbol(anAny, Decl(everyTypeWithAnnotationAndInitializer.ts, 29, 3))
diff --git a/tests/baselines/reference/everyTypeWithInitializer.symbols b/tests/baselines/reference/everyTypeWithInitializer.symbols
index 0a22252164b..078f2e305d1 100644
--- a/tests/baselines/reference/everyTypeWithInitializer.symbols
+++ b/tests/baselines/reference/everyTypeWithInitializer.symbols
@@ -51,9 +51,9 @@ module M {
     export function F2(x: number): string { return x.toString(); }
 >F2 : Symbol(F2, Decl(everyTypeWithInitializer.ts, 19, 5))
 >x : Symbol(x, Decl(everyTypeWithInitializer.ts, 21, 23))
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(everyTypeWithInitializer.ts, 21, 23))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 var aNumber = 9.9;
@@ -64,11 +64,11 @@ var aString = 'this is a string';
 
 var aDate = new Date(12);
 >aDate : Symbol(aDate, Decl(everyTypeWithInitializer.ts, 26, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anObject = new Object();
 >anObject : Symbol(anObject, Decl(everyTypeWithInitializer.ts, 27, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anAny = null;
 >anAny : Symbol(anAny, Decl(everyTypeWithInitializer.ts, 29, 3))
diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt
new file mode 100644
index 00000000000..c20e4b19008
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.errors.txt
@@ -0,0 +1,165 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(8,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(9,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(10,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(11,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(12,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(13,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(13,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(15,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(16,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(16,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(17,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(18,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(19,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(20,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(22,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(23,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(23,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(24,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(25,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(26,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts(27,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts (45 errors) ====
+    
+    var t1 = 10;
+    var t2 = 10;
+    var s;
+    
+    // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+    // TempateHead & TemplateTail are empty
+    `${1 + typeof t1 ** t2 ** t1}`;
+           ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-t1 ** t2 - t1}`;
+       ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-++t1 ** t2 - t1}`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-t1++ ** t2 - t1}`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${!t1 ** t2 ** --t1 }`;
+       ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${typeof t1 ** t2 ** t1}`;
+       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    `${-t1 ** t2 - t1}${-t1 ** t2 - t1}`;
+       ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                        ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-++t1 ** t2 - t1}${-++t1 ** t2 - t1}`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                          ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-t1++ ** t2 - t1}${-t1++ ** t2 - t1}`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                          ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 }`;
+       ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                            ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1}`;
+       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                               ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1}`;
+           ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    `${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1}`;
+       ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                     ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1}`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1}`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 }`;
+       ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                         ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                         ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1}`;
+       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                            ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                            ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1}`;
+           ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                                    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                                    ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js
new file mode 100644
index 00000000000..cf97360b23a
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.js
@@ -0,0 +1,53 @@
+//// [exponentiationOperatorInTemplateStringWithSyntaxError1.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// TempateHead & TemplateTail are empty
+`${1 + typeof t1 ** t2 ** t1}`;
+`${-t1 ** t2 - t1}`;
+`${-++t1 ** t2 - t1}`;
+`${-t1++ ** t2 - t1}`;
+`${!t1 ** t2 ** --t1 }`;
+`${typeof t1 ** t2 ** t1}`;
+
+`${-t1 ** t2 - t1}${-t1 ** t2 - t1}`;
+`${-++t1 ** t2 - t1}${-++t1 ** t2 - t1}`;
+`${-t1++ ** t2 - t1}${-t1++ ** t2 - t1}`;
+`${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 }`;
+`${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1}`;
+`${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1}`;
+
+`${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1}`;
+`${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1}`;
+`${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1}`;
+`${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 }`;
+`${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1}`;
+`${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1}`;
+
+//// [exponentiationOperatorInTemplateStringWithSyntaxError1.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// TempateHead & TemplateTail are empty
+"" + (1 + Math.pow(typeof t1, Math.pow(t2, t1)));
+"" + (Math.pow(-t1, t2) - t1);
+"" + (Math.pow(-++t1, t2) - t1);
+"" + (Math.pow(-t1++, t2) - t1);
+"" + (Math.pow(!t1, Math.pow(t2, --t1)));
+"" + (Math.pow(typeof t1, Math.pow(t2, t1)));
+"" + (Math.pow(-t1, t2) - t1) + (Math.pow(-t1, t2) - t1);
+"" + (Math.pow(-++t1, t2) - t1) + (Math.pow(-++t1, t2) - t1);
+"" + (Math.pow(-t1++, t2) - t1) + (Math.pow(-t1++, t2) - t1);
+"" + (Math.pow(!t1, Math.pow(t2, --t1))) + (Math.pow(!t1, Math.pow(t2, --t1)));
+"" + (Math.pow(typeof t1, Math.pow(t2, t1))) + (Math.pow(typeof t1, Math.pow(t2, t1)));
+"" + (1 + Math.pow(typeof t1, Math.pow(t2, t1))) + (1 + Math.pow(typeof t1, Math.pow(t2, t1)));
+(Math.pow(-t1, t2) - t1) + " hello world " + (Math.pow(-t1, t2) - t1);
+(Math.pow(-++t1, t2) - t1) + " hello world " + (Math.pow(-++t1, t2) - t1);
+(Math.pow(-t1++, t2) - t1) + " hello world " + (Math.pow(-t1++, t2) - t1);
+(Math.pow(!t1, Math.pow(t2, --t1))) + " hello world " + (Math.pow(!t1, Math.pow(t2, --t1)));
+(Math.pow(typeof t1, Math.pow(t2, t1))) + " hello world " + (Math.pow(typeof t1, Math.pow(t2, t1)));
+(1 + Math.pow(typeof t1, Math.pow(t2, t1))) + " hello world " + (1 + Math.pow(typeof t1, Math.pow(t2, t1)));
diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt
new file mode 100644
index 00000000000..015d1f6d6f0
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.errors.txt
@@ -0,0 +1,166 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(8,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(9,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(10,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(11,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(12,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(13,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(13,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(15,27): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(16,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(16,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(17,29): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,31): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(18,31): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,34): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(19,34): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,42): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(20,42): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(22,40): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(23,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(23,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,10): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(24,42): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,10): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,44): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(25,44): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,10): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,47): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(26,47): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,14): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,14): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,55): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts(27,55): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts (45 errors) ====
+    
+    var t1 = 10;
+    var t2 = 10;
+    var s;
+    
+    // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+    // With templateHead
+    `hello ${-t1 ** t2 - t1}`;
+             ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${-++t1 ** t2 - t1}`;
+             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${-t1++ ** t2 - t1}`;
+             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${!t1 ** t2 ** --t1 }`;
+             ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+             ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${typeof t1 ** t2 ** t1}`;
+             ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+             ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${1 + typeof t1 ** t2 ** t1}`;
+                 ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                 ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    `hello ${-t1 ** t2 - t1}${-t1 ** t2 - t1}`;
+             ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                              ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${-++t1 ** t2 - t1}${-++t1 ** t2 - t1}`;
+             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${-t1++ ** t2 - t1}${-t1++ ** t2 - t1}`;
+             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 }`;
+             ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+             ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                  ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                  ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1}`;
+             ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+             ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                     ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                     ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1}`;
+                 ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                 ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                             ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                             ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    `hello ${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1}`;
+             ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                           ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1}`;
+             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1}`;
+             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                             ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 }`;
+             ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+             ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                               ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                               ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1}`;
+             ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+             ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                                  ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                                  ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `hello ${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1}`;
+                 ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                 ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                                          ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                                          ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js
new file mode 100644
index 00000000000..486c07f8af6
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.js
@@ -0,0 +1,54 @@
+//// [exponentiationOperatorInTemplateStringWithSyntaxError2.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// With templateHead
+`hello ${-t1 ** t2 - t1}`;
+`hello ${-++t1 ** t2 - t1}`;
+`hello ${-t1++ ** t2 - t1}`;
+`hello ${!t1 ** t2 ** --t1 }`;
+`hello ${typeof t1 ** t2 ** t1}`;
+`hello ${1 + typeof t1 ** t2 ** t1}`;
+
+`hello ${-t1 ** t2 - t1}${-t1 ** t2 - t1}`;
+`hello ${-++t1 ** t2 - t1}${-++t1 ** t2 - t1}`;
+`hello ${-t1++ ** t2 - t1}${-t1++ ** t2 - t1}`;
+`hello ${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 }`;
+`hello ${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1}`;
+`hello ${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1}`;
+
+`hello ${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1}`;
+`hello ${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1}`;
+`hello ${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1}`;
+`hello ${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 }`;
+`hello ${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1}`;
+`hello ${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1}`;
+
+
+//// [exponentiationOperatorInTemplateStringWithSyntaxError2.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// With templateHead
+"hello " + (Math.pow(-t1, t2) - t1);
+"hello " + (Math.pow(-++t1, t2) - t1);
+"hello " + (Math.pow(-t1++, t2) - t1);
+"hello " + (Math.pow(!t1, Math.pow(t2, --t1)));
+"hello " + (Math.pow(typeof t1, Math.pow(t2, t1)));
+"hello " + (1 + Math.pow(typeof t1, Math.pow(t2, t1)));
+"hello " + (Math.pow(-t1, t2) - t1) + (Math.pow(-t1, t2) - t1);
+"hello " + (Math.pow(-++t1, t2) - t1) + (Math.pow(-++t1, t2) - t1);
+"hello " + (Math.pow(-t1++, t2) - t1) + (Math.pow(-t1++, t2) - t1);
+"hello " + (Math.pow(!t1, Math.pow(t2, --t1))) + (Math.pow(!t1, Math.pow(t2, --t1)));
+"hello " + (Math.pow(typeof t1, Math.pow(t2, t1))) + (Math.pow(typeof t1, Math.pow(t2, t1)));
+"hello " + (1 + Math.pow(typeof t1, Math.pow(t2, t1))) + (1 + Math.pow(typeof t1, Math.pow(t2, t1)));
+"hello " + (Math.pow(-t1, t2) - t1) + " hello world " + (Math.pow(-t1, t2) - t1);
+"hello " + (Math.pow(-++t1, t2) - t1) + " hello world " + (Math.pow(-++t1, t2) - t1);
+"hello " + (Math.pow(-t1++, t2) - t1) + " hello world " + (Math.pow(-t1++, t2) - t1);
+"hello " + (Math.pow(!t1, Math.pow(t2, --t1))) + " hello world " + (Math.pow(!t1, Math.pow(t2, --t1)));
+"hello " + (Math.pow(typeof t1, Math.pow(t2, t1))) + " hello world " + (Math.pow(typeof t1, Math.pow(t2, t1)));
+"hello " + (1 + Math.pow(typeof t1, Math.pow(t2, t1))) + " hello world " + (1 + Math.pow(typeof t1, Math.pow(t2, t1)));
diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt
new file mode 100644
index 00000000000..320d9a4d309
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.errors.txt
@@ -0,0 +1,165 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(8,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(9,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(10,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(11,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(12,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(13,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(13,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(15,21): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(16,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(16,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(17,23): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,25): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(18,25): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,28): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(19,28): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,36): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(20,36): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(22,34): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(23,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(23,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,4): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(24,36): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,4): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,38): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(25,38): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,4): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,4): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,41): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(26,41): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,8): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,8): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,49): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts(27,49): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts (45 errors) ====
+    
+    var t1 = 10;
+    var t2 = 10;
+    var s;
+    
+    // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+    // With TemplateTail
+    `${-t1 ** t2 - t1} world`;
+       ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-++t1 ** t2 - t1} world`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-t1++ ** t2 - t1} world`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${!t1 ** t2 ** --t1 } world`;
+       ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${typeof t1 ** t2 ** t1} world`;
+       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${1 + typeof t1 ** t2 ** t1} world`;
+           ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    `${-t1 ** t2 - t1}${-t1 ** t2 - t1} world`;
+       ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                        ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-++t1 ** t2 - t1}${-++t1 ** t2 - t1} world`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                          ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-t1++ ** t2 - t1}${-t1++ ** t2 - t1} world`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                          ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 } world`;
+       ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                            ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1} world`;
+       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                               ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1} world`;
+           ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    `${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1} !!`;
+       ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                     ~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1} !!`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1} !!`;
+       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                       ~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 } !!`;
+       ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                         ~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                         ~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1} !!`;
+       ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+       ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                            ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                            ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    `${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1} !!`;
+           ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+           ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+                                                    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                                                    ~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js
new file mode 100644
index 00000000000..1641c2bbb80
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.js
@@ -0,0 +1,53 @@
+//// [exponentiationOperatorInTemplateStringWithSyntaxError3.ts]
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// With TemplateTail
+`${-t1 ** t2 - t1} world`;
+`${-++t1 ** t2 - t1} world`;
+`${-t1++ ** t2 - t1} world`;
+`${!t1 ** t2 ** --t1 } world`;
+`${typeof t1 ** t2 ** t1} world`;
+`${1 + typeof t1 ** t2 ** t1} world`;
+
+`${-t1 ** t2 - t1}${-t1 ** t2 - t1} world`;
+`${-++t1 ** t2 - t1}${-++t1 ** t2 - t1} world`;
+`${-t1++ ** t2 - t1}${-t1++ ** t2 - t1} world`;
+`${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 } world`;
+`${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1} world`;
+`${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1} world`;
+
+`${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1} !!`;
+`${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1} !!`;
+`${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1} !!`;
+`${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 } !!`;
+`${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1} !!`;
+`${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1} !!`;
+
+//// [exponentiationOperatorInTemplateStringWithSyntaxError3.js]
+var t1 = 10;
+var t2 = 10;
+var s;
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// With TemplateTail
+(Math.pow(-t1, t2) - t1) + " world";
+(Math.pow(-++t1, t2) - t1) + " world";
+(Math.pow(-t1++, t2) - t1) + " world";
+(Math.pow(!t1, Math.pow(t2, --t1))) + " world";
+(Math.pow(typeof t1, Math.pow(t2, t1))) + " world";
+(1 + Math.pow(typeof t1, Math.pow(t2, t1))) + " world";
+"" + (Math.pow(-t1, t2) - t1) + (Math.pow(-t1, t2) - t1) + " world";
+"" + (Math.pow(-++t1, t2) - t1) + (Math.pow(-++t1, t2) - t1) + " world";
+"" + (Math.pow(-t1++, t2) - t1) + (Math.pow(-t1++, t2) - t1) + " world";
+"" + (Math.pow(!t1, Math.pow(t2, --t1))) + (Math.pow(!t1, Math.pow(t2, --t1))) + " world";
+"" + (Math.pow(typeof t1, Math.pow(t2, t1))) + (Math.pow(typeof t1, Math.pow(t2, t1))) + " world";
+"" + (1 + Math.pow(typeof t1, Math.pow(t2, t1))) + (1 + Math.pow(typeof t1, Math.pow(t2, t1))) + " world";
+(Math.pow(-t1, t2) - t1) + " hello world " + (Math.pow(-t1, t2) - t1) + " !!";
+(Math.pow(-++t1, t2) - t1) + " hello world " + (Math.pow(-++t1, t2) - t1) + " !!";
+(Math.pow(-t1++, t2) - t1) + " hello world " + (Math.pow(-t1++, t2) - t1) + " !!";
+(Math.pow(!t1, Math.pow(t2, --t1))) + " hello world " + (Math.pow(!t1, Math.pow(t2, --t1))) + " !!";
+(Math.pow(typeof t1, Math.pow(t2, t1))) + " hello world " + (Math.pow(typeof t1, Math.pow(t2, t1))) + " !!";
+(1 + Math.pow(typeof t1, Math.pow(t2, t1))) + " hello world " + (1 + Math.pow(typeof t1, Math.pow(t2, t1))) + " !!";
diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt b/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt
new file mode 100644
index 00000000000..4b56e4f4258
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorSyntaxError1.errors.txt
@@ -0,0 +1,135 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(3,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(4,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(5,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(6,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(7,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(7,7): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(8,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(12,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(13,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(14,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(15,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(16,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(17,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(18,6): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(19,6): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(21,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(22,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(23,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(24,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(25,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(26,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(27,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(28,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(29,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(30,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(31,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(32,1): error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(33,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(34,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(35,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts(36,1): error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts (31 errors) ====
+    
+    // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+    -1 ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +1 ** 2
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** -2 ** 3;
+         ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** -2 ** -3;
+         ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -1 ** -2 ** -3;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+          ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -(1 ** 2) ** 3;
+    ~~~~~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    var temp = 10;
+    
+    -++temp ** 3;
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +--temp ** 3;
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -temp++ ** 3;
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +temp-- ** 3;
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** -++temp ** 3;
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** +--temp ** 3;
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** -temp++ ** 3;
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** +temp-- ** 3;
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    -3 ** temp++;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -3 ** temp--;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -3 ** ++temp;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -3 ** --temp;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** temp++;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** temp--;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** ++temp;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** --temp;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -3 ** temp++ ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -3 ** temp-- ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -3 ** ++temp ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    -3 ** --temp ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '-' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** temp++ ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** temp-- ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** ++temp ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    +3 ** --temp ** 2;
+    ~~
+!!! error TS17006: An unary expression with the '+' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError1.js b/tests/baselines/reference/exponentiationOperatorSyntaxError1.js
new file mode 100644
index 00000000000..05994151610
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorSyntaxError1.js
@@ -0,0 +1,74 @@
+//// [exponentiationOperatorSyntaxError1.ts]
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+-1 ** 2;
++1 ** 2
+1 ** -2 ** 3;
+1 ** -2 ** -3;
+-1 ** -2 ** -3;
+-(1 ** 2) ** 3;
+
+var temp = 10;
+
+-++temp ** 3;
++--temp ** 3;
+-temp++ ** 3;
++temp-- ** 3;
+1 ** -++temp ** 3;
+1 ** +--temp ** 3;
+1 ** -temp++ ** 3;
+1 ** +temp-- ** 3;
+
+-3 ** temp++;
+-3 ** temp--;
+-3 ** ++temp;
+-3 ** --temp;
++3 ** temp++;
++3 ** temp--;
++3 ** ++temp;
++3 ** --temp;
+-3 ** temp++ ** 2;
+-3 ** temp-- ** 2;
+-3 ** ++temp ** 2;
+-3 ** --temp ** 2;
++3 ** temp++ ** 2;
++3 ** temp-- ** 2;
++3 ** ++temp ** 2;
++3 ** --temp ** 2;
+
+
+
+
+//// [exponentiationOperatorSyntaxError1.js]
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+Math.pow(-1, 2);
+Math.pow(+1, 2);
+Math.pow(1, Math.pow(-2, 3));
+Math.pow(1, Math.pow(-2, -3));
+Math.pow(-1, Math.pow(-2, -3));
+Math.pow(-(Math.pow(1, 2)), 3);
+var temp = 10;
+Math.pow(-++temp, 3);
+Math.pow(+--temp, 3);
+Math.pow(-temp++, 3);
+Math.pow(+temp--, 3);
+Math.pow(1, Math.pow(-++temp, 3));
+Math.pow(1, Math.pow(+--temp, 3));
+Math.pow(1, Math.pow(-temp++, 3));
+Math.pow(1, Math.pow(+temp--, 3));
+Math.pow(-3, temp++);
+Math.pow(-3, temp--);
+Math.pow(-3, ++temp);
+Math.pow(-3, --temp);
+Math.pow(+3, temp++);
+Math.pow(+3, temp--);
+Math.pow(+3, ++temp);
+Math.pow(+3, --temp);
+Math.pow(-3, Math.pow(temp++, 2));
+Math.pow(-3, Math.pow(temp--, 2));
+Math.pow(-3, Math.pow(++temp, 2));
+Math.pow(-3, Math.pow(--temp, 2));
+Math.pow(+3, Math.pow(temp++, 2));
+Math.pow(+3, Math.pow(temp--, 2));
+Math.pow(+3, Math.pow(++temp, 2));
+Math.pow(+3, Math.pow(--temp, 2));
diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt
new file mode 100644
index 00000000000..af17a7ddf7a
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorSyntaxError2.errors.txt
@@ -0,0 +1,314 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(5,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(6,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(6,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(7,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(8,1): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(11,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(12,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(12,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(13,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(14,6): error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(16,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(16,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(17,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(17,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(18,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(18,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(19,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(19,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(20,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(20,1): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(22,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(22,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(23,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(23,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(24,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(24,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(25,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(25,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(26,6): error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(28,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(29,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(30,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(31,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(32,1): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(34,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(35,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(36,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(37,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(38,6): error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(40,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(41,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(42,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(43,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(44,1): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(46,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(47,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(48,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(49,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(50,6): error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(52,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(53,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(54,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(54,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(55,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(56,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(56,1): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(58,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(58,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(59,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(59,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(60,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(60,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(61,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(61,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(62,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(62,6): error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(64,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(65,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(66,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(67,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts(68,1): error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts (81 errors) ====
+    
+    // Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+    var temp;
+    
+    delete --temp ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    delete ++temp ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    delete temp-- ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    delete temp++ ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    
+    1 ** delete --temp ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** delete ++temp ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** delete temp-- ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** delete temp++ ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'delete' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    typeof --temp ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    typeof temp-- ** 3;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    typeof 3 ** 4;
+    ~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    typeof temp++ ** 4;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    typeof temp-- ** 4;
+    ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    1 ** typeof --temp ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** typeof temp-- ** 3;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** typeof 3 ** 4;
+         ~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** typeof temp++ ** 4;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** typeof temp-- ** 4;
+         ~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'typeof' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    void --temp ** 3;
+    ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    void temp-- ** 3;
+    ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    void 3 ** 4;
+    ~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    void temp++ ** 4;
+    ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    void temp-- ** 4;
+    ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    1 ** void --temp ** 3;
+         ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** void temp-- ** 3;
+         ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** void 3 ** 4;
+         ~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** void temp++ ** 4;
+         ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** void temp-- ** 4 ;
+         ~~~~~~~~~~~
+!!! error TS17006: An unary expression with the 'void' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    ~ --temp ** 3;
+    ~~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    ~temp-- ** 3;
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    ~3 ** 4;
+    ~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    ~temp++ ** 4;
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    ~temp-- ** 4;
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    1 ** ~ --temp ** 3;
+         ~~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** ~temp-- ** 3;
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** ~3 ** 4;
+         ~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** ~temp++ ** 4;
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** ~temp-- ** 4;
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '~' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    ! --temp ** 3;
+    ~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    !temp-- ** 3;
+    ~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    !3 ** 4;
+    ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    !temp++ ** 4;
+    ~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    !temp-- ** 4;
+    ~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    ~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    1 ** ! --temp ** 3;
+         ~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** !temp-- ** 3;
+         ~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** !3 ** 4;
+         ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** !temp++ ** 4;
+         ~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    1 ** !temp-- ** 4;
+         ~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+         ~~~~~~~
+!!! error TS17006: An unary expression with the '!' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    
+    <number>temp ** 3;
+    ~~~~~~~~~~~~
+!!! error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    <number>++temp ** 3;
+    ~~~~~~~~~~~~~~
+!!! error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    <number>--temp ** 3;
+    ~~~~~~~~~~~~~~
+!!! error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    <number>temp++ ** 3;
+    ~~~~~~~~~~~~~~
+!!! error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
+    <number>temp-- ** 3;
+    ~~~~~~~~~~~~~~
+!!! error TS17007: A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorSyntaxError2.js b/tests/baselines/reference/exponentiationOperatorSyntaxError2.js
new file mode 100644
index 00000000000..9e07273522f
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorSyntaxError2.js
@@ -0,0 +1,126 @@
+//// [exponentiationOperatorSyntaxError2.ts]
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+var temp;
+
+delete --temp ** 3;
+delete ++temp ** 3;
+delete temp-- ** 3;
+delete temp++ ** 3;
+
+
+1 ** delete --temp ** 3;
+1 ** delete ++temp ** 3;
+1 ** delete temp-- ** 3;
+1 ** delete temp++ ** 3;
+
+typeof --temp ** 3;
+typeof temp-- ** 3;
+typeof 3 ** 4;
+typeof temp++ ** 4;
+typeof temp-- ** 4;
+
+1 ** typeof --temp ** 3;
+1 ** typeof temp-- ** 3;
+1 ** typeof 3 ** 4;
+1 ** typeof temp++ ** 4;
+1 ** typeof temp-- ** 4;
+
+void --temp ** 3;
+void temp-- ** 3;
+void 3 ** 4;
+void temp++ ** 4;
+void temp-- ** 4;
+
+1 ** void --temp ** 3;
+1 ** void temp-- ** 3;
+1 ** void 3 ** 4;
+1 ** void temp++ ** 4;
+1 ** void temp-- ** 4 ;
+
+~ --temp ** 3;
+~temp-- ** 3;
+~3 ** 4;
+~temp++ ** 4;
+~temp-- ** 4;
+
+1 ** ~ --temp ** 3;
+1 ** ~temp-- ** 3;
+1 ** ~3 ** 4;
+1 ** ~temp++ ** 4;
+1 ** ~temp-- ** 4;
+
+! --temp ** 3;
+!temp-- ** 3;
+!3 ** 4;
+!temp++ ** 4;
+!temp-- ** 4;
+
+1 ** ! --temp ** 3;
+1 ** !temp-- ** 3;
+1 ** !3 ** 4;
+1 ** !temp++ ** 4;
+1 ** !temp-- ** 4;
+
+<number>temp ** 3;
+<number>++temp ** 3;
+<number>--temp ** 3;
+<number>temp++ ** 3;
+<number>temp-- ** 3;
+
+//// [exponentiationOperatorSyntaxError2.js]
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+var temp;
+Math.pow(delete --temp, 3);
+Math.pow(delete ++temp, 3);
+Math.pow(delete temp--, 3);
+Math.pow(delete temp++, 3);
+Math.pow(1, Math.pow(delete --temp, 3));
+Math.pow(1, Math.pow(delete ++temp, 3));
+Math.pow(1, Math.pow(delete temp--, 3));
+Math.pow(1, Math.pow(delete temp++, 3));
+Math.pow(typeof --temp, 3);
+Math.pow(typeof temp--, 3);
+Math.pow(typeof 3, 4);
+Math.pow(typeof temp++, 4);
+Math.pow(typeof temp--, 4);
+Math.pow(1, Math.pow(typeof --temp, 3));
+Math.pow(1, Math.pow(typeof temp--, 3));
+Math.pow(1, Math.pow(typeof 3, 4));
+Math.pow(1, Math.pow(typeof temp++, 4));
+Math.pow(1, Math.pow(typeof temp--, 4));
+Math.pow(void --temp, 3);
+Math.pow(void temp--, 3);
+Math.pow(void 3, 4);
+Math.pow(void temp++, 4);
+Math.pow(void temp--, 4);
+Math.pow(1, Math.pow(void --temp, 3));
+Math.pow(1, Math.pow(void temp--, 3));
+Math.pow(1, Math.pow(void 3, 4));
+Math.pow(1, Math.pow(void temp++, 4));
+Math.pow(1, Math.pow(void temp--, 4));
+Math.pow(~--temp, 3);
+Math.pow(~temp--, 3);
+Math.pow(~3, 4);
+Math.pow(~temp++, 4);
+Math.pow(~temp--, 4);
+Math.pow(1, Math.pow(~--temp, 3));
+Math.pow(1, Math.pow(~temp--, 3));
+Math.pow(1, Math.pow(~3, 4));
+Math.pow(1, Math.pow(~temp++, 4));
+Math.pow(1, Math.pow(~temp--, 4));
+Math.pow(!--temp, 3);
+Math.pow(!temp--, 3);
+Math.pow(!3, 4);
+Math.pow(!temp++, 4);
+Math.pow(!temp--, 4);
+Math.pow(1, Math.pow(!--temp, 3));
+Math.pow(1, Math.pow(!temp--, 3));
+Math.pow(1, Math.pow(!3, 4));
+Math.pow(1, Math.pow(!temp++, 4));
+Math.pow(1, Math.pow(!temp--, 4));
+Math.pow(temp, 3);
+Math.pow(++temp, 3);
+Math.pow(--temp, 3);
+Math.pow(temp++, 3);
+Math.pow(temp--, 3);
diff --git a/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.js b/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.js
new file mode 100644
index 00000000000..0072c546253
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.js
@@ -0,0 +1,26 @@
+//// [exponentiationOperatorWithAnyAndNumber.ts]
+var a: any;
+var b: number;
+
+// operator **
+var r1 = a ** a;
+var r2 = a ** b;
+var r3 = a ** 0;
+var r4 = 0 ** a;
+var r5 = 0 ** 0;
+var r6 = b ** 0;
+var r7 = 0 ** b;
+var r8 = b ** b;
+
+//// [exponentiationOperatorWithAnyAndNumber.js]
+var a;
+var b;
+// operator **
+var r1 = Math.pow(a, a);
+var r2 = Math.pow(a, b);
+var r3 = Math.pow(a, 0);
+var r4 = Math.pow(0, a);
+var r5 = Math.pow(0, 0);
+var r6 = Math.pow(b, 0);
+var r7 = Math.pow(0, b);
+var r8 = Math.pow(b, b);
diff --git a/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.symbols b/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.symbols
new file mode 100644
index 00000000000..997401a15c9
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.symbols
@@ -0,0 +1,42 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithAnyAndNumber.ts ===
+var a: any;
+>a : Symbol(a, Decl(exponentiationOperatorWithAnyAndNumber.ts, 0, 3))
+
+var b: number;
+>b : Symbol(b, Decl(exponentiationOperatorWithAnyAndNumber.ts, 1, 3))
+
+// operator **
+var r1 = a ** a;
+>r1 : Symbol(r1, Decl(exponentiationOperatorWithAnyAndNumber.ts, 4, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithAnyAndNumber.ts, 0, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithAnyAndNumber.ts, 0, 3))
+
+var r2 = a ** b;
+>r2 : Symbol(r2, Decl(exponentiationOperatorWithAnyAndNumber.ts, 5, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithAnyAndNumber.ts, 0, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithAnyAndNumber.ts, 1, 3))
+
+var r3 = a ** 0;
+>r3 : Symbol(r3, Decl(exponentiationOperatorWithAnyAndNumber.ts, 6, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithAnyAndNumber.ts, 0, 3))
+
+var r4 = 0 ** a;
+>r4 : Symbol(r4, Decl(exponentiationOperatorWithAnyAndNumber.ts, 7, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithAnyAndNumber.ts, 0, 3))
+
+var r5 = 0 ** 0;
+>r5 : Symbol(r5, Decl(exponentiationOperatorWithAnyAndNumber.ts, 8, 3))
+
+var r6 = b ** 0;
+>r6 : Symbol(r6, Decl(exponentiationOperatorWithAnyAndNumber.ts, 9, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithAnyAndNumber.ts, 1, 3))
+
+var r7 = 0 ** b;
+>r7 : Symbol(r7, Decl(exponentiationOperatorWithAnyAndNumber.ts, 10, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithAnyAndNumber.ts, 1, 3))
+
+var r8 = b ** b;
+>r8 : Symbol(r8, Decl(exponentiationOperatorWithAnyAndNumber.ts, 11, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithAnyAndNumber.ts, 1, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithAnyAndNumber.ts, 1, 3))
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.types b/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.types
new file mode 100644
index 00000000000..ec48b80f192
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithAnyAndNumber.types
@@ -0,0 +1,56 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithAnyAndNumber.ts ===
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+// operator **
+var r1 = a ** a;
+>r1 : number
+>a ** a : number
+>a : any
+>a : any
+
+var r2 = a ** b;
+>r2 : number
+>a ** b : number
+>a : any
+>b : number
+
+var r3 = a ** 0;
+>r3 : number
+>a ** 0 : number
+>a : any
+>0 : number
+
+var r4 = 0 ** a;
+>r4 : number
+>0 ** a : number
+>0 : number
+>a : any
+
+var r5 = 0 ** 0;
+>r5 : number
+>0 ** 0 : number
+>0 : number
+>0 : number
+
+var r6 = b ** 0;
+>r6 : number
+>b ** 0 : number
+>b : number
+>0 : number
+
+var r7 = 0 ** b;
+>r7 : number
+>0 ** b : number
+>0 : number
+>b : number
+
+var r8 = b ** b;
+>r8 : number
+>b ** b : number
+>b : number
+>b : number
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithEnum.js b/tests/baselines/reference/exponentiationOperatorWithEnum.js
new file mode 100644
index 00000000000..8175ca30c9e
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithEnum.js
@@ -0,0 +1,49 @@
+//// [exponentiationOperatorWithEnum.ts]
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+var c: E;
+
+// operator **
+var r1 = c ** a;
+var r2 = c ** b;
+var r3 = c ** c;
+var r4 = a ** c;
+var r5 = b ** c;
+var r6 = E.a ** a;
+var r7 = E.a ** b;
+var r8 = E.a ** E.b;
+var r9 = E.a ** 1;
+var r10 = a ** E.b;
+var r11 = b ** E.b;
+var r12 = 1 ** E.b;
+
+//// [exponentiationOperatorWithEnum.js]
+// operands of an enum type are treated as having the primitive type Number.
+var E;
+(function (E) {
+    E[E["a"] = 0] = "a";
+    E[E["b"] = 1] = "b";
+})(E || (E = {}));
+var a;
+var b;
+var c;
+// operator **
+var r1 = Math.pow(c, a);
+var r2 = Math.pow(c, b);
+var r3 = Math.pow(c, c);
+var r4 = Math.pow(a, c);
+var r5 = Math.pow(b, c);
+var r6 = Math.pow(E.a, a);
+var r7 = Math.pow(E.a, b);
+var r8 = Math.pow(E.a, E.b);
+var r9 = Math.pow(E.a, 1);
+var r10 = Math.pow(a, E.b);
+var r11 = Math.pow(b, E.b);
+var r12 = Math.pow(1, E.b);
diff --git a/tests/baselines/reference/exponentiationOperatorWithEnum.symbols b/tests/baselines/reference/exponentiationOperatorWithEnum.symbols
new file mode 100644
index 00000000000..9c8413dc441
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithEnum.symbols
@@ -0,0 +1,98 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnum.ts ===
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+
+    a,
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+
+    b
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+}
+
+var a: any;
+>a : Symbol(a, Decl(exponentiationOperatorWithEnum.ts, 7, 3))
+
+var b: number;
+>b : Symbol(b, Decl(exponentiationOperatorWithEnum.ts, 8, 3))
+
+var c: E;
+>c : Symbol(c, Decl(exponentiationOperatorWithEnum.ts, 9, 3))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+
+// operator **
+var r1 = c ** a;
+>r1 : Symbol(r1, Decl(exponentiationOperatorWithEnum.ts, 12, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnum.ts, 9, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnum.ts, 7, 3))
+
+var r2 = c ** b;
+>r2 : Symbol(r2, Decl(exponentiationOperatorWithEnum.ts, 13, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnum.ts, 9, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnum.ts, 8, 3))
+
+var r3 = c ** c;
+>r3 : Symbol(r3, Decl(exponentiationOperatorWithEnum.ts, 14, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnum.ts, 9, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnum.ts, 9, 3))
+
+var r4 = a ** c;
+>r4 : Symbol(r4, Decl(exponentiationOperatorWithEnum.ts, 15, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnum.ts, 7, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnum.ts, 9, 3))
+
+var r5 = b ** c;
+>r5 : Symbol(r5, Decl(exponentiationOperatorWithEnum.ts, 16, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnum.ts, 8, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnum.ts, 9, 3))
+
+var r6 = E.a ** a;
+>r6 : Symbol(r6, Decl(exponentiationOperatorWithEnum.ts, 17, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnum.ts, 7, 3))
+
+var r7 = E.a ** b;
+>r7 : Symbol(r7, Decl(exponentiationOperatorWithEnum.ts, 18, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnum.ts, 8, 3))
+
+var r8 = E.a ** E.b;
+>r8 : Symbol(r8, Decl(exponentiationOperatorWithEnum.ts, 19, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+
+var r9 = E.a ** 1;
+>r9 : Symbol(r9, Decl(exponentiationOperatorWithEnum.ts, 20, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnum.ts, 2, 8))
+
+var r10 = a ** E.b;
+>r10 : Symbol(r10, Decl(exponentiationOperatorWithEnum.ts, 21, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnum.ts, 7, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+
+var r11 = b ** E.b;
+>r11 : Symbol(r11, Decl(exponentiationOperatorWithEnum.ts, 22, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnum.ts, 8, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+
+var r12 = 1 ** E.b;
+>r12 : Symbol(r12, Decl(exponentiationOperatorWithEnum.ts, 23, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnum.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnum.ts, 3, 6))
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithEnum.types b/tests/baselines/reference/exponentiationOperatorWithEnum.types
new file mode 100644
index 00000000000..037ff9d1261
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithEnum.types
@@ -0,0 +1,112 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnum.ts ===
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+>E : E
+
+    a,
+>a : E
+
+    b
+>b : E
+}
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+var c: E;
+>c : E
+>E : E
+
+// operator **
+var r1 = c ** a;
+>r1 : number
+>c ** a : number
+>c : E
+>a : any
+
+var r2 = c ** b;
+>r2 : number
+>c ** b : number
+>c : E
+>b : number
+
+var r3 = c ** c;
+>r3 : number
+>c ** c : number
+>c : E
+>c : E
+
+var r4 = a ** c;
+>r4 : number
+>a ** c : number
+>a : any
+>c : E
+
+var r5 = b ** c;
+>r5 : number
+>b ** c : number
+>b : number
+>c : E
+
+var r6 = E.a ** a;
+>r6 : number
+>E.a ** a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var r7 = E.a ** b;
+>r7 : number
+>E.a ** b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var r8 = E.a ** E.b;
+>r8 : number
+>E.a ** E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var r9 = E.a ** 1;
+>r9 : number
+>E.a ** 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+>1 : number
+
+var r10 = a ** E.b;
+>r10 : number
+>a ** E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var r11 = b ** E.b;
+>r11 : number
+>b ** E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var r12 = 1 ** E.b;
+>r12 : number
+>1 ** E.b : number
+>1 : number
+>E.b : E
+>E : typeof E
+>b : E
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithEnumUnion.js b/tests/baselines/reference/exponentiationOperatorWithEnumUnion.js
new file mode 100644
index 00000000000..0493c9cdefd
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithEnumUnion.js
@@ -0,0 +1,58 @@
+//// [exponentiationOperatorWithEnumUnion.ts]
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+    a,
+    b
+}
+enum F {
+    c,
+    d
+}
+
+var a: any;
+var b: number;
+var c: E | F;
+
+// operator **
+var r1 = c ** a;
+var r2 = c ** b;
+var r3 = c ** c;
+var r4 = a ** c;
+var r5 = b ** c;
+var r6 = E.a ** a;
+var r7 = E.a ** b;
+var r8 = E.a ** E.b;
+var r9 = E.a ** 1;
+var r10 = a ** E.b;
+var r11 = b ** E.b;
+var r12 = 1 ** E.b;
+
+//// [exponentiationOperatorWithEnumUnion.js]
+// operands of an enum type are treated as having the primitive type Number.
+var E;
+(function (E) {
+    E[E["a"] = 0] = "a";
+    E[E["b"] = 1] = "b";
+})(E || (E = {}));
+var F;
+(function (F) {
+    F[F["c"] = 0] = "c";
+    F[F["d"] = 1] = "d";
+})(F || (F = {}));
+var a;
+var b;
+var c;
+// operator **
+var r1 = Math.pow(c, a);
+var r2 = Math.pow(c, b);
+var r3 = Math.pow(c, c);
+var r4 = Math.pow(a, c);
+var r5 = Math.pow(b, c);
+var r6 = Math.pow(E.a, a);
+var r7 = Math.pow(E.a, b);
+var r8 = Math.pow(E.a, E.b);
+var r9 = Math.pow(E.a, 1);
+var r10 = Math.pow(a, E.b);
+var r11 = Math.pow(b, E.b);
+var r12 = Math.pow(1, E.b);
diff --git a/tests/baselines/reference/exponentiationOperatorWithEnumUnion.symbols b/tests/baselines/reference/exponentiationOperatorWithEnumUnion.symbols
new file mode 100644
index 00000000000..f46a32d8c97
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithEnumUnion.symbols
@@ -0,0 +1,108 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnumUnion.ts ===
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+
+    a,
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+
+    b
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+}
+enum F {
+>F : Symbol(F, Decl(exponentiationOperatorWithEnumUnion.ts, 5, 1))
+
+    c,
+>c : Symbol(F.c, Decl(exponentiationOperatorWithEnumUnion.ts, 6, 8))
+
+    d
+>d : Symbol(F.d, Decl(exponentiationOperatorWithEnumUnion.ts, 7, 6))
+}
+
+var a: any;
+>a : Symbol(a, Decl(exponentiationOperatorWithEnumUnion.ts, 11, 3))
+
+var b: number;
+>b : Symbol(b, Decl(exponentiationOperatorWithEnumUnion.ts, 12, 3))
+
+var c: E | F;
+>c : Symbol(c, Decl(exponentiationOperatorWithEnumUnion.ts, 13, 3))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>F : Symbol(F, Decl(exponentiationOperatorWithEnumUnion.ts, 5, 1))
+
+// operator **
+var r1 = c ** a;
+>r1 : Symbol(r1, Decl(exponentiationOperatorWithEnumUnion.ts, 16, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnumUnion.ts, 13, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnumUnion.ts, 11, 3))
+
+var r2 = c ** b;
+>r2 : Symbol(r2, Decl(exponentiationOperatorWithEnumUnion.ts, 17, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnumUnion.ts, 13, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnumUnion.ts, 12, 3))
+
+var r3 = c ** c;
+>r3 : Symbol(r3, Decl(exponentiationOperatorWithEnumUnion.ts, 18, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnumUnion.ts, 13, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnumUnion.ts, 13, 3))
+
+var r4 = a ** c;
+>r4 : Symbol(r4, Decl(exponentiationOperatorWithEnumUnion.ts, 19, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnumUnion.ts, 11, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnumUnion.ts, 13, 3))
+
+var r5 = b ** c;
+>r5 : Symbol(r5, Decl(exponentiationOperatorWithEnumUnion.ts, 20, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnumUnion.ts, 12, 3))
+>c : Symbol(c, Decl(exponentiationOperatorWithEnumUnion.ts, 13, 3))
+
+var r6 = E.a ** a;
+>r6 : Symbol(r6, Decl(exponentiationOperatorWithEnumUnion.ts, 21, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnumUnion.ts, 11, 3))
+
+var r7 = E.a ** b;
+>r7 : Symbol(r7, Decl(exponentiationOperatorWithEnumUnion.ts, 22, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnumUnion.ts, 12, 3))
+
+var r8 = E.a ** E.b;
+>r8 : Symbol(r8, Decl(exponentiationOperatorWithEnumUnion.ts, 23, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+
+var r9 = E.a ** 1;
+>r9 : Symbol(r9, Decl(exponentiationOperatorWithEnumUnion.ts, 24, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithEnumUnion.ts, 2, 8))
+
+var r10 = a ** E.b;
+>r10 : Symbol(r10, Decl(exponentiationOperatorWithEnumUnion.ts, 25, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithEnumUnion.ts, 11, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+
+var r11 = b ** E.b;
+>r11 : Symbol(r11, Decl(exponentiationOperatorWithEnumUnion.ts, 26, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithEnumUnion.ts, 12, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+
+var r12 = 1 ** E.b;
+>r12 : Symbol(r12, Decl(exponentiationOperatorWithEnumUnion.ts, 27, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithEnumUnion.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithEnumUnion.ts, 3, 6))
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithEnumUnion.types b/tests/baselines/reference/exponentiationOperatorWithEnumUnion.types
new file mode 100644
index 00000000000..5be479b9e63
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithEnumUnion.types
@@ -0,0 +1,122 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnumUnion.ts ===
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+>E : E
+
+    a,
+>a : E
+
+    b
+>b : E
+}
+enum F {
+>F : F
+
+    c,
+>c : F
+
+    d
+>d : F
+}
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+var c: E | F;
+>c : E | F
+>E : E
+>F : F
+
+// operator **
+var r1 = c ** a;
+>r1 : number
+>c ** a : number
+>c : E | F
+>a : any
+
+var r2 = c ** b;
+>r2 : number
+>c ** b : number
+>c : E | F
+>b : number
+
+var r3 = c ** c;
+>r3 : number
+>c ** c : number
+>c : E | F
+>c : E | F
+
+var r4 = a ** c;
+>r4 : number
+>a ** c : number
+>a : any
+>c : E | F
+
+var r5 = b ** c;
+>r5 : number
+>b ** c : number
+>b : number
+>c : E | F
+
+var r6 = E.a ** a;
+>r6 : number
+>E.a ** a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var r7 = E.a ** b;
+>r7 : number
+>E.a ** b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var r8 = E.a ** E.b;
+>r8 : number
+>E.a ** E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var r9 = E.a ** 1;
+>r9 : number
+>E.a ** 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+>1 : number
+
+var r10 = a ** E.b;
+>r10 : number
+>a ** E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var r11 = b ** E.b;
+>r11 : number
+>b ** E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var r12 = 1 ** E.b;
+>r12 : number
+>1 ** E.b : number
+>1 : number
+>E.b : E
+>E : typeof E
+>b : E
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithInvalidOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithInvalidOperands.errors.txt
new file mode 100644
index 00000000000..b62cd9601e4
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithInvalidOperands.errors.txt
@@ -0,0 +1,239 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(15,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(17,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(18,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(19,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(21,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(22,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(22,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(23,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(24,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(24,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(25,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(25,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(26,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(26,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(29,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(31,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(32,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(33,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(35,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(36,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(36,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(37,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(38,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(38,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(39,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(39,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(40,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(40,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(42,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(43,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(43,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(44,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(45,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(45,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(46,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(46,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(47,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(47,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(49,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(50,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(50,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(51,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(52,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(52,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(53,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(53,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(54,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(54,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(57,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(59,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(60,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(61,19): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(64,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(66,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(67,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts(68,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts (56 errors) ====
+    // these operators require their operands to be of type Any, the Number primitive type, or
+    // an enum type
+    enum E { a, b, c }
+    
+    var a: any;
+    var b: boolean;
+    var c: number;
+    var d: string;
+    var e: { a: number };
+    var f: Number;
+    
+    // All of the below should be an error unless otherwise noted
+    // operator **
+    var r1a1 = a ** a; //ok
+    var r1a2 = a ** b;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1a3 = a ** c; //ok
+    var r1a4 = a ** d;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1a5 = a ** e;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1a6 = a ** f;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1b1 = b ** a;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b2 = b ** b;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b3 = b ** c;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b4 = b ** d;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b5 = b ** e;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b6 = b ** f;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1c1 = c ** a; //ok
+    var r1c2 = c ** b;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1c3 = c ** c; //ok
+    var r1c4 = c ** d;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1c5 = c ** e;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1c6 = c ** f;
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1d1 = d ** a;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d2 = d ** b;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d3 = d ** c;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d4 = d ** d;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d5 = d ** e;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d6 = d ** f;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1e1 = e ** a;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1e2 = e ** b;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1e3 = e ** c;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1e4 = e ** d;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1e5 = e ** e;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1e6 = e ** f;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1f1 = f ** a;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1f2 = f ** b;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1f3 = f ** c;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1f4 = f ** d;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1f5 = f ** e;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1f6 = f ** f;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1g1 = E.a ** a; //ok
+    var r1g2 = E.a ** b;
+                      ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1g3 = E.a ** c; //ok
+    var r1g4 = E.a ** d;
+                      ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1g5 = E.a ** e;
+                      ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1g6 = E.a ** f;
+                      ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1h1 = a ** E.b; //ok
+    var r1h2 = b ** E.b;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1h3 = c ** E.b; //ok
+    var r1h4 = d ** E.b;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1h5 = e ** E.b;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1h6 = f ** E.b
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithInvalidOperands.js b/tests/baselines/reference/exponentiationOperatorWithInvalidOperands.js
new file mode 100644
index 00000000000..e7fb22ca6f1
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithInvalidOperands.js
@@ -0,0 +1,135 @@
+//// [exponentiationOperatorWithInvalidOperands.ts]
+// these operators require their operands to be of type Any, the Number primitive type, or
+// an enum type
+enum E { a, b, c }
+
+var a: any;
+var b: boolean;
+var c: number;
+var d: string;
+var e: { a: number };
+var f: Number;
+
+// All of the below should be an error unless otherwise noted
+// operator **
+var r1a1 = a ** a; //ok
+var r1a2 = a ** b;
+var r1a3 = a ** c; //ok
+var r1a4 = a ** d;
+var r1a5 = a ** e;
+var r1a6 = a ** f;
+
+var r1b1 = b ** a;
+var r1b2 = b ** b;
+var r1b3 = b ** c;
+var r1b4 = b ** d;
+var r1b5 = b ** e;
+var r1b6 = b ** f;
+
+var r1c1 = c ** a; //ok
+var r1c2 = c ** b;
+var r1c3 = c ** c; //ok
+var r1c4 = c ** d;
+var r1c5 = c ** e;
+var r1c6 = c ** f;
+
+var r1d1 = d ** a;
+var r1d2 = d ** b;
+var r1d3 = d ** c;
+var r1d4 = d ** d;
+var r1d5 = d ** e;
+var r1d6 = d ** f;
+
+var r1e1 = e ** a;
+var r1e2 = e ** b;
+var r1e3 = e ** c;
+var r1e4 = e ** d;
+var r1e5 = e ** e;
+var r1e6 = e ** f;
+
+var r1f1 = f ** a;
+var r1f2 = f ** b;
+var r1f3 = f ** c;
+var r1f4 = f ** d;
+var r1f5 = f ** e;
+var r1f6 = f ** f;
+
+var r1g1 = E.a ** a; //ok
+var r1g2 = E.a ** b;
+var r1g3 = E.a ** c; //ok
+var r1g4 = E.a ** d;
+var r1g5 = E.a ** e;
+var r1g6 = E.a ** f;
+
+var r1h1 = a ** E.b; //ok
+var r1h2 = b ** E.b;
+var r1h3 = c ** E.b; //ok
+var r1h4 = d ** E.b;
+var r1h5 = e ** E.b;
+var r1h6 = f ** E.b
+
+//// [exponentiationOperatorWithInvalidOperands.js]
+// these operators require their operands to be of type Any, the Number primitive type, or
+// an enum type
+var E;
+(function (E) {
+    E[E["a"] = 0] = "a";
+    E[E["b"] = 1] = "b";
+    E[E["c"] = 2] = "c";
+})(E || (E = {}));
+var a;
+var b;
+var c;
+var d;
+var e;
+var f;
+// All of the below should be an error unless otherwise noted
+// operator **
+var r1a1 = Math.pow(a, a); //ok
+var r1a2 = Math.pow(a, b);
+var r1a3 = Math.pow(a, c); //ok
+var r1a4 = Math.pow(a, d);
+var r1a5 = Math.pow(a, e);
+var r1a6 = Math.pow(a, f);
+var r1b1 = Math.pow(b, a);
+var r1b2 = Math.pow(b, b);
+var r1b3 = Math.pow(b, c);
+var r1b4 = Math.pow(b, d);
+var r1b5 = Math.pow(b, e);
+var r1b6 = Math.pow(b, f);
+var r1c1 = Math.pow(c, a); //ok
+var r1c2 = Math.pow(c, b);
+var r1c3 = Math.pow(c, c); //ok
+var r1c4 = Math.pow(c, d);
+var r1c5 = Math.pow(c, e);
+var r1c6 = Math.pow(c, f);
+var r1d1 = Math.pow(d, a);
+var r1d2 = Math.pow(d, b);
+var r1d3 = Math.pow(d, c);
+var r1d4 = Math.pow(d, d);
+var r1d5 = Math.pow(d, e);
+var r1d6 = Math.pow(d, f);
+var r1e1 = Math.pow(e, a);
+var r1e2 = Math.pow(e, b);
+var r1e3 = Math.pow(e, c);
+var r1e4 = Math.pow(e, d);
+var r1e5 = Math.pow(e, e);
+var r1e6 = Math.pow(e, f);
+var r1f1 = Math.pow(f, a);
+var r1f2 = Math.pow(f, b);
+var r1f3 = Math.pow(f, c);
+var r1f4 = Math.pow(f, d);
+var r1f5 = Math.pow(f, e);
+var r1f6 = Math.pow(f, f);
+var r1g1 = Math.pow(E.a, a); //ok
+var r1g2 = Math.pow(E.a, b);
+var r1g3 = Math.pow(E.a, c); //ok
+var r1g4 = Math.pow(E.a, d);
+var r1g5 = Math.pow(E.a, e);
+var r1g6 = Math.pow(E.a, f);
+var r1h1 = Math.pow(a, E.b); //ok
+var r1h2 = Math.pow(b, E.b);
+var r1h3 = Math.pow(c, E.b); //ok
+var r1h4 = Math.pow(d, E.b);
+var r1h5 = Math.pow(e, E.b);
+var r1h6 = Math.pow(f, E.b);
diff --git a/tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.errors.txt
new file mode 100644
index 00000000000..f43cbd0042a
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.errors.txt
@@ -0,0 +1,123 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(4,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(5,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(6,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(7,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(8,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(10,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(11,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(12,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(13,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(14,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(16,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(17,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(18,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(19,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(20,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(22,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(23,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(24,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(25,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(26,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(28,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(29,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(31,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(33,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(34,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(35,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts(36,6): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts (28 errors) ====
+    var temp: any;
+    
+    // Error: incorrect type on left-hand side 
+    (! --temp) ** 3;
+    ~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!temp--) ** 3;
+    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!3) ** 4;
+    ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!temp++) ** 4;
+    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!temp--) ** 4;
+    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    (! --temp) ** 3 ** 1;
+    ~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!temp--) ** 3 ** 1;
+    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!3) ** 4 ** 1;
+    ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!temp++) ** 4 ** 1;
+    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (!temp--) ** 4 ** 1;
+    ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    (typeof --temp) ** 3;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (typeof temp--) ** 3;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (typeof 3) ** 4;
+    ~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (typeof temp++) ** 4;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (typeof temp--) ** 4;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    1 ** (typeof --temp) ** 3;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    1 ** (typeof temp--) ** 3;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    1 ** (typeof 3) ** 4;
+         ~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    1 ** (typeof temp++) ** 4;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    1 ** (typeof temp--) ** 4;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    (delete --temp) ** 3;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (delete ++temp) ** 3;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (delete temp--) ** 3;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    (delete temp++) ** 3;
+    ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    1 ** (delete --temp) ** 3;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    1 ** (delete ++temp) ** 3;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    1 ** (delete temp--) ** 3;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    1 ** (delete temp++) ** 3;
+         ~~~~~~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.js b/tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.js
new file mode 100644
index 00000000000..8977ea10eed
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.js
@@ -0,0 +1,69 @@
+//// [exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts]
+var temp: any;
+
+// Error: incorrect type on left-hand side 
+(! --temp) ** 3;
+(!temp--) ** 3;
+(!3) ** 4;
+(!temp++) ** 4;
+(!temp--) ** 4;
+
+(! --temp) ** 3 ** 1;
+(!temp--) ** 3 ** 1;
+(!3) ** 4 ** 1;
+(!temp++) ** 4 ** 1;
+(!temp--) ** 4 ** 1;
+
+(typeof --temp) ** 3;
+(typeof temp--) ** 3;
+(typeof 3) ** 4;
+(typeof temp++) ** 4;
+(typeof temp--) ** 4;
+
+1 ** (typeof --temp) ** 3;
+1 ** (typeof temp--) ** 3;
+1 ** (typeof 3) ** 4;
+1 ** (typeof temp++) ** 4;
+1 ** (typeof temp--) ** 4;
+
+(delete --temp) ** 3;
+(delete ++temp) ** 3;
+(delete temp--) ** 3;
+(delete temp++) ** 3;
+
+1 ** (delete --temp) ** 3;
+1 ** (delete ++temp) ** 3;
+1 ** (delete temp--) ** 3;
+1 ** (delete temp++) ** 3;
+
+//// [exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.js]
+var temp;
+// Error: incorrect type on left-hand side 
+Math.pow((!--temp), 3);
+Math.pow((!temp--), 3);
+Math.pow((!3), 4);
+Math.pow((!temp++), 4);
+Math.pow((!temp--), 4);
+Math.pow((!--temp), Math.pow(3, 1));
+Math.pow((!temp--), Math.pow(3, 1));
+Math.pow((!3), Math.pow(4, 1));
+Math.pow((!temp++), Math.pow(4, 1));
+Math.pow((!temp--), Math.pow(4, 1));
+Math.pow((typeof --temp), 3);
+Math.pow((typeof temp--), 3);
+Math.pow((typeof 3), 4);
+Math.pow((typeof temp++), 4);
+Math.pow((typeof temp--), 4);
+Math.pow(1, Math.pow((typeof --temp), 3));
+Math.pow(1, Math.pow((typeof temp--), 3));
+Math.pow(1, Math.pow((typeof 3), 4));
+Math.pow(1, Math.pow((typeof temp++), 4));
+Math.pow(1, Math.pow((typeof temp--), 4));
+Math.pow((delete --temp), 3);
+Math.pow((delete ++temp), 3);
+Math.pow((delete temp--), 3);
+Math.pow((delete temp++), 3);
+Math.pow(1, Math.pow((delete --temp), 3));
+Math.pow(1, Math.pow((delete ++temp), 3));
+Math.pow(1, Math.pow((delete temp--), 3));
+Math.pow(1, Math.pow((delete temp++), 3));
diff --git a/tests/baselines/reference/exponentiationOperatorWithNew.errors.txt b/tests/baselines/reference/exponentiationOperatorWithNew.errors.txt
new file mode 100644
index 00000000000..ae694a321b4
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNew.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNew.ts(6,1): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNew.ts (1 errors) ====
+    var a: any;
+    var b: any;
+    var c: any;
+    new a ** b ** c;
+    new a ** new b ** c;
+    new (a ** b ** c);
+    ~~~~~~~~~~~~~~~~~
+!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithNew.js b/tests/baselines/reference/exponentiationOperatorWithNew.js
new file mode 100644
index 00000000000..6fb7e62c450
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNew.js
@@ -0,0 +1,15 @@
+//// [exponentiationOperatorWithNew.ts]
+var a: any;
+var b: any;
+var c: any;
+new a ** b ** c;
+new a ** new b ** c;
+new (a ** b ** c);
+
+//// [exponentiationOperatorWithNew.js]
+var a;
+var b;
+var c;
+Math.pow(new a, Math.pow(b, c));
+Math.pow(new a, Math.pow(new b, c));
+new (Math.pow(a, Math.pow(b, c)));
diff --git a/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.errors.txt
new file mode 100644
index 00000000000..99535985628
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.errors.txt
@@ -0,0 +1,98 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(9,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(9,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(10,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(10,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(11,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(11,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(13,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(13,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(14,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(14,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(15,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(15,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(17,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(17,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(18,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(18,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(19,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(19,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(21,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(21,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(22,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(22,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(23,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts(23,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts (24 errors) ====
+    // If one operand is the null or undefined value, it is treated as having the type of the
+    // other operand.
+    
+    var a: boolean;
+    var b: string;
+    var c: Object;
+    
+    // operator **
+    var r1a1 = null ** a;
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1a2 = null ** b;
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1a3 = null ** c;
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1b1 = a ** null;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b2 = b ** null;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b3 = c ** null;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1c1 = null ** true;
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1c2 = null ** '';
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1c3 = null ** {};
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1d1 = true ** null;
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d2 = '' ** null;
+               ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                     ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d3 = {} ** null;
+               ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                     ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.js b/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.js
new file mode 100644
index 00000000000..8af703fd032
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.js
@@ -0,0 +1,44 @@
+//// [exponentiationOperatorWithNullValueAndInvalidOperands.ts]
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+var a: boolean;
+var b: string;
+var c: Object;
+
+// operator **
+var r1a1 = null ** a;
+var r1a2 = null ** b;
+var r1a3 = null ** c;
+
+var r1b1 = a ** null;
+var r1b2 = b ** null;
+var r1b3 = c ** null;
+
+var r1c1 = null ** true;
+var r1c2 = null ** '';
+var r1c3 = null ** {};
+
+var r1d1 = true ** null;
+var r1d2 = '' ** null;
+var r1d3 = {} ** null;
+
+//// [exponentiationOperatorWithNullValueAndInvalidOperands.js]
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+var a;
+var b;
+var c;
+// operator **
+var r1a1 = Math.pow(null, a);
+var r1a2 = Math.pow(null, b);
+var r1a3 = Math.pow(null, c);
+var r1b1 = Math.pow(a, null);
+var r1b2 = Math.pow(b, null);
+var r1b3 = Math.pow(c, null);
+var r1c1 = Math.pow(null, true);
+var r1c2 = Math.pow(null, '');
+var r1c3 = Math.pow(null, {});
+var r1d1 = Math.pow(true, null);
+var r1d2 = Math.pow('', null);
+var r1d3 = Math.pow({}, null);
diff --git a/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.js b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.js
new file mode 100644
index 00000000000..a7fe81296e0
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.js
@@ -0,0 +1,41 @@
+//// [exponentiationOperatorWithNullValueAndValidOperands.ts]
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+
+// operator **
+var r1 = null ** a;
+var r2 = null ** b;
+var r3 = null ** 1;
+var r4 = null ** E.a;
+var r5 = a ** null;
+var r6 = b ** null;
+var r7 = 0 ** null;
+var r8 = E.b ** null;
+
+//// [exponentiationOperatorWithNullValueAndValidOperands.js]
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+var E;
+(function (E) {
+    E[E["a"] = 0] = "a";
+    E[E["b"] = 1] = "b";
+})(E || (E = {}));
+var a;
+var b;
+// operator **
+var r1 = Math.pow(null, a);
+var r2 = Math.pow(null, b);
+var r3 = Math.pow(null, 1);
+var r4 = Math.pow(null, E.a);
+var r5 = Math.pow(a, null);
+var r6 = Math.pow(b, null);
+var r7 = Math.pow(0, null);
+var r8 = Math.pow(E.b, null);
diff --git a/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.symbols b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.symbols
new file mode 100644
index 00000000000..cc1ead64f67
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.symbols
@@ -0,0 +1,55 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts ===
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+>E : Symbol(E, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 0, 0))
+
+    a,
+>a : Symbol(E.a, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 3, 8))
+
+    b
+>b : Symbol(E.b, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 4, 6))
+}
+
+var a: any;
+>a : Symbol(a, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 8, 3))
+
+var b: number;
+>b : Symbol(b, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 9, 3))
+
+// operator **
+var r1 = null ** a;
+>r1 : Symbol(r1, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 12, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 8, 3))
+
+var r2 = null ** b;
+>r2 : Symbol(r2, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 13, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 9, 3))
+
+var r3 = null ** 1;
+>r3 : Symbol(r3, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 14, 3))
+
+var r4 = null ** E.a;
+>r4 : Symbol(r4, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 15, 3))
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 3, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 3, 8))
+
+var r5 = a ** null;
+>r5 : Symbol(r5, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 16, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 8, 3))
+
+var r6 = b ** null;
+>r6 : Symbol(r6, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 17, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 9, 3))
+
+var r7 = 0 ** null;
+>r7 : Symbol(r7, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 18, 3))
+
+var r8 = E.b ** null;
+>r8 : Symbol(r8, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 19, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 4, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithNullValueAndValidOperands.ts, 4, 6))
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.types b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.types
new file mode 100644
index 00000000000..2a3c4807763
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithNullValueAndValidOperands.types
@@ -0,0 +1,73 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts ===
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+>E : E
+
+    a,
+>a : E
+
+    b
+>b : E
+}
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+// operator **
+var r1 = null ** a;
+>r1 : number
+>null ** a : number
+>null : null
+>a : any
+
+var r2 = null ** b;
+>r2 : number
+>null ** b : number
+>null : null
+>b : number
+
+var r3 = null ** 1;
+>r3 : number
+>null ** 1 : number
+>null : null
+>1 : number
+
+var r4 = null ** E.a;
+>r4 : number
+>null ** E.a : number
+>null : null
+>E.a : E
+>E : typeof E
+>a : E
+
+var r5 = a ** null;
+>r5 : number
+>a ** null : number
+>a : any
+>null : null
+
+var r6 = b ** null;
+>r6 : number
+>b ** null : number
+>b : number
+>null : null
+
+var r7 = 0 ** null;
+>r7 : number
+>0 ** null : number
+>0 : number
+>null : null
+
+var r8 = E.b ** null;
+>r8 : number
+>E.b ** null : number
+>E.b : E
+>E : typeof E
+>b : E
+>null : null
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.errors.txt b/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
new file mode 100644
index 00000000000..86f4930e77c
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.errors.txt
@@ -0,0 +1,33 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(2,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(2,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(3,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(3,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(4,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(4,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(5,10): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts(5,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts (8 errors) ====
+    // operator **
+    var r1 = null ** null;
+             ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                     ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r2 = null ** undefined;
+             ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                     ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r3 = undefined ** null;
+             ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                          ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r4 = undefined ** undefined;
+             ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                          ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.js b/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.js
new file mode 100644
index 00000000000..86b775cd82b
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.js
@@ -0,0 +1,14 @@
+//// [exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts]
+// operator **
+var r1 = null ** null;
+var r2 = null ** undefined;
+var r3 = undefined ** null;
+var r4 = undefined ** undefined;
+
+
+//// [exponentiationOperatorWithOnlyNullValueOrUndefinedValue.js]
+// operator **
+var r1 = Math.pow(null, null);
+var r2 = Math.pow(null, undefined);
+var r3 = Math.pow(undefined, null);
+var r4 = Math.pow(undefined, undefined);
diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt
new file mode 100644
index 00000000000..53379f29933
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.errors.txt
@@ -0,0 +1,57 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(2,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(3,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(4,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(5,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(6,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(9,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(12,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(13,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(14,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts(15,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts (12 errors) ====
+    
+    var a = 1 ** `${ 3 }`;
+                 ~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var b = 1 ** `2${ 3 }`;
+                 ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var c = 1 ** `${ 3 }4`;
+                 ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var d = 1 ** `2${ 3 }4`;
+                 ~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var e = `${ 3 }` ** 5;
+            ~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var f = `2${ 3 }` ** 5;
+            ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var g = `${ 3 }4` ** 5;
+            ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var h = `2${ 3 }4` ** 5;
+            ~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var k = 10;
+    k **= `${ 3 }`;
+          ~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    k **= `2${ 3 }`;
+          ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    k **= `2${ 3 }4`;
+          ~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    k **= `2${ 3 }4`;
+          ~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    
+     
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js
new file mode 100644
index 00000000000..5bd9a9609a0
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.js
@@ -0,0 +1,34 @@
+//// [exponentiationOperatorWithTemplateStringInvalid.ts]
+
+var a = 1 ** `${ 3 }`;
+var b = 1 ** `2${ 3 }`;
+var c = 1 ** `${ 3 }4`;
+var d = 1 ** `2${ 3 }4`;
+var e = `${ 3 }` ** 5;
+var f = `2${ 3 }` ** 5;
+var g = `${ 3 }4` ** 5;
+var h = `2${ 3 }4` ** 5;
+
+var k = 10;
+k **= `${ 3 }`;
+k **= `2${ 3 }`;
+k **= `2${ 3 }4`;
+k **= `2${ 3 }4`;
+
+
+ 
+
+//// [exponentiationOperatorWithTemplateStringInvalid.js]
+var a = Math.pow(1, "" + 3);
+var b = Math.pow(1, "2" + 3);
+var c = Math.pow(1, 3 + "4");
+var d = Math.pow(1, "2" + 3 + "4");
+var e = Math.pow("" + 3, 5);
+var f = Math.pow("2" + 3, 5);
+var g = Math.pow(3 + "4", 5);
+var h = Math.pow("2" + 3 + "4", 5);
+var k = 10;
+k = Math.pow(k, "" + 3);
+k = Math.pow(k, "2" + 3);
+k = Math.pow(k, "2" + 3 + "4");
+k = Math.pow(k, "2" + 3 + "4");
diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt
new file mode 100644
index 00000000000..39ade9df205
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.errors.txt
@@ -0,0 +1,57 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(2,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(3,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(4,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(5,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(6,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(9,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(12,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(13,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(14,7): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(15,1): error TS2304: Cannot find name 'kj'.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts(15,8): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts (13 errors) ====
+    
+    var a = 1 ** `${ 3 }`;
+                 ~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var b = 1 ** `2${ 3 }`;
+                 ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var c = 1 ** `${ 3 }4`;
+                 ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var d = 1 ** `2${ 3 }4`;
+                 ~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var e = `${ 3 }` ** 5;
+            ~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var f = `2${ 3 }` ** 5;
+            ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var g = `${ 3 }4` ** 5;
+            ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var h = `2${ 3 }4` ** 5;
+            ~~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var k = 10;
+    k **= `${ 3 }`;
+          ~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    k **= `2${ 3 }`;
+          ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    k **= `2${ 3 }4`;
+          ~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    kj **= `2${ 3 }4`;
+    ~~
+!!! error TS2304: Cannot find name 'kj'.
+           ~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js
new file mode 100644
index 00000000000..cde5133039f
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.js
@@ -0,0 +1,31 @@
+//// [exponentiationOperatorWithTemplateStringInvalidES6.ts]
+
+var a = 1 ** `${ 3 }`;
+var b = 1 ** `2${ 3 }`;
+var c = 1 ** `${ 3 }4`;
+var d = 1 ** `2${ 3 }4`;
+var e = `${ 3 }` ** 5;
+var f = `2${ 3 }` ** 5;
+var g = `${ 3 }4` ** 5;
+var h = `2${ 3 }4` ** 5;
+
+var k = 10;
+k **= `${ 3 }`;
+k **= `2${ 3 }`;
+k **= `2${ 3 }4`;
+kj **= `2${ 3 }4`;
+
+//// [exponentiationOperatorWithTemplateStringInvalidES6.js]
+var a = Math.pow(1, `${3}`);
+var b = Math.pow(1, `2${3}`);
+var c = Math.pow(1, `${3}4`);
+var d = Math.pow(1, `2${3}4`);
+var e = Math.pow(`${3}`, 5);
+var f = Math.pow(`2${3}`, 5);
+var g = Math.pow(`${3}4`, 5);
+var h = Math.pow(`2${3}4`, 5);
+var k = 10;
+k = Math.pow(k, `${3}`);
+k = Math.pow(k, `2${3}`);
+k = Math.pow(k, `2${3}4`);
+kj = Math.pow(kj, `2${3}4`);
diff --git a/tests/baselines/reference/exponentiationOperatorWithTypeParameter.errors.txt b/tests/baselines/reference/exponentiationOperatorWithTypeParameter.errors.txt
new file mode 100644
index 00000000000..46fd0832468
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithTypeParameter.errors.txt
@@ -0,0 +1,77 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(9,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(10,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(11,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(11,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(12,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(12,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(13,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(14,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(15,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(15,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(16,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(16,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(17,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(17,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(18,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(18,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(19,16): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts(19,21): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts (18 errors) ====
+    // type parameter type is not valid for arithmetic operand
+    function foo<T>(t: T) {
+        var a: any;
+        var b: boolean;
+        var c: number;
+        var d: string;
+        var e: {};
+    
+        var r1a1 = a ** t;
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r2a1 = t ** a;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r1b1 = b ** t;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r2b1 = t ** b;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r1c1 = c ** t;
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r2c1 = t ** c;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r1d1 = d ** t;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r2d1 = t ** d;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r1e1 = e ** t;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r2e1 = t ** d;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        var r1f1 = t ** t;
+                   ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                        ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithTypeParameter.js b/tests/baselines/reference/exponentiationOperatorWithTypeParameter.js
new file mode 100644
index 00000000000..45eb12ac331
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithTypeParameter.js
@@ -0,0 +1,42 @@
+//// [exponentiationOperatorWithTypeParameter.ts]
+// type parameter type is not valid for arithmetic operand
+function foo<T>(t: T) {
+    var a: any;
+    var b: boolean;
+    var c: number;
+    var d: string;
+    var e: {};
+
+    var r1a1 = a ** t;
+    var r2a1 = t ** a;
+    var r1b1 = b ** t;
+    var r2b1 = t ** b;
+    var r1c1 = c ** t;
+    var r2c1 = t ** c;
+    var r1d1 = d ** t;
+    var r2d1 = t ** d;
+    var r1e1 = e ** t;
+    var r2e1 = t ** d;
+    var r1f1 = t ** t;
+}
+
+//// [exponentiationOperatorWithTypeParameter.js]
+// type parameter type is not valid for arithmetic operand
+function foo(t) {
+    var a;
+    var b;
+    var c;
+    var d;
+    var e;
+    var r1a1 = Math.pow(a, t);
+    var r2a1 = Math.pow(t, a);
+    var r1b1 = Math.pow(b, t);
+    var r2b1 = Math.pow(t, b);
+    var r1c1 = Math.pow(c, t);
+    var r2c1 = Math.pow(t, c);
+    var r1d1 = Math.pow(d, t);
+    var r2d1 = Math.pow(t, d);
+    var r1e1 = Math.pow(e, t);
+    var r2e1 = Math.pow(t, d);
+    var r1f1 = Math.pow(t, t);
+}
diff --git a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.errors.txt b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.errors.txt
new file mode 100644
index 00000000000..f456e0f554f
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.errors.txt
@@ -0,0 +1,98 @@
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(9,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(9,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(10,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(10,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(11,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(11,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(13,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(13,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(14,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(14,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(15,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(15,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(17,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(17,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(18,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(18,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(19,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(19,25): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(21,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(21,20): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(22,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(22,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(23,12): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts(23,18): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts (24 errors) ====
+    // If one operand is the undefined or undefined value, it is treated as having the type of the
+    // other operand.
+    
+    var a: boolean;
+    var b: string;
+    var c: Object;
+    
+    // operator **
+    var r1a1 = undefined ** a;
+               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1a2 = undefined ** b;
+               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1a3 = undefined ** c;
+               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1b1 = a ** undefined;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b2 = b ** undefined;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1b3 = c ** undefined;
+               ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                    ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1c1 = undefined ** true;
+               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1c2 = undefined ** '';
+               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1c3 = undefined ** {};
+               ~~~~~~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                            ~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    
+    var r1d1 = true ** undefined;
+               ~~~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                       ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d2 = '' ** undefined;
+               ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                     ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+    var r1d3 = {} ** undefined;
+               ~~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                     ~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.js b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.js
new file mode 100644
index 00000000000..89a7c6910b5
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.js
@@ -0,0 +1,44 @@
+//// [exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts]
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+var a: boolean;
+var b: string;
+var c: Object;
+
+// operator **
+var r1a1 = undefined ** a;
+var r1a2 = undefined ** b;
+var r1a3 = undefined ** c;
+
+var r1b1 = a ** undefined;
+var r1b2 = b ** undefined;
+var r1b3 = c ** undefined;
+
+var r1c1 = undefined ** true;
+var r1c2 = undefined ** '';
+var r1c3 = undefined ** {};
+
+var r1d1 = true ** undefined;
+var r1d2 = '' ** undefined;
+var r1d3 = {} ** undefined;
+
+//// [exponentiationOperatorWithUndefinedValueAndInvalidOperands.js]
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+var a;
+var b;
+var c;
+// operator **
+var r1a1 = Math.pow(undefined, a);
+var r1a2 = Math.pow(undefined, b);
+var r1a3 = Math.pow(undefined, c);
+var r1b1 = Math.pow(a, undefined);
+var r1b2 = Math.pow(b, undefined);
+var r1b3 = Math.pow(c, undefined);
+var r1c1 = Math.pow(undefined, true);
+var r1c2 = Math.pow(undefined, '');
+var r1c3 = Math.pow(undefined, {});
+var r1d1 = Math.pow(true, undefined);
+var r1d2 = Math.pow('', undefined);
+var r1d3 = Math.pow({}, undefined);
diff --git a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.js b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.js
new file mode 100644
index 00000000000..0f9d04faaa2
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.js
@@ -0,0 +1,41 @@
+//// [exponentiationOperatorWithUndefinedValueAndValidOperands.ts]
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+
+// operator *
+var rk1 = undefined ** a;
+var rk2 = undefined ** b;
+var rk3 = undefined ** 1;
+var rk4 = undefined ** E.a;
+var rk5 = a ** undefined;
+var rk6 = b ** undefined;
+var rk7 = 0 ** undefined;
+var rk8 = E.b ** undefined;
+
+//// [exponentiationOperatorWithUndefinedValueAndValidOperands.js]
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+var E;
+(function (E) {
+    E[E["a"] = 0] = "a";
+    E[E["b"] = 1] = "b";
+})(E || (E = {}));
+var a;
+var b;
+// operator *
+var rk1 = Math.pow(undefined, a);
+var rk2 = Math.pow(undefined, b);
+var rk3 = Math.pow(undefined, 1);
+var rk4 = Math.pow(undefined, E.a);
+var rk5 = Math.pow(a, undefined);
+var rk6 = Math.pow(b, undefined);
+var rk7 = Math.pow(0, undefined);
+var rk8 = Math.pow(E.b, undefined);
diff --git a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.symbols b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.symbols
new file mode 100644
index 00000000000..e15ccecf70e
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.symbols
@@ -0,0 +1,63 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts ===
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+>E : Symbol(E, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 0, 0))
+
+    a,
+>a : Symbol(E.a, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 3, 8))
+
+    b
+>b : Symbol(E.b, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 4, 6))
+}
+
+var a: any;
+>a : Symbol(a, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+
+var b: number;
+>b : Symbol(b, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+
+// operator *
+var rk1 = undefined ** a;
+>rk1 : Symbol(rk1, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 12, 3))
+>undefined : Symbol(undefined)
+>a : Symbol(a, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+
+var rk2 = undefined ** b;
+>rk2 : Symbol(rk2, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 13, 3))
+>undefined : Symbol(undefined)
+>b : Symbol(b, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+
+var rk3 = undefined ** 1;
+>rk3 : Symbol(rk3, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 14, 3))
+>undefined : Symbol(undefined)
+
+var rk4 = undefined ** E.a;
+>rk4 : Symbol(rk4, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 15, 3))
+>undefined : Symbol(undefined)
+>E.a : Symbol(E.a, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 3, 8))
+>E : Symbol(E, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 0, 0))
+>a : Symbol(E.a, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 3, 8))
+
+var rk5 = a ** undefined;
+>rk5 : Symbol(rk5, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 16, 3))
+>a : Symbol(a, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 8, 3))
+>undefined : Symbol(undefined)
+
+var rk6 = b ** undefined;
+>rk6 : Symbol(rk6, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 17, 3))
+>b : Symbol(b, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 9, 3))
+>undefined : Symbol(undefined)
+
+var rk7 = 0 ** undefined;
+>rk7 : Symbol(rk7, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 18, 3))
+>undefined : Symbol(undefined)
+
+var rk8 = E.b ** undefined;
+>rk8 : Symbol(rk8, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 19, 3))
+>E.b : Symbol(E.b, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 4, 6))
+>E : Symbol(E, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 0, 0))
+>b : Symbol(E.b, Decl(exponentiationOperatorWithUndefinedValueAndValidOperands.ts, 4, 6))
+>undefined : Symbol(undefined)
+
diff --git a/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.types b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.types
new file mode 100644
index 00000000000..4e44144511e
--- /dev/null
+++ b/tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndValidOperands.types
@@ -0,0 +1,73 @@
+=== tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts ===
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+>E : E
+
+    a,
+>a : E
+
+    b
+>b : E
+}
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+// operator *
+var rk1 = undefined ** a;
+>rk1 : number
+>undefined ** a : number
+>undefined : undefined
+>a : any
+
+var rk2 = undefined ** b;
+>rk2 : number
+>undefined ** b : number
+>undefined : undefined
+>b : number
+
+var rk3 = undefined ** 1;
+>rk3 : number
+>undefined ** 1 : number
+>undefined : undefined
+>1 : number
+
+var rk4 = undefined ** E.a;
+>rk4 : number
+>undefined ** E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rk5 = a ** undefined;
+>rk5 : number
+>a ** undefined : number
+>a : any
+>undefined : undefined
+
+var rk6 = b ** undefined;
+>rk6 : number
+>b ** undefined : number
+>b : number
+>undefined : undefined
+
+var rk7 = 0 ** undefined;
+>rk7 : number
+>0 ** undefined : number
+>0 : number
+>undefined : undefined
+
+var rk8 = E.b ** undefined;
+>rk8 : number
+>E.b ** undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
diff --git a/tests/baselines/reference/exportAssignValueAndType.symbols b/tests/baselines/reference/exportAssignValueAndType.symbols
index b6d5b5b3bb6..faca2c6ffd0 100644
--- a/tests/baselines/reference/exportAssignValueAndType.symbols
+++ b/tests/baselines/reference/exportAssignValueAndType.symbols
@@ -16,7 +16,7 @@ interface server {
 
     startTime: Date;
 >startTime : Symbol(startTime, Decl(exportAssignValueAndType.ts, 5, 20))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
  
 var x = 5;
@@ -24,7 +24,7 @@ var x = 5;
 
 var server = new Date();
 >server : Symbol(server, Decl(exportAssignValueAndType.ts, 2, 1), Decl(exportAssignValueAndType.ts, 10, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 export = server;
 >server : Symbol(server, Decl(exportAssignValueAndType.ts, 2, 1), Decl(exportAssignValueAndType.ts, 10, 3))
diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols
index 2c286e8518d..e79faf36f35 100644
--- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols
+++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols
@@ -13,7 +13,7 @@ interface x {
 >x : Symbol(x, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 0, 0))
 
     (): Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: string;
 >foo : Symbol(foo, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 2, 13))
diff --git a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
index bcbf5eb1f60..e2ddbdb419c 100644
--- a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
+++ b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols
@@ -5,9 +5,9 @@ function Greeter() {
     //...
 }
 Greeter.prototype.greet = function () {
->Greeter.prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
+>Greeter.prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --))
 >Greeter : Symbol(Greeter, Decl(exportAssignmentWithoutIdentifier1.ts, 0, 0))
->prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
+>prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --))
 
     //...
 }
diff --git a/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.js b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.js
new file mode 100644
index 00000000000..3acb89b8696
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.js
@@ -0,0 +1,9 @@
+//// [exportDefaultClassWithStaticPropertyAssignmentsInES6.ts]
+export default class {
+    static z: string = "Foo";
+}
+
+//// [exportDefaultClassWithStaticPropertyAssignmentsInES6.js]
+export default class default_1 {
+}
+default_1.z = "Foo";
diff --git a/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.symbols b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.symbols
new file mode 100644
index 00000000000..6d08eb93d92
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts ===
+export default class {
+    static z: string = "Foo";
+>z : Symbol(default.z, Decl(exportDefaultClassWithStaticPropertyAssignmentsInES6.ts, 0, 22))
+}
diff --git a/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.types b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.types
new file mode 100644
index 00000000000..657e0301f83
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts ===
+export default class {
+    static z: string = "Foo";
+>z : string
+>"Foo" : string
+}
diff --git a/tests/baselines/reference/exportEqualNamespaces.symbols b/tests/baselines/reference/exportEqualNamespaces.symbols
index f6f0767d414..1773883c68b 100644
--- a/tests/baselines/reference/exportEqualNamespaces.symbols
+++ b/tests/baselines/reference/exportEqualNamespaces.symbols
@@ -4,7 +4,7 @@ declare module server {
 
     interface Server extends Object { }
 >Server : Symbol(Server, Decl(exportEqualNamespaces.ts, 0, 23))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface server {
@@ -16,7 +16,7 @@ interface server {
 
     startTime: Date;
 >startTime : Symbol(startTime, Decl(exportEqualNamespaces.ts, 5, 22))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
  
 var x = 5;
@@ -24,7 +24,7 @@ var x = 5;
 
 var server = new Date();
 >server : Symbol(server, Decl(exportEqualNamespaces.ts, 0, 0), Decl(exportEqualNamespaces.ts, 2, 1), Decl(exportEqualNamespaces.ts, 10, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 export = server;
 >server : Symbol(server, Decl(exportEqualNamespaces.ts, 0, 0), Decl(exportEqualNamespaces.ts, 2, 1), Decl(exportEqualNamespaces.ts, 10, 3))
diff --git a/tests/baselines/reference/exportedBlockScopedDeclarations.errors.txt b/tests/baselines/reference/exportedBlockScopedDeclarations.errors.txt
new file mode 100644
index 00000000000..06d832c86e1
--- /dev/null
+++ b/tests/baselines/reference/exportedBlockScopedDeclarations.errors.txt
@@ -0,0 +1,44 @@
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(1,13): error TS2448: Block-scoped variable 'foo' used before its declaration.
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(2,20): error TS2448: Block-scoped variable 'bar' used before its declaration.
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(4,15): error TS2448: Block-scoped variable 'bar' used before its declaration.
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(7,22): error TS2448: Block-scoped variable 'bar' used before its declaration.
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(10,12): error TS2448: Block-scoped variable 'foo1' used before its declaration.
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(11,19): error TS2448: Block-scoped variable 'bar1' used before its declaration.
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(13,14): error TS2448: Block-scoped variable 'bar1' used before its declaration.
+tests/cases/compiler/exportedBlockScopedDeclarations.ts(16,21): error TS2448: Block-scoped variable 'bar1' used before its declaration.
+
+
+==== tests/cases/compiler/exportedBlockScopedDeclarations.ts (8 errors) ====
+    const foo = foo; // compile error
+                ~~~
+!!! error TS2448: Block-scoped variable 'foo' used before its declaration.
+    export const bar = bar; // should be compile error
+                       ~~~
+!!! error TS2448: Block-scoped variable 'bar' used before its declaration.
+    function f() {
+      const bar = bar; // compile error
+                  ~~~
+!!! error TS2448: Block-scoped variable 'bar' used before its declaration.
+    }
+    namespace NS {
+      export const bar = bar; // should be compile error
+                         ~~~
+!!! error TS2448: Block-scoped variable 'bar' used before its declaration.
+    }
+    
+    let foo1 = foo1; // compile error
+               ~~~~
+!!! error TS2448: Block-scoped variable 'foo1' used before its declaration.
+    export let bar1 = bar1; // should be compile error
+                      ~~~~
+!!! error TS2448: Block-scoped variable 'bar1' used before its declaration.
+    function f1() {
+      let bar1 = bar1; // compile error
+                 ~~~~
+!!! error TS2448: Block-scoped variable 'bar1' used before its declaration.
+    }
+    namespace NS1 {
+      export let bar1 = bar1; // should be compile error
+                        ~~~~
+!!! error TS2448: Block-scoped variable 'bar1' used before its declaration.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/exportedBlockScopedDeclarations.js b/tests/baselines/reference/exportedBlockScopedDeclarations.js
new file mode 100644
index 00000000000..81399ddafb5
--- /dev/null
+++ b/tests/baselines/reference/exportedBlockScopedDeclarations.js
@@ -0,0 +1,40 @@
+//// [exportedBlockScopedDeclarations.ts]
+const foo = foo; // compile error
+export const bar = bar; // should be compile error
+function f() {
+  const bar = bar; // compile error
+}
+namespace NS {
+  export const bar = bar; // should be compile error
+}
+
+let foo1 = foo1; // compile error
+export let bar1 = bar1; // should be compile error
+function f1() {
+  let bar1 = bar1; // compile error
+}
+namespace NS1 {
+  export let bar1 = bar1; // should be compile error
+}
+
+//// [exportedBlockScopedDeclarations.js]
+define(["require", "exports"], function (require, exports) {
+    var foo = foo; // compile error
+    exports.bar = exports.bar; // should be compile error
+    function f() {
+        var bar = bar; // compile error
+    }
+    var NS;
+    (function (NS) {
+        NS.bar = NS.bar; // should be compile error
+    })(NS || (NS = {}));
+    var foo1 = foo1; // compile error
+    exports.bar1 = exports.bar1; // should be compile error
+    function f1() {
+        var bar1 = bar1; // compile error
+    }
+    var NS1;
+    (function (NS1) {
+        NS1.bar1 = NS1.bar1; // should be compile error
+    })(NS1 || (NS1 = {}));
+});
diff --git a/tests/baselines/reference/exportedVariable1.symbols b/tests/baselines/reference/exportedVariable1.symbols
index 96c4b0210ba..eb8d4d2f007 100644
--- a/tests/baselines/reference/exportedVariable1.symbols
+++ b/tests/baselines/reference/exportedVariable1.symbols
@@ -5,9 +5,9 @@ export var foo = {name: "Bill"};
 
 var upper = foo.name.toUpperCase();
 >upper : Symbol(upper, Decl(exportedVariable1.ts, 1, 3))
->foo.name.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>foo.name.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >foo.name : Symbol(name, Decl(exportedVariable1.ts, 0, 18))
 >foo : Symbol(foo, Decl(exportedVariable1.ts, 0, 10))
 >name : Symbol(name, Decl(exportedVariable1.ts, 0, 18))
->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/exportsAndImports1-es6.js b/tests/baselines/reference/exportsAndImports1-es6.js
new file mode 100644
index 00000000000..5610968bf79
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports1-es6.js
@@ -0,0 +1,73 @@
+//// [tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts] ////
+
+//// [t1.ts]
+
+var v = 1;
+function f() { }
+class C {
+}
+interface I {
+}
+enum E {
+    A, B, C
+}
+const enum D {
+    A, B, C
+}
+module M {
+    export var x;
+}
+module N {
+    export interface I {
+    }
+}
+type T = number;
+import a = M.x;
+
+export { v, f, C, I, E, D, M, N, T, a };
+
+//// [t2.ts]
+export { v, f, C, I, E, D, M, N, T, a } from "./t1";
+
+//// [t3.ts]
+import { v, f, C, I, E, D, M, N, T, a } from "./t1";
+export { v, f, C, I, E, D, M, N, T, a };
+
+
+//// [t1.js]
+var v = 1;
+exports.v = v;
+function f() { }
+exports.f = f;
+class C {
+}
+exports.C = C;
+var E;
+(function (E) {
+    E[E["A"] = 0] = "A";
+    E[E["B"] = 1] = "B";
+    E[E["C"] = 2] = "C";
+})(E || (E = {}));
+exports.E = E;
+var M;
+(function (M) {
+})(M || (M = {}));
+exports.M = M;
+var a = M.x;
+exports.a = a;
+//// [t2.js]
+var t1_1 = require("./t1");
+exports.v = t1_1.v;
+exports.f = t1_1.f;
+exports.C = t1_1.C;
+exports.E = t1_1.E;
+exports.M = t1_1.M;
+exports.a = t1_1.a;
+//// [t3.js]
+var t1_1 = require("./t1");
+exports.v = t1_1.v;
+exports.f = t1_1.f;
+exports.C = t1_1.C;
+exports.E = t1_1.E;
+exports.M = t1_1.M;
+exports.a = t1_1.a;
diff --git a/tests/baselines/reference/exportsAndImports1-es6.symbols b/tests/baselines/reference/exportsAndImports1-es6.symbols
new file mode 100644
index 00000000000..dc90c8c7bf9
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports1-es6.symbols
@@ -0,0 +1,101 @@
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+var v = 1;
+>v : Symbol(v, Decl(t1.ts, 1, 3))
+
+function f() { }
+>f : Symbol(f, Decl(t1.ts, 1, 10))
+
+class C {
+>C : Symbol(C, Decl(t1.ts, 2, 16))
+}
+interface I {
+>I : Symbol(I, Decl(t1.ts, 4, 1))
+}
+enum E {
+>E : Symbol(E, Decl(t1.ts, 6, 1))
+
+    A, B, C
+>A : Symbol(E.A, Decl(t1.ts, 7, 8))
+>B : Symbol(E.B, Decl(t1.ts, 8, 6))
+>C : Symbol(E.C, Decl(t1.ts, 8, 9))
+}
+const enum D {
+>D : Symbol(D, Decl(t1.ts, 9, 1))
+
+    A, B, C
+>A : Symbol(D.A, Decl(t1.ts, 10, 14))
+>B : Symbol(D.B, Decl(t1.ts, 11, 6))
+>C : Symbol(D.C, Decl(t1.ts, 11, 9))
+}
+module M {
+>M : Symbol(M, Decl(t1.ts, 12, 1))
+
+    export var x;
+>x : Symbol(x, Decl(t1.ts, 14, 14))
+}
+module N {
+>N : Symbol(N, Decl(t1.ts, 15, 1))
+
+    export interface I {
+>I : Symbol(I, Decl(t1.ts, 16, 10))
+    }
+}
+type T = number;
+>T : Symbol(T, Decl(t1.ts, 19, 1))
+
+import a = M.x;
+>a : Symbol(a, Decl(t1.ts, 20, 16))
+>M : Symbol(M, Decl(t1.ts, 12, 1))
+>x : Symbol(a, Decl(t1.ts, 14, 14))
+
+export { v, f, C, I, E, D, M, N, T, a };
+>v : Symbol(v, Decl(t1.ts, 23, 8))
+>f : Symbol(f, Decl(t1.ts, 23, 11))
+>C : Symbol(C, Decl(t1.ts, 23, 14))
+>I : Symbol(I, Decl(t1.ts, 23, 17))
+>E : Symbol(E, Decl(t1.ts, 23, 20))
+>D : Symbol(D, Decl(t1.ts, 23, 23))
+>M : Symbol(M, Decl(t1.ts, 23, 26))
+>N : Symbol(N, Decl(t1.ts, 23, 29))
+>T : Symbol(T, Decl(t1.ts, 23, 32))
+>a : Symbol(a, Decl(t1.ts, 23, 35))
+
+=== tests/cases/conformance/es6/modules/t2.ts ===
+export { v, f, C, I, E, D, M, N, T, a } from "./t1";
+>v : Symbol(v, Decl(t2.ts, 0, 8))
+>f : Symbol(f, Decl(t2.ts, 0, 11))
+>C : Symbol(C, Decl(t2.ts, 0, 14))
+>I : Symbol(I, Decl(t2.ts, 0, 17))
+>E : Symbol(E, Decl(t2.ts, 0, 20))
+>D : Symbol(D, Decl(t2.ts, 0, 23))
+>M : Symbol(M, Decl(t2.ts, 0, 26))
+>N : Symbol(N, Decl(t2.ts, 0, 29))
+>T : Symbol(T, Decl(t2.ts, 0, 32))
+>a : Symbol(a, Decl(t2.ts, 0, 35))
+
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import { v, f, C, I, E, D, M, N, T, a } from "./t1";
+>v : Symbol(v, Decl(t3.ts, 0, 8))
+>f : Symbol(f, Decl(t3.ts, 0, 11))
+>C : Symbol(C, Decl(t3.ts, 0, 14))
+>I : Symbol(I, Decl(t3.ts, 0, 17))
+>E : Symbol(E, Decl(t3.ts, 0, 20))
+>D : Symbol(D, Decl(t3.ts, 0, 23))
+>M : Symbol(M, Decl(t3.ts, 0, 26))
+>N : Symbol(N, Decl(t3.ts, 0, 29))
+>T : Symbol(T, Decl(t3.ts, 0, 32))
+>a : Symbol(a, Decl(t3.ts, 0, 35))
+
+export { v, f, C, I, E, D, M, N, T, a };
+>v : Symbol(v, Decl(t3.ts, 1, 8))
+>f : Symbol(f, Decl(t3.ts, 1, 11))
+>C : Symbol(C, Decl(t3.ts, 1, 14))
+>I : Symbol(I, Decl(t3.ts, 1, 17))
+>E : Symbol(E, Decl(t3.ts, 1, 20))
+>D : Symbol(D, Decl(t3.ts, 1, 23))
+>M : Symbol(M, Decl(t3.ts, 1, 26))
+>N : Symbol(N, Decl(t3.ts, 1, 29))
+>T : Symbol(T, Decl(t3.ts, 1, 32))
+>a : Symbol(a, Decl(t3.ts, 1, 35))
+
diff --git a/tests/baselines/reference/exportsAndImports1-es6.types b/tests/baselines/reference/exportsAndImports1-es6.types
new file mode 100644
index 00000000000..4ba83121541
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports1-es6.types
@@ -0,0 +1,102 @@
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+var v = 1;
+>v : number
+>1 : number
+
+function f() { }
+>f : () => void
+
+class C {
+>C : C
+}
+interface I {
+>I : I
+}
+enum E {
+>E : E
+
+    A, B, C
+>A : E
+>B : E
+>C : E
+}
+const enum D {
+>D : D
+
+    A, B, C
+>A : D
+>B : D
+>C : D
+}
+module M {
+>M : typeof M
+
+    export var x;
+>x : any
+}
+module N {
+>N : any
+
+    export interface I {
+>I : I
+    }
+}
+type T = number;
+>T : number
+
+import a = M.x;
+>a : any
+>M : typeof M
+>x : any
+
+export { v, f, C, I, E, D, M, N, T, a };
+>v : number
+>f : () => void
+>C : typeof C
+>I : any
+>E : typeof E
+>D : typeof D
+>M : typeof M
+>N : any
+>T : any
+>a : any
+
+=== tests/cases/conformance/es6/modules/t2.ts ===
+export { v, f, C, I, E, D, M, N, T, a } from "./t1";
+>v : number
+>f : () => void
+>C : typeof C
+>I : any
+>E : typeof E
+>D : typeof D
+>M : typeof M
+>N : any
+>T : any
+>a : any
+
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import { v, f, C, I, E, D, M, N, T, a } from "./t1";
+>v : number
+>f : () => void
+>C : typeof C
+>I : any
+>E : typeof E
+>D : typeof D
+>M : typeof M
+>N : any
+>T : any
+>a : any
+
+export { v, f, C, I, E, D, M, N, T, a };
+>v : number
+>f : () => void
+>C : typeof C
+>I : any
+>E : typeof E
+>D : typeof D
+>M : typeof M
+>N : any
+>T : any
+>a : any
+
diff --git a/tests/baselines/reference/exportsAndImports2-es6.js b/tests/baselines/reference/exportsAndImports2-es6.js
new file mode 100644
index 00000000000..aa58c0d8902
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports2-es6.js
@@ -0,0 +1,26 @@
+//// [tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts] ////
+
+//// [t1.ts]
+
+export var x = "x";
+export var y = "y";
+
+//// [t2.ts]
+export { x as y, y as x } from "./t1";
+
+//// [t3.ts]
+import { x, y } from "./t1";
+export { x as y, y as x };
+
+
+//// [t1.js]
+exports.x = "x";
+exports.y = "y";
+//// [t2.js]
+var t1_1 = require("./t1");
+exports.y = t1_1.x;
+exports.x = t1_1.y;
+//// [t3.js]
+var t1_1 = require("./t1");
+exports.y = t1_1.x;
+exports.x = t1_1.y;
diff --git a/tests/baselines/reference/exportsAndImports2-es6.symbols b/tests/baselines/reference/exportsAndImports2-es6.symbols
new file mode 100644
index 00000000000..8b53794abae
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports2-es6.symbols
@@ -0,0 +1,26 @@
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+export var x = "x";
+>x : Symbol(x, Decl(t1.ts, 1, 10))
+
+export var y = "y";
+>y : Symbol(y, Decl(t1.ts, 2, 10))
+
+=== tests/cases/conformance/es6/modules/t2.ts ===
+export { x as y, y as x } from "./t1";
+>x : Symbol(y, Decl(t2.ts, 0, 8))
+>y : Symbol(y, Decl(t2.ts, 0, 8))
+>y : Symbol(x, Decl(t2.ts, 0, 16))
+>x : Symbol(x, Decl(t2.ts, 0, 16))
+
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import { x, y } from "./t1";
+>x : Symbol(x, Decl(t3.ts, 0, 8))
+>y : Symbol(y, Decl(t3.ts, 0, 11))
+
+export { x as y, y as x };
+>x : Symbol(y, Decl(t3.ts, 1, 8))
+>y : Symbol(y, Decl(t3.ts, 1, 8))
+>y : Symbol(x, Decl(t3.ts, 1, 16))
+>x : Symbol(x, Decl(t3.ts, 1, 16))
+
diff --git a/tests/baselines/reference/exportsAndImports2-es6.types b/tests/baselines/reference/exportsAndImports2-es6.types
new file mode 100644
index 00000000000..32de763c567
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports2-es6.types
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+export var x = "x";
+>x : string
+>"x" : string
+
+export var y = "y";
+>y : string
+>"y" : string
+
+=== tests/cases/conformance/es6/modules/t2.ts ===
+export { x as y, y as x } from "./t1";
+>x : string
+>y : string
+>y : string
+>x : string
+
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import { x, y } from "./t1";
+>x : string
+>y : string
+
+export { x as y, y as x };
+>x : string
+>y : string
+>y : string
+>x : string
+
diff --git a/tests/baselines/reference/exportsAndImports3-es6.js b/tests/baselines/reference/exportsAndImports3-es6.js
new file mode 100644
index 00000000000..d8e142de41d
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports3-es6.js
@@ -0,0 +1,75 @@
+//// [tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts] ////
+
+//// [t1.ts]
+
+export var v = 1;
+export function f() { }
+export class C {
+}
+export interface I {
+}
+export enum E {
+    A, B, C
+}
+export const enum D {
+    A, B, C
+}
+export module M {
+    export var x;
+}
+export module N {
+    export interface I {
+    }
+}
+export type T = number;
+export import a = M.x;
+
+export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 };
+
+//// [t2.ts]
+export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+
+//// [t3.ts]
+import { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+export { v, f, C, I, E, D, M, N, T, a };
+
+
+//// [t1.js]
+exports.v = 1;
+exports.v1 = exports.v;
+function f() { }
+exports.f = f;
+exports.f1 = f;
+class C {
+}
+exports.C = C;
+exports.C1 = C;
+(function (E) {
+    E[E["A"] = 0] = "A";
+    E[E["B"] = 1] = "B";
+    E[E["C"] = 2] = "C";
+})(exports.E || (exports.E = {}));
+var E = exports.E;
+exports.E1 = E;
+var M;
+(function (M) {
+})(M = exports.M || (exports.M = {}));
+exports.M1 = M;
+exports.a = M.x;
+exports.a1 = exports.a;
+//// [t2.js]
+var t1_1 = require("./t1");
+exports.v = t1_1.v1;
+exports.f = t1_1.f1;
+exports.C = t1_1.C1;
+exports.E = t1_1.E1;
+exports.M = t1_1.M1;
+exports.a = t1_1.a1;
+//// [t3.js]
+var t1_1 = require("./t1");
+exports.v = t1_1.v1;
+exports.f = t1_1.f1;
+exports.C = t1_1.C1;
+exports.E = t1_1.E1;
+exports.M = t1_1.M1;
+exports.a = t1_1.a1;
diff --git a/tests/baselines/reference/exportsAndImports3-es6.symbols b/tests/baselines/reference/exportsAndImports3-es6.symbols
new file mode 100644
index 00000000000..a46d7df2a68
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports3-es6.symbols
@@ -0,0 +1,131 @@
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+export var v = 1;
+>v : Symbol(v, Decl(t1.ts, 1, 10))
+
+export function f() { }
+>f : Symbol(f, Decl(t1.ts, 1, 17))
+
+export class C {
+>C : Symbol(C, Decl(t1.ts, 2, 23))
+}
+export interface I {
+>I : Symbol(I, Decl(t1.ts, 4, 1))
+}
+export enum E {
+>E : Symbol(E, Decl(t1.ts, 6, 1))
+
+    A, B, C
+>A : Symbol(E.A, Decl(t1.ts, 7, 15))
+>B : Symbol(E.B, Decl(t1.ts, 8, 6))
+>C : Symbol(E.C, Decl(t1.ts, 8, 9))
+}
+export const enum D {
+>D : Symbol(D, Decl(t1.ts, 9, 1))
+
+    A, B, C
+>A : Symbol(D.A, Decl(t1.ts, 10, 21))
+>B : Symbol(D.B, Decl(t1.ts, 11, 6))
+>C : Symbol(D.C, Decl(t1.ts, 11, 9))
+}
+export module M {
+>M : Symbol(M, Decl(t1.ts, 12, 1))
+
+    export var x;
+>x : Symbol(x, Decl(t1.ts, 14, 14))
+}
+export module N {
+>N : Symbol(N, Decl(t1.ts, 15, 1))
+
+    export interface I {
+>I : Symbol(I, Decl(t1.ts, 16, 17))
+    }
+}
+export type T = number;
+>T : Symbol(T, Decl(t1.ts, 19, 1))
+
+export import a = M.x;
+>a : Symbol(a, Decl(t1.ts, 20, 23))
+>M : Symbol(M, Decl(t1.ts, 12, 1))
+>x : Symbol(a, Decl(t1.ts, 14, 14))
+
+export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 };
+>v : Symbol(v1, Decl(t1.ts, 23, 8))
+>v1 : Symbol(v1, Decl(t1.ts, 23, 8))
+>f : Symbol(f1, Decl(t1.ts, 23, 17))
+>f1 : Symbol(f1, Decl(t1.ts, 23, 17))
+>C : Symbol(C1, Decl(t1.ts, 23, 26))
+>C1 : Symbol(C1, Decl(t1.ts, 23, 26))
+>I : Symbol(I1, Decl(t1.ts, 23, 35))
+>I1 : Symbol(I1, Decl(t1.ts, 23, 35))
+>E : Symbol(E1, Decl(t1.ts, 23, 44))
+>E1 : Symbol(E1, Decl(t1.ts, 23, 44))
+>D : Symbol(D1, Decl(t1.ts, 23, 53))
+>D1 : Symbol(D1, Decl(t1.ts, 23, 53))
+>M : Symbol(M1, Decl(t1.ts, 23, 62))
+>M1 : Symbol(M1, Decl(t1.ts, 23, 62))
+>N : Symbol(N1, Decl(t1.ts, 23, 71))
+>N1 : Symbol(N1, Decl(t1.ts, 23, 71))
+>T : Symbol(T1, Decl(t1.ts, 23, 80))
+>T1 : Symbol(T1, Decl(t1.ts, 23, 80))
+>a : Symbol(a1, Decl(t1.ts, 23, 89))
+>a1 : Symbol(a1, Decl(t1.ts, 23, 89))
+
+=== tests/cases/conformance/es6/modules/t2.ts ===
+export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+>v1 : Symbol(v, Decl(t2.ts, 0, 8))
+>v : Symbol(v, Decl(t2.ts, 0, 8))
+>f1 : Symbol(f, Decl(t2.ts, 0, 17))
+>f : Symbol(f, Decl(t2.ts, 0, 17))
+>C1 : Symbol(C, Decl(t2.ts, 0, 26))
+>C : Symbol(C, Decl(t2.ts, 0, 26))
+>I1 : Symbol(I, Decl(t2.ts, 0, 35))
+>I : Symbol(I, Decl(t2.ts, 0, 35))
+>E1 : Symbol(E, Decl(t2.ts, 0, 44))
+>E : Symbol(E, Decl(t2.ts, 0, 44))
+>D1 : Symbol(D, Decl(t2.ts, 0, 53))
+>D : Symbol(D, Decl(t2.ts, 0, 53))
+>M1 : Symbol(M, Decl(t2.ts, 0, 62))
+>M : Symbol(M, Decl(t2.ts, 0, 62))
+>N1 : Symbol(N, Decl(t2.ts, 0, 71))
+>N : Symbol(N, Decl(t2.ts, 0, 71))
+>T1 : Symbol(T, Decl(t2.ts, 0, 80))
+>T : Symbol(T, Decl(t2.ts, 0, 80))
+>a1 : Symbol(a, Decl(t2.ts, 0, 89))
+>a : Symbol(a, Decl(t2.ts, 0, 89))
+
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+>v1 : Symbol(v, Decl(t3.ts, 0, 8))
+>v : Symbol(v, Decl(t3.ts, 0, 8))
+>f1 : Symbol(f, Decl(t3.ts, 0, 17))
+>f : Symbol(f, Decl(t3.ts, 0, 17))
+>C1 : Symbol(C, Decl(t3.ts, 0, 26))
+>C : Symbol(C, Decl(t3.ts, 0, 26))
+>I1 : Symbol(I, Decl(t3.ts, 0, 35))
+>I : Symbol(I, Decl(t3.ts, 0, 35))
+>E1 : Symbol(E, Decl(t3.ts, 0, 44))
+>E : Symbol(E, Decl(t3.ts, 0, 44))
+>D1 : Symbol(D, Decl(t3.ts, 0, 53))
+>D : Symbol(D, Decl(t3.ts, 0, 53))
+>M1 : Symbol(M, Decl(t3.ts, 0, 62))
+>M : Symbol(M, Decl(t3.ts, 0, 62))
+>N1 : Symbol(N, Decl(t3.ts, 0, 71))
+>N : Symbol(N, Decl(t3.ts, 0, 71))
+>T1 : Symbol(T, Decl(t3.ts, 0, 80))
+>T : Symbol(T, Decl(t3.ts, 0, 80))
+>a1 : Symbol(a, Decl(t3.ts, 0, 89))
+>a : Symbol(a, Decl(t3.ts, 0, 89))
+
+export { v, f, C, I, E, D, M, N, T, a };
+>v : Symbol(v, Decl(t3.ts, 1, 8))
+>f : Symbol(f, Decl(t3.ts, 1, 11))
+>C : Symbol(C, Decl(t3.ts, 1, 14))
+>I : Symbol(I, Decl(t3.ts, 1, 17))
+>E : Symbol(E, Decl(t3.ts, 1, 20))
+>D : Symbol(D, Decl(t3.ts, 1, 23))
+>M : Symbol(M, Decl(t3.ts, 1, 26))
+>N : Symbol(N, Decl(t3.ts, 1, 29))
+>T : Symbol(T, Decl(t3.ts, 1, 32))
+>a : Symbol(a, Decl(t3.ts, 1, 35))
+
diff --git a/tests/baselines/reference/exportsAndImports3-es6.types b/tests/baselines/reference/exportsAndImports3-es6.types
new file mode 100644
index 00000000000..0b8235d969c
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports3-es6.types
@@ -0,0 +1,132 @@
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+export var v = 1;
+>v : number
+>1 : number
+
+export function f() { }
+>f : () => void
+
+export class C {
+>C : C
+}
+export interface I {
+>I : I
+}
+export enum E {
+>E : E
+
+    A, B, C
+>A : E
+>B : E
+>C : E
+}
+export const enum D {
+>D : D
+
+    A, B, C
+>A : D
+>B : D
+>C : D
+}
+export module M {
+>M : typeof M
+
+    export var x;
+>x : any
+}
+export module N {
+>N : any
+
+    export interface I {
+>I : I
+    }
+}
+export type T = number;
+>T : number
+
+export import a = M.x;
+>a : any
+>M : typeof M
+>x : any
+
+export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 };
+>v : number
+>v1 : number
+>f : () => void
+>f1 : () => void
+>C : typeof C
+>C1 : typeof C
+>I : any
+>I1 : any
+>E : typeof E
+>E1 : typeof E
+>D : typeof D
+>D1 : typeof D
+>M : typeof M
+>M1 : typeof M
+>N : any
+>N1 : any
+>T : any
+>T1 : any
+>a : any
+>a1 : any
+
+=== tests/cases/conformance/es6/modules/t2.ts ===
+export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+>v1 : number
+>v : number
+>f1 : () => void
+>f : () => void
+>C1 : typeof C
+>C : typeof C
+>I1 : any
+>I : any
+>E1 : typeof E
+>E : typeof E
+>D1 : typeof D
+>D : typeof D
+>M1 : typeof M
+>M : typeof M
+>N1 : any
+>N : any
+>T1 : any
+>T : any
+>a1 : any
+>a : any
+
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+>v1 : number
+>v : number
+>f1 : () => void
+>f : () => void
+>C1 : typeof C
+>C : typeof C
+>I1 : any
+>I : any
+>E1 : typeof E
+>E : typeof E
+>D1 : typeof D
+>D : typeof D
+>M1 : typeof M
+>M : typeof M
+>N1 : any
+>N : any
+>T1 : any
+>T : any
+>a1 : any
+>a : any
+
+export { v, f, C, I, E, D, M, N, T, a };
+>v : number
+>f : () => void
+>C : typeof C
+>I : any
+>E : typeof E
+>D : typeof D
+>M : typeof M
+>N : any
+>T : any
+>a : any
+
diff --git a/tests/baselines/reference/exportsAndImports4-es6.js b/tests/baselines/reference/exportsAndImports4-es6.js
new file mode 100644
index 00000000000..7cae0c01489
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports4-es6.js
@@ -0,0 +1,66 @@
+//// [tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts] ////
+
+//// [t1.ts]
+
+export default "hello";
+
+//// [t2.ts]
+import a = require("./t1");
+a.default;
+import b from "./t1";
+b;
+import * as c from "./t1";
+c.default;
+import { default as d } from "./t1";
+d;
+import e1, * as e2 from "./t1";
+e1;
+e2.default;
+import f1, { default as f2 } from "./t1";
+f1;
+f2;
+import "./t1";
+
+//// [t3.ts]
+import a = require("./t1");
+a.default;
+import b from "./t1";
+b;
+import * as c from "./t1";
+c.default;
+import { default as d } from "./t1";
+d;
+import e1, * as e2 from "./t1";
+e1;
+e2.default;
+import f1, { default as f2 } from "./t1";
+f1;
+f2;
+export { a, b, c, d, e1, e2, f1, f2 };
+
+
+//// [t1.js]
+exports.default = "hello";
+//// [t3.js]
+var a = require("./t1");
+exports.a = a;
+a.default;
+var t1_1 = require("./t1");
+exports.b = t1_1.default;
+t1_1.default;
+var c = require("./t1");
+exports.c = c;
+c.default;
+var t1_2 = require("./t1");
+exports.d = t1_2.default;
+t1_2.default;
+var t1_3 = require("./t1"), e2 = t1_3;
+exports.e1 = t1_3.default;
+exports.e2 = e2;
+t1_3.default;
+e2.default;
+var t1_4 = require("./t1");
+exports.f1 = t1_4.default;
+exports.f2 = t1_4.default;
+t1_4.default;
+t1_4.default;
diff --git a/tests/baselines/reference/exportsAndImports4-es6.symbols b/tests/baselines/reference/exportsAndImports4-es6.symbols
new file mode 100644
index 00000000000..0204d9bd586
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports4-es6.symbols
@@ -0,0 +1,68 @@
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import a = require("./t1");
+>a : Symbol(a, Decl(t3.ts, 0, 0))
+
+a.default;
+>a.default : Symbol(a.default, Decl(t1.ts, 0, 0))
+>a : Symbol(a, Decl(t3.ts, 0, 0))
+>default : Symbol(a.default, Decl(t1.ts, 0, 0))
+
+import b from "./t1";
+>b : Symbol(b, Decl(t3.ts, 2, 6))
+
+b;
+>b : Symbol(b, Decl(t3.ts, 2, 6))
+
+import * as c from "./t1";
+>c : Symbol(c, Decl(t3.ts, 4, 6))
+
+c.default;
+>c.default : Symbol(a.default, Decl(t1.ts, 0, 0))
+>c : Symbol(c, Decl(t3.ts, 4, 6))
+>default : Symbol(a.default, Decl(t1.ts, 0, 0))
+
+import { default as d } from "./t1";
+>default : Symbol(d, Decl(t3.ts, 6, 8))
+>d : Symbol(d, Decl(t3.ts, 6, 8))
+
+d;
+>d : Symbol(d, Decl(t3.ts, 6, 8))
+
+import e1, * as e2 from "./t1";
+>e1 : Symbol(e1, Decl(t3.ts, 8, 6))
+>e2 : Symbol(e2, Decl(t3.ts, 8, 10))
+
+e1;
+>e1 : Symbol(e1, Decl(t3.ts, 8, 6))
+
+e2.default;
+>e2.default : Symbol(a.default, Decl(t1.ts, 0, 0))
+>e2 : Symbol(e2, Decl(t3.ts, 8, 10))
+>default : Symbol(a.default, Decl(t1.ts, 0, 0))
+
+import f1, { default as f2 } from "./t1";
+>f1 : Symbol(f1, Decl(t3.ts, 11, 6))
+>default : Symbol(f2, Decl(t3.ts, 11, 12))
+>f2 : Symbol(f2, Decl(t3.ts, 11, 12))
+
+f1;
+>f1 : Symbol(f1, Decl(t3.ts, 11, 6))
+
+f2;
+>f2 : Symbol(f2, Decl(t3.ts, 11, 12))
+
+export { a, b, c, d, e1, e2, f1, f2 };
+>a : Symbol(a, Decl(t3.ts, 14, 8))
+>b : Symbol(b, Decl(t3.ts, 14, 11))
+>c : Symbol(c, Decl(t3.ts, 14, 14))
+>d : Symbol(d, Decl(t3.ts, 14, 17))
+>e1 : Symbol(e1, Decl(t3.ts, 14, 20))
+>e2 : Symbol(e2, Decl(t3.ts, 14, 24))
+>f1 : Symbol(f1, Decl(t3.ts, 14, 28))
+>f2 : Symbol(f2, Decl(t3.ts, 14, 32))
+
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+No type information for this code.export default "hello";
+No type information for this code.
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/exportsAndImports4-es6.types b/tests/baselines/reference/exportsAndImports4-es6.types
new file mode 100644
index 00000000000..4bd6f8c0e1e
--- /dev/null
+++ b/tests/baselines/reference/exportsAndImports4-es6.types
@@ -0,0 +1,68 @@
+=== tests/cases/conformance/es6/modules/t3.ts ===
+import a = require("./t1");
+>a : typeof a
+
+a.default;
+>a.default : string
+>a : typeof a
+>default : string
+
+import b from "./t1";
+>b : string
+
+b;
+>b : string
+
+import * as c from "./t1";
+>c : typeof a
+
+c.default;
+>c.default : string
+>c : typeof a
+>default : string
+
+import { default as d } from "./t1";
+>default : string
+>d : string
+
+d;
+>d : string
+
+import e1, * as e2 from "./t1";
+>e1 : string
+>e2 : typeof a
+
+e1;
+>e1 : string
+
+e2.default;
+>e2.default : string
+>e2 : typeof a
+>default : string
+
+import f1, { default as f2 } from "./t1";
+>f1 : string
+>default : string
+>f2 : string
+
+f1;
+>f1 : string
+
+f2;
+>f2 : string
+
+export { a, b, c, d, e1, e2, f1, f2 };
+>a : typeof a
+>b : string
+>c : typeof a
+>d : string
+>e1 : string
+>e2 : typeof a
+>f1 : string
+>f2 : string
+
+=== tests/cases/conformance/es6/modules/t1.ts ===
+
+No type information for this code.export default "hello";
+No type information for this code.
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/extendBooleanInterface.symbols b/tests/baselines/reference/extendBooleanInterface.symbols
index 8e123eb050e..be2fb30226d 100644
--- a/tests/baselines/reference/extendBooleanInterface.symbols
+++ b/tests/baselines/reference/extendBooleanInterface.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/primitives/boolean/extendBooleanInterface.ts ===
 interface Boolean {
->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11), Decl(extendBooleanInterface.ts, 0, 0))
+>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(extendBooleanInterface.ts, 0, 0))
 
     doStuff(): string;
 >doStuff : Symbol(doStuff, Decl(extendBooleanInterface.ts, 0, 19))
diff --git a/tests/baselines/reference/extendNumberInterface.symbols b/tests/baselines/reference/extendNumberInterface.symbols
index 56d2f8b0014..218f0f41cb2 100644
--- a/tests/baselines/reference/extendNumberInterface.symbols
+++ b/tests/baselines/reference/extendNumberInterface.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/primitives/number/extendNumberInterface.ts ===
 interface Number {
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(extendNumberInterface.ts, 0, 0))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(extendNumberInterface.ts, 0, 0))
 
     doStuff(): string;
 >doStuff : Symbol(doStuff, Decl(extendNumberInterface.ts, 0, 18))
diff --git a/tests/baselines/reference/extendStringInterface.symbols b/tests/baselines/reference/extendStringInterface.symbols
index a72773647a8..aa20b2e2c15 100644
--- a/tests/baselines/reference/extendStringInterface.symbols
+++ b/tests/baselines/reference/extendStringInterface.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/primitives/string/extendStringInterface.ts ===
 interface String {
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(extendStringInterface.ts, 0, 0))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(extendStringInterface.ts, 0, 0))
 
     doStuff(): string;
 >doStuff : Symbol(doStuff, Decl(extendStringInterface.ts, 0, 18))
diff --git a/tests/baselines/reference/externFunc.symbols b/tests/baselines/reference/externFunc.symbols
index 1a02596d7db..b23a70695cf 100644
--- a/tests/baselines/reference/externFunc.symbols
+++ b/tests/baselines/reference/externFunc.symbols
@@ -1,8 +1,8 @@
 === tests/cases/compiler/externFunc.ts ===
 declare function parseInt(s:string):number;
->parseInt : Symbol(parseInt, Decl(lib.d.ts, 28, 38), Decl(externFunc.ts, 0, 0))
+>parseInt : Symbol(parseInt, Decl(lib.d.ts, --, --), Decl(externFunc.ts, 0, 0))
 >s : Symbol(s, Decl(externFunc.ts, 0, 26))
 
 parseInt("2");
->parseInt : Symbol(parseInt, Decl(lib.d.ts, 28, 38), Decl(externFunc.ts, 0, 0))
+>parseInt : Symbol(parseInt, Decl(lib.d.ts, --, --), Decl(externFunc.ts, 0, 0))
 
diff --git a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
index 731e8558bab..ea0ed9a605c 100644
--- a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
+++ b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols
@@ -12,7 +12,7 @@ function fn(x = () => this, y = x()) {
 }
 
 fn.call(4); // Should be 4
->fn.call : Symbol(Function.call, Decl(lib.d.ts, 234, 45))
+>fn.call : Symbol(Function.call, Decl(lib.d.ts, --, --))
 >fn : Symbol(fn, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 0))
->call : Symbol(Function.call, Decl(lib.d.ts, 234, 45))
+>call : Symbol(Function.call, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols b/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols
index eff8999a0f7..97d485c4b56 100644
--- a/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols
+++ b/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols
@@ -2,7 +2,7 @@
 class A<T extends Object>{
 >A : Symbol(A, Decl(fillInMissingTypeArgsOnConstructCalls.ts, 0, 0))
 >T : Symbol(T, Decl(fillInMissingTypeArgsOnConstructCalls.ts, 0, 8))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
       list: T ;
 >list : Symbol(list, Decl(fillInMissingTypeArgsOnConstructCalls.ts, 0, 26))
diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols b/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols
index 998e59c0b8f..86f91c82663 100644
--- a/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols
+++ b/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols
@@ -18,9 +18,9 @@ f("", x => null, x => x.toLowerCase());
 >f : Symbol(f, Decl(fixingTypeParametersRepeatedly1.ts, 0, 0))
 >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 5))
 >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 16))
->x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 16))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
 // First overload of g should type check just like f
 declare function g<T>(x: T, y: (p: T) => T, z: (p: T) => T): T;
@@ -45,7 +45,7 @@ g("", x => null, x => x.toLowerCase());
 >g : Symbol(g, Decl(fixingTypeParametersRepeatedly1.ts, 1, 39), Decl(fixingTypeParametersRepeatedly1.ts, 4, 63))
 >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 5))
 >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 16))
->x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 16))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols
index 09a7e06cc21..bcfc3f981bd 100644
--- a/tests/baselines/reference/for-of13.symbols
+++ b/tests/baselines/reference/for-of13.symbols
@@ -4,6 +4,6 @@ var v: string;
 
 for (v of [""].values()) { }
 >v : Symbol(v, Decl(for-of13.ts, 0, 3))
->[""].values : Symbol(Array.values, Decl(lib.d.ts, 4146, 37))
->values : Symbol(Array.values, Decl(lib.d.ts, 4146, 37))
+>[""].values : Symbol(Array.values, Decl(lib.d.ts, --, --))
+>values : Symbol(Array.values, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols
index 76621026a00..34e11d3d388 100644
--- a/tests/baselines/reference/for-of18.symbols
+++ b/tests/baselines/reference/for-of18.symbols
@@ -22,9 +22,9 @@ class StringIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of18.ts, 1, 33))
diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols
index 35892922df3..81aafd32d13 100644
--- a/tests/baselines/reference/for-of19.symbols
+++ b/tests/baselines/reference/for-of19.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of19.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols
index f01969e23bb..727b69e3c9d 100644
--- a/tests/baselines/reference/for-of20.symbols
+++ b/tests/baselines/reference/for-of20.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of20.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols
index c740cf62446..1464a42aab2 100644
--- a/tests/baselines/reference/for-of21.symbols
+++ b/tests/baselines/reference/for-of21.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of21.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols
index bf4304a8216..1aac39dae6e 100644
--- a/tests/baselines/reference/for-of22.symbols
+++ b/tests/baselines/reference/for-of22.symbols
@@ -28,9 +28,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of22.ts, 5, 13))
diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols
index a45775127b0..f4f34fcef93 100644
--- a/tests/baselines/reference/for-of23.symbols
+++ b/tests/baselines/reference/for-of23.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of23.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols
index ef08deb568d..dfa358da0bd 100644
--- a/tests/baselines/reference/for-of25.symbols
+++ b/tests/baselines/reference/for-of25.symbols
@@ -10,9 +10,9 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 1, 37))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return x;
 >x : Symbol(x, Decl(for-of25.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols
index abaa0a92dcc..9f4d1455c3f 100644
--- a/tests/baselines/reference/for-of26.symbols
+++ b/tests/baselines/reference/for-of26.symbols
@@ -16,9 +16,9 @@ class StringIterator {
 >x : Symbol(x, Decl(for-of26.ts, 0, 3))
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of26.ts, 1, 37))
diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols
index 727574805b9..57148c53f13 100644
--- a/tests/baselines/reference/for-of27.symbols
+++ b/tests/baselines/reference/for-of27.symbols
@@ -7,7 +7,7 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 37))
 
     [Symbol.iterator]: any;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols
index 4e1bf8ad3dc..91081d3abdf 100644
--- a/tests/baselines/reference/for-of28.symbols
+++ b/tests/baselines/reference/for-of28.symbols
@@ -10,9 +10,9 @@ class StringIterator {
 >next : Symbol(next, Decl(for-of28.ts, 2, 22))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of28.ts, 0, 37))
diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols
index b0a39571f6f..b8ce9da9ce2 100644
--- a/tests/baselines/reference/for-of37.symbols
+++ b/tests/baselines/reference/for-of37.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of37.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of37.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (var v of map) {
 >v : Symbol(v, Decl(for-of37.ts, 1, 8))
diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols
index 67ee08bbb5f..18d2dda6db8 100644
--- a/tests/baselines/reference/for-of38.symbols
+++ b/tests/baselines/reference/for-of38.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of38.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of38.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (var [k, v] of map) {
 >k : Symbol(k, Decl(for-of38.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols
index 2f3a2a9a574..a9177d12435 100644
--- a/tests/baselines/reference/for-of40.symbols
+++ b/tests/baselines/reference/for-of40.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of40.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of40.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (var [k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of40.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of44.symbols b/tests/baselines/reference/for-of44.symbols
index 839de020702..d7057da0ee2 100644
--- a/tests/baselines/reference/for-of44.symbols
+++ b/tests/baselines/reference/for-of44.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of44.ts ===
 var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]]
 >array : Symbol(array, Decl(for-of44.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (var [num, strBoolSym] of array) {
 >num : Symbol(num, Decl(for-of44.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols
index 6f75dd6311d..7d8ffd4ba86 100644
--- a/tests/baselines/reference/for-of45.symbols
+++ b/tests/baselines/reference/for-of45.symbols
@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of45.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for ([k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of45.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of48.errors.txt b/tests/baselines/reference/for-of48.errors.txt
index f6826e14c61..8a8fd668714 100644
--- a/tests/baselines/reference/for-of48.errors.txt
+++ b/tests/baselines/reference/for-of48.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,12): error TS1005: ':' expected.
+tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,10): error TS2322: Type 'boolean' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/es6/for-ofStatements/for-of48.ts (1 errors) ====
@@ -6,8 +6,8 @@ tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,12): error TS1005: ':
     var array = [{ x: "", y: true }]
     enum E { x }
     for ({x, y = E.x} of array) {
-               ~
-!!! error TS1005: ':' expected.
+             ~
+!!! error TS2322: Type 'boolean' is not assignable to type 'number'.
         x;
         y;
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of48.js b/tests/baselines/reference/for-of48.js
index 2a5e4e32b94..65e23076fd9 100644
--- a/tests/baselines/reference/for-of48.js
+++ b/tests/baselines/reference/for-of48.js
@@ -14,7 +14,7 @@ var E;
 (function (E) {
     E[E["x"] = 0] = "x";
 })(E || (E = {}));
-for ({ x, y:  = E.x } of array) {
+for ({ x, y = E.x } of array) {
     x;
     y;
 }
diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols
index 7fb77790ef7..435390f2a6e 100644
--- a/tests/baselines/reference/for-of50.symbols
+++ b/tests/baselines/reference/for-of50.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of50.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of50.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (const [k, v] of map) {
 >k : Symbol(k, Decl(for-of50.ts, 1, 12))
diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols
index 9aadb415e8f..191377bdd47 100644
--- a/tests/baselines/reference/for-of57.symbols
+++ b/tests/baselines/reference/for-of57.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of57.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(for-of57.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 
 for (let num of iter) { }
 >num : Symbol(num, Decl(for-of57.ts, 1, 8))
diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols
index 6f7c6d6cdbe..e72d55e5813 100644
--- a/tests/baselines/reference/forStatements.symbols
+++ b/tests/baselines/reference/forStatements.symbols
@@ -51,9 +51,9 @@ module M {
     export function F2(x: number): string { return x.toString(); }
 >F2 : Symbol(F2, Decl(forStatements.ts, 19, 5))
 >x : Symbol(x, Decl(forStatements.ts, 21, 23))
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(forStatements.ts, 21, 23))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 for(var aNumber: number = 9.9;;){} 
@@ -64,13 +64,13 @@ for(var aString: string = 'this is a string';;){}
 
 for(var aDate: Date = new Date(12);;){}
 >aDate : Symbol(aDate, Decl(forStatements.ts, 26, 7))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for(var anObject: Object = new Object();;){}
 >anObject : Symbol(anObject, Decl(forStatements.ts, 27, 7))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for(var anAny: any = null;;){}
 >anAny : Symbol(anAny, Decl(forStatements.ts, 29, 7))
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
index 6a98fbf133e..1f131bb9701 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
@@ -102,7 +102,7 @@ for (var a: string[] = []; ;) { }
 
 for (var a = new Array<string>(); ;) { }
 >a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (var a: typeof a; ;) { }
 >a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
diff --git a/tests/baselines/reference/funcdecl.symbols b/tests/baselines/reference/funcdecl.symbols
index 2538e3a9a04..b91ec3814cf 100644
--- a/tests/baselines/reference/funcdecl.symbols
+++ b/tests/baselines/reference/funcdecl.symbols
@@ -40,7 +40,7 @@ function withMultiParams(a : number, b, c: Object) {
 >a : Symbol(a, Decl(funcdecl.ts, 19, 25))
 >b : Symbol(b, Decl(funcdecl.ts, 19, 36))
 >c : Symbol(c, Decl(funcdecl.ts, 19, 39))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     return a;
 >a : Symbol(a, Decl(funcdecl.ts, 19, 25))
diff --git a/tests/baselines/reference/functionConstraintSatisfaction.symbols b/tests/baselines/reference/functionConstraintSatisfaction.symbols
index eb71bb78e25..969ac928374 100644
--- a/tests/baselines/reference/functionConstraintSatisfaction.symbols
+++ b/tests/baselines/reference/functionConstraintSatisfaction.symbols
@@ -4,7 +4,7 @@
 function foo<T extends Function>(x: T): T { return x; }
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
 >T : Symbol(T, Decl(functionConstraintSatisfaction.ts, 2, 13))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 2, 33))
 >T : Symbol(T, Decl(functionConstraintSatisfaction.ts, 2, 13))
 >T : Symbol(T, Decl(functionConstraintSatisfaction.ts, 2, 13))
@@ -39,7 +39,7 @@ var c: { (): string; (x): string };
 var r = foo(new Function());
 >r : Symbol(r, Decl(functionConstraintSatisfaction.ts, 17, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r1 = foo((x) => x);
 >r1 : Symbol(r1, Decl(functionConstraintSatisfaction.ts, 18, 3))
@@ -154,7 +154,7 @@ var r11 = foo(<U extends Date>(x: U) => x);
 >r11 : Symbol(r11, Decl(functionConstraintSatisfaction.ts, 42, 3))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31))
 >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15))
 >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31))
@@ -192,7 +192,7 @@ var r16 = foo(c2);
 
 interface F2 extends Function { foo: string; }
 >F2 : Symbol(F2, Decl(functionConstraintSatisfaction.ts, 47, 18))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 49, 31))
 
 var f2: F2;
diff --git a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols
index cf504147346..4809c88d7fa 100644
--- a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols
+++ b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols
@@ -5,8 +5,8 @@ function foo(args: { (x): number }[]) {
 >x : Symbol(x, Decl(functionDeclarationWithArgumentOfTypeFunctionTypeArray.ts, 0, 22))
 
     return args.length;
->args.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>args.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >args : Symbol(args, Decl(functionDeclarationWithArgumentOfTypeFunctionTypeArray.ts, 0, 13))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 }
 
diff --git a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
index db66aa5618b..5211ee999bf 100644
--- a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
+++ b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols
@@ -6,7 +6,7 @@ class CDoc {
         function doSomething(a: Function) {
 >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23))
 >a : Symbol(a, Decl(functionExpressionAndLambdaMatchesFunction.ts, 2, 29))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
         }
         doSomething(() => undefined);
 >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23))
diff --git a/tests/baselines/reference/functionExpressionContextualTyping1.symbols b/tests/baselines/reference/functionExpressionContextualTyping1.symbols
index 6182e4bb9a8..736fa86b9ca 100644
--- a/tests/baselines/reference/functionExpressionContextualTyping1.symbols
+++ b/tests/baselines/reference/functionExpressionContextualTyping1.symbols
@@ -18,9 +18,9 @@ var a0: (n: number, s: string) => number = (num, str) => {
 >str : Symbol(str, Decl(functionExpressionContextualTyping1.ts, 8, 48))
 
     num.toExponential();
->num.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>num.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >num : Symbol(num, Decl(functionExpressionContextualTyping1.ts, 8, 44))
->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 
     return 0;
 }
@@ -37,7 +37,7 @@ var a1: (c: Class<Number>) => number = (a1) => {
 >a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 3))
 >c : Symbol(c, Decl(functionExpressionContextualTyping1.ts, 17, 9))
 >Class : Symbol(Class, Decl(functionExpressionContextualTyping1.ts, 11, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 40))
 
     a1.foo();
diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols
index f9205f37650..3932261b27c 100644
--- a/tests/baselines/reference/functionImplementations.symbols
+++ b/tests/baselines/reference/functionImplementations.symbols
@@ -279,9 +279,9 @@ var f7: (x: number) => string | number = x => { // should be (x: number) => numb
 >x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
 
     return x.toString();
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 var f8: (x: number) => any = x => { // should be (x: number) => Base
 >f8 : Symbol(f8, Decl(functionImplementations.ts, 134, 3))
diff --git a/tests/baselines/reference/functionOnlyHasThrow.symbols b/tests/baselines/reference/functionOnlyHasThrow.symbols
index fc8d60a58be..43846067381 100644
--- a/tests/baselines/reference/functionOnlyHasThrow.symbols
+++ b/tests/baselines/reference/functionOnlyHasThrow.symbols
@@ -3,5 +3,5 @@ function clone():number {
 >clone : Symbol(clone, Decl(functionOnlyHasThrow.ts, 0, 0))
 
 	throw new Error("To be implemented");
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols b/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols
index 93a56c86035..0dda3ba81a8 100644
--- a/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols
+++ b/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols
@@ -16,5 +16,5 @@ interface I {
 >U : Symbol(U, Decl(functionOverloadsOnGenericArity2.ts, 3, 9))
 >T : Symbol(T, Decl(functionOverloadsOnGenericArity2.ts, 3, 11))
 >p : Symbol(p, Decl(functionOverloadsOnGenericArity2.ts, 3, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs.symbols b/tests/baselines/reference/functionSubtypingOfVarArgs.symbols
index 334766dc10c..3aa266ec030 100644
--- a/tests/baselines/reference/functionSubtypingOfVarArgs.symbols
+++ b/tests/baselines/reference/functionSubtypingOfVarArgs.symbols
@@ -11,11 +11,11 @@ class EventBase {
 >args : Symbol(args, Decl(functionSubtypingOfVarArgs.ts, 3, 19))
 
         this._listeners.push(listener);
->this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >this._listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs.ts, 0, 17))
 >this : Symbol(EventBase, Decl(functionSubtypingOfVarArgs.ts, 0, 0))
 >_listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs.ts, 0, 17))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >listener : Symbol(listener, Decl(functionSubtypingOfVarArgs.ts, 3, 8))
     }
 }
diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols b/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols
index 227264f9617..c2f77199e28 100644
--- a/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols
+++ b/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols
@@ -12,11 +12,11 @@ class EventBase {
 >args : Symbol(args, Decl(functionSubtypingOfVarArgs2.ts, 3, 19))
 
         this._listeners.push(listener);
->this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >this._listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs2.ts, 0, 17))
 >this : Symbol(EventBase, Decl(functionSubtypingOfVarArgs2.ts, 0, 0))
 >_listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs2.ts, 0, 17))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >listener : Symbol(listener, Decl(functionSubtypingOfVarArgs2.ts, 3, 8))
     }
 }
diff --git a/tests/baselines/reference/functionType.symbols b/tests/baselines/reference/functionType.symbols
index f972b6fc8a1..30a5a7cc447 100644
--- a/tests/baselines/reference/functionType.symbols
+++ b/tests/baselines/reference/functionType.symbols
@@ -3,12 +3,12 @@ function salt() {}
 >salt : Symbol(salt, Decl(functionType.ts, 0, 0))
 
 salt.apply("hello", []);
->salt.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>salt.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >salt : Symbol(salt, Decl(functionType.ts, 0, 0))
->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 
 (new Function("return 5"))();
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
  
  
 
diff --git a/tests/baselines/reference/functionsInClassExpressions.js b/tests/baselines/reference/functionsInClassExpressions.js
new file mode 100644
index 00000000000..debd8138831
--- /dev/null
+++ b/tests/baselines/reference/functionsInClassExpressions.js
@@ -0,0 +1,25 @@
+//// [functionsInClassExpressions.ts]
+let Foo = class {
+    constructor() {
+        this.bar++;
+    }
+    bar = 0;
+    inc = () => {
+        this.bar++;
+    }
+    m() { return this.bar; }
+}
+
+//// [functionsInClassExpressions.js]
+var Foo = (function () {
+    function class_1() {
+        var _this = this;
+        this.bar = 0;
+        this.inc = function () {
+            _this.bar++;
+        };
+        this.bar++;
+    }
+    class_1.prototype.m = function () { return this.bar; };
+    return class_1;
+})();
diff --git a/tests/baselines/reference/functionsInClassExpressions.symbols b/tests/baselines/reference/functionsInClassExpressions.symbols
new file mode 100644
index 00000000000..a1da3a3175c
--- /dev/null
+++ b/tests/baselines/reference/functionsInClassExpressions.symbols
@@ -0,0 +1,27 @@
+=== tests/cases/compiler/functionsInClassExpressions.ts ===
+let Foo = class {
+>Foo : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 3))
+
+    constructor() {
+        this.bar++;
+>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
+>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+    }
+    bar = 0;
+>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+
+    inc = () => {
+>inc : Symbol((Anonymous class).inc, Decl(functionsInClassExpressions.ts, 4, 12))
+
+        this.bar++;
+>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
+>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+    }
+    m() { return this.bar; }
+>m : Symbol((Anonymous class).m, Decl(functionsInClassExpressions.ts, 7, 5))
+>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9))
+>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5))
+}
diff --git a/tests/baselines/reference/functionsInClassExpressions.types b/tests/baselines/reference/functionsInClassExpressions.types
new file mode 100644
index 00000000000..ee4b5696cc1
--- /dev/null
+++ b/tests/baselines/reference/functionsInClassExpressions.types
@@ -0,0 +1,32 @@
+=== tests/cases/compiler/functionsInClassExpressions.ts ===
+let Foo = class {
+>Foo : typeof (Anonymous class)
+>class {    constructor() {        this.bar++;    }    bar = 0;    inc = () => {        this.bar++;    }    m() { return this.bar; }} : typeof (Anonymous class)
+
+    constructor() {
+        this.bar++;
+>this.bar++ : number
+>this.bar : number
+>this : this
+>bar : number
+    }
+    bar = 0;
+>bar : number
+>0 : number
+
+    inc = () => {
+>inc : () => void
+>() => {        this.bar++;    } : () => void
+
+        this.bar++;
+>this.bar++ : number
+>this.bar : number
+>this : this
+>bar : number
+    }
+    m() { return this.bar; }
+>m : () => number
+>this.bar : number
+>this : this
+>bar : number
+}
diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols
index 287b7be66d0..df0bb33e02f 100644
--- a/tests/baselines/reference/generatedContextualTyping.symbols
+++ b/tests/baselines/reference/generatedContextualTyping.symbols
@@ -74,7 +74,7 @@ var x7: Base[] = [d1, d2];
 
 var x8: Array<Base> = [d1, d2];
 >x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 12, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -165,7 +165,7 @@ class x19 { member: Base[] = [d1, d2] }
 class x20 { member: Array<Base> = [d1, d2] }
 >x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 23, 39))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 24, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -260,7 +260,7 @@ class x31 { private member: Base[] = [d1, d2] }
 class x32 { private member: Array<Base> = [d1, d2] }
 >x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 35, 47))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 36, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -355,7 +355,7 @@ class x43 { public member: Base[] = [d1, d2] }
 class x44 { public member: Array<Base> = [d1, d2] }
 >x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 47, 46))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 48, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -450,7 +450,7 @@ class x55 { static member: Base[] = [d1, d2] }
 class x56 { static member: Array<Base> = [d1, d2] }
 >x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 59, 46))
 >member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 60, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -545,7 +545,7 @@ class x67 { private static member: Base[] = [d1, d2] }
 class x68 { private static member: Array<Base> = [d1, d2] }
 >x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 71, 54))
 >member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 72, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -640,7 +640,7 @@ class x79 { public static member: Base[] = [d1, d2] }
 class x80 { public static member: Array<Base> = [d1, d2] }
 >x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 83, 53))
 >member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 84, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -735,7 +735,7 @@ class x91 { constructor(parm: Base[] = [d1, d2]) { } }
 class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
 >x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 95, 54))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -830,7 +830,7 @@ class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
 class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
 >x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 107, 62))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 108, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -925,7 +925,7 @@ class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
 class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
 >x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 119, 63))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 120, 25))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1020,7 +1020,7 @@ function x127(parm: Base[] = [d1, d2]) { }
 function x128(parm: Array<Base> = [d1, d2]) { }
 >x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 131, 42))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1107,7 +1107,7 @@ function x139(): Base[] { return [d1, d2]; }
 
 function x140(): Array<Base> { return [d1, d2]; }
 >x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 143, 44))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1206,7 +1206,7 @@ function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
 
 function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
 >x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 155, 61))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1303,7 +1303,7 @@ var x163: () => Base[] = () => { return [d1, d2]; };
 
 var x164: () => Array<Base> = () => { return [d1, d2]; };
 >x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1386,7 +1386,7 @@ var x175: () => Base[] = function() { return [d1, d2]; };
 
 var x176: () => Array<Base> = function() { return [d1, d2]; };
 >x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1477,7 +1477,7 @@ module x187 { var t: Base[] = [d1, d2]; }
 module x188 { var t: Array<Base> = [d1, d2]; }
 >x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 191, 41))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1572,7 +1572,7 @@ module x199 { export var t: Base[] = [d1, d2]; }
 module x200 { export var t: Array<Base> = [d1, d2]; }
 >x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 203, 48))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1647,7 +1647,7 @@ var x211 = <Base[]>[d1, d2];
 
 var x212 = <Array<Base>>[d1, d2];
 >x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 214, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -1715,7 +1715,7 @@ var x221 = (<Base[]>undefined) || [d1, d2];
 
 var x222 = (<Array<Base>>undefined) || [d1, d2];
 >x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 223, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
@@ -1791,7 +1791,7 @@ var x231: Base[]; x231 = [d1, d2];
 
 var x232: Array<Base>; x232 = [d1, d2];
 >x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
@@ -1894,7 +1894,7 @@ var x243: { n: Base[]; } = { n: [d1, d2] };
 var x244: { n: Array<Base>; } = { n: [d1, d2] };
 >x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 245, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 33))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
@@ -1967,7 +1967,7 @@ var x255: Base[][] = [[d1, d2]];
 
 var x256: Array<Base>[] = [[d1, d2]];
 >x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 254, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2035,7 +2035,7 @@ var x265: Base[] = [d1, d2] || undefined;
 
 var x266: Array<Base> = [d1, d2] || undefined;
 >x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 263, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2097,7 +2097,7 @@ var x273: Base[] = undefined || [d1, d2];
 
 var x274: Array<Base> = undefined || [d1, d2];
 >x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 271, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
@@ -2166,7 +2166,7 @@ var x281: Base[] = [d1, d2] || [d1, d2];
 
 var x282: Array<Base> = [d1, d2] || [d1, d2];
 >x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 279, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2255,7 +2255,7 @@ var x291: Base[] = true ? [d1, d2] : [d1, d2];
 
 var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
 >x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 289, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2359,7 +2359,7 @@ var x303: Base[] = true ? undefined : [d1, d2];
 
 var x304: Array<Base> = true ? undefined : [d1, d2];
 >x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 301, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
@@ -2454,7 +2454,7 @@ var x315: Base[] = true ? [d1, d2] : undefined;
 
 var x316: Array<Base> = true ? [d1, d2] : undefined;
 >x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 313, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
 >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
@@ -2557,7 +2557,7 @@ function x327(n: Base[]) { }; x327([d1, d2]);
 function x328(n: Array<Base>) { }; x328([d1, d2]);
 >x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
@@ -2671,7 +2671,7 @@ var x339 = (n: Base[]) => n; x339([d1, d2]);
 var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 >x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
 >x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3))
@@ -2783,7 +2783,7 @@ var x351 = function(n: Base[]) { }; x351([d1, d2]);
 var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 >x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3))
 >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
diff --git a/tests/baselines/reference/generatorES6_6.symbols b/tests/baselines/reference/generatorES6_6.symbols
index f424048eeec..96b8b861c8b 100644
--- a/tests/baselines/reference/generatorES6_6.symbols
+++ b/tests/baselines/reference/generatorES6_6.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(generatorES6_6.ts, 0, 0))
 
   *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
     let a = yield 1;
 >a : Symbol(a, Decl(generatorES6_6.ts, 2, 7))
diff --git a/tests/baselines/reference/generatorOverloads4.symbols b/tests/baselines/reference/generatorOverloads4.symbols
index 233af97ee59..341ba9c4a0d 100644
--- a/tests/baselines/reference/generatorOverloads4.symbols
+++ b/tests/baselines/reference/generatorOverloads4.symbols
@@ -5,15 +5,15 @@ class C {
     f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 1, 6))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 
     f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 2, 6))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 
     *f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 3, 7))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/generatorOverloads5.symbols b/tests/baselines/reference/generatorOverloads5.symbols
index e3b14d76cd0..07de0c87f51 100644
--- a/tests/baselines/reference/generatorOverloads5.symbols
+++ b/tests/baselines/reference/generatorOverloads5.symbols
@@ -5,15 +5,15 @@ module M {
     function f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 1, 15))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 
     function f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 2, 15))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 
     function* f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 3, 16))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/generatorTypeCheck1.symbols b/tests/baselines/reference/generatorTypeCheck1.symbols
index 3353182c7db..b9456ccba48 100644
--- a/tests/baselines/reference/generatorTypeCheck1.symbols
+++ b/tests/baselines/reference/generatorTypeCheck1.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
 function* g1(): Iterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/generatorTypeCheck10.symbols b/tests/baselines/reference/generatorTypeCheck10.symbols
index 9dc3d726f8d..2112a9b1ebc 100644
--- a/tests/baselines/reference/generatorTypeCheck10.symbols
+++ b/tests/baselines/reference/generatorTypeCheck10.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts ===
 function* g(): IterableIterator<any> {
 >g : Symbol(g, Decl(generatorTypeCheck10.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 
     return;
 }
diff --git a/tests/baselines/reference/generatorTypeCheck11.symbols b/tests/baselines/reference/generatorTypeCheck11.symbols
index fabd19cd199..439b97caa7f 100644
--- a/tests/baselines/reference/generatorTypeCheck11.symbols
+++ b/tests/baselines/reference/generatorTypeCheck11.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 
     return 0;
 }
diff --git a/tests/baselines/reference/generatorTypeCheck12.symbols b/tests/baselines/reference/generatorTypeCheck12.symbols
index 4fe733933bb..1c7661a06cf 100644
--- a/tests/baselines/reference/generatorTypeCheck12.symbols
+++ b/tests/baselines/reference/generatorTypeCheck12.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 
     return "";
 }
diff --git a/tests/baselines/reference/generatorTypeCheck13.symbols b/tests/baselines/reference/generatorTypeCheck13.symbols
index 8a720da6ee5..7d9587e5ac9 100644
--- a/tests/baselines/reference/generatorTypeCheck13.symbols
+++ b/tests/baselines/reference/generatorTypeCheck13.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 
     yield 0;
     return "";
diff --git a/tests/baselines/reference/generatorTypeCheck17.symbols b/tests/baselines/reference/generatorTypeCheck17.symbols
index 28c4bb60055..523579dd47b 100644
--- a/tests/baselines/reference/generatorTypeCheck17.symbols
+++ b/tests/baselines/reference/generatorTypeCheck17.symbols
@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck17.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck19.symbols b/tests/baselines/reference/generatorTypeCheck19.symbols
index 0c6bbbb462e..b74b5f727a6 100644
--- a/tests/baselines/reference/generatorTypeCheck19.symbols
+++ b/tests/baselines/reference/generatorTypeCheck19.symbols
@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck19.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck2.symbols b/tests/baselines/reference/generatorTypeCheck2.symbols
index 99d9a0f0505..5741e089d1b 100644
--- a/tests/baselines/reference/generatorTypeCheck2.symbols
+++ b/tests/baselines/reference/generatorTypeCheck2.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts ===
 function* g1(): Iterable<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck2.ts, 0, 0))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols
index f2c13cf6199..2f2c27d2810 100644
--- a/tests/baselines/reference/generatorTypeCheck26.symbols
+++ b/tests/baselines/reference/generatorTypeCheck26.symbols
@@ -1,20 +1,20 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33))
 
     yield x => x.length;
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     yield *[x => x.length];
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     return x => x.length;
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10))
diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols
index e05147aa4b5..27c5cbf5db8 100644
--- a/tests/baselines/reference/generatorTypeCheck27.symbols
+++ b/tests/baselines/reference/generatorTypeCheck27.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck27.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33))
 
     yield * function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols
index b157d464292..a7e799679d7 100644
--- a/tests/baselines/reference/generatorTypeCheck28.symbols
+++ b/tests/baselines/reference/generatorTypeCheck28.symbols
@@ -1,20 +1,20 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck28.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33))
 
     yield * {
         *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
             yield x => x.length;
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
         }
     };
 }
diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols
index 54a5cc0fdb6..4b332f6c86b 100644
--- a/tests/baselines/reference/generatorTypeCheck29.symbols
+++ b/tests/baselines/reference/generatorTypeCheck29.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
 
     yield function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck3.symbols b/tests/baselines/reference/generatorTypeCheck3.symbols
index 5fdef53c6f3..6e97cd6f280 100644
--- a/tests/baselines/reference/generatorTypeCheck3.symbols
+++ b/tests/baselines/reference/generatorTypeCheck3.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts ===
 function* g1(): IterableIterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck3.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols
index d107c4bde19..3c56fde9039 100644
--- a/tests/baselines/reference/generatorTypeCheck30.symbols
+++ b/tests/baselines/reference/generatorTypeCheck30.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
 
     yield function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols
index bb24ffb1eb6..a637f154dc4 100644
--- a/tests/baselines/reference/generatorTypeCheck45.symbols
+++ b/tests/baselines/reference/generatorTypeCheck45.symbols
@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))
@@ -19,9 +19,9 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
 >foo : Symbol(foo, Decl(generatorTypeCheck45.ts, 0, 0))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(generatorTypeCheck45.ts, 2, 45))
 >undefined : Symbol(undefined)
 
diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols
index a6dd01be70f..abb170b12a7 100644
--- a/tests/baselines/reference/generatorTypeCheck46.symbols
+++ b/tests/baselines/reference/generatorTypeCheck46.symbols
@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck46.ts, 0, 32))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23))
@@ -21,15 +21,15 @@ foo("", function* () {
 
     yield* {
         *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
             yield x => x.length
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
         }
     }
 }, p => undefined); // T is fixed, should be string
diff --git a/tests/baselines/reference/genericArray1.symbols b/tests/baselines/reference/genericArray1.symbols
index b403bd2b720..b73872b8d55 100644
--- a/tests/baselines/reference/genericArray1.symbols
+++ b/tests/baselines/reference/genericArray1.symbols
@@ -13,10 +13,10 @@ interface String{
 
 var lengths = ["a", "b", "c"].map(x => x.length);
 >lengths : Symbol(lengths, Decl(genericArray1.ts, 12, 3))
->["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericArray1.ts, 12, 34))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols b/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols
index 49ccf7ad595..e7a52c5e264 100644
--- a/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols
+++ b/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols
@@ -40,5 +40,5 @@ var r5 = foo<any[]>([1, '']); // any[]
 var r6 = foo<Object[]>([1, '']); // Object[]
 >r6 : Symbol(r6, Decl(genericCallWithArrayLiteralArgs.ts, 11, 3))
 >foo : Symbol(foo, Decl(genericCallWithArrayLiteralArgs.ts, 0, 0))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols
index 14a91401efb..3824029dfec 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols
@@ -16,11 +16,11 @@ var a: {
 
     [x: string]: Object;
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 7, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: number]: Date;
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 8, 5))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 };
 var r = foo(a);
@@ -31,7 +31,7 @@ var r = foo(a);
 function other<T extends Date>(arg: T) {
 >other : Symbol(other, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 10, 15))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 31))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 15))
 
@@ -40,7 +40,7 @@ function other<T extends Date>(arg: T) {
 
         [x: string]: Object;
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 14, 9))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         [x: number]: T
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 15, 9))
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols
index 77787e77299..4e7622d3d81 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols
@@ -14,7 +14,7 @@ function foo<T>(x: T) {
 var a: { [x: number]: Date };
 >a : Symbol(a, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 6, 3))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 6, 10))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r = foo(a);
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 7, 3))
@@ -41,7 +41,7 @@ function other<T>(arg: T) {
 function other2<T extends Date>(arg: T) {
 >other2 : Symbol(other2, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 12, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 16))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 32))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 16))
 
@@ -63,9 +63,9 @@ function other2<T extends Date>(arg: T) {
 function other3<T extends Date, U extends Date>(arg: T) {
 >other3 : Symbol(other3, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 18, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 16))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 31))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 48))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 16))
 
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols
index 62b7c82b8e3..932cedf148e 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols
@@ -14,7 +14,7 @@ function foo<T>(x: T) {
 var a: { [x: string]: Date };
 >a : Symbol(a, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 6, 3))
 >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 6, 10))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r = foo(a);
 >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 7, 3))
@@ -41,7 +41,7 @@ function other<T>(arg: T) {
 function other2<T extends Date>(arg: T) {
 >other2 : Symbol(other2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 12, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 16))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 32))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 16))
 
@@ -57,16 +57,16 @@ function other2<T extends Date>(arg: T) {
 
     var d: Date = r2['hm']; // ok
 >d : Symbol(d, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 17, 7))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 16, 7))
 }
 
 function other3<T extends Date, U extends Date>(arg: T) {
 >other3 : Symbol(other3, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 18, 1))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 16))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 31))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 48))
 >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 16))
 
@@ -82,7 +82,7 @@ function other3<T extends Date, U extends Date>(arg: T) {
 
     var d: Date = r2['hm']; // ok
 >d : Symbol(d, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 23, 7))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 22, 7))
 
     // BUG 821629
diff --git a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols
index 3ce4f709b7d..68df4a89b36 100644
--- a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols
+++ b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols
@@ -11,7 +11,7 @@ declare module EndGate {
 }
 
 interface Number extends EndGate.ICloneable { }
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 4, 1))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 4, 1))
 >EndGate.ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes.ts, 0, 24))
 >EndGate : Symbol(EndGate, Decl(genericConstraintOnExtendedBuiltinTypes.ts, 0, 0), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 6, 47), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 17, 1))
 >ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes.ts, 0, 24))
diff --git a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols
index be96d92c357..c5e9f0a79f5 100644
--- a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols
+++ b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols
@@ -11,7 +11,7 @@ module EndGate {
 }
 
 interface Number extends EndGate.ICloneable { }
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1))
 >EndGate.ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 0, 16))
 >EndGate : Symbol(EndGate, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 0, 0), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 6, 47), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 16, 1))
 >ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 0, 16))
@@ -51,7 +51,7 @@ module EndGate.Tweening {
     export class NumberTween extends Tween<Number>{
 >NumberTween : Symbol(NumberTween, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 18, 25))
 >Tween : Symbol(Tween, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 8, 25))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1))
 
         constructor(from: number) {
 >from : Symbol(from, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 20, 20))
diff --git a/tests/baselines/reference/genericContextualTypingSpecialization.symbols b/tests/baselines/reference/genericContextualTypingSpecialization.symbols
index 05312d889c9..b244ab496be 100644
--- a/tests/baselines/reference/genericContextualTypingSpecialization.symbols
+++ b/tests/baselines/reference/genericContextualTypingSpecialization.symbols
@@ -3,9 +3,9 @@ var b: number[];
 >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3))
 
 b.reduce<number>((c, d) => c + d, 0); // should not error on '+'
->b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))
 >d : Symbol(d, Decl(genericContextualTypingSpecialization.ts, 1, 20))
 >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18))
diff --git a/tests/baselines/reference/genericFunctionSpecializations1.symbols b/tests/baselines/reference/genericFunctionSpecializations1.symbols
index e3c21ea418b..aaf607cbd47 100644
--- a/tests/baselines/reference/genericFunctionSpecializations1.symbols
+++ b/tests/baselines/reference/genericFunctionSpecializations1.symbols
@@ -18,7 +18,7 @@ function foo4<T>(test: string); // valid
 function foo4<T extends String>(test: T) { }
 >foo4 : Symbol(foo4, Decl(genericFunctionSpecializations1.ts, 1, 29), Decl(genericFunctionSpecializations1.ts, 3, 31))
 >T : Symbol(T, Decl(genericFunctionSpecializations1.ts, 4, 14))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >test : Symbol(test, Decl(genericFunctionSpecializations1.ts, 4, 32))
 >T : Symbol(T, Decl(genericFunctionSpecializations1.ts, 4, 14))
 
diff --git a/tests/baselines/reference/genericFunctions2.symbols b/tests/baselines/reference/genericFunctions2.symbols
index 59068cbd8dd..246f59c8e8a 100644
--- a/tests/baselines/reference/genericFunctions2.symbols
+++ b/tests/baselines/reference/genericFunctions2.symbols
@@ -19,8 +19,8 @@ var lengths = map(myItems, x => x.length);
 >map : Symbol(map, Decl(genericFunctions2.ts, 0, 0))
 >myItems : Symbol(myItems, Decl(genericFunctions2.ts, 2, 3))
 >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
 
diff --git a/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols b/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols
index fa04763f2ab..fd79d736ffd 100644
--- a/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols
+++ b/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols
@@ -7,7 +7,7 @@ interface Utils {
 >T : Symbol(T, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 8))
 >S : Symbol(S, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 10))
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 8))
 >folder : Symbol(folder, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 27))
 >s : Symbol(s, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 38))
diff --git a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
index 2fe7e295a0d..d033f7b66bb 100644
--- a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
+++ b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols
@@ -63,7 +63,7 @@ var r3 = utils.mapReduce(c, (x) => { return 1 }, (y) => { return new Date() });
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 29))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 50))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return new Date() });
 >r4 : Symbol(r4, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 3))
@@ -73,7 +73,7 @@ var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return
 >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3))
 >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 29))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 58))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f1 = (x: string) => { return 1 };
 >f1 : Symbol(f1, Decl(genericFunctionsWithOptionalParameters3.ts, 11, 3))
@@ -82,7 +82,7 @@ var f1 = (x: string) => { return 1 };
 var f2 = (y: number) => { return new Date() };
 >f2 : Symbol(f2, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 3))
 >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 10))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r5 = utils.mapReduce(c, f1, f2);
 >r5 : Symbol(r5, Decl(genericFunctionsWithOptionalParameters3.ts, 13, 3))
diff --git a/tests/baselines/reference/genericInference1.symbols b/tests/baselines/reference/genericInference1.symbols
index 6980668c6eb..8beecf27254 100644
--- a/tests/baselines/reference/genericInference1.symbols
+++ b/tests/baselines/reference/genericInference1.symbols
@@ -1,9 +1,9 @@
 === tests/cases/compiler/genericInference1.ts ===
 ['a', 'b', 'c'].map(x => x.length);
->['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(genericInference1.ts, 0, 20))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/genericInference2.symbols b/tests/baselines/reference/genericInference2.symbols
index 83b371005f7..52b80747cb9 100644
--- a/tests/baselines/reference/genericInference2.symbols
+++ b/tests/baselines/reference/genericInference2.symbols
@@ -49,11 +49,11 @@
     }; 
     var x_v = o.name().length;  // should be 'number'
 >x_v : Symbol(x_v, Decl(genericInference2.ts, 14, 7))
->o.name().length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>o.name().length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >o.name : Symbol(name, Decl(genericInference2.ts, 10, 13))
 >o : Symbol(o, Decl(genericInference2.ts, 10, 7))
 >name : Symbol(name, Decl(genericInference2.ts, 10, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     var age_v = o.age();  // should be 'number'
 >age_v : Symbol(age_v, Decl(genericInference2.ts, 15, 7))
diff --git a/tests/baselines/reference/genericMethodOverspecialization.symbols b/tests/baselines/reference/genericMethodOverspecialization.symbols
index 651aced0fcd..808addf068c 100644
--- a/tests/baselines/reference/genericMethodOverspecialization.symbols
+++ b/tests/baselines/reference/genericMethodOverspecialization.symbols
@@ -27,9 +27,9 @@ interface Document {
 
 var elements = names.map(function (name) {
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->names.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>names.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >names : Symbol(names, Decl(genericMethodOverspecialization.ts, 0, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >name : Symbol(name, Decl(genericMethodOverspecialization.ts, 12, 35))
 
     return document.getElementById(name);
@@ -43,9 +43,9 @@ var elements = names.map(function (name) {
 
 var xxx = elements.filter(function (e) {
 >xxx : Symbol(xxx, Decl(genericMethodOverspecialization.ts, 17, 3))
->elements.filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87))
+>elements.filter : Symbol(Array.filter, Decl(lib.d.ts, --, --))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87))
+>filter : Symbol(Array.filter, Decl(lib.d.ts, --, --))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 17, 36))
 
     return !e.isDisabled;
@@ -57,9 +57,9 @@ var xxx = elements.filter(function (e) {
 
 var widths:number[] = elements.map(function (e) { // should not error
 >widths : Symbol(widths, Decl(genericMethodOverspecialization.ts, 21, 3))
->elements.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>elements.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 21, 45))
 
     return e.clientWidth;
diff --git a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
index 056b4ce96ab..cd558fdd10a 100644
--- a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
+++ b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols
@@ -24,9 +24,9 @@ function compose<A, B, C>(f: (b: B) => C, g: (a:A) => B): (a:A) => C {
 
         return f(g.apply(null, a));
 >f : Symbol(f, Decl(genericTypeParameterEquivalence2.ts, 1, 26))
->g.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>g.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >g : Symbol(g, Decl(genericTypeParameterEquivalence2.ts, 1, 41))
->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(genericTypeParameterEquivalence2.ts, 2, 21))
 
     };
@@ -46,9 +46,9 @@ function forEach<A>(list: A[], f: (a: A, n?: number) => void ): void {
     for (var i = 0; i < list.length; ++i) {
 >i : Symbol(i, Decl(genericTypeParameterEquivalence2.ts, 9, 12))
 >i : Symbol(i, Decl(genericTypeParameterEquivalence2.ts, 9, 12))
->list.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>list.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >list : Symbol(list, Decl(genericTypeParameterEquivalence2.ts, 8, 20))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(genericTypeParameterEquivalence2.ts, 9, 12))
 
         f(list[i], i);
@@ -83,9 +83,9 @@ function filter<A>(f: (a: A) => boolean, ar: A[]): A[] {
 >el : Symbol(el, Decl(genericTypeParameterEquivalence2.ts, 17, 17))
 
             ret.push(el);
->ret.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>ret.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >ret : Symbol(ret, Decl(genericTypeParameterEquivalence2.ts, 16, 7))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >el : Symbol(el, Decl(genericTypeParameterEquivalence2.ts, 17, 17))
         }
     } );
@@ -102,9 +102,9 @@ function length2<A>(ar: A[]): number {
 >A : Symbol(A, Decl(genericTypeParameterEquivalence2.ts, 27, 17))
 
     return ar.length;
->ar.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>ar.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >ar : Symbol(ar, Decl(genericTypeParameterEquivalence2.ts, 27, 20))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 }
 
 // curry1 :: ((a,b)->c) -> (a->(b->c))
diff --git a/tests/baselines/reference/getterSetterNonAccessor.symbols b/tests/baselines/reference/getterSetterNonAccessor.symbols
index 10ffc55480c..f10542c0a0c 100644
--- a/tests/baselines/reference/getterSetterNonAccessor.symbols
+++ b/tests/baselines/reference/getterSetterNonAccessor.symbols
@@ -7,10 +7,10 @@ function setFunc(v){}
 >v : Symbol(v, Decl(getterSetterNonAccessor.ts, 1, 17))
 
 Object.defineProperty({}, "0", <PropertyDescriptor>({
->Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
+>Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --))
+>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --))
 
           get: getFunc,
 >get : Symbol(get, Decl(getterSetterNonAccessor.ts, 3, 53))
diff --git a/tests/baselines/reference/globalThis.symbols b/tests/baselines/reference/globalThis.symbols
index 77b65bbfa2b..6ca1054f1af 100644
--- a/tests/baselines/reference/globalThis.symbols
+++ b/tests/baselines/reference/globalThis.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/globalThis.ts ===
 var __e = Math.E;  // should not generate 'this.Math.E'
 >__e : Symbol(__e, Decl(globalThis.ts, 0, 3))
->Math.E : Symbol(Math.E, Decl(lib.d.ts, 524, 16))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->E : Symbol(Math.E, Decl(lib.d.ts, 524, 16))
+>Math.E : Symbol(Math.E, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>E : Symbol(Math.E, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.symbols b/tests/baselines/reference/heterogeneousArrayLiterals.symbols
index c7a73d56414..c1d98b5873a 100644
--- a/tests/baselines/reference/heterogeneousArrayLiterals.symbols
+++ b/tests/baselines/reference/heterogeneousArrayLiterals.symbols
@@ -15,7 +15,7 @@ var d = [{}, 1]; // {}[]
 
 var e = [{}, Object]; // {}[]
 >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 6, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f = [[], [1]]; // number[][]
 >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 8, 3))
diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols
index 36a990010ef..e2b375cb54b 100644
--- a/tests/baselines/reference/ifDoWhileStatements.symbols
+++ b/tests/baselines/reference/ifDoWhileStatements.symbols
@@ -67,9 +67,9 @@ module M {
     export function F2(x: number): string { return x.toString(); }
 >F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 25, 5))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23))
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 module N {
@@ -85,9 +85,9 @@ module N {
     export function F2(x: number): string { return x.toString(); }
 >F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 33, 5))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23))
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 // literals
diff --git a/tests/baselines/reference/implementArrayInterface.symbols b/tests/baselines/reference/implementArrayInterface.symbols
index 97d106157fe..5a671d41de3 100644
--- a/tests/baselines/reference/implementArrayInterface.symbols
+++ b/tests/baselines/reference/implementArrayInterface.symbols
@@ -2,7 +2,7 @@
 declare class MyArray<T> implements Array<T> {
 >MyArray : Symbol(MyArray, Decl(implementArrayInterface.ts, 0, 0))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22))
 
     toString(): string;
diff --git a/tests/baselines/reference/incrementAndDecrement.errors.txt b/tests/baselines/reference/incrementAndDecrement.errors.txt
index 7cbf8cbc0fe..d41764176a4 100644
--- a/tests/baselines/reference/incrementAndDecrement.errors.txt
+++ b/tests/baselines/reference/incrementAndDecrement.errors.txt
@@ -3,25 +3,41 @@ tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(8,5): err
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(11,5): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(14,5): error TS1005: ';' expected.
 tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(17,5): error TS1005: ';' expected.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(24,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(25,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(26,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(27,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(34,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(35,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(36,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(37,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(44,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(45,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(46,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(47,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(55,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(56,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(57,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(24,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(24,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(25,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(25,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(26,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(26,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(27,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(27,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(34,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(34,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(35,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(35,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(36,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(36,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(37,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(37,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(44,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(44,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(45,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(45,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(46,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(46,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(47,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(47,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(55,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(55,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(56,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(56,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(57,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(57,6): error TS1109: Expression expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,4): error TS1005: ';' expected.
+tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,6): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/operators/incrementAndDecrement.ts (21 errors) ====
+==== tests/cases/conformance/expressions/operators/incrementAndDecrement.ts (37 errors) ====
     enum E { A, B, C };
     var x = 4;
     var e = E.B;
@@ -56,17 +72,25 @@ tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,3): er
     ++x;
     --x;
     ++x++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --x--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     ++x--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --x++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     
     // Pre and postfix++ on enum
     e++;
@@ -74,17 +98,25 @@ tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,3): er
     ++e;
     --e;
     ++e++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --e--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     ++e--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --e++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     
     // Pre and postfix++ on value of type 'any'
     a++;
@@ -92,17 +124,25 @@ tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,3): er
     ++a;
     --a;
     ++a++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --a--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     ++a--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --a++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     
     
     // Pre and postfix++ on other types
@@ -111,17 +151,25 @@ tests/cases/conformance/expressions/operators/incrementAndDecrement.ts(58,3): er
     ++w; // Error
     --w; // Error
     ++w++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --w--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     ++w--; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     --w++; // Error
-      ~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+       ~~
+!!! error TS1005: ';' expected.
+         ~
+!!! error TS1109: Expression expected.
     
     
     
\ No newline at end of file
diff --git a/tests/baselines/reference/incrementAndDecrement.js b/tests/baselines/reference/incrementAndDecrement.js
index 09c0b3ae490..49324498c9a 100644
--- a/tests/baselines/reference/incrementAndDecrement.js
+++ b/tests/baselines/reference/incrementAndDecrement.js
@@ -90,34 +90,50 @@ x++;
 x--;
 ++x;
 --x;
-++x++; // Error
---x--; // Error
-++x--; // Error
---x++; // Error
+++x;
+++; // Error
+--x;
+--; // Error
+++x;
+--; // Error
+--x;
+++; // Error
 // Pre and postfix++ on enum
 e++;
 e--;
 ++e;
 --e;
-++e++; // Error
---e--; // Error
-++e--; // Error
---e++; // Error
+++e;
+++; // Error
+--e;
+--; // Error
+++e;
+--; // Error
+--e;
+++; // Error
 // Pre and postfix++ on value of type 'any'
 a++;
 a--;
 ++a;
 --a;
-++a++; // Error
---a--; // Error
-++a--; // Error
---a++; // Error
+++a;
+++; // Error
+--a;
+--; // Error
+++a;
+--; // Error
+--a;
+++; // Error
 // Pre and postfix++ on other types
 w++; // Error
 w--; // Error
 ++w; // Error
 --w; // Error
-++w++; // Error
---w--; // Error
-++w--; // Error
---w++; // Error
+++w;
+++; // Error
+--w;
+--; // Error
+++w;
+--; // Error
+--w;
+++; // Error
diff --git a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
index ab301964026..92e639df21e 100644
--- a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.errors.txt
@@ -36,13 +36,16 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(60,24): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(63,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(65,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(67,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(67,7): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(67,9): error TS1109: Expression expected.
 tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(68,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(68,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,3): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(68,7): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(68,9): error TS1109: Expression expected.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,10): error TS1005: ';' expected.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts(69,12): error TS1109: Expression expected.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts (42 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithAnyOtherTypeInvalidOperations.ts (45 errors) ====
     // ++ operator on any type
     var ANY1;
     var ANY2: any[] = [1, 2];
@@ -186,13 +189,19 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     
     ++ANY1++;
-      ~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+          ~~
+!!! error TS1005: ';' expected.
+            ~
+!!! error TS1109: Expression expected.
     ++ANY2++;
       ~~~~
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-      ~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+          ~~
+!!! error TS1005: ';' expected.
+            ~
+!!! error TS1109: Expression expected.
     ++ANY2[0]++;
-      ~~~~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
\ No newline at end of file
+             ~~
+!!! error TS1005: ';' expected.
+               ~
+!!! error TS1109: Expression expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.js b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.js
index 259dcac404e..73ec64dfc55 100644
--- a/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.js
+++ b/tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.js
@@ -128,6 +128,9 @@ var ResultIsNumber30 = obj1.y++;
 // miss assignment operators
 ++ANY2;
 ANY2++;
-++ANY1++;
-++ANY2++;
-++ANY2[0]++;
+++ANY1;
+++;
+++ANY2;
+++;
+++ANY2[0];
+++;
diff --git a/tests/baselines/reference/indexer3.symbols b/tests/baselines/reference/indexer3.symbols
index 1de91806faa..fa6f905def6 100644
--- a/tests/baselines/reference/indexer3.symbols
+++ b/tests/baselines/reference/indexer3.symbols
@@ -2,10 +2,10 @@
 var dateMap: { [x: string]: Date; } = {}
 >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3))
 >x : Symbol(x, Decl(indexer3.ts, 0, 16))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r: Date = dateMap["hello"] // result type includes indexer using BCT
 >r : Symbol(r, Decl(indexer3.ts, 1, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3))
 
diff --git a/tests/baselines/reference/indexersInClassType.symbols b/tests/baselines/reference/indexersInClassType.symbols
index e459888cc0d..0852463c37d 100644
--- a/tests/baselines/reference/indexersInClassType.symbols
+++ b/tests/baselines/reference/indexersInClassType.symbols
@@ -4,14 +4,14 @@ class C {
 
     [x: number]: Date;
 >x : Symbol(x, Decl(indexersInClassType.ts, 1, 5))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [x: string]: Object;
 >x : Symbol(x, Decl(indexersInClassType.ts, 2, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     1: Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     'a': {}
 
diff --git a/tests/baselines/reference/inferSecondaryParameter.symbols b/tests/baselines/reference/inferSecondaryParameter.symbols
index c2527ed14b3..5522770c02f 100644
--- a/tests/baselines/reference/inferSecondaryParameter.symbols
+++ b/tests/baselines/reference/inferSecondaryParameter.symbols
@@ -6,7 +6,7 @@ interface Ib { m(test: string, fn: Function); }
 >m : Symbol(m, Decl(inferSecondaryParameter.ts, 2, 14))
 >test : Symbol(test, Decl(inferSecondaryParameter.ts, 2, 17))
 >fn : Symbol(fn, Decl(inferSecondaryParameter.ts, 2, 30))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b: Ib = { m: function (test: string, fn: Function) { } };
 >b : Symbol(b, Decl(inferSecondaryParameter.ts, 4, 3))
@@ -14,7 +14,7 @@ var b: Ib = { m: function (test: string, fn: Function) { } };
 >m : Symbol(m, Decl(inferSecondaryParameter.ts, 4, 13))
 >test : Symbol(test, Decl(inferSecondaryParameter.ts, 4, 27))
 >fn : Symbol(fn, Decl(inferSecondaryParameter.ts, 4, 40))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 b.m("test", function (bug) {
 >b.m : Symbol(Ib.m, Decl(inferSecondaryParameter.ts, 2, 14))
diff --git a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
index 6170a4d1149..3e17cdfb2a4 100644
--- a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
+++ b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols
@@ -28,7 +28,7 @@ interface Take<T> {
 foo(n => n.length, () => 'hi');
 >foo : Symbol(foo, Decl(inferenceFromParameterlessLambda.ts, 0, 0))
 >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4))
->n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>n.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
index 3fee48fc837..07812704840 100644
--- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols
@@ -30,9 +30,9 @@ foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } }
 >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod1.ts, 2, 1))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 9))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
->p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 46))
 >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 54))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
index fc8d39858b6..2f4aa942b91 100644
--- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
+++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols
@@ -30,9 +30,9 @@ foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } }
 >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod2.ts, 2, 1))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 9))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
->p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 46))
 >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 54))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols b/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols
index 4babc614183..e8d66f2bbcb 100644
--- a/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols
+++ b/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols
@@ -14,7 +14,7 @@ function foo<T extends (p: string) => number>(x: T): T {
 foo(x => x.length);
 >foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0))
 >x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols b/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols
index 3c47eb4c697..e1525c50012 100644
--- a/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols
+++ b/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols
@@ -16,7 +16,7 @@ foo({ m(x) { return x.length } });
 >foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0))
 >m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 4, 5))
 >x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols
index 5fcc91d816e..c6ac17b0ccb 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols
+++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols
@@ -11,7 +11,7 @@ function identity<A>(a: A): A {
 }
 var x = [1, 2, 3].map(identity)[0];
 >x : Symbol(x, Decl(inferentialTypingWithFunctionType2.ts, 3, 3))
->[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >identity : Symbol(identity, Decl(inferentialTypingWithFunctionType2.ts, 0, 0))
 
diff --git a/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols b/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols
index 9c65c2e3655..108170e8895 100644
--- a/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols
+++ b/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols
@@ -12,7 +12,7 @@ class B<T> extends A<T> {}
 var a = new A<Date>();
 >a : Symbol(a, Decl(inheritanceOfGenericConstructorMethod1.ts, 2, 3))
 >A : Symbol(A, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b1 = new B(); // no error
 >b1 : Symbol(b1, Decl(inheritanceOfGenericConstructorMethod1.ts, 3, 3))
@@ -21,12 +21,12 @@ var b1 = new B(); // no error
 var b2: B<Date> = new B<Date>(); // no error
 >b2 : Symbol(b2, Decl(inheritanceOfGenericConstructorMethod1.ts, 4, 3))
 >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b3 = new B<Date>(); // error, could not select overload for 'new' expression
 >b3 : Symbol(b3, Decl(inheritanceOfGenericConstructorMethod1.ts, 5, 3))
 >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
index a76a4aad7fa..b4e6eac2183 100644
--- a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
+++ b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/inheritedFunctionAssignmentCompatibility.ts ===
 interface IResultCallback extends Function { }
 >IResultCallback : Symbol(IResultCallback, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 0))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function fn(cb: IResultCallback) { }
 >fn : Symbol(fn, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 46))
diff --git a/tests/baselines/reference/inheritedGenericCallSignature.symbols b/tests/baselines/reference/inheritedGenericCallSignature.symbols
index 49170401165..f70e4c7d75f 100644
--- a/tests/baselines/reference/inheritedGenericCallSignature.symbols
+++ b/tests/baselines/reference/inheritedGenericCallSignature.symbols
@@ -13,7 +13,7 @@ interface I1<T> {
 
 
 interface Object {}
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11), Decl(inheritedGenericCallSignature.ts, 5, 1))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(inheritedGenericCallSignature.ts, 5, 1))
 
  
 
@@ -34,7 +34,7 @@ interface I2<T> extends I1<T[]> {
 var x: I2<Date>;
 >x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 20, 3))
 >I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 8, 19))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
  
 
@@ -44,7 +44,7 @@ var y = x(undefined);
 >undefined : Symbol(undefined)
 
 y.length;  // should not error
->y.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>y.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 24, 3))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols
index 1b1c6b21beb..1a204dd9f32 100644
--- a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols
+++ b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols
@@ -20,9 +20,9 @@ var b:B;
 
 // Should not error
 b('foo').charAt(0);
->b('foo').charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>b('foo').charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(inheritedOverloadedSpecializedSignatures.ts, 8, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 interface A {
 >A : Symbol(A, Decl(inheritedOverloadedSpecializedSignatures.ts, 0, 0), Decl(inheritedOverloadedSpecializedSignatures.ts, 10, 19), Decl(inheritedOverloadedSpecializedSignatures.ts, 19, 1))
diff --git a/tests/baselines/reference/innerBoundLambdaEmit.symbols b/tests/baselines/reference/innerBoundLambdaEmit.symbols
index 689aa7d075b..48bbe1fad4b 100644
--- a/tests/baselines/reference/innerBoundLambdaEmit.symbols
+++ b/tests/baselines/reference/innerBoundLambdaEmit.symbols
@@ -9,8 +9,8 @@ module M {
 >bar : Symbol(bar, Decl(innerBoundLambdaEmit.ts, 3, 7))
 }
 interface Array<T> {
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(innerBoundLambdaEmit.ts, 4, 1))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(innerBoundLambdaEmit.ts, 5, 16))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(innerBoundLambdaEmit.ts, 4, 1))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(innerBoundLambdaEmit.ts, 5, 16))
 
     toFoo(): M.Foo
 >toFoo : Symbol(toFoo, Decl(innerBoundLambdaEmit.ts, 5, 20))
diff --git a/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols b/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols
index b890c6c9ecf..36502a9988d 100644
--- a/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols
+++ b/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols
@@ -5,63 +5,63 @@
 function f<T extends Date>() {
 >f : Symbol(f, Decl(innerTypeParameterShadowingOuterOne.ts, 0, 0))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     function g<T extends Number>() {
 >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 30))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 4, 15))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var x: T;
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 5, 11))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 4, 15))
 
         x.toFixed();
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 5, 11))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
     }
     var x: T;
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 8, 7))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 11))
 
     x.getDate();
->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 8, 7))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 }
 
 function f2<T extends Date, U extends Date>() {
 >f2 : Symbol(f2, Decl(innerTypeParameterShadowingOuterOne.ts, 10, 1))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 27))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     function g<T extends Number, U extends Number>() {
 >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 47))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 13, 15))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 13, 32))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var x: U;
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 14, 11))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 13, 32))
 
         x.toFixed();
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 14, 11))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
     }
     var x: U;
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 17, 7))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 27))
 
     x.getDate();
->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 17, 7))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 }
 //function f2<T extends Date, U extends T>() {
 //    function g<T extends Number, U extends T>() {
diff --git a/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols b/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols
index 13afcb3e123..e19ab7aad28 100644
--- a/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols
+++ b/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols
@@ -5,21 +5,21 @@
 class C<T extends Date> {
 >C : Symbol(C, Decl(innerTypeParameterShadowingOuterOne2.ts, 0, 0))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     g<T extends Number>() {
 >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 25))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 4, 6))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var x: T;
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 5, 11))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 4, 6))
 
         x.toFixed();
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 5, 11))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
     }
 
     h() {
@@ -30,34 +30,34 @@ class C<T extends Date> {
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 8))
 
         x.getDate();
->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 10, 11))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
     }
 }
 
 class C2<T extends Date, U extends Date> {
 >C2 : Symbol(C2, Decl(innerTypeParameterShadowingOuterOne2.ts, 13, 1))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 24))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     g<T extends Number, U extends Number>() {
 >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 42))
 >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 16, 6))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 16, 23))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         var x: U;
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 17, 11))
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 16, 23))
 
         x.toFixed();
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 17, 11))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
     }
 
     h() {
@@ -68,9 +68,9 @@ class C2<T extends Date, U extends Date> {
 >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 24))
 
         x.getDate();
->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 22, 11))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
     }
 }
 //class C2<T extends Date, U extends T> {
diff --git a/tests/baselines/reference/instanceAndStaticDeclarations1.symbols b/tests/baselines/reference/instanceAndStaticDeclarations1.symbols
index d6b4789232c..8e9d4a320a0 100644
--- a/tests/baselines/reference/instanceAndStaticDeclarations1.symbols
+++ b/tests/baselines/reference/instanceAndStaticDeclarations1.symbols
@@ -32,9 +32,9 @@ class Point {
 >y : Symbol(Point.y, Decl(instanceAndStaticDeclarations1.ts, 3, 33))
 
         return Math.sqrt(dx * dx + dy * dy);
->Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27))
+>Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --))
 >dx : Symbol(dx, Decl(instanceAndStaticDeclarations1.ts, 5, 11))
 >dx : Symbol(dx, Decl(instanceAndStaticDeclarations1.ts, 5, 11))
 >dy : Symbol(dy, Decl(instanceAndStaticDeclarations1.ts, 6, 11))
diff --git a/tests/baselines/reference/instanceOfAssignability.symbols b/tests/baselines/reference/instanceOfAssignability.symbols
index b01f29a5faf..1bf39df2dd2 100644
--- a/tests/baselines/reference/instanceOfAssignability.symbols
+++ b/tests/baselines/reference/instanceOfAssignability.symbols
@@ -48,12 +48,12 @@ class Giraffe extends Mammal { neck; }
 function fn1(x: Array<number>|Array<string>|boolean) {
 >fn1 : Symbol(fn1, Decl(instanceOfAssignability.ts, 19, 38))
 >x : Symbol(x, Decl(instanceOfAssignability.ts, 21, 13))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 	if(x instanceof Array) {
 >x : Symbol(x, Decl(instanceOfAssignability.ts, 21, 13))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 		// 1.5: y: Array<number>|Array<string>
 		// Want: y: Array<number>|Array<string>
@@ -154,12 +154,12 @@ function fn6(x: Animal|Mammal) {
 function fn7(x: Array<number>|Array<string>) {
 >fn7 : Symbol(fn7, Decl(instanceOfAssignability.ts, 67, 1))
 >x : Symbol(x, Decl(instanceOfAssignability.ts, 69, 13))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 	if(x instanceof Array) {
 >x : Symbol(x, Decl(instanceOfAssignability.ts, 69, 13))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 		// 1.5: y: Array<number>|Array<string>
 		// Want: y: Array<number>|Array<string>
diff --git a/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols b/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols
index 44859d83f72..481e241d69d 100644
--- a/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols
+++ b/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols
@@ -7,14 +7,14 @@ var x1: any;
 
 var x2: Function;
 >x2 : Symbol(x2, Decl(instanceofOperatorWithLHSIsObject.ts, 3, 3))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var a: {};
 >a : Symbol(a, Decl(instanceofOperatorWithLHSIsObject.ts, 5, 3))
 
 var b: Object;
 >b : Symbol(b, Decl(instanceofOperatorWithLHSIsObject.ts, 6, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var c: C;
 >c : Symbol(c, Decl(instanceofOperatorWithLHSIsObject.ts, 7, 3))
diff --git a/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols b/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols
index e15f4b7ea45..5d02ff54ae2 100644
--- a/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols
+++ b/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols
@@ -1,14 +1,14 @@
 === tests/cases/conformance/expressions/binaryOperators/instanceofOperator/instanceofOperatorWithRHSIsSubtypeOfFunction.ts ===
 interface I extends Function { }
 >I : Symbol(I, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 0, 0))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var x: any;
 >x : Symbol(x, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 2, 3))
 
 var f1: Function;
 >f1 : Symbol(f1, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 3, 3))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f2: I;
 >f2 : Symbol(f2, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 4, 3))
diff --git a/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols b/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols
index 6b45cd1daad..8e5f0413299 100644
--- a/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols
+++ b/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols
@@ -7,14 +7,14 @@ if (typeof x !== "string") {
 >x : Symbol(x, Decl(interfaceDoesNotDependOnBaseTypes.ts, 0, 3))
 
     x.push("");
->x.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>x.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(interfaceDoesNotDependOnBaseTypes.ts, 0, 3))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 
     x.push([""]);
->x.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>x.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(interfaceDoesNotDependOnBaseTypes.ts, 0, 3))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 }
 
 type StringTree = string | StringTreeArray;
@@ -23,6 +23,6 @@ type StringTree = string | StringTreeArray;
 
 interface StringTreeArray extends Array<StringTree> { }
 >StringTreeArray : Symbol(StringTreeArray, Decl(interfaceDoesNotDependOnBaseTypes.ts, 6, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >StringTree : Symbol(StringTree, Decl(interfaceDoesNotDependOnBaseTypes.ts, 4, 1))
 
diff --git a/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols b/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols
index 28dcb55238b..f544aac424d 100644
--- a/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols
+++ b/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols
@@ -9,7 +9,7 @@ interface Foo {
     new (): any;
     new (x: string): Object;
 >x : Symbol(x, Decl(interfaceWithOverloadedCallAndConstructSignatures.ts, 5, 9))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var f: Foo;
diff --git a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
index 46c8e92261f..f248bba02f0 100644
--- a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
+++ b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols
@@ -39,7 +39,7 @@ interface Foo {
 
     g: Object;
 >g : Symbol(g, Decl(interfaceWithPropertyOfEveryType.ts, 13, 16))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     h: (x: number) => number;
 >h : Symbol(h, Decl(interfaceWithPropertyOfEveryType.ts, 14, 14))
diff --git a/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols b/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols
index 40ec7863a04..1d4a024294f 100644
--- a/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols
+++ b/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols
@@ -13,7 +13,7 @@ interface Foo {
 
     new (x: string): Object;
 >x : Symbol(x, Decl(interfaceWithSpecializedCallAndConstructSignatures.ts, 5, 9))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var f: Foo;
diff --git a/tests/baselines/reference/invalidSplice.symbols b/tests/baselines/reference/invalidSplice.symbols
index dc028776cb3..5aceb66a227 100644
--- a/tests/baselines/reference/invalidSplice.symbols
+++ b/tests/baselines/reference/invalidSplice.symbols
@@ -1,6 +1,6 @@
 === tests/cases/compiler/invalidSplice.ts ===
 var arr = [].splice(0,3,4,5);
 >arr : Symbol(arr, Decl(invalidSplice.ts, 0, 3))
->[].splice : Symbol(Array.splice, Decl(lib.d.ts, 1060, 50), Decl(lib.d.ts, 1066, 31))
->splice : Symbol(Array.splice, Decl(lib.d.ts, 1060, 50), Decl(lib.d.ts, 1066, 31))
+>[].splice : Symbol(Array.splice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>splice : Symbol(Array.splice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/isArray.symbols b/tests/baselines/reference/isArray.symbols
index 75351b377be..b60123e6b2e 100644
--- a/tests/baselines/reference/isArray.symbols
+++ b/tests/baselines/reference/isArray.symbols
@@ -4,19 +4,19 @@ var maybeArray: number | number[];
 
 
 if (Array.isArray(maybeArray)) {
->Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, 1166, 28))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, 1166, 28))
+>Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, --, --))
 >maybeArray : Symbol(maybeArray, Decl(isArray.ts, 0, 3))
 
     maybeArray.length; // OK
->maybeArray.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>maybeArray.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >maybeArray : Symbol(maybeArray, Decl(isArray.ts, 0, 3))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 }
 else {
     maybeArray.toFixed(); // OK
->maybeArray.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>maybeArray.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >maybeArray : Symbol(maybeArray, Decl(isArray.ts, 0, 3))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols
index 659a1330616..2af21772cfb 100644
--- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols
+++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols
@@ -127,7 +127,7 @@ module schema {
     export function createValidator8(schema: any): Array<{ <T>(data: T) : T}> {
 >createValidator8 : Symbol(createValidator8, Decl(isDeclarationVisibleNodeKinds.ts, 52, 15))
 >schema : Symbol(schema, Decl(isDeclarationVisibleNodeKinds.ts, 53, 37))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60))
 >data : Symbol(data, Decl(isDeclarationVisibleNodeKinds.ts, 53, 63))
 >T : Symbol(T, Decl(isDeclarationVisibleNodeKinds.ts, 53, 60))
diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols
index fae627e9c95..2877a2233da 100644
--- a/tests/baselines/reference/iterableArrayPattern1.symbols
+++ b/tests/baselines/reference/iterableArrayPattern1.symbols
@@ -13,7 +13,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iterableArrayPattern1.ts, 4, 28))
@@ -22,9 +22,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iterableArrayPattern1.ts, 0, 32))
diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols
index fefeaced83f..6181edbf1fd 100644
--- a/tests/baselines/reference/iterableArrayPattern11.symbols
+++ b/tests/baselines/reference/iterableArrayPattern11.symbols
@@ -36,9 +36,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern11.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols
index fd00059449a..e4b4baf3bd5 100644
--- a/tests/baselines/reference/iterableArrayPattern12.symbols
+++ b/tests/baselines/reference/iterableArrayPattern12.symbols
@@ -36,9 +36,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern12.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols
index 8271e564f9e..02f219e7092 100644
--- a/tests/baselines/reference/iterableArrayPattern13.symbols
+++ b/tests/baselines/reference/iterableArrayPattern13.symbols
@@ -35,9 +35,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern13.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols
index d4f2949e24f..dad1262cee9 100644
--- a/tests/baselines/reference/iterableArrayPattern2.symbols
+++ b/tests/baselines/reference/iterableArrayPattern2.symbols
@@ -13,7 +13,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iterableArrayPattern2.ts, 4, 28))
@@ -22,9 +22,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iterableArrayPattern2.ts, 0, 35))
diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols
index 9e38c52ad70..e0372862b9e 100644
--- a/tests/baselines/reference/iterableArrayPattern3.symbols
+++ b/tests/baselines/reference/iterableArrayPattern3.symbols
@@ -37,9 +37,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern3.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols
index 5a991f0d5b3..393d9fbca51 100644
--- a/tests/baselines/reference/iterableArrayPattern30.symbols
+++ b/tests/baselines/reference/iterableArrayPattern30.symbols
@@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
 >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11))
 >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18))
 >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21))
->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols
index d3a7f4fb1d7..fb1cce1b8f9 100644
--- a/tests/baselines/reference/iterableArrayPattern4.symbols
+++ b/tests/baselines/reference/iterableArrayPattern4.symbols
@@ -37,9 +37,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern4.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols
index efb88d2e608..07d580fcea1 100644
--- a/tests/baselines/reference/iterableArrayPattern9.symbols
+++ b/tests/baselines/reference/iterableArrayPattern9.symbols
@@ -32,9 +32,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern9.ts, 2, 27))
diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols
index f23d571d072..5af4fdbcd78 100644
--- a/tests/baselines/reference/iterableContextualTyping1.symbols
+++ b/tests/baselines/reference/iterableContextualTyping1.symbols
@@ -1,10 +1,10 @@
 === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts ===
 var iter: Iterable<(x: string) => number> = [s => s.length];
 >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols
index 03099b124c9..d24abca314b 100644
--- a/tests/baselines/reference/iteratorSpreadInArray.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray.ts, 5, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray.ts, 0, 36))
diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols
index a46d22a481a..f982bf2deab 100644
--- a/tests/baselines/reference/iteratorSpreadInArray11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 
 var array = [...iter];
 >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3))
diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols
index 906e8288af0..029d83d2111 100644
--- a/tests/baselines/reference/iteratorSpreadInArray2.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols
@@ -13,7 +13,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray2.ts, 5, 28))
@@ -22,9 +22,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray2.ts, 0, 59))
@@ -48,9 +48,9 @@ class NumberIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(NumberIterator, Decl(iteratorSpreadInArray2.ts, 13, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols
index e25374c80a8..05f90d44174 100644
--- a/tests/baselines/reference/iteratorSpreadInArray3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray3.ts, 5, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray3.ts, 0, 47))
diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols
index 1856d1bb682..e7ace40c4de 100644
--- a/tests/baselines/reference/iteratorSpreadInArray4.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray4.ts, 5, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray4.ts, 0, 42))
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols
index c68550b7fa7..e498e68b9eb 100644
--- a/tests/baselines/reference/iteratorSpreadInArray7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols
@@ -3,9 +3,9 @@ var array: symbol[];
 >array : Symbol(array, Decl(iteratorSpreadInArray7.ts, 0, 3))
 
 array.concat([...new SymbolIterator]);
->array.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>array.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >array : Symbol(array, Decl(iteratorSpreadInArray7.ts, 0, 3))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38))
 
 class SymbolIterator {
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray7.ts, 6, 28))
@@ -26,9 +26,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38))
diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols
index 874a034631d..e504283a3bd 100644
--- a/tests/baselines/reference/iteratorSpreadInCall11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols
@@ -19,7 +19,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall11.ts, 7, 28))
@@ -28,9 +28,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall11.ts, 2, 42))
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols
index 0f84a0e1cbb..4b7f553e969 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols
@@ -22,7 +22,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall12.ts, 9, 28))
@@ -31,9 +31,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 4, 1))
@@ -57,9 +57,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 17, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols
index 6f329329431..402b156002f 100644
--- a/tests/baselines/reference/iteratorSpreadInCall3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols
@@ -16,7 +16,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall3.ts, 6, 28))
@@ -25,9 +25,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall3.ts, 2, 32))
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols
index 01a0112b026..855b434f07c 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall5.ts, 6, 28))
@@ -26,9 +26,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 2, 43))
@@ -52,9 +52,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 14, 1))
diff --git a/tests/baselines/reference/letDeclarations-access.symbols b/tests/baselines/reference/letDeclarations-access.symbols
index dfc9ea4c533..060ebc80b80 100644
--- a/tests/baselines/reference/letDeclarations-access.symbols
+++ b/tests/baselines/reference/letDeclarations-access.symbols
@@ -81,7 +81,7 @@ x;
 >x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3))
 
 x.toString();
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt
deleted file mode 100644
index 5b8633312d9..00000000000
--- a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/file1.ts(2,1): error TS2448: Block-scoped variable 'l' used before its declaration.
-
-
-==== tests/cases/compiler/file1.ts (1 errors) ====
-    
-    l;
-    ~
-!!! error TS2448: Block-scoped variable 'l' used before its declaration.
-    
-==== tests/cases/compiler/file2.ts (0 errors) ====
-    const l = 0;
\ No newline at end of file
diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.symbols b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.symbols
new file mode 100644
index 00000000000..c5a067ede4d
--- /dev/null
+++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.symbols
@@ -0,0 +1,9 @@
+=== tests/cases/compiler/file1.ts ===
+
+l;
+>l : Symbol(l, Decl(file2.ts, 0, 5))
+
+=== tests/cases/compiler/file2.ts ===
+const l = 0;
+>l : Symbol(l, Decl(file2.ts, 0, 5))
+
diff --git a/tests/baselines/reference/letDeclarations-useBeforeDefinition2.types b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.types
new file mode 100644
index 00000000000..793a7a78ba7
--- /dev/null
+++ b/tests/baselines/reference/letDeclarations-useBeforeDefinition2.types
@@ -0,0 +1,10 @@
+=== tests/cases/compiler/file1.ts ===
+
+l;
+>l : number
+
+=== tests/cases/compiler/file2.ts ===
+const l = 0;
+>l : number
+>0 : number
+
diff --git a/tests/baselines/reference/library_ArraySlice.symbols b/tests/baselines/reference/library_ArraySlice.symbols
index 02c58859d40..f29defbc3f9 100644
--- a/tests/baselines/reference/library_ArraySlice.symbols
+++ b/tests/baselines/reference/library_ArraySlice.symbols
@@ -1,23 +1,23 @@
 === tests/cases/compiler/library_ArraySlice.ts ===
 // Array.prototype.slice can have zero, one, or two arguments
 Array.prototype.slice();
->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 
 Array.prototype.slice(0);
->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 
 Array.prototype.slice(0, 1);
->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
+>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/library_DatePrototypeProperties.symbols b/tests/baselines/reference/library_DatePrototypeProperties.symbols
index c6d0b7e87fb..8aa5f81f2f5 100644
--- a/tests/baselines/reference/library_DatePrototypeProperties.symbols
+++ b/tests/baselines/reference/library_DatePrototypeProperties.symbols
@@ -2,310 +2,310 @@
 // Properties of the Date prototype object as per ES5 spec
 // http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.5
 Date.prototype.constructor;
->Date.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18))
+>Date.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --))
 
 Date.prototype.toString();
->Date.prototype.toString : Symbol(Date.toString, Decl(lib.d.ts, 636, 16))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toString : Symbol(Date.toString, Decl(lib.d.ts, 636, 16))
+>Date.prototype.toString : Symbol(Date.toString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toString : Symbol(Date.toString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toDateString();
->Date.prototype.toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, 638, 23))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, 638, 23))
+>Date.prototype.toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toTimeString();
->Date.prototype.toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, 640, 27))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, 640, 27))
+>Date.prototype.toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toLocaleString();
->Date.prototype.toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, 642, 27))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, 642, 27))
+>Date.prototype.toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toLocaleDateString();
->Date.prototype.toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, 644, 29))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, 644, 29))
+>Date.prototype.toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toLocaleTimeString();
->Date.prototype.toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, 646, 33))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, 646, 33))
+>Date.prototype.toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, --, --))
 
 Date.prototype.valueOf();
->Date.prototype.valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, 648, 33))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, 648, 33))
+>Date.prototype.valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, --, --))
 
 Date.prototype.getTime();
->Date.prototype.getTime : Symbol(Date.getTime, Decl(lib.d.ts, 650, 22))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getTime : Symbol(Date.getTime, Decl(lib.d.ts, 650, 22))
+>Date.prototype.getTime : Symbol(Date.getTime, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getTime : Symbol(Date.getTime, Decl(lib.d.ts, --, --))
 
 Date.prototype.getFullYear();
->Date.prototype.getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, 652, 22))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, 652, 22))
+>Date.prototype.getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCFullYear();
->Date.prototype.getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, 654, 26))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, 654, 26))
+>Date.prototype.getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.getMonth();
->Date.prototype.getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, 656, 29))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, 656, 29))
+>Date.prototype.getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCMonth();
->Date.prototype.getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, 658, 23))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, 658, 23))
+>Date.prototype.getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.getDate();
->Date.prototype.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>Date.prototype.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCDate();
->Date.prototype.getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, 662, 22))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, 662, 22))
+>Date.prototype.getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.getDay();
->Date.prototype.getDay : Symbol(Date.getDay, Decl(lib.d.ts, 664, 25))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getDay : Symbol(Date.getDay, Decl(lib.d.ts, 664, 25))
+>Date.prototype.getDay : Symbol(Date.getDay, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getDay : Symbol(Date.getDay, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCDay();
->Date.prototype.getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, 666, 21))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, 666, 21))
+>Date.prototype.getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, --, --))
 
 Date.prototype.getHours();
->Date.prototype.getHours : Symbol(Date.getHours, Decl(lib.d.ts, 668, 24))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getHours : Symbol(Date.getHours, Decl(lib.d.ts, 668, 24))
+>Date.prototype.getHours : Symbol(Date.getHours, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getHours : Symbol(Date.getHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCHours();
->Date.prototype.getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, 670, 23))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, 670, 23))
+>Date.prototype.getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.getMinutes();
->Date.prototype.getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, 672, 26))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, 672, 26))
+>Date.prototype.getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCMinutes();
->Date.prototype.getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, 674, 25))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, 674, 25))
+>Date.prototype.getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.getSeconds();
->Date.prototype.getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, 676, 28))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, 676, 28))
+>Date.prototype.getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCSeconds();
->Date.prototype.getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, 678, 25))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, 678, 25))
+>Date.prototype.getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getMilliseconds();
->Date.prototype.getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, 680, 28))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, 680, 28))
+>Date.prototype.getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getUTCMilliseconds();
->Date.prototype.getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, 682, 30))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, 682, 30))
+>Date.prototype.getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.getTimezoneOffset();
->Date.prototype.getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, 684, 33))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, 684, 33))
+>Date.prototype.getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, --, --))
 
 Date.prototype.setTime(0);
->Date.prototype.setTime : Symbol(Date.setTime, Decl(lib.d.ts, 686, 32))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setTime : Symbol(Date.setTime, Decl(lib.d.ts, 686, 32))
+>Date.prototype.setTime : Symbol(Date.setTime, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setTime : Symbol(Date.setTime, Decl(lib.d.ts, --, --))
 
 Date.prototype.setMilliseconds(0);
->Date.prototype.setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, 691, 34))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, 691, 34))
+>Date.prototype.setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCMilliseconds(0);
->Date.prototype.setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, 696, 40))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, 696, 40))
+>Date.prototype.setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setSeconds(0);
->Date.prototype.setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, 701, 43))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, 701, 43))
+>Date.prototype.setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCSeconds(0);
->Date.prototype.setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, 708, 49))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, 708, 49))
+>Date.prototype.setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, --, --))
 
 Date.prototype.setMinutes(0);
->Date.prototype.setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, 714, 52))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, 714, 52))
+>Date.prototype.setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCMinutes(0);
->Date.prototype.setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, 721, 63))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, 721, 63))
+>Date.prototype.setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, --, --))
 
 Date.prototype.setHours(0);
->Date.prototype.setHours : Symbol(Date.setHours, Decl(lib.d.ts, 728, 66))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setHours : Symbol(Date.setHours, Decl(lib.d.ts, 728, 66))
+>Date.prototype.setHours : Symbol(Date.setHours, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setHours : Symbol(Date.setHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCHours(0);
->Date.prototype.setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, 736, 77))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, 736, 77))
+>Date.prototype.setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, --, --))
 
 Date.prototype.setDate(0);
->Date.prototype.setDate : Symbol(Date.setDate, Decl(lib.d.ts, 744, 80))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setDate : Symbol(Date.setDate, Decl(lib.d.ts, 744, 80))
+>Date.prototype.setDate : Symbol(Date.setDate, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setDate : Symbol(Date.setDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCDate(0);
->Date.prototype.setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, 749, 34))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, 749, 34))
+>Date.prototype.setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, --, --))
 
 Date.prototype.setMonth(0);
->Date.prototype.setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, 754, 37))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, 754, 37))
+>Date.prototype.setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCMonth(0);
->Date.prototype.setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, 760, 51))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, 760, 51))
+>Date.prototype.setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, --, --))
 
 Date.prototype.setFullYear(0);
->Date.prototype.setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, 766, 54))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, 766, 54))
+>Date.prototype.setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.setUTCFullYear(0);
->Date.prototype.setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, 773, 69))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, 773, 69))
+>Date.prototype.setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, --, --))
 
 Date.prototype.toUTCString();
->Date.prototype.toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, 780, 72))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, 780, 72))
+>Date.prototype.toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toISOString();
->Date.prototype.toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, 782, 26))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, 782, 26))
+>Date.prototype.toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, --, --))
 
 Date.prototype.toJSON(null);
->Date.prototype.toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, 784, 26))
->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15))
->toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, 784, 26))
+>Date.prototype.toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, --, --))
+>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --))
+>toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/library_ObjectPrototypeProperties.symbols b/tests/baselines/reference/library_ObjectPrototypeProperties.symbols
index eb24374af2a..acbeccc02d0 100644
--- a/tests/baselines/reference/library_ObjectPrototypeProperties.symbols
+++ b/tests/baselines/reference/library_ObjectPrototypeProperties.symbols
@@ -2,52 +2,52 @@
 // Properties of the Object Prototype Object as per ES5 spec
 // http://www.ecma-international.org/ecma-262/5.1/#sec-15.2.4
 Object.prototype.constructor;
->Object.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18))
->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18))
+>Object.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --))
+>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --))
 
 Object.prototype.toString();
->Object.prototype.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>Object.prototype.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
+>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 Object.prototype.toLocaleString();
->Object.prototype.toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, 99, 23))
->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, 99, 23))
+>Object.prototype.toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, --, --))
+>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, --, --))
 
 Object.prototype.valueOf();
->Object.prototype.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29))
->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29))
+>Object.prototype.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --))
+>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --))
 
 Object.prototype.hasOwnProperty("string");
->Object.prototype.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>Object.prototype.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
+>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
 Object.prototype.isPrototypeOf(Object);
->Object.prototype.isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, 111, 39))
->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, 111, 39))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object.prototype.isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, --, --))
+>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 Object.prototype.propertyIsEnumerable("string");
->Object.prototype.propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, 117, 38))
->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22))
->propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, 117, 38))
+>Object.prototype.propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, --, --))
+>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --))
+>propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/library_RegExpExecArraySlice.symbols b/tests/baselines/reference/library_RegExpExecArraySlice.symbols
index bc460801fe8..d1ad57ff1d5 100644
--- a/tests/baselines/reference/library_RegExpExecArraySlice.symbols
+++ b/tests/baselines/reference/library_RegExpExecArraySlice.symbols
@@ -2,20 +2,20 @@
 // RegExpExecArray.slice can have zero, one, or two arguments
 var regExpExecArrayValue: RegExpExecArray;
 >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3))
->RegExpExecArray : Symbol(RegExpExecArray, Decl(lib.d.ts, 820, 1))
+>RegExpExecArray : Symbol(RegExpExecArray, Decl(lib.d.ts, --, --))
 
 regExpExecArrayValue.slice();
->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 
 regExpExecArrayValue.slice(0);
->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 
 regExpExecArrayValue.slice(0,1);
->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/library_StringSlice.symbols b/tests/baselines/reference/library_StringSlice.symbols
index 92c80089511..de79b8755ac 100644
--- a/tests/baselines/reference/library_StringSlice.symbols
+++ b/tests/baselines/reference/library_StringSlice.symbols
@@ -1,23 +1,23 @@
 === tests/cases/compiler/library_StringSlice.ts ===
 // String.prototype.slice can have zero, one, or two arguments
 String.prototype.slice();
->String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35))
->String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
->prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26))
->slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35))
+>String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, --, --))
+>String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --))
+>slice : Symbol(String.slice, Decl(lib.d.ts, --, --))
 
 String.prototype.slice(0);
->String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35))
->String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
->prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26))
->slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35))
+>String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, --, --))
+>String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --))
+>slice : Symbol(String.slice, Decl(lib.d.ts, --, --))
 
 String.prototype.slice(0,1);
->String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35))
->String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
->prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26))
->slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35))
+>String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, --, --))
+>String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --))
+>slice : Symbol(String.slice, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/localTypes5.symbols b/tests/baselines/reference/localTypes5.symbols
index 4ffe53b3e53..41851a617de 100644
--- a/tests/baselines/reference/localTypes5.symbols
+++ b/tests/baselines/reference/localTypes5.symbols
@@ -22,7 +22,7 @@ function foo<A>() {
 >Y : Symbol(Y, Decl(localTypes5.ts, 3, 36))
 
             })<Date>();
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
         }
     }
     var x = new X();
diff --git a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
index ff266361321..e91c8b71572 100644
--- a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
+++ b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols
@@ -88,9 +88,9 @@ var ResultIsBoolean11 = !(STRING + STRING);
 
 var ResultIsBoolean12 = !STRING.charAt(0);
 >ResultIsBoolean12 : Symbol(ResultIsBoolean12, Decl(logicalNotOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(logicalNotOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 // multiple ! operator
 var ResultIsBoolean13 = !!STRING;
diff --git a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
index 6cfbf7ea6b6..a7dfba5f4cb 100644
--- a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
+++ b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols
@@ -14,7 +14,7 @@ var r = a || ((a) => a.toLowerCase());
 >r : Symbol(r, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 3))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 6, 3))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15))
->a.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>a.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/memberAccessOnConstructorType.symbols b/tests/baselines/reference/memberAccessOnConstructorType.symbols
index 0e3c707c4f9..c9c06c6f021 100644
--- a/tests/baselines/reference/memberAccessOnConstructorType.symbols
+++ b/tests/baselines/reference/memberAccessOnConstructorType.symbols
@@ -3,7 +3,7 @@ var f: new () => void;
 >f : Symbol(f, Decl(memberAccessOnConstructorType.ts, 0, 3))
 
 f.arguments == 0;
->f.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>f.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >f : Symbol(f, Decl(memberAccessOnConstructorType.ts, 0, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols
index f34501f025b..78383c29377 100644
--- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols
+++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols
@@ -11,7 +11,7 @@ interface C extends D {
 
 	b(): Date;
 >b : Symbol(b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var c:C;
@@ -38,7 +38,7 @@ var d: number = c.a();
 
 var e: Date = c.b();
 >e : Symbol(e, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 12, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >c.b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23))
 >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3))
 >b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23))
diff --git a/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols b/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols
index 337ef1dbb1c..1aa65e8825a 100644
--- a/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols
+++ b/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols
@@ -69,7 +69,7 @@ class D implements A<boolean> {
 
     b: Date;
 >b : Symbol(b, Decl(mergedInterfacesWithMultipleBases3.ts, 28, 14))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     c: string;
 >c : Symbol(c, Decl(mergedInterfacesWithMultipleBases3.ts, 29, 12))
diff --git a/tests/baselines/reference/modulePrologueAMD.js b/tests/baselines/reference/modulePrologueAMD.js
new file mode 100644
index 00000000000..904808b9f6b
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueAMD.js
@@ -0,0 +1,15 @@
+//// [modulePrologueAMD.ts]
+"use strict";
+
+export class Foo {}
+
+//// [modulePrologueAMD.js]
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    var Foo = (function () {
+        function Foo() {
+        }
+        return Foo;
+    })();
+    exports.Foo = Foo;
+});
diff --git a/tests/baselines/reference/modulePrologueAMD.symbols b/tests/baselines/reference/modulePrologueAMD.symbols
new file mode 100644
index 00000000000..d6bb74d951a
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueAMD.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/modulePrologueAMD.ts ===
+"use strict";
+
+export class Foo {}
+>Foo : Symbol(Foo, Decl(modulePrologueAMD.ts, 0, 13))
+
diff --git a/tests/baselines/reference/modulePrologueAMD.types b/tests/baselines/reference/modulePrologueAMD.types
new file mode 100644
index 00000000000..b57b5a8bf2f
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueAMD.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/modulePrologueAMD.ts ===
+"use strict";
+>"use strict" : string
+
+export class Foo {}
+>Foo : Foo
+
diff --git a/tests/baselines/reference/modulePrologueCommonjs.js b/tests/baselines/reference/modulePrologueCommonjs.js
new file mode 100644
index 00000000000..67b704a3650
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueCommonjs.js
@@ -0,0 +1,13 @@
+//// [modulePrologueCommonjs.ts]
+"use strict";
+
+export class Foo {}
+
+//// [modulePrologueCommonjs.js]
+"use strict";
+var Foo = (function () {
+    function Foo() {
+    }
+    return Foo;
+})();
+exports.Foo = Foo;
diff --git a/tests/baselines/reference/modulePrologueCommonjs.symbols b/tests/baselines/reference/modulePrologueCommonjs.symbols
new file mode 100644
index 00000000000..01a2da349f2
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueCommonjs.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/modulePrologueCommonjs.ts ===
+"use strict";
+
+export class Foo {}
+>Foo : Symbol(Foo, Decl(modulePrologueCommonjs.ts, 0, 13))
+
diff --git a/tests/baselines/reference/modulePrologueCommonjs.types b/tests/baselines/reference/modulePrologueCommonjs.types
new file mode 100644
index 00000000000..5d76532b3e4
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueCommonjs.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/modulePrologueCommonjs.ts ===
+"use strict";
+>"use strict" : string
+
+export class Foo {}
+>Foo : Foo
+
diff --git a/tests/baselines/reference/modulePrologueES6.js b/tests/baselines/reference/modulePrologueES6.js
new file mode 100644
index 00000000000..e34f85c9d8d
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueES6.js
@@ -0,0 +1,9 @@
+//// [modulePrologueES6.ts]
+"use strict";
+
+export class Foo {}
+
+//// [modulePrologueES6.js]
+"use strict";
+export class Foo {
+}
diff --git a/tests/baselines/reference/modulePrologueES6.symbols b/tests/baselines/reference/modulePrologueES6.symbols
new file mode 100644
index 00000000000..f45180a6998
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueES6.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/modulePrologueES6.ts ===
+"use strict";
+
+export class Foo {}
+>Foo : Symbol(Foo, Decl(modulePrologueES6.ts, 0, 13))
+
diff --git a/tests/baselines/reference/modulePrologueES6.types b/tests/baselines/reference/modulePrologueES6.types
new file mode 100644
index 00000000000..5f09a60ac6a
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueES6.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/modulePrologueES6.ts ===
+"use strict";
+>"use strict" : string
+
+export class Foo {}
+>Foo : Foo
+
diff --git a/tests/baselines/reference/modulePrologueSystem.js b/tests/baselines/reference/modulePrologueSystem.js
new file mode 100644
index 00000000000..91703d1c7fb
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueSystem.js
@@ -0,0 +1,21 @@
+//// [modulePrologueSystem.ts]
+"use strict";
+
+export class Foo {}
+
+//// [modulePrologueSystem.js]
+System.register([], function(exports_1) {
+    "use strict";
+    var Foo;
+    return {
+        setters:[],
+        execute: function() {
+            Foo = (function () {
+                function Foo() {
+                }
+                return Foo;
+            })();
+            exports_1("Foo", Foo);
+        }
+    }
+});
diff --git a/tests/baselines/reference/modulePrologueSystem.symbols b/tests/baselines/reference/modulePrologueSystem.symbols
new file mode 100644
index 00000000000..9e5ed9d452a
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueSystem.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/modulePrologueSystem.ts ===
+"use strict";
+
+export class Foo {}
+>Foo : Symbol(Foo, Decl(modulePrologueSystem.ts, 0, 13))
+
diff --git a/tests/baselines/reference/modulePrologueSystem.types b/tests/baselines/reference/modulePrologueSystem.types
new file mode 100644
index 00000000000..ac0d52e4a2b
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueSystem.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/modulePrologueSystem.ts ===
+"use strict";
+>"use strict" : string
+
+export class Foo {}
+>Foo : Foo
+
diff --git a/tests/baselines/reference/modulePrologueUmd.js b/tests/baselines/reference/modulePrologueUmd.js
new file mode 100644
index 00000000000..65803af6cad
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueUmd.js
@@ -0,0 +1,22 @@
+//// [modulePrologueUmd.ts]
+"use strict";
+
+export class Foo {}
+
+//// [modulePrologueUmd.js]
+(function (factory) {
+    if (typeof module === 'object' && typeof module.exports === 'object') {
+        var v = factory(require, exports); if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === 'function' && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var Foo = (function () {
+        function Foo() {
+        }
+        return Foo;
+    })();
+    exports.Foo = Foo;
+});
diff --git a/tests/baselines/reference/modulePrologueUmd.symbols b/tests/baselines/reference/modulePrologueUmd.symbols
new file mode 100644
index 00000000000..3b015b2ea44
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueUmd.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/modulePrologueUmd.ts ===
+"use strict";
+
+export class Foo {}
+>Foo : Symbol(Foo, Decl(modulePrologueUmd.ts, 0, 13))
+
diff --git a/tests/baselines/reference/modulePrologueUmd.types b/tests/baselines/reference/modulePrologueUmd.types
new file mode 100644
index 00000000000..2a1064da8e2
--- /dev/null
+++ b/tests/baselines/reference/modulePrologueUmd.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/modulePrologueUmd.ts ===
+"use strict";
+>"use strict" : string
+
+export class Foo {}
+>Foo : Foo
+
diff --git a/tests/baselines/reference/multipleDefaultExports01.errors.txt b/tests/baselines/reference/multipleDefaultExports01.errors.txt
index 72898d474e8..16aa3b2f7b1 100644
--- a/tests/baselines/reference/multipleDefaultExports01.errors.txt
+++ b/tests/baselines/reference/multipleDefaultExports01.errors.txt
@@ -1,6 +1,6 @@
-tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2300: Duplicate identifier 'foo'.
-tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2300: Duplicate identifier 'bar'.
-tests/cases/conformance/es6/modules/m1.ts(11,1): error TS2300: Duplicate identifier 'default'.
+tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2528: A module cannot have multiple default exports.
+tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2528: A module cannot have multiple default exports.
+tests/cases/conformance/es6/modules/m1.ts(11,1): error TS2528: A module cannot have multiple default exports.
 tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typeof foo' is not callable. Did you mean to include 'new'?
 
 
@@ -8,20 +8,20 @@ tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typ
     
     export default class foo {
                          ~~~
-!!! error TS2300: Duplicate identifier 'foo'.
+!!! error TS2528: A module cannot have multiple default exports.
     
     }
     
     export default function bar() {
                             ~~~
-!!! error TS2300: Duplicate identifier 'bar'.
+!!! error TS2528: A module cannot have multiple default exports.
     
     }
     
     var x = 10;
     export default x;
     ~~~~~~~~~~~~~~~~~
-!!! error TS2300: Duplicate identifier 'default'.
+!!! error TS2528: A module cannot have multiple default exports.
     
 ==== tests/cases/conformance/es6/modules/m2.ts (1 errors) ====
     import Entity from "./m1"
diff --git a/tests/baselines/reference/multipleDefaultExports03.errors.txt b/tests/baselines/reference/multipleDefaultExports03.errors.txt
new file mode 100644
index 00000000000..5c4b075b009
--- /dev/null
+++ b/tests/baselines/reference/multipleDefaultExports03.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(2,22): error TS2528: A module cannot have multiple default exports.
+tests/cases/conformance/es6/modules/multipleDefaultExports03.ts(5,22): error TS2528: A module cannot have multiple default exports.
+
+
+==== tests/cases/conformance/es6/modules/multipleDefaultExports03.ts (2 errors) ====
+    
+    export default class C {
+                         ~
+!!! error TS2528: A module cannot have multiple default exports.
+    }
+    
+    export default class C {
+                         ~
+!!! error TS2528: A module cannot have multiple default exports.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/multipleDefaultExports03.js b/tests/baselines/reference/multipleDefaultExports03.js
new file mode 100644
index 00000000000..2824c7a5ac1
--- /dev/null
+++ b/tests/baselines/reference/multipleDefaultExports03.js
@@ -0,0 +1,23 @@
+//// [multipleDefaultExports03.ts]
+
+export default class C {
+}
+
+export default class C {
+}
+
+//// [multipleDefaultExports03.js]
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = C;
+var C = (function () {
+    function C() {
+    }
+    return C;
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = C;
diff --git a/tests/baselines/reference/multipleDefaultExports04.errors.txt b/tests/baselines/reference/multipleDefaultExports04.errors.txt
new file mode 100644
index 00000000000..e67659f6b9f
--- /dev/null
+++ b/tests/baselines/reference/multipleDefaultExports04.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(2,25): error TS2393: Duplicate function implementation.
+tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(5,25): error TS2393: Duplicate function implementation.
+
+
+==== tests/cases/conformance/es6/modules/multipleDefaultExports04.ts (2 errors) ====
+    
+    export default function f() {
+                            ~
+!!! error TS2393: Duplicate function implementation.
+    }
+    
+    export default function f() {
+                            ~
+!!! error TS2393: Duplicate function implementation.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/multipleDefaultExports04.js b/tests/baselines/reference/multipleDefaultExports04.js
new file mode 100644
index 00000000000..73582d7389e
--- /dev/null
+++ b/tests/baselines/reference/multipleDefaultExports04.js
@@ -0,0 +1,17 @@
+//// [multipleDefaultExports04.ts]
+
+export default function f() {
+}
+
+export default function f() {
+}
+
+//// [multipleDefaultExports04.js]
+function f() {
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = f;
+function f() {
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = f;
diff --git a/tests/baselines/reference/negateOperatorWithStringType.symbols b/tests/baselines/reference/negateOperatorWithStringType.symbols
index 00a90bdf743..5ef0afc7e1c 100644
--- a/tests/baselines/reference/negateOperatorWithStringType.symbols
+++ b/tests/baselines/reference/negateOperatorWithStringType.symbols
@@ -88,9 +88,9 @@ var ResultIsNumber11 = -(STRING + STRING);
 
 var ResultIsNumber12 = -STRING.charAt(0);
 >ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(negateOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(negateOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 // miss assignment operators
 -"";
diff --git a/tests/baselines/reference/nestedSelf.symbols b/tests/baselines/reference/nestedSelf.symbols
index 08f41f155d6..a14a9b9d374 100644
--- a/tests/baselines/reference/nestedSelf.symbols
+++ b/tests/baselines/reference/nestedSelf.symbols
@@ -10,8 +10,8 @@ module M {
 
    public foo() { [1,2,3].map((x) => { return this.n * x; })}
 >foo : Symbol(foo, Decl(nestedSelf.ts, 2, 17))
->[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(nestedSelf.ts, 3, 31))
 >this.n : Symbol(n, Decl(nestedSelf.ts, 1, 17))
 >this : Symbol(C, Decl(nestedSelf.ts, 0, 10))
diff --git a/tests/baselines/reference/newArrays.symbols b/tests/baselines/reference/newArrays.symbols
index fd30b2fe25e..663b6380bc7 100644
--- a/tests/baselines/reference/newArrays.symbols
+++ b/tests/baselines/reference/newArrays.symbols
@@ -25,7 +25,7 @@ module M {
 >this.fa : Symbol(fa, Decl(newArrays.ts, 2, 12))
 >this : Symbol(Gar, Decl(newArrays.ts, 1, 13))
 >fa : Symbol(fa, Decl(newArrays.ts, 2, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Foo : Symbol(Foo, Decl(newArrays.ts, 0, 10))
 >this.x : Symbol(x, Decl(newArrays.ts, 3, 19))
 >this : Symbol(Gar, Decl(newArrays.ts, 1, 13))
diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
index 9144d725efb..6cee1604cf0 100644
--- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
+++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols
@@ -4,11 +4,11 @@ var regexMatchList = ['', ''];
 >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3))
 
 regexMatchList.forEach(match => ''.replace(match, ''));
->regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23))
->''.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
+>''.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23))
 
diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
index 7c8f57795b4..96b38408560 100644
--- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
+++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols
@@ -74,7 +74,7 @@ var m: MyMap<number> = {
     "1": 1,
     "2": 2,
     "Okay that's enough for today.": NaN
->NaN : Symbol(NaN, Decl(lib.d.ts, 21, 11))
+>NaN : Symbol(NaN, Decl(lib.d.ts, --, --))
 
 };
 
diff --git a/tests/baselines/reference/nullAssignableToEveryType.symbols b/tests/baselines/reference/nullAssignableToEveryType.symbols
index 7179a02c0bc..a01077c8eb4 100644
--- a/tests/baselines/reference/nullAssignableToEveryType.symbols
+++ b/tests/baselines/reference/nullAssignableToEveryType.symbols
@@ -38,7 +38,7 @@ var d: boolean = null;
 
 var e: Date = null;
 >e : Symbol(e, Decl(nullAssignableToEveryType.ts, 15, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var f: any = null;
 >f : Symbol(f, Decl(nullAssignableToEveryType.ts, 16, 3))
@@ -48,7 +48,7 @@ var g: void = null;
 
 var h: Object = null;
 >h : Symbol(h, Decl(nullAssignableToEveryType.ts, 18, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var i: {} = null;
 >i : Symbol(i, Decl(nullAssignableToEveryType.ts, 19, 3))
@@ -58,7 +58,7 @@ var j: () => {} = null;
 
 var k: Function = null;
 >k : Symbol(k, Decl(nullAssignableToEveryType.ts, 21, 3))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var l: (x: number) => string = null;
 >l : Symbol(l, Decl(nullAssignableToEveryType.ts, 22, 3))
@@ -89,18 +89,18 @@ var o: <T>(x: T) => T = null;
 
 var p: Number = null;
 >p : Symbol(p, Decl(nullAssignableToEveryType.ts, 29, 3))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var q: String = null;
 >q : Symbol(q, Decl(nullAssignableToEveryType.ts, 30, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo<T, U, V extends Date>(x: T, y: U, z: V) {
 >foo : Symbol(foo, Decl(nullAssignableToEveryType.ts, 30, 21))
 >T : Symbol(T, Decl(nullAssignableToEveryType.ts, 32, 13))
 >U : Symbol(U, Decl(nullAssignableToEveryType.ts, 32, 15))
 >V : Symbol(V, Decl(nullAssignableToEveryType.ts, 32, 18))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(nullAssignableToEveryType.ts, 32, 35))
 >T : Symbol(T, Decl(nullAssignableToEveryType.ts, 32, 13))
 >y : Symbol(y, Decl(nullAssignableToEveryType.ts, 32, 40))
diff --git a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
index 7f81995c9be..cb6fab17560 100644
--- a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
+++ b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols
@@ -39,11 +39,11 @@ var r3 = true ? null : true;
 
 var r4 = true ? new Date() : null;
 >r4 : Symbol(r4, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 18, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 19, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r4 = true ? null : new Date();
 >r4 : Symbol(r4, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 18, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 19, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r5 = true ? /1/ : null;
 >r5 : Symbol(r5, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 21, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 22, 3))
@@ -233,11 +233,11 @@ function f18<T, U>(x: U) {
 
 var r19 = true ? new Object() : null;
 >r19 : Symbol(r19, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 85, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 86, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r19 = true ? null : new Object();
 >r19 : Symbol(r19, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 85, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 86, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r20 = true ? {} : null;
 >r20 : Symbol(r20, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 3))
diff --git a/tests/baselines/reference/numberPropertyAccess.symbols b/tests/baselines/reference/numberPropertyAccess.symbols
index fdfd4c404de..4792c16609a 100644
--- a/tests/baselines/reference/numberPropertyAccess.symbols
+++ b/tests/baselines/reference/numberPropertyAccess.symbols
@@ -4,23 +4,23 @@ var x = 1;
 
 var a = x.toExponential();
 >a : Symbol(a, Decl(numberPropertyAccess.ts, 1, 3))
->x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3))
->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 
 var b = x.hasOwnProperty('toFixed');
 >b : Symbol(b, Decl(numberPropertyAccess.ts, 2, 3))
->x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3))
->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
 var c = x['toExponential']();
 >c : Symbol(c, Decl(numberPropertyAccess.ts, 4, 3))
 >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3))
->'toExponential' : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>'toExponential' : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 
 var d = x['hasOwnProperty']('toFixed');
 >d : Symbol(d, Decl(numberPropertyAccess.ts, 5, 3))
 >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3))
->'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/objectLitGetterSetter.symbols b/tests/baselines/reference/objectLitGetterSetter.symbols
index 512e459c8c0..15f3cdd8a4f 100644
--- a/tests/baselines/reference/objectLitGetterSetter.symbols
+++ b/tests/baselines/reference/objectLitGetterSetter.symbols
@@ -3,17 +3,17 @@
 >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15))
 
             Object.defineProperty(obj, "accProperty", <PropertyDescriptor>({
->Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
->defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60))
+>Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15))
->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
+>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --))
 
                 get: function () {
 >get : Symbol(get, Decl(objectLitGetterSetter.ts, 1, 76))
 
                     eval("public = 1;");
->eval : Symbol(eval, Decl(lib.d.ts, 22, 29))
+>eval : Symbol(eval, Decl(lib.d.ts, --, --))
 
                     return 11;
                 },
diff --git a/tests/baselines/reference/objectMembersOnTypes.symbols b/tests/baselines/reference/objectMembersOnTypes.symbols
index 12cc909dcd9..3114d3b9695 100644
--- a/tests/baselines/reference/objectMembersOnTypes.symbols
+++ b/tests/baselines/reference/objectMembersOnTypes.symbols
@@ -10,25 +10,25 @@ var x: number;
 >x : Symbol(x, Decl(objectMembersOnTypes.ts, 2, 3))
 
 x.toString();
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectMembersOnTypes.ts, 2, 3))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 var i: I;
 >i : Symbol(i, Decl(objectMembersOnTypes.ts, 4, 3))
 >I : Symbol(I, Decl(objectMembersOnTypes.ts, 0, 0))
 
 i.toString(); // used to be an error
->i.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>i.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(objectMembersOnTypes.ts, 4, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var c: AAA;
 >c : Symbol(c, Decl(objectMembersOnTypes.ts, 6, 3))
 >AAA : Symbol(AAA, Decl(objectMembersOnTypes.ts, 0, 14))
 
 c.toString(); // used to be an error
->c.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>c.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >c : Symbol(c, Decl(objectMembersOnTypes.ts, 6, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/objectTypePropertyAccess.symbols b/tests/baselines/reference/objectTypePropertyAccess.symbols
index 519bf589260..2117b9ce35a 100644
--- a/tests/baselines/reference/objectTypePropertyAccess.symbols
+++ b/tests/baselines/reference/objectTypePropertyAccess.symbols
@@ -13,14 +13,14 @@ var c: C;
 
 var r1 = c.toString();
 >r1 : Symbol(r1, Decl(objectTypePropertyAccess.ts, 6, 3))
->c.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>c.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >c : Symbol(c, Decl(objectTypePropertyAccess.ts, 5, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r2 = c['toString']();
 >r2 : Symbol(r2, Decl(objectTypePropertyAccess.ts, 7, 3))
 >c : Symbol(c, Decl(objectTypePropertyAccess.ts, 5, 3))
->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r3 = c.foo;
 >r3 : Symbol(r3, Decl(objectTypePropertyAccess.ts, 8, 3))
@@ -45,14 +45,14 @@ var i: I;
 
 var r4 = i.toString();
 >r4 : Symbol(r4, Decl(objectTypePropertyAccess.ts, 9, 3), Decl(objectTypePropertyAccess.ts, 15, 3))
->i.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>i.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(objectTypePropertyAccess.ts, 14, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r5 = i['toString']();
 >r5 : Symbol(r5, Decl(objectTypePropertyAccess.ts, 16, 3))
 >i : Symbol(i, Decl(objectTypePropertyAccess.ts, 14, 3))
->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r6 = i.bar;
 >r6 : Symbol(r6, Decl(objectTypePropertyAccess.ts, 17, 3))
@@ -74,14 +74,14 @@ var a = {
 
 var r8 = a.toString();
 >r8 : Symbol(r8, Decl(objectTypePropertyAccess.ts, 24, 3))
->a.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>a.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(objectTypePropertyAccess.ts, 20, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r9 = a['toString']();
 >r9 : Symbol(r9, Decl(objectTypePropertyAccess.ts, 25, 3))
 >a : Symbol(a, Decl(objectTypePropertyAccess.ts, 20, 3))
->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r10 = a.foo;
 >r10 : Symbol(r10, Decl(objectTypePropertyAccess.ts, 26, 3))
diff --git a/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols b/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols
index 36127117f43..60b7b08397a 100644
--- a/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols
+++ b/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols
@@ -20,9 +20,9 @@ var r2b: (x: any, y?: any) => any = i.apply;
 >r2b : Symbol(r2b, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 9, 3))
 >x : Symbol(x, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 9, 10))
 >y : Symbol(y, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 9, 17))
->i.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>i.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 7, 3))
->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 
 var b: {
 >b : Symbol(b, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 11, 3))
@@ -38,7 +38,7 @@ var rb4: (x: any, y?: any) => any = b.apply;
 >rb4 : Symbol(rb4, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 16, 3))
 >x : Symbol(x, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 16, 10))
 >y : Symbol(y, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 16, 17))
->b.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>b.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 11, 3))
->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols
index de1f2abc5aa..2d80be5f4ea 100644
--- a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols
+++ b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols
@@ -3,14 +3,14 @@
 // no errors expected below 
 
 interface Function {
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 0, 0))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 0, 0))
 
     data: number;
 >data : Symbol(data, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 3, 20))
 
     [x: string]: Object;
 >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 5, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I {
@@ -50,9 +50,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call;
 
 var r1c = i.arguments;
 >r1c : Symbol(r1c, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 17, 3))
->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 14, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
 var r1d = i.data;
 >r1d : Symbol(r1d, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 18, 3))
@@ -97,9 +97,9 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call;
 
 var r2c = x.arguments;
 >r2c : Symbol(r2c, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 29, 3))
->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 21, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
 var r2d = x.data;
 >r2d : Symbol(r2d, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 30, 3))
diff --git a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols
index 0ddebe0e68c..07b0ca1a9c1 100644
--- a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols
+++ b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols
@@ -39,9 +39,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call;
 
 var r1c = i.arguments;
 >r1c : Symbol(r1c, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 12, 3))
->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 9, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
 var x: {
 >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 14, 3))
@@ -76,7 +76,7 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call;
 
 var r2c = x.arguments;
 >r2c : Symbol(r2c, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 22, 3))
->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 14, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols
index 57479c548ee..009291b0fb3 100644
--- a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols
+++ b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols
@@ -1,13 +1,13 @@
 === tests/cases/conformance/types/members/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts ===
 interface Function {
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 0, 0))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 0, 0))
 
     data: number;
 >data : Symbol(data, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 0, 20))
 
     [x: string]: Object;
 >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 2, 5))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I {
@@ -47,9 +47,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call;
 
 var r1c = i.arguments;
 >r1c : Symbol(r1c, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 14, 3))
->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 11, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
 var r1d = i.data;
 >r1d : Symbol(r1d, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 15, 3))
@@ -94,9 +94,9 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call;
 
 var r2c = x.arguments;
 >r2c : Symbol(r2c, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 26, 3))
->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 18, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
 var r2d = x.data;
 >r2d : Symbol(r2d, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 27, 3))
diff --git a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols
index 8478fd1d37c..c623bcb6f63 100644
--- a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols
+++ b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols
@@ -36,9 +36,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call;
 
 var r1c = i.arguments;
 >r1c : Symbol(r1c, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 9, 3))
->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 6, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
 var x: {
 >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 11, 3))
@@ -73,7 +73,7 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call;
 
 var r2c = x.arguments;
 >r2c : Symbol(r2c, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 19, 3))
->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 11, 3))
->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19))
+>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
index c95105a8626..d3c463d9a15 100644
--- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
+++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols
@@ -9,19 +9,19 @@ class C {
 
     "0.1": void;
     ".1": Object;
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "1": number;
     "1.": string;
     "1..": boolean;
     "1.0": Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": RegExp;
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1": Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var c: C;
@@ -115,19 +115,19 @@ interface I {
 
     "0.1": void;
     ".1": Object;
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "1": number;
     "1.": string;
     "1..": boolean;
     "1.0": Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": RegExp;
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1": Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var i: I;
@@ -221,19 +221,19 @@ var a: {
 
     "0.1": void;
     ".1": Object;
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "1": number;
     "1.": string;
     "1..": boolean;
     "1.0": Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": RegExp;
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1": Date;
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var r1 = a['0.1'];
@@ -323,17 +323,17 @@ var b = {
 
     "0.1": <void>null,
     ".1": new Object(),
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "1": 1,
     "1.": "",
     "1..": true,
     "1.0": new Date(),
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     "-1.0": /123/,
     "-1": Date
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 };
 
diff --git a/tests/baselines/reference/objectTypesIdentity2.symbols b/tests/baselines/reference/objectTypesIdentity2.symbols
index e78def5ca00..6db54e5b59a 100644
--- a/tests/baselines/reference/objectTypesIdentity2.symbols
+++ b/tests/baselines/reference/objectTypesIdentity2.symbols
@@ -29,13 +29,13 @@ interface I {
 
     foo: Date;
 >foo : Symbol(foo, Decl(objectTypesIdentity2.ts, 14, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var a: { foo: RegExp; }
 >a : Symbol(a, Decl(objectTypesIdentity2.ts, 18, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentity2.ts, 18, 8))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 enum E { A }
 >E : Symbol(E, Decl(objectTypesIdentity2.ts, 18, 23))
diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
index 85c138a8c34..7e081608bc0 100644
--- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols
@@ -51,13 +51,13 @@ var a: { foo(x: Date): string }
 >a : Symbol(a, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 8))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b = { foo(x: RegExp) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 14))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1(x: A);
 >foo1 : Symbol(foo1, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 42), Decl(objectTypesIdentityWithCallSignatures2.ts, 25, 20), Decl(objectTypesIdentityWithCallSignatures2.ts, 26, 20))
diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
index 0d37d7fc97b..90ec832873c 100644
--- a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols
@@ -37,13 +37,13 @@ interface I2<T> {
 var a: { new(x: Date): string }
 >a : Symbol(a, Decl(objectTypesIdentityWithConstructSignatures2.ts, 18, 3))
 >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignatures2.ts, 18, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var b = { new(x: RegExp) { return ''; } }; // not a construct signature, function called new
 >b : Symbol(b, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 3))
 >new : Symbol(new, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 9))
 >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 14))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: B);
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 42), Decl(objectTypesIdentityWithConstructSignatures2.ts, 21, 21), Decl(objectTypesIdentityWithConstructSignatures2.ts, 22, 21))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
index 3b681c55c13..b8432af2425 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols
@@ -9,7 +9,7 @@ class A {
     foo<T extends Date>(x: T): string { return null; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 4, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 8))
 }
@@ -17,7 +17,7 @@ class A {
 class B<T extends Array<number>> {
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 8, 8))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): string { return null; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 8, 34))
@@ -28,7 +28,7 @@ class B<T extends Array<number>> {
 class C<T extends String> {
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 12, 8))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): string { return null; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 12, 27))
@@ -39,7 +39,7 @@ class C<T extends String> {
 interface I<T extends Number> {
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 16, 12))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): string;
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 16, 31))
@@ -53,7 +53,7 @@ interface I2 {
     foo<T extends Boolean>(x: T): string;
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 20, 14))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 21, 8))
->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11))
+>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 21, 27))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 21, 8))
 }
@@ -62,7 +62,7 @@ var a: { foo<T extends Array<string>>(x: T): string }
 >a : Symbol(a, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 13))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 38))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 13))
 
@@ -70,7 +70,7 @@ var b = { foo<T extends RegExp>(x: T) { return ''; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 14))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 32))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 14))
 
@@ -92,13 +92,13 @@ function foo1b(x: B<Array<number>>);
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 36))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: B<Array<number>>); // error
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 36))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: any) { }
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 36))
@@ -108,13 +108,13 @@ function foo1c(x: C<String>);
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: C<String>); // error
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: any) { }
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 29))
@@ -124,13 +124,13 @@ function foo2(x: I<Number>);
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 28), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: I<Number>); // error
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 28), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: any) { }
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 28), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 28))
@@ -173,7 +173,7 @@ function foo5(x: B<Array<number>>); // ok
 >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 52, 35))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 52, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo5(x: any) { }
 >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 52, 35))
@@ -188,7 +188,7 @@ function foo5b(x: C<String>); // ok
 >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 56, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 56, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo5b(x: any) { }
 >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 56, 29))
@@ -203,7 +203,7 @@ function foo6(x: I<Number>); // ok
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 60, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 60, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo6(x: any) { }
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 60, 28))
@@ -227,13 +227,13 @@ function foo8(x: B<Array<number>>);
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: I<Number>); // ok
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 28))
@@ -243,13 +243,13 @@ function foo9(x: B<Array<number>>);
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: C<String>); // ok
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 14))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: any) { }
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 28))
@@ -259,7 +259,7 @@ function foo10(x: B<Array<number>>);
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 75, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 76, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 75, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo10(x: typeof a); // ok
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 75, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 76, 28))
@@ -274,7 +274,7 @@ function foo11(x: B<Array<number>>);
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 79, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 80, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 79, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo11(x: typeof b); // ok
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 79, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 80, 28))
@@ -289,13 +289,13 @@ function foo12(x: I<Number>);
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<String>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 29))
@@ -310,7 +310,7 @@ function foo12b(x: C<String>); // ok
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 88, 30))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 88, 16))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12b(x: any) { }
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 88, 30))
@@ -320,7 +320,7 @@ function foo13(x: I<Number>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 91, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 92, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 91, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 91, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 92, 28))
@@ -335,7 +335,7 @@ function foo14(x: I<Number>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 95, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 96, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 95, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 95, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 96, 28))
@@ -355,7 +355,7 @@ function foo15(x: C<String>); // ok
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 100, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 100, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo15(x: any) { }
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 100, 29))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
index a9210b20f32..e199d538e4b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols
@@ -41,7 +41,7 @@ interface I<T> {
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 16, 16))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 17, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
@@ -52,7 +52,7 @@ interface I2 {
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 21, 8))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 21, 11))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 21, 8))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var a: { foo<T>(x: T): T }
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
index e1c4e120370..a0c520ef3fa 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols
@@ -9,7 +9,7 @@ class A {
     foo<T extends Date>(x: T): string { return null; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 4, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 8))
 }
@@ -17,7 +17,7 @@ class A {
 class B<T extends Date> {
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 8, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): number { return null; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 8, 25))
@@ -28,7 +28,7 @@ class B<T extends Date> {
 class C<T extends Date> {
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 12, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): boolean { return null; }
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 12, 25))
@@ -39,13 +39,13 @@ class C<T extends Date> {
 interface I<T extends Date> {
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: T): Date;
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 17, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
@@ -54,17 +54,17 @@ interface I2 {
     foo<T extends Date>(x: T): RegExp;
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 20, 14))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 8))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var a: { foo<T extends Date>(x: T): T }
 >a : Symbol(a, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 29))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13))
@@ -73,7 +73,7 @@ var b = { foo<T extends Date>(x: T) { return null; } };
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 3))
 >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 30))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14))
 
@@ -95,13 +95,13 @@ function foo1b(x: B<Date>);
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: B<Date>); // error
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: any) { }
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27))
@@ -111,13 +111,13 @@ function foo1c(x: C<Date>);
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: C<Date>); // error
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: any) { }
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27))
@@ -127,13 +127,13 @@ function foo2(x: I<Date>);
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: I<Date>); // error
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: any) { }
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26))
@@ -176,7 +176,7 @@ function foo5(x: B<Date>); // ok
 >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo5(x: any) { }
 >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 26))
@@ -191,7 +191,7 @@ function foo5b(x: C<Date>); // ok
 >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo5b(x: any) { }
 >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 27))
@@ -206,7 +206,7 @@ function foo6(x: I<Date>); // ok
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo6(x: any) { }
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 26))
@@ -230,13 +230,13 @@ function foo8(x: B<Date>);
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: I<Date>); // ok
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26))
@@ -246,13 +246,13 @@ function foo9(x: B<Date>);
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: C<Date>); // ok
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 14))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: any) { }
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26))
@@ -262,7 +262,7 @@ function foo10(x: B<Date>);
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 76, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo10(x: typeof a); // ok
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 76, 28))
@@ -277,7 +277,7 @@ function foo11(x: B<Date>);
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 80, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo11(x: typeof b); // ok
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 80, 28))
@@ -292,13 +292,13 @@ function foo12(x: I<Date>);
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<Date>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27))
@@ -313,7 +313,7 @@ function foo12b(x: C<Date>); // ok
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 16))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12b(x: any) { }
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 28))
@@ -323,7 +323,7 @@ function foo13(x: I<Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 92, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 92, 28))
@@ -338,7 +338,7 @@ function foo14(x: I<Date>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 96, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 96, 28))
@@ -358,7 +358,7 @@ function foo15(x: C<Date>); // ok
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo15(x: any) { }
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 27))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
index 9b801aa2c6f..a4760572e7d 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols
@@ -211,7 +211,7 @@ function foo6(x: I<string, number, boolean, Date>); // ok
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 57, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 51))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo6(x: any) { }
 >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 57, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 51))
@@ -240,7 +240,7 @@ function foo8(x: I<string, string, boolean, Date>); // error
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 63, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 65, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 51))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 63, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 65, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 51))
@@ -294,14 +294,14 @@ function foo12(x: I<B<string, number>, number, Date, string>);
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 4, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<B<string, number>, number, Date>); // error
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 79, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 62), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 54))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 8, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 4, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 79, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 62), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 54))
@@ -325,9 +325,9 @@ function foo13(x: I<string, Date, RegExp, Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 87, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 49), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 90, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 87, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 49), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 90, 28))
@@ -342,8 +342,8 @@ function foo14(x: I<string, Date, RegExp, boolean>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 91, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 94, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 91, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 94, 28))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols
index 7e9f1a97f69..d1f87946de5 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols
@@ -85,7 +85,7 @@ function foo13(x: I<boolean, string, number, Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 23, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 26, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 23, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 26, 28))
@@ -100,7 +100,7 @@ function foo14(x: I<boolean, string, number, Date>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 27, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 30, 22))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: I2); // error
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 27, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 30, 22))
@@ -129,7 +129,7 @@ function foo15(x: I<boolean, string, number, Date>);
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 38, 22))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo15(x: I2); // ok
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 38, 22))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
index 6f53dcf17b2..fb3fba82cb2 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols
@@ -6,7 +6,7 @@
 class B<T extends Array<number>> {
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 4, 8))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x: T) { return null; }
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 5, 16))
@@ -16,7 +16,7 @@ class B<T extends Array<number>> {
 class C<T extends String> {
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 8, 8))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x: T) { return null; }
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 9, 16))
@@ -26,7 +26,7 @@ class C<T extends String> {
 interface I<T extends Number> {
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 12, 12))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     new(x: T): string;
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 13, 8))
@@ -38,7 +38,7 @@ interface I2 {
 
     new<T extends Boolean>(x: T): string;
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 17, 8))
->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11))
+>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 17, 27))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 17, 8))
 }
@@ -46,7 +46,7 @@ interface I2 {
 var a: { new<T extends Array<string>>(x: T): string }
 >a : Symbol(a, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 3))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 13))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 38))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 13))
 
@@ -54,7 +54,7 @@ var b = { new<T extends RegExp>(x: T) { return ''; } }; // not a construct signa
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 3))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 14))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 32))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 14))
 
@@ -62,13 +62,13 @@ function foo1b(x: B<Array<number>>);
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 36))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: B<Array<number>>); // error
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 36))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: any) { }
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 36))
@@ -78,13 +78,13 @@ function foo1c(x: C<String>);
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: C<String>); // error
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: any) { }
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 29))
@@ -94,13 +94,13 @@ function foo2(x: I<Number>);
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 28), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: I<Number>); // error
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 28), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: any) { }
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 28), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 28))
@@ -138,13 +138,13 @@ function foo8(x: B<Array<number>>);
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: I<Number>); // ok
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 28))
@@ -154,13 +154,13 @@ function foo9(x: B<Array<number>>);
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: C<String>); // error, types are structurally equal
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 14))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: any) { }
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 28))
@@ -170,7 +170,7 @@ function foo10(x: B<Array<number>>);
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 51, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 52, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 51, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo10(x: typeof a); // ok
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 51, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 52, 28))
@@ -185,7 +185,7 @@ function foo11(x: B<Array<number>>);
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 55, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 56, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 55, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo11(x: typeof b); // ok
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 55, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 56, 28))
@@ -200,13 +200,13 @@ function foo12(x: I<Number>);
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<String>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 29))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 29))
@@ -221,7 +221,7 @@ function foo12b(x: C<String>); // ok
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 64, 30))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 64, 16))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12b(x: any) { }
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 64, 30))
@@ -231,7 +231,7 @@ function foo13(x: I<Number>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 67, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 68, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 67, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 67, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 68, 28))
@@ -246,7 +246,7 @@ function foo14(x: I<Number>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 71, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 72, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 71, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 71, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 72, 28))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
index 703ee5d3cc4..422b5820a8b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols
@@ -28,7 +28,7 @@ interface I<T> {
     new(x: T): Date;
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 13, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
@@ -38,7 +38,7 @@ interface I2 {
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 17, 8))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 17, 11))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 17, 8))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var a: { new<T>(x: T): T }
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
index faa0995c2dd..e44493e933b 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols
@@ -6,7 +6,7 @@
 class B<T extends Date> {
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 4, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x: T) { return null; }
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 5, 16))
@@ -16,7 +16,7 @@ class B<T extends Date> {
 class C<T extends Date> {
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 8, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(x: T) { return null; }
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 9, 16))
@@ -26,12 +26,12 @@ class C<T extends Date> {
 interface I<T extends Date> {
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     new(x: T): Date;
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 13, 8))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 12, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface I2 {
@@ -39,16 +39,16 @@ interface I2 {
 
     new<T extends Date>(x: T): RegExp;
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 24))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 8))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var a: { new<T extends Date>(x: T): T }
 >a : Symbol(a, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 3))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 29))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13))
@@ -57,7 +57,7 @@ var b = { new<T extends Date>(x: T) { return null; } }; // not a construct signa
 >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 3))
 >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 9))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 30))
 >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14))
 
@@ -65,13 +65,13 @@ function foo1b(x: B<Date>);
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: B<Date>); // error
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1b(x: any) { }
 >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27))
@@ -81,13 +81,13 @@ function foo1c(x: C<Date>);
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: C<Date>); // error
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo1c(x: any) { }
 >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27))
@@ -97,13 +97,13 @@ function foo2(x: I<Date>);
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: I<Date>); // error
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo2(x: any) { }
 >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26))
@@ -141,13 +141,13 @@ function foo8(x: B<Date>);
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: I<Date>); // ok
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26))
@@ -157,13 +157,13 @@ function foo9(x: B<Date>);
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 14))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: C<Date>); // error since types are structurally equal
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 14))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo9(x: any) { }
 >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26))
@@ -173,7 +173,7 @@ function foo10(x: B<Date>);
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 52, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo10(x: typeof a); // ok
 >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 52, 28))
@@ -188,7 +188,7 @@ function foo11(x: B<Date>);
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 56, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 15))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo11(x: typeof b); // ok
 >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 56, 28))
@@ -203,13 +203,13 @@ function foo12(x: I<Date>);
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<Date>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27))
@@ -224,7 +224,7 @@ function foo12b(x: C<Date>); // ok
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 16))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12b(x: any) { }
 >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 28))
@@ -234,7 +234,7 @@ function foo13(x: I<Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 68, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 68, 28))
@@ -249,7 +249,7 @@ function foo14(x: I<Date>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 72, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 72, 28))
@@ -269,7 +269,7 @@ function foo15(x: C<Date>); // ok
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 73, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 75, 22), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 27))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo15(x: any) { }
 >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 73, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 75, 22), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 27))
diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
index d7797a833c9..48f28e40b8a 100644
--- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
+++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols
@@ -159,7 +159,7 @@ function foo8(x: I<string, string, boolean, Date>); // BUG 832086
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 39, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 41, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 51))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 14))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo8(x: any) { }
 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 39, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 41, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 51))
@@ -213,14 +213,14 @@ function foo12(x: I<B<string, number>, number, Date, string>);
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: C<B<string, number>, number, Date>); // ok
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 62), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 54))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 15))
 >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 4, 1))
 >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo12(x: any) { }
 >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 62), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 54))
@@ -244,9 +244,9 @@ function foo13(x: I<string, Date, RegExp, Date>);
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 63, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 49), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 66, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo13(x: typeof a); // ok
 >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 63, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 49), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 66, 28))
@@ -261,8 +261,8 @@ function foo14(x: I<string, Date, RegExp, boolean>);
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 67, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 52), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 70, 28))
 >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 15))
 >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function foo14(x: typeof b); // ok
 >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 67, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 52), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 70, 28))
diff --git a/tests/baselines/reference/overloadOnGenericArity.symbols b/tests/baselines/reference/overloadOnGenericArity.symbols
index 28f3c74fd2b..a9fddb65177 100644
--- a/tests/baselines/reference/overloadOnGenericArity.symbols
+++ b/tests/baselines/reference/overloadOnGenericArity.symbols
@@ -10,7 +10,7 @@ interface Test {
     then(p: string): Date; // Error: Overloads cannot differ only by return type
 >then : Symbol(then, Decl(overloadOnGenericArity.ts, 0, 16), Decl(overloadOnGenericArity.ts, 1, 31))
 >p : Symbol(p, Decl(overloadOnGenericArity.ts, 2, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
   
 
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
index bc2bd0785b9..02390079e38 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
+++ b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols
@@ -14,9 +14,9 @@ module Bugs {
 
     var result= message.replace(/\{(\d+)\}/g, function(match, ...rest) {
 >result : Symbol(result, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 7))
->message.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
+>message.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >message : Symbol(message, Decl(overloadResolutionOverNonCTLambdas.ts, 5, 16))
->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
+>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >match : Symbol(match, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 55))
 >rest : Symbol(rest, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 61))
 
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
index 850f188a58b..d352216b74e 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
+++ b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols
@@ -39,17 +39,17 @@ module Bugs {
 >IToken : Symbol(IToken, Decl(overloadResolutionOverNonCTObjectLit.ts, 0, 13))
 
                                 tokens.push({ startIndex: 1, type: '', bracket: 3 });
->tokens.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>tokens.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 45))
 >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 60))
 >bracket : Symbol(bracket, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 70))
 
                                 tokens.push(<IToken>({ startIndex: 1, type: '', bracket: 3, state: null, length: 10 }));
->tokens.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>tokens.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >IToken : Symbol(IToken, Decl(overloadResolutionOverNonCTObjectLit.ts, 0, 13))
 >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 54))
 >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 69))
diff --git a/tests/baselines/reference/overloadResolutionWithAny.symbols b/tests/baselines/reference/overloadResolutionWithAny.symbols
index af998b6b376..425855fb7da 100644
--- a/tests/baselines/reference/overloadResolutionWithAny.symbols
+++ b/tests/baselines/reference/overloadResolutionWithAny.symbols
@@ -37,7 +37,7 @@ var func2: {
     (s: string, t: any): RegExp;
 >s : Symbol(s, Decl(overloadResolutionWithAny.ts, 13, 5))
 >t : Symbol(t, Decl(overloadResolutionWithAny.ts, 13, 15))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     (s: any, t: any): string;
 >s : Symbol(s, Decl(overloadResolutionWithAny.ts, 14, 5))
diff --git a/tests/baselines/reference/overloadsWithConstraints.symbols b/tests/baselines/reference/overloadsWithConstraints.symbols
index 68b675093bf..4b33826e6b8 100644
--- a/tests/baselines/reference/overloadsWithConstraints.symbols
+++ b/tests/baselines/reference/overloadsWithConstraints.symbols
@@ -2,7 +2,7 @@
 declare function f<T extends Number>(x: T): T;
 >f : Symbol(f, Decl(overloadsWithConstraints.ts, 0, 0), Decl(overloadsWithConstraints.ts, 0, 46))
 >T : Symbol(T, Decl(overloadsWithConstraints.ts, 0, 19))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(overloadsWithConstraints.ts, 0, 37))
 >T : Symbol(T, Decl(overloadsWithConstraints.ts, 0, 19))
 >T : Symbol(T, Decl(overloadsWithConstraints.ts, 0, 19))
@@ -10,7 +10,7 @@ declare function f<T extends Number>(x: T): T;
 declare function f<T extends String>(x: T): T
 >f : Symbol(f, Decl(overloadsWithConstraints.ts, 0, 0), Decl(overloadsWithConstraints.ts, 0, 46))
 >T : Symbol(T, Decl(overloadsWithConstraints.ts, 1, 19))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(overloadsWithConstraints.ts, 1, 37))
 >T : Symbol(T, Decl(overloadsWithConstraints.ts, 1, 19))
 >T : Symbol(T, Decl(overloadsWithConstraints.ts, 1, 19))
diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.symbols b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
index 698e26734ad..e5efefb89a0 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping1.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping1.symbols
@@ -102,9 +102,9 @@ var h = fun((((x => x))), ((x => x)), 10);
 var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
 >i : Symbol(i, Decl(parenthesizedContexualTyping1.ts, 18, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 43))
@@ -113,9 +113,9 @@ var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10);
 var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
 >j : Symbol(j, Decl(parenthesizedContexualTyping1.ts, 19, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 47))
@@ -124,9 +124,9 @@ var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10);
 var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
 >k : Symbol(k, Decl(parenthesizedContexualTyping1.ts, 20, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 47))
@@ -137,9 +137,9 @@ var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10);
 var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10);
 >l : Symbol(l, Decl(parenthesizedContexualTyping1.ts, 21, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 51))
diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.symbols b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
index f7616f07710..bd735a8078a 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping2.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping2.symbols
@@ -128,9 +128,9 @@ var h = fun((((x => { x<number>(undefined); return x; }))),((x => { x<number>(un
 var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x => undefined), 10);
 >i : Symbol(i, Decl(parenthesizedContexualTyping2.ts, 25, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34))
 >undefined : Symbol(undefined)
@@ -141,9 +141,9 @@ var i = fun((Math.random() < 0.5 ? x => { x<number>(undefined); return x; } : x
 var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), 10);
 >j : Symbol(j, Decl(parenthesizedContexualTyping2.ts, 26, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36))
 >undefined : Symbol(undefined)
@@ -154,9 +154,9 @@ var j = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) : (x => undefined)), x => { x<number>(undefined); return x; }, 10);
 >k : Symbol(k, Decl(parenthesizedContexualTyping2.ts, 27, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36))
 >undefined : Symbol(undefined)
@@ -171,9 +171,9 @@ var k = fun((Math.random() < 0.5 ? (x => { x<number>(undefined); return x; }) :
 var l = fun(((Math.random() < 0.5 ? ((x => { x<number>(undefined); return x; })) : ((x => undefined)))),((x => { x<number>(undefined); return x; })), 10);
 >l : Symbol(l, Decl(parenthesizedContexualTyping2.ts, 28, 3))
 >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51))
->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
+>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38))
 >undefined : Symbol(undefined)
diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.symbols b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
index b0d696e2d21..4db888efd61 100644
--- a/tests/baselines/reference/parenthesizedContexualTyping3.symbols
+++ b/tests/baselines/reference/parenthesizedContexualTyping3.symbols
@@ -9,7 +9,7 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T;
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17))
 >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 6, 20))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 6, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 56))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17))
@@ -22,7 +22,7 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: T) =>
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17))
 >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 7, 20))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 7, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 56))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17))
@@ -39,7 +39,7 @@ function tempFun<T>(tempStrs: TemplateStringsArray, g: (x: T) => T, x: T): T {
 >tempFun : Symbol(tempFun, Decl(parenthesizedContexualTyping3.ts, 0, 0), Decl(parenthesizedContexualTyping3.ts, 6, 77), Decl(parenthesizedContexualTyping3.ts, 7, 93))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17))
 >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 8, 20))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 8, 51))
 >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 8, 56))
 >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 8, 17))
diff --git a/tests/baselines/reference/parenthesizedTypes.symbols b/tests/baselines/reference/parenthesizedTypes.symbols
index ec0ec4e4c6f..7d7706795d5 100644
--- a/tests/baselines/reference/parenthesizedTypes.symbols
+++ b/tests/baselines/reference/parenthesizedTypes.symbols
@@ -40,19 +40,19 @@ var d: ({ (x: string): string } | { (x: number): number })[];
 
 var d: Array<((x: string) => string) | ((x: number) => number)>;
 >d : Symbol(d, Decl(parenthesizedTypes.ts, 12, 3), Decl(parenthesizedTypes.ts, 13, 3), Decl(parenthesizedTypes.ts, 14, 3), Decl(parenthesizedTypes.ts, 15, 3), Decl(parenthesizedTypes.ts, 16, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedTypes.ts, 14, 15))
 >x : Symbol(x, Decl(parenthesizedTypes.ts, 14, 41))
 
 var d: Array<{ (x: string): string } | { (x: number): number }>;
 >d : Symbol(d, Decl(parenthesizedTypes.ts, 12, 3), Decl(parenthesizedTypes.ts, 13, 3), Decl(parenthesizedTypes.ts, 14, 3), Decl(parenthesizedTypes.ts, 15, 3), Decl(parenthesizedTypes.ts, 16, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedTypes.ts, 15, 16))
 >x : Symbol(x, Decl(parenthesizedTypes.ts, 15, 42))
 
 var d: (Array<{ (x: string): string } | { (x: number): number }>);
 >d : Symbol(d, Decl(parenthesizedTypes.ts, 12, 3), Decl(parenthesizedTypes.ts, 13, 3), Decl(parenthesizedTypes.ts, 14, 3), Decl(parenthesizedTypes.ts, 15, 3), Decl(parenthesizedTypes.ts, 16, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(parenthesizedTypes.ts, 16, 17))
 >x : Symbol(x, Decl(parenthesizedTypes.ts, 16, 43))
 
diff --git a/tests/baselines/reference/parseRegularExpressionMixedWithComments.errors.txt b/tests/baselines/reference/parseRegularExpressionMixedWithComments.errors.txt
index a6d63ce1754..b4e08a6af46 100644
--- a/tests/baselines/reference/parseRegularExpressionMixedWithComments.errors.txt
+++ b/tests/baselines/reference/parseRegularExpressionMixedWithComments.errors.txt
@@ -1,12 +1,10 @@
 tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts(5,18): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts(5,22): error TS1109: Expression expected.
 tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts(5,23): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts(6,18): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts(6,26): error TS1109: Expression expected.
 tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts(6,27): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 
 
-==== tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts (6 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpressionMixedWithComments.ts (4 errors) ====
     var regex1 = / asdf /;
     var regex2 = /**// asdf /;
     var regex3 = /**///**/ asdf /       // should be a comment line
@@ -14,14 +12,10 @@ tests/cases/conformance/parser/ecmascript5/RegularExpressions/parseRegularExpres
     var regex4 = /**// /**/asdf /;
                      ~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-                         ~
-!!! error TS1109: Expression expected.
                           ~~~~~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
     var regex5 = /**// asdf/**/ /;
                      ~~~~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-                             ~
-!!! error TS1109: Expression expected.
                               ~~~
 !!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
\ No newline at end of file
diff --git a/tests/baselines/reference/parseRegularExpressionMixedWithComments.js b/tests/baselines/reference/parseRegularExpressionMixedWithComments.js
index c7aded33697..78752a77f75 100644
--- a/tests/baselines/reference/parseRegularExpressionMixedWithComments.js
+++ b/tests/baselines/reference/parseRegularExpressionMixedWithComments.js
@@ -10,5 +10,5 @@ var regex5 = /**// asdf/**/ /;
 var regex1 = / asdf /;
 var regex2 = / asdf /;
 var regex3 = 1;
-var regex4 = / / *  * /asdf /;
-var regex5 = / asdf/ *  * / /;
+var regex4 = Math.pow(/ /, /asdf /);
+var regex5 = Math.pow(/ asdf/, / /);
diff --git a/tests/baselines/reference/parser630933.symbols b/tests/baselines/reference/parser630933.symbols
index 70a069c3581..0f2ac0679e0 100644
--- a/tests/baselines/reference/parser630933.symbols
+++ b/tests/baselines/reference/parser630933.symbols
@@ -4,7 +4,7 @@ var a = "Hello";
 
 var b = a.match(/\/ver=([^/]+)/);
 >b : Symbol(b, Decl(parser630933.ts, 1, 3))
->a.match : Symbol(String.match, Decl(lib.d.ts, 317, 40), Decl(lib.d.ts, 323, 44))
+>a.match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(parser630933.ts, 0, 3))
->match : Symbol(String.match, Decl(lib.d.ts, 317, 40), Decl(lib.d.ts, 323, 44))
+>match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/parserS7.9_A5.7_T1.errors.txt b/tests/baselines/reference/parserS7.9_A5.7_T1.errors.txt
index ed5f1738c50..63bb9f06ecd 100644
--- a/tests/baselines/reference/parserS7.9_A5.7_T1.errors.txt
+++ b/tests/baselines/reference/parserS7.9_A5.7_T1.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/parser/ecmascript5/parserS7.9_A5.7_T1.ts(17,1): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/parser/ecmascript5/parserS7.9_A5.7_T1.ts(17,1): error TS1109: Expression expected.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/parserS7.9_A5.7_T1.ts (1 errors) ====
@@ -20,8 +20,7 @@ tests/cases/conformance/parser/ecmascript5/parserS7.9_A5.7_T1.ts(17,1): error TS
     ++
     ++
     ~~
+!!! error TS1109: Expression expected.
     y
-    ~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
     
     
\ No newline at end of file
diff --git a/tests/baselines/reference/parserS7.9_A5.7_T1.js b/tests/baselines/reference/parserS7.9_A5.7_T1.js
index ae5896c28e5..575d62caf19 100644
--- a/tests/baselines/reference/parserS7.9_A5.7_T1.js
+++ b/tests/baselines/reference/parserS7.9_A5.7_T1.js
@@ -33,4 +33,5 @@ y
  */
 var x = 0, y = 0;
 var z = x;
-++++y;
+++;
+++y;
diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols
index f21959df892..b337b6ae30b 100644
--- a/tests/baselines/reference/parserSymbolProperty1.symbols
+++ b/tests/baselines/reference/parserSymbolProperty1.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(parserSymbolProperty1.ts, 0, 0))
 
     [Symbol.iterator]: string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols
index 9f43ba7b006..d4bfa388fa8 100644
--- a/tests/baselines/reference/parserSymbolProperty2.symbols
+++ b/tests/baselines/reference/parserSymbolProperty2.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(parserSymbolProperty2.ts, 0, 0))
 
     [Symbol.unscopables](): string;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols
index e3a3b1d5609..b740d5be4ad 100644
--- a/tests/baselines/reference/parserSymbolProperty3.symbols
+++ b/tests/baselines/reference/parserSymbolProperty3.symbols
@@ -3,7 +3,7 @@ declare class C {
 >C : Symbol(C, Decl(parserSymbolProperty3.ts, 0, 0))
 
     [Symbol.unscopables](): string;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols
index ba0134e82a9..65250e977b7 100644
--- a/tests/baselines/reference/parserSymbolProperty4.symbols
+++ b/tests/baselines/reference/parserSymbolProperty4.symbols
@@ -3,7 +3,7 @@ declare class C {
 >C : Symbol(C, Decl(parserSymbolProperty4.ts, 0, 0))
 
     [Symbol.toPrimitive]: string;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols
index 970f8a0b753..c883c0aa12f 100644
--- a/tests/baselines/reference/parserSymbolProperty5.symbols
+++ b/tests/baselines/reference/parserSymbolProperty5.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty5.ts, 0, 0))
 
     [Symbol.toPrimitive]: string;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols
index 29831fad7ef..d8a2b9bf1cc 100644
--- a/tests/baselines/reference/parserSymbolProperty6.symbols
+++ b/tests/baselines/reference/parserSymbolProperty6.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty6.ts, 0, 0))
 
     [Symbol.toStringTag]: string = "";
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols
index 8322d312839..9319dfe87bb 100644
--- a/tests/baselines/reference/parserSymbolProperty7.symbols
+++ b/tests/baselines/reference/parserSymbolProperty7.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty7.ts, 0, 0))
 
     [Symbol.toStringTag](): void { }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols
index 7c5dfbff7c6..2a58473973e 100644
--- a/tests/baselines/reference/parserSymbolProperty8.symbols
+++ b/tests/baselines/reference/parserSymbolProperty8.symbols
@@ -3,7 +3,7 @@ var x: {
 >x : Symbol(x, Decl(parserSymbolProperty8.ts, 0, 3))
 
     [Symbol.toPrimitive](): string
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols
index 7ee5e7e6998..85c66b21d5e 100644
--- a/tests/baselines/reference/parserSymbolProperty9.symbols
+++ b/tests/baselines/reference/parserSymbolProperty9.symbols
@@ -3,7 +3,7 @@ var x: {
 >x : Symbol(x, Decl(parserSymbolProperty9.ts, 0, 3))
 
     [Symbol.toPrimitive]: string
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/parserUnaryExpression5.errors.txt b/tests/baselines/reference/parserUnaryExpression5.errors.txt
index b5d98b8cef4..0daa8d154c3 100644
--- a/tests/baselines/reference/parserUnaryExpression5.errors.txt
+++ b/tests/baselines/reference/parserUnaryExpression5.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression5.ts(1,4): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression5.ts(1,4): error TS1109: Expression expected.
 tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression5.ts(1,11): error TS2304: Cannot find name 'foo'.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/Expressions/parserUnaryExpression5.ts (2 errors) ====
     ++ delete foo.bar
-       ~~~~~~~~~~~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+       ~~~~~~
+!!! error TS1109: Expression expected.
               ~~~
 !!! error TS2304: Cannot find name 'foo'.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserUnaryExpression5.js b/tests/baselines/reference/parserUnaryExpression5.js
index 9495ee15b88..c1bbbd00818 100644
--- a/tests/baselines/reference/parserUnaryExpression5.js
+++ b/tests/baselines/reference/parserUnaryExpression5.js
@@ -2,4 +2,5 @@
 ++ delete foo.bar
 
 //// [parserUnaryExpression5.js]
-++delete foo.bar;
+++;
+delete foo.bar;
diff --git a/tests/baselines/reference/plusOperatorWithStringType.symbols b/tests/baselines/reference/plusOperatorWithStringType.symbols
index 1ff2cec5dff..fd3e10c172f 100644
--- a/tests/baselines/reference/plusOperatorWithStringType.symbols
+++ b/tests/baselines/reference/plusOperatorWithStringType.symbols
@@ -88,9 +88,9 @@ var ResultIsNumber11 = +(STRING + STRING);
 
 var ResultIsNumber12 = +STRING.charAt(0);
 >ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(plusOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(plusOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 // miss assignment operators
 +"";
diff --git a/tests/baselines/reference/promiseChaining.symbols b/tests/baselines/reference/promiseChaining.symbols
index 1ad7044faae..f13323742ce 100644
--- a/tests/baselines/reference/promiseChaining.symbols
+++ b/tests/baselines/reference/promiseChaining.symbols
@@ -38,9 +38,9 @@ class Chain<T> {
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 49))
 >then : Symbol(Chain.then, Decl(promiseChaining.ts, 1, 36))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 76))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(promiseChaining.ts, 5, 76))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return new Chain(result);
 >Chain : Symbol(Chain, Decl(promiseChaining.ts, 0, 0))
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 3fc23ce5253..93e86b9ec2e 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -22,13 +22,13 @@ interface T3 {
 
 function f1(): Promise<T1> {
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5136, 39), Decl(lib.d.ts, 5143, 54))
->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5136, 39), Decl(lib.d.ts, 5143, 54))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -47,22 +47,22 @@ function f2(x: T1): T2 {
 
 var x3 = f1()
 >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3))
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
->f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
 
     .then(f2, (e: Error) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     throw e;
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 
 })
     .then((x: T2) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
diff --git a/tests/baselines/reference/propagationOfPromiseInitialization.symbols b/tests/baselines/reference/propagationOfPromiseInitialization.symbols
index 2289c175168..25527f05809 100644
--- a/tests/baselines/reference/propagationOfPromiseInitialization.symbols
+++ b/tests/baselines/reference/propagationOfPromiseInitialization.symbols
@@ -36,9 +36,9 @@ foo.then((x) => {
 
     // x is inferred to be string
     x.length;
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propagationOfPromiseInitialization.ts, 8, 9))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     return 123;
 });
diff --git a/tests/baselines/reference/propertyAccess7.symbols b/tests/baselines/reference/propertyAccess7.symbols
index f6407ae8c3c..9f9dd879f6a 100644
--- a/tests/baselines/reference/propertyAccess7.symbols
+++ b/tests/baselines/reference/propertyAccess7.symbols
@@ -3,7 +3,7 @@ var foo: string;
 >foo : Symbol(foo, Decl(propertyAccess7.ts, 0, 3))
 
 foo.toUpperCase();
->foo.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>foo.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 >foo : Symbol(foo, Decl(propertyAccess7.ts, 0, 3))
->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32))
+>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
index 99856e99ae1..bf5cb72a708 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols
@@ -5,7 +5,7 @@
 class C<T extends Date> {
 >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     f() {
 >f : Symbol(f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25))
@@ -17,13 +17,13 @@ class C<T extends Date> {
         var a = x['getDate'](); // number
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 6, 11))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 5, 11))
->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
         return a + x.getDate();
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 6, 11))
->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 5, 11))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
     }
 }
 
@@ -31,13 +31,13 @@ var r = (new C<Date>()).f();
 >r : Symbol(r, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 3))
 >(new C<Date>()).f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25))
 >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 0, 0))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25))
 
 interface I<T extends Date> {
 >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 28))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: T;
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29))
@@ -46,42 +46,42 @@ interface I<T extends Date> {
 var i: I<Date>;
 >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 16, 3))
 >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 28))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r2 = i.foo.getDate();
 >r2 : Symbol(r2, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 17, 3))
->i.foo.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>i.foo.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29))
 >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 16, 3))
 >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
 var r2b = i.foo['getDate']();
 >r2b : Symbol(r2b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 18, 3))
 >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29))
 >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 16, 3))
 >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29))
->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
 var a: {
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 20, 3))
 
     <T extends Date>(): T;
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 21, 5))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 21, 5))
 }
 var r3 = a<Date>().getDate();
 >r3 : Symbol(r3, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 23, 3))
->a<Date>().getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>a<Date>().getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 20, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
 var r3b = a()['getDate']();
 >r3b : Symbol(r3b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 24, 3))
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 20, 3))
->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 3))
@@ -89,20 +89,20 @@ var b = {
     foo: <T extends Date>(x: T) => {
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26))
 >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10))
 
         var a = x['getDate'](); // number
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 28, 11))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26))
->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 
         return a + x.getDate();
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 28, 11))
->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26))
->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26))
+>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --))
     }
 }
 
@@ -111,5 +111,5 @@ var r4 = b.foo(new Date());
 >b.foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 3))
 >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
index 425c7e42aff..7417346a791 100644
--- a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
+++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols
@@ -13,13 +13,13 @@ class C<T> {
         var a = x['toString'](); // should be string
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 3, 11))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 2, 11))
->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
         return a + x.toString();
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 3, 11))
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 2, 11))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
     }
 }
 
@@ -43,18 +43,18 @@ var i: I<number>;
 
 var r2 = i.foo.toString();
 >r2 : Symbol(r2, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 14, 3))
->i.foo.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>i.foo.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16))
 >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 13, 3))
 >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 var r2b = i.foo['toString']();
 >r2b : Symbol(r2b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 15, 3))
 >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16))
 >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 13, 3))
 >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16))
->'toString' : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>'toString' : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 var a: {
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 17, 3))
@@ -65,14 +65,14 @@ var a: {
 }
 var r3: string = a().toString();
 >r3 : Symbol(r3, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 20, 3))
->a().toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>a().toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 17, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var r3b: string = a()['toString']();
 >r3b : Symbol(r3b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 21, 3))
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 17, 3))
->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var b = {
 >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 3))
@@ -86,13 +86,13 @@ var b = {
         var a = x['toString'](); // should be string
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 25, 11))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 13))
->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
         return a + x.toString();
 >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 25, 11))
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 13))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/prototypeOnConstructorFunctions.symbols b/tests/baselines/reference/prototypeOnConstructorFunctions.symbols
index ada59370532..d3644ad89b2 100644
--- a/tests/baselines/reference/prototypeOnConstructorFunctions.symbols
+++ b/tests/baselines/reference/prototypeOnConstructorFunctions.symbols
@@ -15,9 +15,9 @@ var i: I1;
 
 
 i.const.prototype.prop = "yo";
->i.const.prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
+>i.const.prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --))
 >i.const : Symbol(I1.const, Decl(prototypeOnConstructorFunctions.ts, 0, 14))
 >i : Symbol(i, Decl(prototypeOnConstructorFunctions.ts, 5, 3))
 >const : Symbol(I1.const, Decl(prototypeOnConstructorFunctions.ts, 0, 14))
->prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48))
+>prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/recursiveGenericUnionType1.js b/tests/baselines/reference/recursiveGenericUnionType1.js
new file mode 100644
index 00000000000..54faae39b86
--- /dev/null
+++ b/tests/baselines/reference/recursiveGenericUnionType1.js
@@ -0,0 +1,29 @@
+//// [recursiveGenericUnionType1.ts]
+declare module Test1 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>;
+    };
+    export type IStringContainer = Container<string>;
+}
+
+declare module Test2 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>;
+    };
+    export type IStringContainer = Container<string>;
+}
+
+var x: Test1.Container<number>;
+
+var s1: Test1.IStringContainer;
+var s2: Test2.IStringContainer;
+s1 = s2;
+s2 = s1;
+
+
+//// [recursiveGenericUnionType1.js]
+var x;
+var s1;
+var s2;
+s1 = s2;
+s2 = s1;
diff --git a/tests/baselines/reference/recursiveGenericUnionType1.symbols b/tests/baselines/reference/recursiveGenericUnionType1.symbols
new file mode 100644
index 00000000000..bd48cf90cde
--- /dev/null
+++ b/tests/baselines/reference/recursiveGenericUnionType1.symbols
@@ -0,0 +1,62 @@
+=== tests/cases/compiler/recursiveGenericUnionType1.ts ===
+declare module Test1 {
+>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType1.ts, 0, 0))
+
+    export type Container<T> = T | {
+>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 0, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 1, 26))
+>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 1, 26))
+
+        [i: string]: Container<T>;
+>i : Symbol(i, Decl(recursiveGenericUnionType1.ts, 2, 9))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 0, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 1, 26))
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType1.ts, 3, 6))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 0, 22))
+}
+
+declare module Test2 {
+>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType1.ts, 5, 1))
+
+    export type Container<T> = T | {
+>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 7, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 8, 26))
+>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 8, 26))
+
+        [i: string]: Container<T>;
+>i : Symbol(i, Decl(recursiveGenericUnionType1.ts, 9, 9))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 7, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 8, 26))
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType1.ts, 10, 6))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 7, 22))
+}
+
+var x: Test1.Container<number>;
+>x : Symbol(x, Decl(recursiveGenericUnionType1.ts, 14, 3))
+>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType1.ts, 0, 0))
+>Container : Symbol(Test1.Container, Decl(recursiveGenericUnionType1.ts, 0, 22))
+
+var s1: Test1.IStringContainer;
+>s1 : Symbol(s1, Decl(recursiveGenericUnionType1.ts, 16, 3))
+>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType1.ts, 0, 0))
+>IStringContainer : Symbol(Test1.IStringContainer, Decl(recursiveGenericUnionType1.ts, 3, 6))
+
+var s2: Test2.IStringContainer;
+>s2 : Symbol(s2, Decl(recursiveGenericUnionType1.ts, 17, 3))
+>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType1.ts, 5, 1))
+>IStringContainer : Symbol(Test2.IStringContainer, Decl(recursiveGenericUnionType1.ts, 10, 6))
+
+s1 = s2;
+>s1 : Symbol(s1, Decl(recursiveGenericUnionType1.ts, 16, 3))
+>s2 : Symbol(s2, Decl(recursiveGenericUnionType1.ts, 17, 3))
+
+s2 = s1;
+>s2 : Symbol(s2, Decl(recursiveGenericUnionType1.ts, 17, 3))
+>s1 : Symbol(s1, Decl(recursiveGenericUnionType1.ts, 16, 3))
+
diff --git a/tests/baselines/reference/recursiveGenericUnionType1.types b/tests/baselines/reference/recursiveGenericUnionType1.types
new file mode 100644
index 00000000000..c153aba0e7c
--- /dev/null
+++ b/tests/baselines/reference/recursiveGenericUnionType1.types
@@ -0,0 +1,64 @@
+=== tests/cases/compiler/recursiveGenericUnionType1.ts ===
+declare module Test1 {
+>Test1 : any
+
+    export type Container<T> = T | {
+>Container : T | { [i: string]: T | any; }
+>T : T
+>T : T
+
+        [i: string]: Container<T>;
+>i : string
+>Container : T | { [i: string]: T | any; }
+>T : T
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : string | { [i: string]: string | any; }
+>Container : T | { [i: string]: T | any; }
+}
+
+declare module Test2 {
+>Test2 : any
+
+    export type Container<T> = T | {
+>Container : T | { [i: string]: T | any; }
+>T : T
+>T : T
+
+        [i: string]: Container<T>;
+>i : string
+>Container : T | { [i: string]: T | any; }
+>T : T
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : string | { [i: string]: string | any; }
+>Container : T | { [i: string]: T | any; }
+}
+
+var x: Test1.Container<number>;
+>x : number | { [i: string]: number | any; }
+>Test1 : any
+>Container : T | { [i: string]: T | any; }
+
+var s1: Test1.IStringContainer;
+>s1 : string | { [i: string]: string | any; }
+>Test1 : any
+>IStringContainer : string | { [i: string]: string | any; }
+
+var s2: Test2.IStringContainer;
+>s2 : string | { [i: string]: string | any; }
+>Test2 : any
+>IStringContainer : string | { [i: string]: string | any; }
+
+s1 = s2;
+>s1 = s2 : string | { [i: string]: string | any; }
+>s1 : string | { [i: string]: string | any; }
+>s2 : string | { [i: string]: string | any; }
+
+s2 = s1;
+>s2 = s1 : string | { [i: string]: string | any; }
+>s2 : string | { [i: string]: string | any; }
+>s1 : string | { [i: string]: string | any; }
+
diff --git a/tests/baselines/reference/recursiveGenericUnionType2.js b/tests/baselines/reference/recursiveGenericUnionType2.js
new file mode 100644
index 00000000000..bb7977d02cd
--- /dev/null
+++ b/tests/baselines/reference/recursiveGenericUnionType2.js
@@ -0,0 +1,29 @@
+//// [recursiveGenericUnionType2.ts]
+declare module Test1 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>[];
+    };
+    export type IStringContainer = Container<string>;
+}
+
+declare module Test2 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>[];
+    };
+    export type IStringContainer = Container<string>;
+}
+
+var x: Test1.Container<number>;
+
+var s1: Test1.IStringContainer;
+var s2: Test2.IStringContainer;
+s1 = s2;
+s2 = s1;
+
+
+//// [recursiveGenericUnionType2.js]
+var x;
+var s1;
+var s2;
+s1 = s2;
+s2 = s1;
diff --git a/tests/baselines/reference/recursiveGenericUnionType2.symbols b/tests/baselines/reference/recursiveGenericUnionType2.symbols
new file mode 100644
index 00000000000..bd189e68f3a
--- /dev/null
+++ b/tests/baselines/reference/recursiveGenericUnionType2.symbols
@@ -0,0 +1,62 @@
+=== tests/cases/compiler/recursiveGenericUnionType2.ts ===
+declare module Test1 {
+>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType2.ts, 0, 0))
+
+    export type Container<T> = T | {
+>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 0, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 1, 26))
+>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 1, 26))
+
+        [i: string]: Container<T>[];
+>i : Symbol(i, Decl(recursiveGenericUnionType2.ts, 2, 9))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 0, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 1, 26))
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType2.ts, 3, 6))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 0, 22))
+}
+
+declare module Test2 {
+>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType2.ts, 5, 1))
+
+    export type Container<T> = T | {
+>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 7, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 8, 26))
+>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 8, 26))
+
+        [i: string]: Container<T>[];
+>i : Symbol(i, Decl(recursiveGenericUnionType2.ts, 9, 9))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 7, 22))
+>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 8, 26))
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType2.ts, 10, 6))
+>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 7, 22))
+}
+
+var x: Test1.Container<number>;
+>x : Symbol(x, Decl(recursiveGenericUnionType2.ts, 14, 3))
+>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType2.ts, 0, 0))
+>Container : Symbol(Test1.Container, Decl(recursiveGenericUnionType2.ts, 0, 22))
+
+var s1: Test1.IStringContainer;
+>s1 : Symbol(s1, Decl(recursiveGenericUnionType2.ts, 16, 3))
+>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType2.ts, 0, 0))
+>IStringContainer : Symbol(Test1.IStringContainer, Decl(recursiveGenericUnionType2.ts, 3, 6))
+
+var s2: Test2.IStringContainer;
+>s2 : Symbol(s2, Decl(recursiveGenericUnionType2.ts, 17, 3))
+>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType2.ts, 5, 1))
+>IStringContainer : Symbol(Test2.IStringContainer, Decl(recursiveGenericUnionType2.ts, 10, 6))
+
+s1 = s2;
+>s1 : Symbol(s1, Decl(recursiveGenericUnionType2.ts, 16, 3))
+>s2 : Symbol(s2, Decl(recursiveGenericUnionType2.ts, 17, 3))
+
+s2 = s1;
+>s2 : Symbol(s2, Decl(recursiveGenericUnionType2.ts, 17, 3))
+>s1 : Symbol(s1, Decl(recursiveGenericUnionType2.ts, 16, 3))
+
diff --git a/tests/baselines/reference/recursiveGenericUnionType2.types b/tests/baselines/reference/recursiveGenericUnionType2.types
new file mode 100644
index 00000000000..f98cf144780
--- /dev/null
+++ b/tests/baselines/reference/recursiveGenericUnionType2.types
@@ -0,0 +1,64 @@
+=== tests/cases/compiler/recursiveGenericUnionType2.ts ===
+declare module Test1 {
+>Test1 : any
+
+    export type Container<T> = T | {
+>Container : T | { [i: string]: (T | any)[]; }
+>T : T
+>T : T
+
+        [i: string]: Container<T>[];
+>i : string
+>Container : T | { [i: string]: (T | any)[]; }
+>T : T
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : string | { [i: string]: (string | any)[]; }
+>Container : T | { [i: string]: (T | any)[]; }
+}
+
+declare module Test2 {
+>Test2 : any
+
+    export type Container<T> = T | {
+>Container : T | { [i: string]: (T | any)[]; }
+>T : T
+>T : T
+
+        [i: string]: Container<T>[];
+>i : string
+>Container : T | { [i: string]: (T | any)[]; }
+>T : T
+
+    };
+    export type IStringContainer = Container<string>;
+>IStringContainer : string | { [i: string]: (string | any)[]; }
+>Container : T | { [i: string]: (T | any)[]; }
+}
+
+var x: Test1.Container<number>;
+>x : number | { [i: string]: (number | any)[]; }
+>Test1 : any
+>Container : T | { [i: string]: (T | any)[]; }
+
+var s1: Test1.IStringContainer;
+>s1 : string | { [i: string]: (string | any)[]; }
+>Test1 : any
+>IStringContainer : string | { [i: string]: (string | any)[]; }
+
+var s2: Test2.IStringContainer;
+>s2 : string | { [i: string]: (string | any)[]; }
+>Test2 : any
+>IStringContainer : string | { [i: string]: (string | any)[]; }
+
+s1 = s2;
+>s1 = s2 : string | { [i: string]: (string | any)[]; }
+>s1 : string | { [i: string]: (string | any)[]; }
+>s2 : string | { [i: string]: (string | any)[]; }
+
+s2 = s1;
+>s2 = s1 : string | { [i: string]: (string | any)[]; }
+>s2 : string | { [i: string]: (string | any)[]; }
+>s1 : string | { [i: string]: (string | any)[]; }
+
diff --git a/tests/baselines/reference/regExpWithSlashInCharClass.symbols b/tests/baselines/reference/regExpWithSlashInCharClass.symbols
index 68a257a9666..105724b12f1 100644
--- a/tests/baselines/reference/regExpWithSlashInCharClass.symbols
+++ b/tests/baselines/reference/regExpWithSlashInCharClass.symbols
@@ -1,16 +1,16 @@
 === tests/cases/compiler/regExpWithSlashInCharClass.ts ===
 var foo1 = "a/".replace(/.[/]/, "");
 >foo1 : Symbol(foo1, Decl(regExpWithSlashInCharClass.ts, 0, 3))
->"a/".replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
+>"a/".replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var foo2 = "a//".replace(/.[//]/g, "");
 >foo2 : Symbol(foo2, Decl(regExpWithSlashInCharClass.ts, 1, 3))
->"a//".replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
+>"a//".replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var foo3 = "a/".replace(/.[/no sleep /till/]/, "bugfix");
 >foo3 : Symbol(foo3, Decl(regExpWithSlashInCharClass.ts, 2, 3))
->"a/".replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63))
+>"a/".replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/returnStatements.symbols b/tests/baselines/reference/returnStatements.symbols
index e12f3ba5d8a..7d8b6d69d82 100644
--- a/tests/baselines/reference/returnStatements.symbols
+++ b/tests/baselines/reference/returnStatements.symbols
@@ -18,8 +18,8 @@ function fn5(): boolean { return true; }
 
 function fn6(): Date { return new Date(12); }
 >fn6 : Symbol(fn6, Decl(returnStatements.ts, 5, 40))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 function fn7(): any { return null; }
 >fn7 : Symbol(fn7, Decl(returnStatements.ts, 6, 45))
diff --git a/tests/baselines/reference/returnTypeParameterWithModules.symbols b/tests/baselines/reference/returnTypeParameterWithModules.symbols
index c4b354ad920..7f8fab382a3 100644
--- a/tests/baselines/reference/returnTypeParameterWithModules.symbols
+++ b/tests/baselines/reference/returnTypeParameterWithModules.symbols
@@ -8,17 +8,17 @@ module M1 {
 >ar : Symbol(ar, Decl(returnTypeParameterWithModules.ts, 1, 30))
 >f : Symbol(f, Decl(returnTypeParameterWithModules.ts, 1, 33))
 >e : Symbol(e, Decl(returnTypeParameterWithModules.ts, 1, 36))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(returnTypeParameterWithModules.ts, 1, 27))
 
         return Array.prototype.reduce.apply(ar, e ? [f, e] : [f]);
->Array.prototype.reduce.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
->Array.prototype.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41))
->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120))
->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20))
+>Array.prototype.reduce.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
+>Array.prototype.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --))
+>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --))
 >ar : Symbol(ar, Decl(returnTypeParameterWithModules.ts, 1, 30))
 >e : Symbol(e, Decl(returnTypeParameterWithModules.ts, 1, 36))
 >f : Symbol(f, Decl(returnTypeParameterWithModules.ts, 1, 33))
diff --git a/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols b/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols
index 9e72d85a7fe..48cf549efad 100644
--- a/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols
+++ b/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols
@@ -11,8 +11,8 @@ var x: number[];
 >x : Symbol(x, Decl(reverseInferenceInContextualInstantiation.ts, 1, 3))
 
 x.sort(compare); // Error, but shouldn't be
->x.sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
+>x.sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(reverseInferenceInContextualInstantiation.ts, 1, 3))
->sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45))
+>sort : Symbol(Array.sort, Decl(lib.d.ts, --, --))
 >compare : Symbol(compare, Decl(reverseInferenceInContextualInstantiation.ts, 0, 0))
 
diff --git a/tests/baselines/reference/scopeResolutionIdentifiers.symbols b/tests/baselines/reference/scopeResolutionIdentifiers.symbols
index c3547aab60c..3ba780b8290 100644
--- a/tests/baselines/reference/scopeResolutionIdentifiers.symbols
+++ b/tests/baselines/reference/scopeResolutionIdentifiers.symbols
@@ -51,7 +51,7 @@ class C {
 
     s: Date;
 >s : Symbol(s, Decl(scopeResolutionIdentifiers.ts, 21, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     n = this.s;
 >n : Symbol(n, Decl(scopeResolutionIdentifiers.ts, 22, 12))
@@ -70,7 +70,7 @@ class C {
 
         var p: Date;
 >p : Symbol(p, Decl(scopeResolutionIdentifiers.ts, 25, 11), Decl(scopeResolutionIdentifiers.ts, 26, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt
new file mode 100644
index 00000000000..7ac5fe9a26c
--- /dev/null
+++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt
@@ -0,0 +1,164 @@
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(40,9): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(46,12): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(72,5): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,5): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+  Types of property 'x' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+  Types of property 'x' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,12): error TS2304: Cannot find name 's'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
+
+
+==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts (12 errors) ====
+    
+    
+    (function() {
+    	var s0;
+    	for ({ s0 = 5 } of [{ s0: 1 }]) {
+    	}
+    });
+    (function() {
+    	var s0;
+    	for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
+    	}
+    });
+    
+    (function() {
+    	var s1;
+    	for ({ s1 = 5 } of [{}]) {
+    	       ~~
+!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
+    	}
+    });
+    
+    (function() {
+    	var s1;
+    	for ({ s1:s1 = 5 } of [{}]) {
+    	       ~~
+!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
+    	}
+    });
+    
+    (function() {
+    	var s2;
+    	for ({ s2 = 5 } of [{ s2: "" }]) {
+    	}
+    });
+    
+    (function() {
+    	var s2;
+    	for ({ s2:s2 = 5 } of [{ s2: "" }]) {
+    	}
+    });
+    
+    (function() {
+    	var s3: string;
+    	for ({ s3 = 5 } of [{ s3: "" }]) {
+    	       ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	}
+    });
+    
+    (function() {
+    	var s3: string;
+    	for ({ s3:s3 = 5 } of [{ s3: "" }]) {
+    	          ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	}
+    });
+    
+    (function() {
+    	let y;
+    	({ y = 5 } = { y: 1 })
+    });
+    
+    (function() {
+    	let y;
+    	({ y:y = 5 } = { y: 1 })
+    });
+    
+    (function() {
+    	let y0: number;
+    	({ y0 = 5 } = { y0: 1 })
+    });
+    
+    (function() {
+    	let y0: number;
+    	({ y0:y0 = 5 } = { y0: 1 })
+    });
+    
+    (function() {
+    	let y1: string;
+    	({ y1 = 5 } = {})
+    	   ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y1: string;
+    	({ y1:y1 = 5 } = {})
+    	      ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y2: string, y3: { x: string };
+    	({ y2 = 5, y3 = { x: 1 } } = {})
+    	   ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	           ~~
+!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+!!! error TS2322:   Types of property 'x' are incompatible.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y2: string, y3: { x: string };
+    	({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
+    	      ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	                 ~~
+!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+!!! error TS2322:   Types of property 'x' are incompatible.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y4: number, y5: { x: number };
+    	({ y4 = 5, y5 = { x: 1 } } = {})
+    });
+    
+    (function() {
+    	let y4: number, y5: { x: number };
+    	({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
+    });
+    
+    
+    (function() {
+    	let z;
+    	({ z = { x: 5 } } = { z: { x: 1 } });
+    });
+    
+    
+    (function() {
+    	let z;
+    	({ z:z = { x: 5 } } = { z: { x: 1 } });
+    });
+    
+    (function() {
+    	let a = { s = 5 };
+    	          ~
+!!! error TS2304: Cannot find name 's'.
+    	            ~
+!!! error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
+    });
+    
+    function foo({a = 4, b = { x: 5 }}) {
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js
new file mode 100644
index 00000000000..981ee08e20c
--- /dev/null
+++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js
@@ -0,0 +1,242 @@
+//// [shorthandPropertyAssignmentsInDestructuring.ts]
+
+
+(function() {
+	var s0;
+	for ({ s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+(function() {
+	var s0;
+	for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1:s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2:s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3:s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	let y;
+	({ y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y;
+	({ y:y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0:y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y1: string;
+	({ y1 = 5 } = {})
+});
+
+(function() {
+	let y1: string;
+	({ y1:y1 = 5 } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2 = 5, y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4 = 5, y5 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
+});
+
+
+(function() {
+	let z;
+	({ z = { x: 5 } } = { z: { x: 1 } });
+});
+
+
+(function() {
+	let z;
+	({ z:z = { x: 5 } } = { z: { x: 1 } });
+});
+
+(function() {
+	let a = { s = 5 };
+});
+
+function foo({a = 4, b = { x: 5 }}) {
+}
+
+//// [shorthandPropertyAssignmentsInDestructuring.js]
+(function () {
+    var s0;
+    for (var _i = 0, _a = [{ s0: 1 }]; _i < _a.length; _i++) {
+        _b = _a[_i].s0, s0 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var s0;
+    for (var _i = 0, _a = [{ s0: 1 }]; _i < _a.length; _i++) {
+        _b = _a[_i].s0, s0 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var s1;
+    for (var _i = 0, _a = [{}]; _i < _a.length; _i++) {
+        _b = _a[_i].s1, s1 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var s1;
+    for (var _i = 0, _a = [{}]; _i < _a.length; _i++) {
+        _b = _a[_i].s1, s1 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var s2;
+    for (var _i = 0, _a = [{ s2: "" }]; _i < _a.length; _i++) {
+        _b = _a[_i].s2, s2 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var s2;
+    for (var _i = 0, _a = [{ s2: "" }]; _i < _a.length; _i++) {
+        _b = _a[_i].s2, s2 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var s3;
+    for (var _i = 0, _a = [{ s3: "" }]; _i < _a.length; _i++) {
+        _b = _a[_i].s3, s3 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var s3;
+    for (var _i = 0, _a = [{ s3: "" }]; _i < _a.length; _i++) {
+        _b = _a[_i].s3, s3 = _b === void 0 ? 5 : _b;
+    }
+    var _b;
+});
+(function () {
+    var y;
+    (_a = { y: 1 }, _b = _a.y, y = _b === void 0 ? 5 : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var y;
+    (_a = { y: 1 }, _b = _a.y, y = _b === void 0 ? 5 : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var y0;
+    (_a = { y0: 1 }, _b = _a.y0, y0 = _b === void 0 ? 5 : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var y0;
+    (_a = { y0: 1 }, _b = _a.y0, y0 = _b === void 0 ? 5 : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var y1;
+    (_a = {}, _b = _a.y1, y1 = _b === void 0 ? 5 : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var y1;
+    (_a = {}, _b = _a.y1, y1 = _b === void 0 ? 5 : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var y2, y3;
+    (_a = {}, _b = _a.y2, y2 = _b === void 0 ? 5 : _b, _c = _a.y3, y3 = _c === void 0 ? { x: 1 } : _c, _a);
+    var _a, _b, _c;
+});
+(function () {
+    var y2, y3;
+    (_a = {}, _b = _a.y2, y2 = _b === void 0 ? 5 : _b, _c = _a.y3, y3 = _c === void 0 ? { x: 1 } : _c, _a);
+    var _a, _b, _c;
+});
+(function () {
+    var y4, y5;
+    (_a = {}, _b = _a.y4, y4 = _b === void 0 ? 5 : _b, _c = _a.y5, y5 = _c === void 0 ? { x: 1 } : _c, _a);
+    var _a, _b, _c;
+});
+(function () {
+    var y4, y5;
+    (_a = {}, _b = _a.y4, y4 = _b === void 0 ? 5 : _b, _c = _a.y5, y5 = _c === void 0 ? { x: 1 } : _c, _a);
+    var _a, _b, _c;
+});
+(function () {
+    var z;
+    (_a = { z: { x: 1 } }, _b = _a.z, z = _b === void 0 ? { x: 5 } : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var z;
+    (_a = { z: { x: 1 } }, _b = _a.z, z = _b === void 0 ? { x: 5 } : _b, _a);
+    var _a, _b;
+});
+(function () {
+    var a = { s: s };
+});
+function foo(_a) {
+    var _b = _a.a, a = _b === void 0 ? 4 : _b, _c = _a.b, b = _c === void 0 ? { x: 5 } : _c;
+}
diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt
new file mode 100644
index 00000000000..7e6b6b35d7f
--- /dev/null
+++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt
@@ -0,0 +1,164 @@
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(16,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(22,9): error TS2459: Type '{}' has no property 's1' and no string index signature.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(40,9): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(46,12): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(72,5): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(77,8): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,5): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(82,13): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+  Types of property 'x' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,8): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(87,19): error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+  Types of property 'x' are incompatible.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,12): error TS2304: Cannot find name 's'.
+tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(113,14): error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
+
+
+==== tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts (12 errors) ====
+    
+    
+    (function() {
+    	var s0;
+    	for ({ s0 = 5 } of [{ s0: 1 }]) {
+    	}
+    });
+    (function() {
+    	var s0;
+    	for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
+    	}
+    });
+    
+    (function() {
+    	var s1;
+    	for ({ s1 = 5 } of [{}]) {
+    	       ~~
+!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
+    	}
+    });
+    
+    (function() {
+    	var s1;
+    	for ({ s1:s1 = 5 } of [{}]) {
+    	       ~~
+!!! error TS2459: Type '{}' has no property 's1' and no string index signature.
+    	}
+    });
+    
+    (function() {
+    	var s2;
+    	for ({ s2 = 5 } of [{ s2: "" }]) {
+    	}
+    });
+    
+    (function() {
+    	var s2;
+    	for ({ s2:s2 = 5 } of [{ s2: "" }]) {
+    	}
+    });
+    
+    (function() {
+    	var s3: string;
+    	for ({ s3 = 5 } of [{ s3: "" }]) {
+    	       ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	}
+    });
+    
+    (function() {
+    	var s3: string;
+    	for ({ s3:s3 = 5 } of [{ s3: "" }]) {
+    	          ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	}
+    });
+    
+    (function() {
+    	let y;
+    	({ y = 5 } = { y: 1 })
+    });
+    
+    (function() {
+    	let y;
+    	({ y:y = 5 } = { y: 1 })
+    });
+    
+    (function() {
+    	let y0: number;
+    	({ y0 = 5 } = { y0: 1 })
+    });
+    
+    (function() {
+    	let y0: number;
+    	({ y0:y0 = 5 } = { y0: 1 })
+    });
+    
+    (function() {
+    	let y1: string;
+    	({ y1 = 5 } = {})
+    	   ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y1: string;
+    	({ y1:y1 = 5 } = {})
+    	      ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y2: string, y3: { x: string };
+    	({ y2 = 5, y3 = { x: 1 } } = {})
+    	   ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	           ~~
+!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+!!! error TS2322:   Types of property 'x' are incompatible.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y2: string, y3: { x: string };
+    	({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
+    	      ~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+    	                 ~~
+!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'.
+!!! error TS2322:   Types of property 'x' are incompatible.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+    });
+    
+    (function() {
+    	let y4: number, y5: { x: number };
+    	({ y4 = 5, y5 = { x: 1 } } = {})
+    });
+    
+    (function() {
+    	let y4: number, y5: { x: number };
+    	({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
+    });
+    
+    
+    (function() {
+    	let z;
+    	({ z = { x: 5 } } = { z: { x: 1 } });
+    });
+    
+    
+    (function() {
+    	let z;
+    	({ z:z = { x: 5 } } = { z: { x: 1 } });
+    });
+    
+    (function() {
+    	let a = { s = 5 };
+    	          ~
+!!! error TS2304: Cannot find name 's'.
+    	            ~
+!!! error TS1312: '=' can only be used in an object literal property inside a destructuring assignment.
+    });
+    
+    function foo({a = 4, b = { x: 5 }}) {
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js
new file mode 100644
index 00000000000..11068708110
--- /dev/null
+++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js
@@ -0,0 +1,213 @@
+//// [shorthandPropertyAssignmentsInDestructuring_ES6.ts]
+
+
+(function() {
+	var s0;
+	for ({ s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+(function() {
+	var s0;
+	for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1:s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2:s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3:s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	let y;
+	({ y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y;
+	({ y:y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0:y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y1: string;
+	({ y1 = 5 } = {})
+});
+
+(function() {
+	let y1: string;
+	({ y1:y1 = 5 } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2 = 5, y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4 = 5, y5 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
+});
+
+
+(function() {
+	let z;
+	({ z = { x: 5 } } = { z: { x: 1 } });
+});
+
+
+(function() {
+	let z;
+	({ z:z = { x: 5 } } = { z: { x: 1 } });
+});
+
+(function() {
+	let a = { s = 5 };
+});
+
+function foo({a = 4, b = { x: 5 }}) {
+}
+
+//// [shorthandPropertyAssignmentsInDestructuring_ES6.js]
+(function () {
+    var s0;
+    for ({ s0 = 5 } of [{ s0: 1 }]) {
+    }
+});
+(function () {
+    var s0;
+    for ({ s0: s0 = 5 } of [{ s0: 1 }]) {
+    }
+});
+(function () {
+    var s1;
+    for ({ s1 = 5 } of [{}]) {
+    }
+});
+(function () {
+    var s1;
+    for ({ s1: s1 = 5 } of [{}]) {
+    }
+});
+(function () {
+    var s2;
+    for ({ s2 = 5 } of [{ s2: "" }]) {
+    }
+});
+(function () {
+    var s2;
+    for ({ s2: s2 = 5 } of [{ s2: "" }]) {
+    }
+});
+(function () {
+    var s3;
+    for ({ s3 = 5 } of [{ s3: "" }]) {
+    }
+});
+(function () {
+    var s3;
+    for ({ s3: s3 = 5 } of [{ s3: "" }]) {
+    }
+});
+(function () {
+    let y;
+    ({ y = 5 } = { y: 1 });
+});
+(function () {
+    let y;
+    ({ y: y = 5 } = { y: 1 });
+});
+(function () {
+    let y0;
+    ({ y0 = 5 } = { y0: 1 });
+});
+(function () {
+    let y0;
+    ({ y0: y0 = 5 } = { y0: 1 });
+});
+(function () {
+    let y1;
+    ({ y1 = 5 } = {});
+});
+(function () {
+    let y1;
+    ({ y1: y1 = 5 } = {});
+});
+(function () {
+    let y2, y3;
+    ({ y2 = 5, y3 = { x: 1 } } = {});
+});
+(function () {
+    let y2, y3;
+    ({ y2: y2 = 5, y3: y3 = { x: 1 } } = {});
+});
+(function () {
+    let y4, y5;
+    ({ y4 = 5, y5 = { x: 1 } } = {});
+});
+(function () {
+    let y4, y5;
+    ({ y4: y4 = 5, y5: y5 = { x: 1 } } = {});
+});
+(function () {
+    let z;
+    ({ z = { x: 5 } } = { z: { x: 1 } });
+});
+(function () {
+    let z;
+    ({ z: z = { x: 5 } } = { z: { x: 1 } });
+});
+(function () {
+    let a = { s = 5 };
+});
+function foo({ a = 4, b = { x: 5 } }) {
+}
diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
index ab79174a43a..49528257830 100644
--- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
+++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols
@@ -1,9 +1,9 @@
 === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts ===
 [].map(() => [].map(p => ({ X: p })));
->[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
 >X : Symbol(X, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 27))
 >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20))
diff --git a/tests/baselines/reference/sourceMap-FileWithComments.symbols b/tests/baselines/reference/sourceMap-FileWithComments.symbols
index d065f6d4db8..50993547428 100644
--- a/tests/baselines/reference/sourceMap-FileWithComments.symbols
+++ b/tests/baselines/reference/sourceMap-FileWithComments.symbols
@@ -25,9 +25,9 @@ module Shapes {
         // Instance member
         getDist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
 >getDist : Symbol(getDist, Decl(sourceMap-FileWithComments.ts, 12, 59))
->Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27))
+>Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --))
 >this.x : Symbol(x, Decl(sourceMap-FileWithComments.ts, 12, 20))
 >this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15))
 >x : Symbol(x, Decl(sourceMap-FileWithComments.ts, 12, 20))
diff --git a/tests/baselines/reference/sourceMapValidationClasses.symbols b/tests/baselines/reference/sourceMapValidationClasses.symbols
index 7b5eb5ffdfa..8608cd4ed21 100644
--- a/tests/baselines/reference/sourceMapValidationClasses.symbols
+++ b/tests/baselines/reference/sourceMapValidationClasses.symbols
@@ -60,15 +60,15 @@ module Foo.Bar {
         for (var i = 0; i < restGreetings.length; i++) {
 >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16))
 >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16))
->restGreetings.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>restGreetings.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >restGreetings : Symbol(restGreetings, Decl(sourceMapValidationClasses.ts, 20, 35))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16))
 
             greeters.push(new Greeter(restGreetings[i]));
->greeters.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>greeters.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >greeters : Symbol(greeters, Decl(sourceMapValidationClasses.ts, 21, 11))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >Greeter : Symbol(Greeter, Decl(sourceMapValidationClasses.ts, 1, 17))
 >restGreetings : Symbol(restGreetings, Decl(sourceMapValidationClasses.ts, 20, 35))
 >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16))
@@ -86,9 +86,9 @@ module Foo.Bar {
     for (var j = 0; j < b.length; j++) {
 >j : Symbol(j, Decl(sourceMapValidationClasses.ts, 32, 12))
 >j : Symbol(j, Decl(sourceMapValidationClasses.ts, 32, 12))
->b.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>b.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(sourceMapValidationClasses.ts, 30, 7))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >j : Symbol(j, Decl(sourceMapValidationClasses.ts, 32, 12))
 
         b[j].greet();
diff --git a/tests/baselines/reference/sourceMapValidationDecorators.symbols b/tests/baselines/reference/sourceMapValidationDecorators.symbols
index e22afb7b7fc..90204d0b71f 100644
--- a/tests/baselines/reference/sourceMapValidationDecorators.symbols
+++ b/tests/baselines/reference/sourceMapValidationDecorators.symbols
@@ -2,35 +2,35 @@
 declare function ClassDecorator1(target: Function): void;
 >ClassDecorator1 : Symbol(ClassDecorator1, Decl(sourceMapValidationDecorators.ts, 0, 0))
 >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 0, 33))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function ClassDecorator2(x: number): (target: Function) => void;
 >ClassDecorator2 : Symbol(ClassDecorator2, Decl(sourceMapValidationDecorators.ts, 0, 57))
 >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 1, 33))
 >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 1, 46))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 declare function PropertyDecorator1(target: Object, key: string | symbol, descriptor?: PropertyDescriptor): void;
 >PropertyDecorator1 : Symbol(PropertyDecorator1, Decl(sourceMapValidationDecorators.ts, 1, 72))
 >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 2, 36))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 2, 51))
 >descriptor : Symbol(descriptor, Decl(sourceMapValidationDecorators.ts, 2, 73))
->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
+>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --))
 
 declare function PropertyDecorator2(x: number): (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void;
 >PropertyDecorator2 : Symbol(PropertyDecorator2, Decl(sourceMapValidationDecorators.ts, 2, 113))
 >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 3, 36))
 >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 3, 49))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 3, 64))
 >descriptor : Symbol(descriptor, Decl(sourceMapValidationDecorators.ts, 3, 86))
->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66))
+>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --))
 
 declare function ParameterDecorator1(target: Object, key: string | symbol, paramIndex: number): void;
 >ParameterDecorator1 : Symbol(ParameterDecorator1, Decl(sourceMapValidationDecorators.ts, 3, 128))
 >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 4, 37))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 4, 52))
 >paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 4, 74))
 
@@ -38,7 +38,7 @@ declare function ParameterDecorator2(x: number): (target: Object, key: string |
 >ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 101))
 >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 5, 37))
 >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 5, 50))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 5, 65))
 >paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 5, 87))
 
diff --git a/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols b/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols
index f2306df6827..321d262d9e7 100644
--- a/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols
+++ b/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols
@@ -26,7 +26,7 @@ try
 >x : Symbol(x, Decl(sourceMapValidationTryCatchFinally.ts, 0, 3))
 
     throw new Error();
->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 catch (e)
 >e : Symbol(e, Decl(sourceMapValidationTryCatchFinally.ts, 13, 7))
diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
index 9f03f8fca01..9114afccdf4 100644
--- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
+++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols
@@ -23,9 +23,9 @@ function foo() {
 >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7))
 
     series2.map(seriesExtent);
->series2.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7))
 
     return null;
@@ -34,11 +34,11 @@ function foo() {
 
 var keyExtent2: any[] = series.data.map(function (d: string) { return d; });
 >keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 19, 3))
->series.data.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>series.data.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >series.data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19))
 >series : Symbol(series, Decl(specializationsShouldNotAffectEachOther.ts, 5, 3))
 >data : Symbol(Series.data, Decl(specializationsShouldNotAffectEachOther.ts, 1, 19))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50))
 >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50))
 
diff --git a/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols b/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols
index 0730ccaf409..8b1bbfb6aab 100644
--- a/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols
+++ b/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols
@@ -55,7 +55,7 @@ class C2<T> {
 class C3<T extends String> {
 >C3 : Symbol(C3, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 18, 1))
 >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 20, 9))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: 'a');
 >foo : Symbol(foo, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 20, 28), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 21, 16), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 22, 19), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 23, 14))
@@ -131,7 +131,7 @@ interface I2<T> {
 interface I3<T extends String> {
 >I3 : Symbol(I3, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 43, 1))
 >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 45, 13))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     (x: 'a');
 >x : Symbol(x, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 46, 5))
@@ -236,7 +236,7 @@ var a3: {
     foo<T extends String>(x: T);
 >foo : Symbol(foo, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 75, 16), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 76, 19), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 77, 16))
 >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 78, 8))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 78, 26))
 >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 78, 8))
 }
diff --git a/tests/baselines/reference/staticInstanceResolution2.symbols b/tests/baselines/reference/staticInstanceResolution2.symbols
index 349088f5ded..cb7b96445c2 100644
--- a/tests/baselines/reference/staticInstanceResolution2.symbols
+++ b/tests/baselines/reference/staticInstanceResolution2.symbols
@@ -3,9 +3,9 @@ class A { }
 >A : Symbol(A, Decl(staticInstanceResolution2.ts, 0, 0))
 
 A.hasOwnProperty('foo');
->A.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>A.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(staticInstanceResolution2.ts, 0, 0))
->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
 class B {
 >B : Symbol(B, Decl(staticInstanceResolution2.ts, 1, 24))
@@ -13,9 +13,9 @@ class B {
     constructor() { }
 }
 B.hasOwnProperty('foo');
->B.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>B.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 >B : Symbol(B, Decl(staticInstanceResolution2.ts, 1, 24))
->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
 
 
diff --git a/tests/baselines/reference/stringIncludes.symbols b/tests/baselines/reference/stringIncludes.symbols
index 1348b62e566..1f1b2e55ccf 100644
--- a/tests/baselines/reference/stringIncludes.symbols
+++ b/tests/baselines/reference/stringIncludes.symbols
@@ -5,11 +5,11 @@ var includes: boolean;
 
 includes = "abcde".includes("cd");
 >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
->includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
+>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, --, --))
+>includes : Symbol(String.includes, Decl(lib.d.ts, --, --))
 
 includes = "abcde".includes("cd", 2);
 >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
->includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37))
+>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, --, --))
+>includes : Symbol(String.includes, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/stringPropCodeGen.symbols b/tests/baselines/reference/stringPropCodeGen.symbols
index b0d9cb91fc2..d2c966f1b6e 100644
--- a/tests/baselines/reference/stringPropCodeGen.symbols
+++ b/tests/baselines/reference/stringPropCodeGen.symbols
@@ -15,9 +15,9 @@ a.foo();
 >foo : Symbol("foo", Decl(stringPropCodeGen.ts, 0, 9))
 
 a.bar.toString();
->a.bar.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>a.bar.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >a.bar : Symbol("bar", Decl(stringPropCodeGen.ts, 2, 25))
 >a : Symbol(a, Decl(stringPropCodeGen.ts, 0, 3))
 >bar : Symbol("bar", Decl(stringPropCodeGen.ts, 2, 25))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/stringPropertyAccess.symbols b/tests/baselines/reference/stringPropertyAccess.symbols
index 26a84d67d6f..ba239deee00 100644
--- a/tests/baselines/reference/stringPropertyAccess.symbols
+++ b/tests/baselines/reference/stringPropertyAccess.symbols
@@ -4,23 +4,23 @@ var x = '';
 
 var a = x.charAt(0);
 >a : Symbol(a, Decl(stringPropertyAccess.ts, 1, 3))
->x.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>x.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 var b = x.hasOwnProperty('charAt');
 >b : Symbol(b, Decl(stringPropertyAccess.ts, 2, 3))
->x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3))
->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
 var c = x['charAt'](0);
 >c : Symbol(c, Decl(stringPropertyAccess.ts, 4, 3))
 >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3))
->'charAt' : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>'charAt' : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 var e = x['hasOwnProperty']('toFixed');
 >e : Symbol(e, Decl(stringPropertyAccess.ts, 5, 3))
 >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3))
->'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22))
+>'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/subtypesOfAny.symbols b/tests/baselines/reference/subtypesOfAny.symbols
index ff4874f1cec..85f5186f705 100644
--- a/tests/baselines/reference/subtypesOfAny.symbols
+++ b/tests/baselines/reference/subtypesOfAny.symbols
@@ -53,7 +53,7 @@ interface I5 {
 
     foo: Date;
 >foo : Symbol(foo, Decl(subtypesOfAny.ts, 27, 21))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
@@ -65,7 +65,7 @@ interface I6 {
 
     foo: RegExp;
 >foo : Symbol(foo, Decl(subtypesOfAny.ts, 33, 21))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
@@ -261,7 +261,7 @@ interface I19 {
 
     foo: Object;
 >foo : Symbol(foo, Decl(subtypesOfAny.ts, 124, 21))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
diff --git a/tests/baselines/reference/subtypingTransitivity.symbols b/tests/baselines/reference/subtypingTransitivity.symbols
index 95e0a4bc9d6..7a1ee279bb3 100644
--- a/tests/baselines/reference/subtypingTransitivity.symbols
+++ b/tests/baselines/reference/subtypingTransitivity.symbols
@@ -4,7 +4,7 @@ class B {
 
     x: Object;
 >x : Symbol(x, Decl(subtypingTransitivity.ts, 0, 9))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 class D extends B {
diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.symbols b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
index 5aa1021d260..02f08016b31 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures2.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures2.symbols
@@ -173,12 +173,12 @@ declare function foo12(a: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
 >foo12 : Symbol(foo12, Decl(subtypingWithCallSignatures2.ts, 38, 36), Decl(subtypingWithCallSignatures2.ts, 40, 92))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 40, 23))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 40, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 40, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures2.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 40, 23))
 
@@ -190,12 +190,12 @@ declare function foo13(a: (x: Array<Base>, y: Array<Derived>) => Array<Derived>)
 >foo13 : Symbol(foo13, Decl(subtypingWithCallSignatures2.ts, 41, 36), Decl(subtypingWithCallSignatures2.ts, 43, 91))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 43, 23))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 43, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 43, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 43, 23))
 
@@ -209,7 +209,7 @@ declare function foo14(a: (x: { a: string; b: number }) => Object): typeof a;
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 46, 27))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 46, 31))
 >b : Symbol(b, Decl(subtypingWithCallSignatures2.ts, 46, 42))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 46, 23))
 
 declare function foo14(a: any): any;
@@ -297,8 +297,8 @@ declare function foo18(a: {
 
         (a: Date): Date;
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 74, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }): typeof a;
@@ -680,25 +680,25 @@ var r11b = [r11arg2, r11arg1];
 var r12arg1 = <T extends Array<Base>>(x: Array<Base>, y: T) => <Array<Derived>>null;
 >r12arg1 : Symbol(r12arg1, Decl(subtypingWithCallSignatures2.ts, 145, 3))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 145, 15))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 145, 38))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 145, 53))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 145, 15))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 
 var r12arg2 = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null;
 >r12arg2 : Symbol(r12arg2, Decl(subtypingWithCallSignatures2.ts, 146, 3))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 146, 15))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 146, 30))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures2.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 
 var r12 = foo12(r12arg1); // any
@@ -719,10 +719,10 @@ var r12b = [r12arg2, r12arg1];
 var r13arg1 = <T extends Array<Derived>>(x: Array<Base>, y: T) => y;
 >r13arg1 : Symbol(r13arg1, Decl(subtypingWithCallSignatures2.ts, 151, 3))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 151, 15))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 151, 41))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 151, 56))
 >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 151, 15))
@@ -731,12 +731,12 @@ var r13arg1 = <T extends Array<Derived>>(x: Array<Base>, y: T) => y;
 var r13arg2 = (x: Array<Base>, y: Array<Derived>) => <Array<Derived>>null;
 >r13arg2 : Symbol(r13arg2, Decl(subtypingWithCallSignatures2.ts, 152, 3))
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 152, 15))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 152, 30))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27))
 
 var r13 = foo13(r13arg1); // any
@@ -771,7 +771,7 @@ var r14arg2 = (x: { a: string; b: number }) => <Object>null;
 >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 158, 15))
 >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 158, 19))
 >b : Symbol(b, Decl(subtypingWithCallSignatures2.ts, 158, 30))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r14 = foo14(r14arg1); // any
 >r14 : Symbol(r14, Decl(subtypingWithCallSignatures2.ts, 159, 3))
diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.symbols b/tests/baselines/reference/subtypingWithCallSignatures3.symbols
index 666977c62d9..37e1c0423c4 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures3.symbols
+++ b/tests/baselines/reference/subtypingWithCallSignatures3.symbols
@@ -101,12 +101,12 @@ module Errors {
 >foo12 : Symbol(foo12, Decl(subtypingWithCallSignatures3.ts, 22, 41), Decl(subtypingWithCallSignatures3.ts, 24, 98))
 >a2 : Symbol(a2, Decl(subtypingWithCallSignatures3.ts, 24, 27))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 24, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 24, 47))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
 >a2 : Symbol(a2, Decl(subtypingWithCallSignatures3.ts, 24, 27))
 
@@ -386,24 +386,24 @@ module Errors {
     var r6arg = (x: Array<Base>, y: Array<Derived2>) => <Array<Derived>>null;
 >r6arg : Symbol(r6arg, Decl(subtypingWithCallSignatures3.ts, 83, 7))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 83, 17))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 83, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31))
 
     var r6arg2 = <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => <T>null;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures3.ts, 84, 7))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 84, 18))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47))
 >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 84, 45))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 84, 60))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15))
 >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 84, 18))
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures2.symbols b/tests/baselines/reference/subtypingWithConstructSignatures2.symbols
index 08f1e814b4d..2173aaa1392 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures2.symbols
+++ b/tests/baselines/reference/subtypingWithConstructSignatures2.symbols
@@ -173,12 +173,12 @@ declare function foo12(a: new (x: Array<Base>, y: Array<Derived2>) => Array<Deri
 >foo12 : Symbol(foo12, Decl(subtypingWithConstructSignatures2.ts, 38, 36), Decl(subtypingWithConstructSignatures2.ts, 40, 96))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 40, 23))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 40, 31))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 40, 46))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures2.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 40, 23))
 
@@ -190,12 +190,12 @@ declare function foo13(a: new (x: Array<Base>, y: Array<Derived>) => Array<Deriv
 >foo13 : Symbol(foo13, Decl(subtypingWithConstructSignatures2.ts, 41, 36), Decl(subtypingWithConstructSignatures2.ts, 43, 95))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 43, 23))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 43, 31))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 43, 46))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 43, 23))
 
@@ -209,7 +209,7 @@ declare function foo14(a: new (x: { a: string; b: number }) => Object): typeof a
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 46, 31))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 46, 35))
 >b : Symbol(b, Decl(subtypingWithConstructSignatures2.ts, 46, 46))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 46, 23))
 
 declare function foo14(a: any): any;
@@ -297,8 +297,8 @@ declare function foo18(a: {
 
         new (a: Date): Date;
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 74, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     }): any[];
 }): typeof a;
@@ -680,25 +680,25 @@ var r11b = [r11arg2, r11arg1];
 var r12arg1: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>;
 >r12arg1 : Symbol(r12arg1, Decl(subtypingWithConstructSignatures2.ts, 145, 3))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 145, 18))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 145, 41))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 145, 56))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 145, 18))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
 
 var r12arg2: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >r12arg2 : Symbol(r12arg2, Decl(subtypingWithConstructSignatures2.ts, 146, 3))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 146, 18))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 146, 33))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures2.ts, 3, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
 
 var r12 = foo12(r12arg1); // any
@@ -719,10 +719,10 @@ var r12b = [r12arg2, r12arg1];
 var r13arg1: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T;
 >r13arg1 : Symbol(r13arg1, Decl(subtypingWithConstructSignatures2.ts, 151, 3))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 151, 18))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 151, 44))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 151, 59))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 151, 18))
@@ -731,12 +731,12 @@ var r13arg1: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T;
 var r13arg2: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >r13arg2 : Symbol(r13arg2, Decl(subtypingWithConstructSignatures2.ts, 152, 3))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 152, 18))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 152, 33))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27))
 
 var r13 = foo13(r13arg1); // any
@@ -769,7 +769,7 @@ var r14arg2: new (x: { a: string; b: number }) => Object;
 >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 158, 18))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 158, 22))
 >b : Symbol(b, Decl(subtypingWithConstructSignatures2.ts, 158, 33))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r14 = foo14(r14arg1); // any
 >r14 : Symbol(r14, Decl(subtypingWithConstructSignatures2.ts, 159, 3))
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures3.symbols b/tests/baselines/reference/subtypingWithConstructSignatures3.symbols
index ce8eda2dcf6..3adce566f95 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures3.symbols
+++ b/tests/baselines/reference/subtypingWithConstructSignatures3.symbols
@@ -101,12 +101,12 @@ module Errors {
 >foo12 : Symbol(foo12, Decl(subtypingWithConstructSignatures3.ts, 22, 41), Decl(subtypingWithConstructSignatures3.ts, 24, 102))
 >a2 : Symbol(a2, Decl(subtypingWithConstructSignatures3.ts, 24, 27))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures3.ts, 24, 36))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures3.ts, 24, 51))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures3.ts, 5, 47))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures3.ts, 4, 31))
 >a2 : Symbol(a2, Decl(subtypingWithConstructSignatures3.ts, 24, 27))
 
@@ -386,24 +386,24 @@ module Errors {
     var r6arg1: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >r6arg1 : Symbol(r6arg1, Decl(subtypingWithConstructSignatures3.ts, 85, 7))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures3.ts, 85, 21))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures3.ts, 85, 36))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures3.ts, 5, 47))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures3.ts, 4, 31))
 
     var r6arg2: new <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T;
 >r6arg2 : Symbol(r6arg2, Decl(subtypingWithConstructSignatures3.ts, 86, 7))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures3.ts, 86, 21))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures3.ts, 5, 47))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures3.ts, 86, 48))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures3.ts, 86, 63))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures3.ts, 86, 21))
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures5.symbols b/tests/baselines/reference/subtypingWithConstructSignatures5.symbols
index ab20c2b7a3f..634f31ff783 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures5.symbols
+++ b/tests/baselines/reference/subtypingWithConstructSignatures5.symbols
@@ -111,23 +111,23 @@ interface A { // T
     a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : Symbol(a12, Decl(subtypingWithConstructSignatures5.ts, 20, 75))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 21, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 21, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures5.ts, 4, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27))
 
     a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : Symbol(a13, Decl(subtypingWithConstructSignatures5.ts, 21, 68))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 22, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 22, 29))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27))
 
     a14: new (x: { a: string; b: number }) => Object;
@@ -135,7 +135,7 @@ interface A { // T
 >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 23, 14))
 >a : Symbol(a, Decl(subtypingWithConstructSignatures5.ts, 23, 18))
 >b : Symbol(b, Decl(subtypingWithConstructSignatures5.ts, 23, 29))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface B extends A {
@@ -280,23 +280,23 @@ interface I extends B {
     a12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; // ok, less specific parameter type
 >a12 : Symbol(a12, Decl(subtypingWithConstructSignatures5.ts, 43, 47))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 44, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 44, 37))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 44, 52))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 44, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27))
 
     a13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; // ok, T = Array<Derived>, satisfies constraint, contextual signature instantiation succeeds
 >a13 : Symbol(a13, Decl(subtypingWithConstructSignatures5.ts, 44, 77))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 45, 14))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27))
 >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 45, 40))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0))
 >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 45, 55))
 >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 45, 14))
diff --git a/tests/baselines/reference/subtypingWithOptionalProperties.symbols b/tests/baselines/reference/subtypingWithOptionalProperties.symbols
index 44ebbe99fd7..a7a8b97e9f0 100644
--- a/tests/baselines/reference/subtypingWithOptionalProperties.symbols
+++ b/tests/baselines/reference/subtypingWithOptionalProperties.symbols
@@ -21,15 +21,15 @@ var r = f({ s: new Object() }); // ok
 >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3))
 >f : Symbol(f, Decl(subtypingWithOptionalProperties.ts, 0, 0))
 >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 8, 11))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 r.s && r.s.toFixed(); // would blow up at runtime
 >r.s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12))
 >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3))
 >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12))
->r.s.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>r.s.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >r.s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12))
 >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3))
 >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.symbols b/tests/baselines/reference/superCallParameterContextualTyping1.symbols
index 80876e2ee9d..ed845b7cd4e 100644
--- a/tests/baselines/reference/superCallParameterContextualTyping1.symbols
+++ b/tests/baselines/reference/superCallParameterContextualTyping1.symbols
@@ -22,9 +22,9 @@ class B extends A<number, string> {
     constructor() { super(value => String(value.toExponential())); }
 >super : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0))
 >value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
->value.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>value.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26))
->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 }
 
diff --git a/tests/baselines/reference/superCallParameterContextualTyping3.symbols b/tests/baselines/reference/superCallParameterContextualTyping3.symbols
index 04bc148ac0f..e51687b4539 100644
--- a/tests/baselines/reference/superCallParameterContextualTyping3.symbols
+++ b/tests/baselines/reference/superCallParameterContextualTyping3.symbols
@@ -42,9 +42,9 @@ class C extends CBase<string> {
 >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 17, 19))
 
                 p.length;
->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 17, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
             }
         });
 
@@ -60,9 +60,9 @@ class C extends CBase<string> {
 >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 25, 19))
 
                 p.length;
->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>p.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 25, 19))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
             }
         });
     }
diff --git a/tests/baselines/reference/superSymbolIndexedAccess1.symbols b/tests/baselines/reference/superSymbolIndexedAccess1.symbols
index 416ac465e24..47131f231cb 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess1.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess1.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess1.ts ===
 var symbol = Symbol.for('myThing');
 >symbol : Symbol(symbol, Decl(superSymbolIndexedAccess1.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --))
 
 class Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess1.ts, 0, 35))
diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.symbols b/tests/baselines/reference/superSymbolIndexedAccess2.symbols
index 726abb3fdc5..9b65ce358bb 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess2.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess2.symbols
@@ -4,9 +4,9 @@ class Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]() {
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 
         return 0;
     }
@@ -17,14 +17,14 @@ class Bar extends Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]() {
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 
         return super[Symbol.isConcatSpreadable]();
 >super : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols
index 9a7d93c7246..0b1999cf606 100644
--- a/tests/baselines/reference/symbolDeclarationEmit1.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit1.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit1.ts, 0, 0))
 
     [Symbol.toPrimitive]: number;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols
index 63602f4fd2c..7d7cbf257df 100644
--- a/tests/baselines/reference/symbolDeclarationEmit10.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols
@@ -3,13 +3,13 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3))
 
     get [Symbol.isConcatSpreadable]() { return '' },
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 
     set [Symbol.isConcatSpreadable](x) { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols
index 850bde66c49..a8b9ab0757d 100644
--- a/tests/baselines/reference/symbolDeclarationEmit11.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit11.symbols
@@ -3,23 +3,23 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit11.ts, 0, 0))
 
     static [Symbol.iterator] = 0;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
     static [Symbol.isConcatSpreadable]() { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 
     static get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
     static set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols
index accb92a8c52..9ac140cbcc4 100644
--- a/tests/baselines/reference/symbolDeclarationEmit13.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit13.symbols
@@ -3,13 +3,13 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit13.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
     set [Symbol.toStringTag](x) { }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols
index 91a5cfdd760..4ee1d1d2ebd 100644
--- a/tests/baselines/reference/symbolDeclarationEmit14.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit14.symbols
@@ -3,12 +3,12 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit14.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
     get [Symbol.toStringTag]() { return ""; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols
index 1993e369aea..f3d7253f1af 100644
--- a/tests/baselines/reference/symbolDeclarationEmit2.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit2.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit2.ts, 0, 0))
 
     [Symbol.toPrimitive] = "";
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols
index 84f39f363f1..4a75ecac742 100644
--- a/tests/baselines/reference/symbolDeclarationEmit3.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit3.symbols
@@ -3,20 +3,20 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit3.ts, 0, 0))
 
     [Symbol.toPrimitive](x: number);
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25))
 
     [Symbol.toPrimitive](x: string);
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25))
 
     [Symbol.toPrimitive](x: any) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols
index 655a91fc88b..eec0912d6ee 100644
--- a/tests/baselines/reference/symbolDeclarationEmit4.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit4.symbols
@@ -3,13 +3,13 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit4.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
     set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols
index 1436f9b9f69..e9ee78e4a7d 100644
--- a/tests/baselines/reference/symbolDeclarationEmit5.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit5.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(symbolDeclarationEmit5.ts, 0, 0))
 
     [Symbol.isConcatSpreadable](): string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols
index f07ebd532fa..64da887014c 100644
--- a/tests/baselines/reference/symbolDeclarationEmit6.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit6.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(symbolDeclarationEmit6.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols
index 0435dc15df2..3bfaee5316c 100644
--- a/tests/baselines/reference/symbolDeclarationEmit7.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit7.symbols
@@ -3,7 +3,7 @@ var obj: {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit7.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols
index 7e95754b1eb..9eead633343 100644
--- a/tests/baselines/reference/symbolDeclarationEmit8.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols
@@ -3,7 +3,7 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]: 0
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols
index d4f08115a21..ec49c196d02 100644
--- a/tests/baselines/reference/symbolDeclarationEmit9.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols
@@ -3,7 +3,7 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]() { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols
index 3db0f7012cb..b064d11b9de 100644
--- a/tests/baselines/reference/symbolProperty11.symbols
+++ b/tests/baselines/reference/symbolProperty11.symbols
@@ -6,9 +6,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty11.ts, 0, 11))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols
index 62ce887a731..a48f02fdacf 100644
--- a/tests/baselines/reference/symbolProperty13.symbols
+++ b/tests/baselines/reference/symbolProperty13.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty13.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty13.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty13.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty13.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols
index c48bd271c87..459b2699e42 100644
--- a/tests/baselines/reference/symbolProperty14.symbols
+++ b/tests/baselines/reference/symbolProperty14.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty14.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty14.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty14.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty14.ts, 2, 1))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols
index 56f722c523b..83a3f4630fe 100644
--- a/tests/baselines/reference/symbolProperty15.symbols
+++ b/tests/baselines/reference/symbolProperty15.symbols
@@ -6,9 +6,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty15.ts, 0, 11))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols
index 092d766034e..d54002167a1 100644
--- a/tests/baselines/reference/symbolProperty16.symbols
+++ b/tests/baselines/reference/symbolProperty16.symbols
@@ -3,18 +3,18 @@ class C {
 >C : Symbol(C, Decl(symbolProperty16.ts, 0, 0))
 
     private [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty16.ts, 1, 32))
 }
 interface I {
 >I : Symbol(I, Decl(symbolProperty16.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols
index b5d930b4005..8f863572639 100644
--- a/tests/baselines/reference/symbolProperty18.symbols
+++ b/tests/baselines/reference/symbolProperty18.symbols
@@ -3,39 +3,39 @@ var i = {
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
 
     [Symbol.iterator]: 0,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
     [Symbol.toStringTag]() { return "" },
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
     set [Symbol.toPrimitive](p: boolean) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(symbolProperty18.ts, 3, 29))
 }
 
 var it = i[Symbol.iterator];
 >it : Symbol(it, Decl(symbolProperty18.ts, 6, 3))
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
 var str = i[Symbol.toStringTag]();
 >str : Symbol(str, Decl(symbolProperty18.ts, 7, 3))
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
 i[Symbol.toPrimitive] = false;
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols
index eae891f2e22..a2c7dd7dcfd 100644
--- a/tests/baselines/reference/symbolProperty19.symbols
+++ b/tests/baselines/reference/symbolProperty19.symbols
@@ -3,15 +3,15 @@ var i = {
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
 
     [Symbol.iterator]: { p: null },
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24))
 
     [Symbol.toStringTag]() { return { p: undefined }; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37))
 >undefined : Symbol(undefined)
 }
@@ -19,14 +19,14 @@ var i = {
 var it = i[Symbol.iterator];
 >it : Symbol(it, Decl(symbolProperty19.ts, 5, 3))
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
 var str = i[Symbol.toStringTag]();
 >str : Symbol(str, Decl(symbolProperty19.ts, 6, 3))
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols
index d03ca9a4c51..a9bc4a440e0 100644
--- a/tests/baselines/reference/symbolProperty2.symbols
+++ b/tests/baselines/reference/symbolProperty2.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty2.ts ===
 var s = Symbol();
 >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols
index 110067abda5..97bb4164c2f 100644
--- a/tests/baselines/reference/symbolProperty20.symbols
+++ b/tests/baselines/reference/symbolProperty20.symbols
@@ -3,15 +3,15 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
 
     [Symbol.iterator]: (s: string) => string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24))
 
     [Symbol.toStringTag](s: number): number;
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty20.ts, 2, 25))
 }
 
@@ -20,16 +20,16 @@ var i: I = {
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
 
     [Symbol.iterator]: s => s,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 
     [Symbol.toStringTag](n) { return n; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 }
diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols
index 2288537456c..1d7f46fa897 100644
--- a/tests/baselines/reference/symbolProperty22.symbols
+++ b/tests/baselines/reference/symbolProperty22.symbols
@@ -5,9 +5,9 @@ interface I<T, U> {
 >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14))
 
     [Symbol.unscopables](x: T): U;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty22.ts, 1, 25))
 >T : Symbol(T, Decl(symbolProperty22.ts, 0, 12))
 >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14))
@@ -27,11 +27,11 @@ declare function foo<T, U>(p1: T, p2: I<T, U>): U;
 
 foo("", { [Symbol.unscopables]: s => s.length });
 >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1))
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>s.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols
index 152048a95a8..06fce65875c 100644
--- a/tests/baselines/reference/symbolProperty23.symbols
+++ b/tests/baselines/reference/symbolProperty23.symbols
@@ -3,9 +3,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0))
 
     [Symbol.toPrimitive]: () => boolean;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
 
 class C implements I {
@@ -13,9 +13,9 @@ class C implements I {
 >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0))
 
     [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
         return true;
     }
diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols
index 7a2e443368f..ae8f95d5859 100644
--- a/tests/baselines/reference/symbolProperty26.symbols
+++ b/tests/baselines/reference/symbolProperty26.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
         return "";
     }
@@ -16,9 +16,9 @@ class C2 extends C1 {
 >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols
index 306802cdff2..d5fcf7ec224 100644
--- a/tests/baselines/reference/symbolProperty27.symbols
+++ b/tests/baselines/reference/symbolProperty27.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
         return {};
     }
@@ -16,9 +16,9 @@ class C2 extends C1 {
 >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols
index 77b476c6ea3..d8c9daba0d9 100644
--- a/tests/baselines/reference/symbolProperty28.symbols
+++ b/tests/baselines/reference/symbolProperty28.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty28.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
@@ -24,8 +24,8 @@ var obj = c[Symbol.toStringTag]().x;
 >obj : Symbol(obj, Decl(symbolProperty28.ts, 9, 3))
 >c[Symbol.toStringTag]().x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
 >c : Symbol(c, Decl(symbolProperty28.ts, 8, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
 
diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols
index c159cc756d8..7817a7c6fd0 100644
--- a/tests/baselines/reference/symbolProperty4.symbols
+++ b/tests/baselines/reference/symbolProperty4.symbols
@@ -3,13 +3,13 @@ var x = {
 >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3))
 
     [Symbol()]: 0,
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     [Symbol()]() { },
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     get [Symbol()]() {
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols
index 29b66c96f1f..26a5dc36ed5 100644
--- a/tests/baselines/reference/symbolProperty40.symbols
+++ b/tests/baselines/reference/symbolProperty40.symbols
@@ -3,21 +3,21 @@ class C {
 >C : Symbol(C, Decl(symbolProperty40.ts, 0, 0))
 
     [Symbol.iterator](x: string): string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22))
 
     [Symbol.iterator](x: number): number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty40.ts, 3, 22))
 
         return undefined;
@@ -31,13 +31,13 @@ var c = new C;
 
 c[Symbol.iterator]("");
 >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
 c[Symbol.iterator](0);
 >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols
index 129c856b804..7db66e5862e 100644
--- a/tests/baselines/reference/symbolProperty41.symbols
+++ b/tests/baselines/reference/symbolProperty41.symbols
@@ -3,24 +3,24 @@ class C {
 >C : Symbol(C, Decl(symbolProperty41.ts, 0, 0))
 
     [Symbol.iterator](x: string): { x: string };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty41.ts, 1, 22))
 >x : Symbol(x, Decl(symbolProperty41.ts, 1, 35))
 
     [Symbol.iterator](x: "hello"): { x: string; hello: string };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty41.ts, 2, 22))
 >x : Symbol(x, Decl(symbolProperty41.ts, 2, 36))
 >hello : Symbol(hello, Decl(symbolProperty41.ts, 2, 47))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(symbolProperty41.ts, 3, 22))
 
         return undefined;
@@ -34,13 +34,13 @@ var c = new C;
 
 c[Symbol.iterator]("");
 >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
 c[Symbol.iterator]("hello");
 >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols
index 34bb5ad967f..46ecb0a6414 100644
--- a/tests/baselines/reference/symbolProperty45.symbols
+++ b/tests/baselines/reference/symbolProperty45.symbols
@@ -3,16 +3,16 @@ class C {
 >C : Symbol(C, Decl(symbolProperty45.ts, 0, 0))
 
     get [Symbol.hasInstance]() {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3876, 32))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3876, 32))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, --, --))
 
         return "";
     }
     get [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols
index 063ae8d3d34..00e47c461ee 100644
--- a/tests/baselines/reference/symbolProperty5.symbols
+++ b/tests/baselines/reference/symbolProperty5.symbols
@@ -3,19 +3,19 @@ var x = {
 >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3))
 
     [Symbol.iterator]: 0,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
     [Symbol.toPrimitive]() { },
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols
index 64472f3c71a..f5197627846 100644
--- a/tests/baselines/reference/symbolProperty50.symbols
+++ b/tests/baselines/reference/symbolProperty50.symbols
@@ -9,8 +9,8 @@ module M {
 >C : Symbol(C, Decl(symbolProperty50.ts, 1, 24))
 
         [Symbol.iterator]() { }
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols
index 45a56260828..4be31dd0a56 100644
--- a/tests/baselines/reference/symbolProperty51.symbols
+++ b/tests/baselines/reference/symbolProperty51.symbols
@@ -9,8 +9,8 @@ module M {
 >C : Symbol(C, Decl(symbolProperty51.ts, 1, 21))
 
         [Symbol.iterator]() { }
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols
index 98f4a7769b2..e6a9c304abe 100644
--- a/tests/baselines/reference/symbolProperty55.symbols
+++ b/tests/baselines/reference/symbolProperty55.symbols
@@ -3,9 +3,9 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
 };
 
@@ -14,13 +14,13 @@ module M {
 
     var Symbol: SymbolConstructor;
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 3850, 1))
+>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, --, --))
 
     // The following should be of type 'any'. This is because even though obj has a property keyed by Symbol.iterator,
     // the key passed in here is the *wrong* Symbol.iterator. It is not the iterator property of the global Symbol.
     obj[Symbol.iterator];
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols
index fe73fb9f330..6ff465daa98 100644
--- a/tests/baselines/reference/symbolProperty56.symbols
+++ b/tests/baselines/reference/symbolProperty56.symbols
@@ -3,9 +3,9 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
 };
 
diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols
index eaf5be2a07c..b256ba651c4 100644
--- a/tests/baselines/reference/symbolProperty57.symbols
+++ b/tests/baselines/reference/symbolProperty57.symbols
@@ -3,14 +3,14 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
 };
 
 // Should give type 'any'.
 obj[Symbol["nonsense"]];
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols
index 04b89f43652..d0eedccf4fa 100644
--- a/tests/baselines/reference/symbolProperty6.symbols
+++ b/tests/baselines/reference/symbolProperty6.symbols
@@ -3,24 +3,24 @@ class C {
 >C : Symbol(C, Decl(symbolProperty6.ts, 0, 0))
 
     [Symbol.iterator] = 0;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --))
 
     [Symbol.unscopables]: number;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
 
     [Symbol.toPrimitive]() { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols
index 541833d686a..8d26d193ef5 100644
--- a/tests/baselines/reference/symbolProperty8.symbols
+++ b/tests/baselines/reference/symbolProperty8.symbols
@@ -3,12 +3,12 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty8.ts, 0, 0))
 
     [Symbol.unscopables]: number;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --))
 
     [Symbol.toPrimitive]();
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols
index bbccd2a0f8b..d5c19af7844 100644
--- a/tests/baselines/reference/symbolType11.symbols
+++ b/tests/baselines/reference/symbolType11.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType11.ts ===
 var s = Symbol.for("logical");
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --))
 
 s && s;
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType16.symbols b/tests/baselines/reference/symbolType16.symbols
index 9a25d9ad152..a31a4e5c677 100644
--- a/tests/baselines/reference/symbolType16.symbols
+++ b/tests/baselines/reference/symbolType16.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolType16.ts ===
 interface Symbol {
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11), Decl(symbolType16.ts, 0, 0))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(symbolType16.ts, 0, 0))
 
     newSymbolProp: number;
 >newSymbolProp : Symbol(newSymbolProp, Decl(symbolType16.ts, 0, 18))
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
index f042978fa8c..2de45d16379 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols
@@ -13,7 +13,7 @@ function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, x: T): T;
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 3, 21))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 3, 56))
 >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping1.ts, 3, 69))
@@ -24,7 +24,7 @@ function tempTag1<T>(templateStrs: TemplateStringsArray, f: FuncType, h: FuncTyp
 >tempTag1 : Symbol(tempTag1, Decl(taggedTemplateContextualTyping1.ts, 1, 48), Decl(taggedTemplateContextualTyping1.ts, 3, 79), Decl(taggedTemplateContextualTyping1.ts, 4, 92))
 >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 4, 18))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 4, 21))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping1.ts, 4, 56))
 >FuncType : Symbol(FuncType, Decl(taggedTemplateContextualTyping1.ts, 0, 0))
 >h : Symbol(h, Decl(taggedTemplateContextualTyping1.ts, 4, 69))
diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
index 6918c5606a8..240cc344de7 100644
--- a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
+++ b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols
@@ -22,7 +22,7 @@ type FuncType2 = (x: <S, T>(p: T) => T) => typeof x;
 function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): number;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 4, 18))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 4, 53))
 >FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0))
 >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 4, 67))
@@ -30,7 +30,7 @@ function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number):
 function tempTag2(templateStrs: TemplateStringsArray, f: FuncType2, h: FuncType2, x: string): string;
 >tempTag2 : Symbol(tempTag2, Decl(taggedTemplateContextualTyping2.ts, 2, 52), Decl(taggedTemplateContextualTyping2.ts, 4, 87), Decl(taggedTemplateContextualTyping2.ts, 5, 101))
 >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping2.ts, 5, 18))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 5, 53))
 >FuncType2 : Symbol(FuncType2, Decl(taggedTemplateContextualTyping2.ts, 1, 49))
 >h : Symbol(h, Decl(taggedTemplateContextualTyping2.ts, 5, 67))
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols
index c4f538d3254..52b8f3ab6f0 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols
@@ -3,7 +3,7 @@
 function foo1(strs: TemplateStringsArray, x: number): string;
 >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 61), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 2, 49))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 14))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 41))
 
 function foo1(strs: string[], x: number): number;
@@ -35,7 +35,7 @@ function foo2(strs: string[], x: number): number;
 function foo2(strs: TemplateStringsArray, x: number): string;
 >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 8, 20), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 10, 49), Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 61))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 14))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 41))
 
 function foo2(...stuff: any[]): any {
diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols
index 0da33002d31..e96912ec3bb 100644
--- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols
+++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols
@@ -2,7 +2,7 @@
 function foo1(strs: TemplateStringsArray, x: number): string;
 >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 1, 49))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 14))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 41))
 
 function foo1(strs: string[], x: number): number;
@@ -34,7 +34,7 @@ function foo2(strs: string[], x: number): number;
 function foo2(strs: TemplateStringsArray, x: number): string;
 >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 61))
 >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 14))
->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38))
+>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 41))
 
 function foo2(...stuff: any[]): any {
diff --git a/tests/baselines/reference/targetTypeArgs.symbols b/tests/baselines/reference/targetTypeArgs.symbols
index 6c1b2cd9cfe..b0d825ddd50 100644
--- a/tests/baselines/reference/targetTypeArgs.symbols
+++ b/tests/baselines/reference/targetTypeArgs.symbols
@@ -14,44 +14,44 @@ foo(function(x) { x });
 >x : Symbol(x, Decl(targetTypeArgs.ts, 4, 13))
 
 [1].forEach(function(v,i,a) { v });
->[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 6, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 6, 25))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21))
 
 ["hello"].every(function(v,i,a) {return true;});
->["hello"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>["hello"].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 7, 25))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 7, 27))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 7, 29))
 
 [1].every(function(v,i,a) {return true;});
->[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 8, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 8, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 8, 23))
 
 [1].every(function(v,i,a) {return true;});
->[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 9, 19))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 9, 21))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 9, 23))
 
 ["s"].every(function(v,i,a) {return true;});
->["s"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
+>["s"].every : Symbol(Array.every, Decl(lib.d.ts, --, --))
+>every : Symbol(Array.every, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 10, 21))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 10, 23))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 10, 25))
 
 ["s"].forEach(function(v,i,a) { v });
->["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >v : Symbol(v, Decl(targetTypeArgs.ts, 11, 23))
 >i : Symbol(i, Decl(targetTypeArgs.ts, 11, 25))
 >a : Symbol(a, Decl(targetTypeArgs.ts, 11, 27))
diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
index dbac3b57366..6df8d8ac2ad 100644
--- a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
+++ b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols
@@ -9,9 +9,9 @@ function suggest(){
 >result : Symbol(result, Decl(targetTypeObjectLiteralToAny.ts, 2, 4))
 					
 	TypeScriptKeywords.forEach(function(keyword) {						
->TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >TypeScriptKeywords : Symbol(TypeScriptKeywords, Decl(targetTypeObjectLiteralToAny.ts, 1, 4))
->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
 >keyword : Symbol(keyword, Decl(targetTypeObjectLiteralToAny.ts, 4, 37))
 
 		result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any
diff --git a/tests/baselines/reference/targetTypingOnFunctions.symbols b/tests/baselines/reference/targetTypingOnFunctions.symbols
index ccf669ffa67..19dfda36f79 100644
--- a/tests/baselines/reference/targetTypingOnFunctions.symbols
+++ b/tests/baselines/reference/targetTypingOnFunctions.symbols
@@ -3,15 +3,15 @@ var fu: (s: string) => string = function (s) { return s.toLowerCase() };
 >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 9))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42))
->s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
 var zu = fu = function (s) { return s.toLowerCase() };
 >zu : Symbol(zu, Decl(targetTypingOnFunctions.ts, 2, 3))
 >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24))
->s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols
index ef18ef3df64..ed7ef9dbc63 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperator.ts ===
 var x = `abc${ new String("Hi") }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperator.ts, 0, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
index 9d8b6024e0c..a7240d4fd22 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts ===
 var x = `abc${ new String("Hi") }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols
index 7deee379f23..22af33732cf 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlus.ts ===
 var x = `abc${ +Infinity }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedUnaryPlus.ts, 0, 3))
->Infinity : Symbol(Infinity, Decl(lib.d.ts, 22, 11))
+>Infinity : Symbol(Infinity, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols
index 39f2cf60c8a..5d27cedede1 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlusES6.ts ===
 var x = `abc${ +Infinity }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedUnaryPlusES6.ts, 0, 3))
->Infinity : Symbol(Infinity, Decl(lib.d.ts, 22, 11))
+>Infinity : Symbol(Infinity, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringWithPropertyAccess.symbols b/tests/baselines/reference/templateStringWithPropertyAccess.symbols
index fc5464f1eff..16b090fe5ff 100644
--- a/tests/baselines/reference/templateStringWithPropertyAccess.symbols
+++ b/tests/baselines/reference/templateStringWithPropertyAccess.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithPropertyAccess.ts ===
 `abc${0}abc`.indexOf(`abc`);
->`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41))
->indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41))
+>`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
+>indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols b/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols
index 22518032fc4..9259aff2a31 100644
--- a/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols
+++ b/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithPropertyAccessES6.ts ===
 `abc${0}abc`.indexOf(`abc`);
->`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41))
->indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41))
+>`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
+>indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
index b10113ff43b..9d405b8f6f6 100644
--- a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
+++ b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols
@@ -7,7 +7,7 @@ class Bug {
 
     private static func: Function[] = [
 >func : Symbol(Bug.func, Decl(thisInPropertyBoundDeclarations.ts, 1, 25))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
      (that: Bug, name: string) => {
 >that : Symbol(that, Decl(thisInPropertyBoundDeclarations.ts, 4, 6))
diff --git a/tests/baselines/reference/thisTypeInClasses.symbols b/tests/baselines/reference/thisTypeInClasses.symbols
index 6383bb01b8d..04ed47b09ff 100644
--- a/tests/baselines/reference/thisTypeInClasses.symbols
+++ b/tests/baselines/reference/thisTypeInClasses.symbols
@@ -44,11 +44,11 @@ class C3 {
 
     c: this | Date;
 >c : Symbol(c, Decl(thisTypeInClasses.ts, 17, 20))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     d: this & Date;
 >d : Symbol(d, Decl(thisTypeInClasses.ts, 18, 19))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     e: (((this)));
 >e : Symbol(e, Decl(thisTypeInClasses.ts, 19, 19))
diff --git a/tests/baselines/reference/thisTypeInInterfaces.symbols b/tests/baselines/reference/thisTypeInInterfaces.symbols
index 498fbcc8796..4ab896ae6f6 100644
--- a/tests/baselines/reference/thisTypeInInterfaces.symbols
+++ b/tests/baselines/reference/thisTypeInInterfaces.symbols
@@ -46,11 +46,11 @@ interface I3 {
 
     c: this | Date;
 >c : Symbol(c, Decl(thisTypeInInterfaces.ts, 18, 20))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     d: this & Date;
 >d : Symbol(d, Decl(thisTypeInInterfaces.ts, 19, 19))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     e: (((this)));
 >e : Symbol(e, Decl(thisTypeInInterfaces.ts, 20, 19))
diff --git a/tests/baselines/reference/thisTypeInTuples.symbols b/tests/baselines/reference/thisTypeInTuples.symbols
index 5b9965510a7..256f182dd69 100644
--- a/tests/baselines/reference/thisTypeInTuples.symbols
+++ b/tests/baselines/reference/thisTypeInTuples.symbols
@@ -1,10 +1,10 @@
 === tests/cases/conformance/types/thisType/thisTypeInTuples.ts ===
 interface Array<T> {
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(thisTypeInTuples.ts, 0, 0))
->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(thisTypeInTuples.ts, 0, 16))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 16))
 
     slice(): this;
->slice : Symbol(slice, Decl(lib.d.ts, 1048, 15), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 }
 
 let t: [number, string] = [42, "hello"];
@@ -12,19 +12,19 @@ let t: [number, string] = [42, "hello"];
 
 let a = t.slice();
 >a : Symbol(a, Decl(thisTypeInTuples.ts, 5, 3))
->t.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15), Decl(thisTypeInTuples.ts, 0, 20))
+>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 >t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 
 let b = t.slice(1);
 >b : Symbol(b, Decl(thisTypeInTuples.ts, 6, 3))
->t.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15), Decl(thisTypeInTuples.ts, 0, 20))
+>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 >t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 
 let c = t.slice(0, 1);
 >c : Symbol(c, Decl(thisTypeInTuples.ts, 7, 3))
->t.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15), Decl(thisTypeInTuples.ts, 0, 20))
+>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 >t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3))
->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15), Decl(thisTypeInTuples.ts, 0, 20))
+>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20))
 
diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols
index cb65755a145..508bdcb9f3f 100644
--- a/tests/baselines/reference/throwStatements.symbols
+++ b/tests/baselines/reference/throwStatements.symbols
@@ -53,9 +53,9 @@ module M {
     export function F2(x: number): string { return x.toString(); }
 >F2 : Symbol(F2, Decl(throwStatements.ts, 21, 5))
 >x : Symbol(x, Decl(throwStatements.ts, 23, 23))
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(throwStatements.ts, 23, 23))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 var aNumber = 9.9;
@@ -72,14 +72,14 @@ throw aString;
 
 var aDate = new Date(12);
 >aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw aDate;
 >aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3))
 
 var anObject = new Object();
 >anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw anObject;
 >anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3))
@@ -202,13 +202,13 @@ throw [];
 throw ['a', ['b']];
 throw /[a-z]/;
 throw new Date();
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw new C();
 >C : Symbol(C, Decl(throwStatements.ts, 4, 1))
 
 throw new Object();
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw new D<number>();
 >D : Symbol(D, Decl(throwStatements.ts, 8, 1))
diff --git a/tests/baselines/reference/toStringOnPrimitives.symbols b/tests/baselines/reference/toStringOnPrimitives.symbols
index f0cdf2c7050..96fb16bf4ca 100644
--- a/tests/baselines/reference/toStringOnPrimitives.symbols
+++ b/tests/baselines/reference/toStringOnPrimitives.symbols
@@ -1,17 +1,17 @@
 === tests/cases/compiler/toStringOnPrimitives.ts ===
 true.toString()
->true.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>true.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 var aBool = false;
 >aBool : Symbol(aBool, Decl(toStringOnPrimitives.ts, 1, 3))
 
 aBool.toString();
->aBool.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>aBool.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >aBool : Symbol(aBool, Decl(toStringOnPrimitives.ts, 1, 3))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
 1..toString();
->1..toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>1..toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
index 79d5bc3e7a7..752e75d4901 100644
--- a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
+++ b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols
@@ -73,16 +73,16 @@ var r1a = _.map(c2, (x) => { return x.toFixed() });
 >map : Symbol(Combinators.map, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 5, 23), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 6, 77))
 >c2 : Symbol(c2, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 9, 3))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21))
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
 var rf1 = (x: number) => { return x.toFixed() };
 >rf1 : Symbol(rf1, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 3))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11))
->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11))
->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
 
 var r1b = _.map(c2, rf1); 
 >r1b : Symbol(r1b, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 13, 3))
diff --git a/tests/baselines/reference/topLevelExports.symbols b/tests/baselines/reference/topLevelExports.symbols
index 56a32820228..733a98bcde5 100644
--- a/tests/baselines/reference/topLevelExports.symbols
+++ b/tests/baselines/reference/topLevelExports.symbols
@@ -8,8 +8,8 @@ function log(n:number) { return n;}
 >n : Symbol(n, Decl(topLevelExports.ts, 2, 13))
 
 void log(foo).toString();
->log(foo).toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>log(foo).toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >log : Symbol(log, Decl(topLevelExports.ts, 0, 19))
 >foo : Symbol(foo, Decl(topLevelExports.ts, 0, 10))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/tsxPreserveEmit1.js b/tests/baselines/reference/tsxPreserveEmit1.js
new file mode 100644
index 00000000000..80aeef6b297
--- /dev/null
+++ b/tests/baselines/reference/tsxPreserveEmit1.js
@@ -0,0 +1,32 @@
+//// [tests/cases/conformance/jsx/tsxPreserveEmit1.tsx] ////
+
+//// [react.d.ts]
+
+declare module 'react' {
+	var x: any;
+	export = x;
+}
+
+declare module ReactRouter {
+	var Route: any;
+	interface Thing { }
+}
+declare module 'react-router' {
+	export = ReactRouter;
+}
+
+//// [test.tsx]
+// Should emit 'react-router' in the AMD dependency list
+import React = require('react');
+import ReactRouter = require('react-router');
+
+import Route = ReactRouter.Route;
+
+var routes = <Route />;
+
+
+//// [test.jsx]
+define(["require", "exports", 'react-router'], function (require, exports, ReactRouter) {
+    var Route = ReactRouter.Route;
+    var routes = <Route />;
+});
diff --git a/tests/baselines/reference/tsxPreserveEmit1.symbols b/tests/baselines/reference/tsxPreserveEmit1.symbols
new file mode 100644
index 00000000000..6dcf4d9ac49
--- /dev/null
+++ b/tests/baselines/reference/tsxPreserveEmit1.symbols
@@ -0,0 +1,41 @@
+=== tests/cases/conformance/jsx/test.tsx ===
+// Should emit 'react-router' in the AMD dependency list
+import React = require('react');
+>React : Symbol(React, Decl(test.tsx, 0, 0))
+
+import ReactRouter = require('react-router');
+>ReactRouter : Symbol(ReactRouter, Decl(test.tsx, 1, 32))
+
+import Route = ReactRouter.Route;
+>Route : Symbol(Route, Decl(test.tsx, 2, 45))
+>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1))
+>Route : Symbol(ReactRouter.Route, Decl(react.d.ts, 7, 4))
+
+var routes = <Route />;
+>routes : Symbol(routes, Decl(test.tsx, 6, 3))
+>Route : Symbol(Route, Decl(test.tsx, 2, 45))
+
+=== tests/cases/conformance/jsx/react.d.ts ===
+
+declare module 'react' {
+	var x: any;
+>x : Symbol(x, Decl(react.d.ts, 2, 4))
+
+	export = x;
+>x : Symbol(x, Decl(react.d.ts, 2, 4))
+}
+
+declare module ReactRouter {
+>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1))
+
+	var Route: any;
+>Route : Symbol(Route, Decl(react.d.ts, 7, 4))
+
+	interface Thing { }
+>Thing : Symbol(Thing, Decl(react.d.ts, 7, 16))
+}
+declare module 'react-router' {
+	export = ReactRouter;
+>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1))
+}
+
diff --git a/tests/baselines/reference/tsxPreserveEmit1.types b/tests/baselines/reference/tsxPreserveEmit1.types
new file mode 100644
index 00000000000..ea64e2d2e94
--- /dev/null
+++ b/tests/baselines/reference/tsxPreserveEmit1.types
@@ -0,0 +1,42 @@
+=== tests/cases/conformance/jsx/test.tsx ===
+// Should emit 'react-router' in the AMD dependency list
+import React = require('react');
+>React : any
+
+import ReactRouter = require('react-router');
+>ReactRouter : typeof ReactRouter
+
+import Route = ReactRouter.Route;
+>Route : any
+>ReactRouter : typeof ReactRouter
+>Route : any
+
+var routes = <Route />;
+>routes : any
+><Route /> : any
+>Route : any
+
+=== tests/cases/conformance/jsx/react.d.ts ===
+
+declare module 'react' {
+	var x: any;
+>x : any
+
+	export = x;
+>x : any
+}
+
+declare module ReactRouter {
+>ReactRouter : typeof ReactRouter
+
+	var Route: any;
+>Route : any
+
+	interface Thing { }
+>Thing : Thing
+}
+declare module 'react-router' {
+	export = ReactRouter;
+>ReactRouter : typeof ReactRouter
+}
+
diff --git a/tests/baselines/reference/tsxReactEmit6.js b/tests/baselines/reference/tsxReactEmit6.js
index d20ef7051e0..4f583929004 100644
--- a/tests/baselines/reference/tsxReactEmit6.js
+++ b/tests/baselines/reference/tsxReactEmit6.js
@@ -19,7 +19,11 @@ namespace M {
 	//  and M.React.__spread
 	var foo;
 	var spread1 = <div x='' {...foo} y='' />;
+
+	// Quotes
+	var x = <div>This "quote" thing</div>;
 }
+
 
 
 //// [file.js]
@@ -33,4 +37,6 @@ var M;
     //  and M.React.__spread
     var foo;
     var spread1 = M.React.createElement("div", M.React.__spread({x: ''}, foo, {y: ''}));
+    // Quotes
+    var x = M.React.createElement("div", null, "This \"quote\" thing");
 })(M || (M = {}));
diff --git a/tests/baselines/reference/tsxReactEmit6.symbols b/tests/baselines/reference/tsxReactEmit6.symbols
index fd717ee4a5b..8eb0561e185 100644
--- a/tests/baselines/reference/tsxReactEmit6.symbols
+++ b/tests/baselines/reference/tsxReactEmit6.symbols
@@ -36,5 +36,12 @@ namespace M {
 >x : Symbol(unknown)
 >foo : Symbol(foo, Decl(react-consumer.tsx, 7, 4))
 >y : Symbol(unknown)
+
+	// Quotes
+	var x = <div>This "quote" thing</div>;
+>x : Symbol(x, Decl(react-consumer.tsx, 11, 4))
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22))
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22))
 }
 
+
diff --git a/tests/baselines/reference/tsxReactEmit6.types b/tests/baselines/reference/tsxReactEmit6.types
index 1b16b84fcc7..b8a307eb9d7 100644
--- a/tests/baselines/reference/tsxReactEmit6.types
+++ b/tests/baselines/reference/tsxReactEmit6.types
@@ -37,5 +37,13 @@ namespace M {
 >x : any
 >foo : any
 >y : any
+
+	// Quotes
+	var x = <div>This "quote" thing</div>;
+>x : JSX.Element
+><div>This "quote" thing</div> : JSX.Element
+>div : any
+>div : any
 }
 
+
diff --git a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols
index 9fe6e31259e..5d46be73518 100644
--- a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols
+++ b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols
@@ -19,8 +19,8 @@ interface A {
     foo(x: Date): Date;
 >foo : Symbol(foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 2, 13), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 3, 27), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 7, 13))
 >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 8, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 interface B<T> {
@@ -45,12 +45,12 @@ interface B<T> {
 >foo : Symbol(foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 12, 22), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 20))
 >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 8))
 >T : Symbol(T, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 12), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 12))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo(x: Date): string;
 >foo : Symbol(foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 12, 22), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 20))
 >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 18, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 var b: B<boolean>;
@@ -100,7 +100,7 @@ interface C<T, U> {
 var c: C<boolean, Date>;
 >c : Symbol(c, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 34, 3))
 >C : Symbol(C, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 22, 20), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 28, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r2 = c.foo(1, 2); // number
 >r2 : Symbol(r2, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 35, 3))
@@ -150,7 +150,7 @@ interface D<T, U> {
 var d: D<boolean, Date>;
 >d : Symbol(d, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 48, 3))
 >D : Symbol(D, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 35, 21), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 42, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var r3 = d.foo(1, 1); // boolean, last definition wins
 >r3 : Symbol(r3, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 49, 3))
diff --git a/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols b/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols
index a94890b51be..c990d3de59d 100644
--- a/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols
+++ b/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols
@@ -5,7 +5,7 @@ declare module m {
     // type alias declaration here shouldnt make the module declaration instantiated
     type Selector = string| string[] |Function;
 >Selector : Symbol(Selector, Decl(typeAliasDoesntMakeModuleInstantiated.ts, 0, 18))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     export interface IStatic {
 >IStatic : Symbol(IStatic, Decl(typeAliasDoesntMakeModuleInstantiated.ts, 2, 47))
diff --git a/tests/baselines/reference/typeAliases.symbols b/tests/baselines/reference/typeAliases.symbols
index 5bbc77c735d..02cc5027b04 100644
--- a/tests/baselines/reference/typeAliases.symbols
+++ b/tests/baselines/reference/typeAliases.symbols
@@ -200,12 +200,12 @@ declare function f15(a: Meters): string;
 >Meters : Symbol(Meters, Decl(typeAliases.ts, 63, 39))
 
 f15(E.x).toLowerCase();
->f15(E.x).toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>f15(E.x).toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >f15 : Symbol(f15, Decl(typeAliases.ts, 67, 17), Decl(typeAliases.ts, 69, 41))
 >E.x : Symbol(E.x, Decl(typeAliases.ts, 67, 8))
 >E : Symbol(E, Decl(typeAliases.ts, 65, 20))
 >x : Symbol(E.x, Decl(typeAliases.ts, 67, 8))
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
 type StringAndBoolean = [string, boolean]
 >StringAndBoolean : Symbol(StringAndBoolean, Decl(typeAliases.ts, 71, 23))
@@ -227,8 +227,8 @@ var y: StringAndBoolean = ["1", false];
 >StringAndBoolean : Symbol(StringAndBoolean, Decl(typeAliases.ts, 71, 23))
 
 y[0].toLowerCase();
->y[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>y[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 >y : Symbol(y, Decl(typeAliases.ts, 78, 3))
 >0 : Symbol(0)
->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
index 557175473da..00de7ec64c9 100644
--- a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
@@ -3,7 +3,7 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType1.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType1.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
index f25ca2bba6b..4626aabb605 100644
--- a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
@@ -3,14 +3,14 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType2.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType2.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
     function inner<U extends Iterable<T>>() {
 >inner : Symbol(inner, Decl(typeArgumentInferenceApparentType2.ts, 0, 46))
 >U : Symbol(U, Decl(typeArgumentInferenceApparentType2.ts, 1, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
         var u: U;
diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols b/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols
index ceb97a73af8..7c24840b5ab 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols
@@ -12,8 +12,8 @@ function foo<T>(x = class { static prop: T }): T {
 }
 
 foo(class { static prop = "hello" }).length;
->foo(class { static prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>foo(class { static prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 0))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression1.ts, 4, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols b/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols
index aedb0230fd6..3f25fd0682f 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols
@@ -12,8 +12,8 @@ function foo<T>(x = class { prop: T }): T {
 }
 
 foo(class { prop = "hello" }).length;
->foo(class { prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>foo(class { prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 0))
 >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression3.ts, 4, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
index 08b61492a54..b73bd8882d2 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols
@@ -15,9 +15,9 @@ var nodes: TreeNode[];
 >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 0))
 
 nodes.map(n => n.name);
->nodes.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 5, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10))
 >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10))
diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
index cb2e8e94656..7cec46cb4b6 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols
@@ -26,9 +26,9 @@ var nodes: TreeNodeMiddleman[];
 >TreeNodeMiddleman : Symbol(TreeNodeMiddleman, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 3, 1))
 
 nodes.map(n => n.name);
->nodes.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 10, 3))
->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92))
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10))
 >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26))
 >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10))
diff --git a/tests/baselines/reference/typeGuardsDefeat.symbols b/tests/baselines/reference/typeGuardsDefeat.symbols
index e5b2b4b2047..388b69b5789 100644
--- a/tests/baselines/reference/typeGuardsDefeat.symbols
+++ b/tests/baselines/reference/typeGuardsDefeat.symbols
@@ -18,9 +18,9 @@ function foo(x: number | string) {
 >f : Symbol(f, Decl(typeGuardsDefeat.ts, 2, 34))
 
         return x.length; // string
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 2, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     else {
         return x++; // number
@@ -35,9 +35,9 @@ function foo2(x: number | string) {
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
 
         return x.length; // string
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     else {
         var f = function () {
@@ -63,9 +63,9 @@ function foo3(x: number | string) {
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
 
         return x.length; // string
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     else {
         var f = () => x * x;
diff --git a/tests/baselines/reference/typeGuardsInClassAccessors.symbols b/tests/baselines/reference/typeGuardsInClassAccessors.symbols
index 17754779ecf..d38c3040e01 100644
--- a/tests/baselines/reference/typeGuardsInClassAccessors.symbols
+++ b/tests/baselines/reference/typeGuardsInClassAccessors.symbols
@@ -24,9 +24,9 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -35,9 +35,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 15, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 15, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return strOrNum;
 >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3))
@@ -51,17 +51,17 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameter of function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 21, 11))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 21, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -70,9 +70,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 29, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 29, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     // Inside private accessor getter
     private get pp1() {
@@ -82,9 +82,9 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -93,9 +93,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 38, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 38, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return strOrNum;
 >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3))
@@ -109,17 +109,17 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameter of function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 44, 20))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 44, 20))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -128,9 +128,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 52, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 52, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     // Inside static accessor getter
     static get s1() {
@@ -140,9 +140,9 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -151,9 +151,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 61, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 61, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return strOrNum;
 >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3))
@@ -167,17 +167,17 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameter of function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 67, 18))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 67, 18))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -186,9 +186,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 75, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 75, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     // Inside private static accessor getter
     private static get ss1() {
@@ -198,9 +198,9 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -209,9 +209,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 84, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 84, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return strOrNum;
 >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3))
@@ -225,17 +225,17 @@ class ClassWithAccessors {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameter of function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 90, 27))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 90, 27))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -244,9 +244,9 @@ class ClassWithAccessors {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 98, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 98, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/typeGuardsInClassMethods.symbols b/tests/baselines/reference/typeGuardsInClassMethods.symbols
index c0d88ff414f..30f01d3619f 100644
--- a/tests/baselines/reference/typeGuardsInClassMethods.symbols
+++ b/tests/baselines/reference/typeGuardsInClassMethods.symbols
@@ -19,9 +19,9 @@ class C1 {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -30,17 +30,17 @@ class C1 {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 12, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 12, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 7, 16))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 7, 16))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     // Inside function declaration
     private p1(param: string | number) {
@@ -51,9 +51,9 @@ class C1 {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -62,17 +62,17 @@ class C1 {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 24, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 24, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 19, 15))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 19, 15))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     // Inside function declaration
     p2(param: string | number) {
@@ -83,9 +83,9 @@ class C1 {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -94,17 +94,17 @@ class C1 {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 36, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 36, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 31, 7))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 31, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     // Inside function declaration
     private static s1(param: string | number) {
@@ -115,9 +115,9 @@ class C1 {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -126,17 +126,17 @@ class C1 {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 48, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 48, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 43, 22))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 43, 22))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     // Inside function declaration
     static s2(param: string | number) {
@@ -147,9 +147,9 @@ class C1 {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -158,17 +158,17 @@ class C1 {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 60, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 60, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 55, 14))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 55, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
 }
 
diff --git a/tests/baselines/reference/typeGuardsInConditionalExpression.symbols b/tests/baselines/reference/typeGuardsInConditionalExpression.symbols
index ac35c1f18b9..7de63d90bf9 100644
--- a/tests/baselines/reference/typeGuardsInConditionalExpression.symbols
+++ b/tests/baselines/reference/typeGuardsInConditionalExpression.symbols
@@ -14,9 +14,9 @@ function foo(x: number | string) {
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13))
 
         ? x.length // string
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         : x++; // number
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13))
@@ -157,9 +157,9 @@ function foo9(x: number | string) {
 
         ? ((y = x.length) && x === "hello") // string
 >y : Symbol(y, Decl(typeGuardsInConditionalExpression.ts, 61, 7))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14))
 
         : x === 10; // number
@@ -187,9 +187,9 @@ function foo10(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
 
         && x.toString()); // x is number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 function foo11(x: number | string | boolean) {
 >foo11 : Symbol(foo11, Decl(typeGuardsInConditionalExpression.ts, 75, 1))
@@ -233,11 +233,11 @@ function foo12(x: number | string | boolean) {
 
         ? (x = 10 && x.toString().length) // number | boolean | string - changed here
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
->x.toString().length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString().length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         : ((b = x) // x is number | boolean | string  - changed in true branch
 >b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 90, 7))
diff --git a/tests/baselines/reference/typeGuardsInExternalModule.symbols b/tests/baselines/reference/typeGuardsInExternalModule.symbols
index 290fe0bf80c..c9e5791f101 100644
--- a/tests/baselines/reference/typeGuardsInExternalModule.symbols
+++ b/tests/baselines/reference/typeGuardsInExternalModule.symbols
@@ -14,9 +14,9 @@ if (typeof var1 === "string") {
 
     num = var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInExternalModule.ts, 4, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInExternalModule.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
 else {
     num = var1; // number
diff --git a/tests/baselines/reference/typeGuardsInFunction.symbols b/tests/baselines/reference/typeGuardsInFunction.symbols
index 32a37f62a07..452e69435ff 100644
--- a/tests/baselines/reference/typeGuardsInFunction.symbols
+++ b/tests/baselines/reference/typeGuardsInFunction.symbols
@@ -18,9 +18,9 @@ function f(param: string | number) {
     num =  typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     // variables in function declaration
     var var2: string | number;
@@ -29,17 +29,17 @@ function f(param: string | number) {
     num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 12, 7))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 12, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     // parameters in function declaration
     num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 7, 11))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 7, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
 // local function declaration
 function f1(param: string | number) {
@@ -57,25 +57,25 @@ function f1(param: string | number) {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables from outer function declaration
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 20, 7))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 20, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in outer declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 19, 12))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 19, 12))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // local
         var var3: string | number;
@@ -84,16 +84,16 @@ function f1(param: string | number) {
         num = typeof var3 === "string" && var3.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 32, 11))
->var3.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var3.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 32, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         num = typeof param1 === "string" && param1.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 21, 16))
->param1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 21, 16))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
 }
 // Function expression
@@ -114,25 +114,25 @@ function f2(param: string | number) {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables from outer function declaration
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 40, 7))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 40, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in outer declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 38, 12))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 38, 12))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // local
         var var3: string | number;
@@ -141,16 +141,16 @@ function f2(param: string | number) {
         num = typeof var3 === "string" && var3.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 53, 11))
->var3.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var3.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 53, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         num = typeof param1 === "string" && param1.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 42, 22))
->param1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 42, 22))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     } (param);
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 38, 12))
@@ -173,25 +173,25 @@ function f3(param: string | number) {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables from outer function declaration
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 61, 7))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 61, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in outer declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 59, 12))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 59, 12))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // local
         var var3: string | number;
@@ -200,16 +200,16 @@ function f3(param: string | number) {
         num = typeof var3 === "string" && var3.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 74, 11))
->var3.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var3.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 74, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         num = typeof param1 === "string" && param1.length; // string
 >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 63, 14))
->param1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 63, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     })(param);
 >param : Symbol(param, Decl(typeGuardsInFunction.ts, 59, 12))
diff --git a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
index d1140e3af60..2f3232b0225 100644
--- a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
+++ b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols
@@ -22,14 +22,14 @@ function foo(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13))
 
                 ? x.toString() // boolean
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
         } ();
 }
@@ -55,14 +55,14 @@ function foo2(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
 
                 ? x.toString() // boolean
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
         } (x); // x here is narrowed to number | boolean
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
@@ -86,14 +86,14 @@ function foo3(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
 
                 ? x.toString() // boolean
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
         })();
 }
@@ -118,14 +118,14 @@ function foo4(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))
 
                 ? x.toString() // boolean
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
         })(x); // x here is narrowed to number | boolean
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))
@@ -180,14 +180,14 @@ module m {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 52, 7))
 
             ? x.toString() // boolean
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 52, 7))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
             : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 52, 7))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
         }
     }
 }
@@ -221,14 +221,14 @@ module m1 {
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 66, 7))
 
             ? x.toString() // boolean
->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 66, 7))
->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
             : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 66, 7))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
         }
     }
 }
diff --git a/tests/baselines/reference/typeGuardsInGlobal.symbols b/tests/baselines/reference/typeGuardsInGlobal.symbols
index 0ae6e75ce17..e052a068651 100644
--- a/tests/baselines/reference/typeGuardsInGlobal.symbols
+++ b/tests/baselines/reference/typeGuardsInGlobal.symbols
@@ -14,9 +14,9 @@ if (typeof var1 === "string") {
 
     num = var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInGlobal.ts, 4, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInGlobal.ts, 5, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
 else {
     num = var1; // number
diff --git a/tests/baselines/reference/typeGuardsInIfStatement.symbols b/tests/baselines/reference/typeGuardsInIfStatement.symbols
index 798fe18cf5a..54a65f0693b 100644
--- a/tests/baselines/reference/typeGuardsInIfStatement.symbols
+++ b/tests/baselines/reference/typeGuardsInIfStatement.symbols
@@ -13,9 +13,9 @@ function foo(x: number | string) {
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13))
 
         return x.length; // string
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     else {
         return x++; // number
@@ -181,9 +181,9 @@ function foo9(x: number | string) {
         // usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
         y = x.length; 
 >y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 91, 7))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return x === "hello"; // string
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14))
@@ -249,9 +249,9 @@ function foo11(x: number | string | boolean) {
             // change value of x
             x = 10 && x.toString() // number | boolean | string
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             )
             : (
@@ -259,9 +259,9 @@ function foo11(x: number | string | boolean) {
             y = x && x.toString() // number | boolean | string
 >y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 121, 11))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
             );
     }
@@ -276,9 +276,9 @@ function foo12(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
 
         return x.toString(); // string | number | boolean - x changed in else branch
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
     else {
         x = 10;
@@ -292,13 +292,13 @@ function foo12(x: number | string | boolean) {
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
 
             ? x.toString() // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
             : x.toString(); // boolean | string
->x.toString : Symbol(toString, Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15))
->toString : Symbol(toString, Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
 }
diff --git a/tests/baselines/reference/typeGuardsInModule.symbols b/tests/baselines/reference/typeGuardsInModule.symbols
index 581bb26d805..9c501e9c22f 100644
--- a/tests/baselines/reference/typeGuardsInModule.symbols
+++ b/tests/baselines/reference/typeGuardsInModule.symbols
@@ -20,9 +20,9 @@ module m1 {
     num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     // variables in module declaration
     var var2: string | number;
@@ -33,9 +33,9 @@ module m1 {
 
         num = var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 13, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     else {
         num = var2; // number
@@ -77,17 +77,17 @@ module m2 {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // local variables from outer module declaration
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3))
 >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 32, 7))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 32, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // exported variable from outer the module
         strOrNum = typeof var3 === "string" && var3; // string | number
@@ -104,9 +104,9 @@ module m2 {
 
             num = var4.length; // string
 >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3))
->var4.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var4.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var4 : Symbol(var4, Decl(typeGuardsInModule.ts, 45, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
         }
         else {
             num = var4; // number
@@ -141,9 +141,9 @@ module m3.m4 {
     num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3))
 >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
     // variables in module declaration
     var var2: string | number;
@@ -154,9 +154,9 @@ module m3.m4 {
 
         num = var2.length; // string
 >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 69, 7))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
     else {
         num = var2; // number
diff --git a/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols b/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols
index 59f51d21e71..21e3dd3701f 100644
--- a/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols
+++ b/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols
@@ -8,9 +8,9 @@ function foo(x: number | string) {
 
     return typeof x === "string" && x.length === 10; // string
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 3, 13))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 3, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
 function foo2(x: number | string) {
 >foo2 : Symbol(foo2, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 5, 1))
@@ -106,17 +106,17 @@ function foo7(x: number | string | boolean) {
         // change value of x
         ? (x = 10 && x.toString()) // number | boolean | string
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         // do not change value
         : (y = x && x.toString()))); // number | boolean | string
 >y : Symbol(y, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 34, 7))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 function foo8(x: number | string) {
 >foo8 : Symbol(foo8, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 45, 1))
@@ -137,7 +137,7 @@ function foo8(x: number | string) {
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
 
         : x.length); // string
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols b/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols
index d33f0b6877b..de9b4396d3d 100644
--- a/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols
+++ b/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols
@@ -8,9 +8,9 @@ function foo(x: number | string) {
 
     return typeof x !== "string" || x.length === 10; // string
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 3, 13))
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 3, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
 function foo2(x: number | string) {
 >foo2 : Symbol(foo2, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 5, 1))
@@ -106,17 +106,17 @@ function foo7(x: number | string | boolean) {
         // change value of x
         ? (x = 10 && x.toString()) // number | boolean | string
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         // do not change value
         : (y = x && x.toString()))); // number | boolean | string
 >y : Symbol(y, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 34, 7))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14))
->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 function foo8(x: number | string) {
 >foo8 : Symbol(foo8, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 45, 1))
@@ -137,7 +137,7 @@ function foo8(x: number | string) {
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
 
         : x.length); // string
->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/typeGuardsObjectMethods.symbols b/tests/baselines/reference/typeGuardsObjectMethods.symbols
index 3f585c1e4c6..2afbb3a8467 100644
--- a/tests/baselines/reference/typeGuardsObjectMethods.symbols
+++ b/tests/baselines/reference/typeGuardsObjectMethods.symbols
@@ -25,9 +25,9 @@ var obj1 = {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -36,17 +36,17 @@ var obj1 = {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 15, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 15, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 10, 11))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 10, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return strOrNum;
 >strOrNum : Symbol(strOrNum, Decl(typeGuardsObjectMethods.ts, 6, 3))
@@ -59,9 +59,9 @@ var obj1 = {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -70,9 +70,9 @@ var obj1 = {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 28, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 28, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         return strOrNum;
 >strOrNum : Symbol(strOrNum, Decl(typeGuardsObjectMethods.ts, 6, 3))
@@ -86,9 +86,9 @@ var obj1 = {
         num = typeof var1 === "string" && var1.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3))
->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // variables in function declaration
         var var2: string | number;
@@ -97,17 +97,17 @@ var obj1 = {
         num = typeof var2 === "string" && var2.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 38, 11))
->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 38, 11))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
 
         // parameters in function declaration
         num = typeof param === "string" && param.length; // string
 >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3))
 >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 33, 13))
->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>param.length : Symbol(String.length, Decl(lib.d.ts, --, --))
 >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 33, 13))
->length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
     }
 };
 // return expression of the method
diff --git a/tests/baselines/reference/typeGuardsWithInstanceOf.symbols b/tests/baselines/reference/typeGuardsWithInstanceOf.symbols
index b010ef12692..81efb5d5b1d 100644
--- a/tests/baselines/reference/typeGuardsWithInstanceOf.symbols
+++ b/tests/baselines/reference/typeGuardsWithInstanceOf.symbols
@@ -13,7 +13,7 @@ var result2: I;
 
 if (!(result instanceof RegExp)) {
 >result : Symbol(result, Decl(typeGuardsWithInstanceOf.ts, 1, 3))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     result = result2;
 >result : Symbol(result, Decl(typeGuardsWithInstanceOf.ts, 1, 3))
diff --git a/tests/baselines/reference/typeInferenceWithTupleType.symbols b/tests/baselines/reference/typeInferenceWithTupleType.symbols
index a78cd0d490b..6f3279db8c2 100644
--- a/tests/baselines/reference/typeInferenceWithTupleType.symbols
+++ b/tests/baselines/reference/typeInferenceWithTupleType.symbols
@@ -41,12 +41,12 @@ function zip<T, U>(array1: T[], array2: U[]): [[T, U]] {
 >U : Symbol(U, Decl(typeInferenceWithTupleType.ts, 8, 15))
 
     if (array1.length != array2.length) {
->array1.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >array1 : Symbol(array1, Decl(typeInferenceWithTupleType.ts, 8, 19))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
->array2.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
+>array2.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >array2 : Symbol(array2, Decl(typeInferenceWithTupleType.ts, 8, 31))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 
         return [[undefined, undefined]];
 >undefined : Symbol(undefined)
@@ -54,9 +54,9 @@ function zip<T, U>(array1: T[], array2: U[]): [[T, U]] {
     }
     var length = array1.length;
 >length : Symbol(length, Decl(typeInferenceWithTupleType.ts, 12, 7))
->array1.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >array1 : Symbol(array1, Decl(typeInferenceWithTupleType.ts, 8, 19))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 
     var zipResult: [[T, U]];
 >zipResult : Symbol(zipResult, Decl(typeInferenceWithTupleType.ts, 13, 7))
@@ -70,9 +70,9 @@ function zip<T, U>(array1: T[], array2: U[]): [[T, U]] {
 >i : Symbol(i, Decl(typeInferenceWithTupleType.ts, 14, 12))
 
         zipResult.push([array1[i], array2[i]]);
->zipResult.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>zipResult.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >zipResult : Symbol(zipResult, Decl(typeInferenceWithTupleType.ts, 13, 7))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >array1 : Symbol(array1, Decl(typeInferenceWithTupleType.ts, 8, 19))
 >i : Symbol(i, Decl(typeInferenceWithTupleType.ts, 14, 12))
 >array2 : Symbol(array2, Decl(typeInferenceWithTupleType.ts, 8, 31))
diff --git a/tests/baselines/reference/typeOfThisInMemberFunctions.symbols b/tests/baselines/reference/typeOfThisInMemberFunctions.symbols
index 31b04a52f86..c0a860af4f7 100644
--- a/tests/baselines/reference/typeOfThisInMemberFunctions.symbols
+++ b/tests/baselines/reference/typeOfThisInMemberFunctions.symbols
@@ -47,7 +47,7 @@ class D<T> {
 class E<T extends Date> {
 >E : Symbol(E, Decl(typeOfThisInMemberFunctions.ts, 19, 1))
 >T : Symbol(T, Decl(typeOfThisInMemberFunctions.ts, 21, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     x: T;
 >x : Symbol(x, Decl(typeOfThisInMemberFunctions.ts, 21, 25))
diff --git a/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols b/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols
index 450b291708f..e38953fe8a2 100644
--- a/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols
+++ b/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols
@@ -2,16 +2,16 @@
 function f<A extends Number>(A: A): A {
 >f : Symbol(f, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 0))
 >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29))
 >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29))
 >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29))
 
     var r = A.toExponential(123);
 >r : Symbol(r, Decl(typeParameterAndArgumentOfSameName1.ts, 1, 7))
->A.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>A.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29))
->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
 
     return null;
 }
diff --git a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols
index c9b06d0d68f..e50bce9e043 100644
--- a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols
+++ b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols
@@ -144,21 +144,21 @@ class C<T> {
     foo4<T extends Date>(x: T);
 >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 9))
 
     foo4<T extends Date>(x: T); // no error, different declaration for each T
 >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 9))
 
     foo4<T extends Date>(x: T) { }
 >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 9))
 }
@@ -166,7 +166,7 @@ class C<T> {
 class C2<T extends Date> {
 >C2 : Symbol(C2, Decl(typeParametersAreIdenticalToThemselves.ts, 36, 1))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 38, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo1(x: T);
 >foo1 : Symbol(foo1, Decl(typeParametersAreIdenticalToThemselves.ts, 38, 26), Decl(typeParametersAreIdenticalToThemselves.ts, 39, 15), Decl(typeParametersAreIdenticalToThemselves.ts, 40, 15))
@@ -271,14 +271,14 @@ interface I<T> {
     foo4<T extends Date>(x: T);
 >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 60, 18), Decl(typeParametersAreIdenticalToThemselves.ts, 62, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 9))
 
     foo4<T extends Date>(x: T); // no error, different declaration for each T
 >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 60, 18), Decl(typeParametersAreIdenticalToThemselves.ts, 62, 31))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 9))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 25))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 9))
 }
@@ -286,7 +286,7 @@ interface I<T> {
 interface I2<T extends Date> {
 >I2 : Symbol(I2, Decl(typeParametersAreIdenticalToThemselves.ts, 64, 1))
 >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 66, 13))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo1(x: T);
 >foo1 : Symbol(foo1, Decl(typeParametersAreIdenticalToThemselves.ts, 66, 30), Decl(typeParametersAreIdenticalToThemselves.ts, 67, 15))
diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols
index 41fbab91e3c..cf5e68b956a 100644
--- a/tests/baselines/reference/typedArrays.symbols
+++ b/tests/baselines/reference/typedArrays.symbols
@@ -8,39 +8,39 @@ function CreateTypedArrayTypes() {
 
     typedArrays[0] = Int8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[1] = Uint8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[2] = Int16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[3] = Uint16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[4] = Int32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[5] = Uint32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[6] = Float32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[7] = Float64Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     typedArrays[8] = Uint8ClampedArray;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
@@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     return typedArrays;
@@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     return typedArrays;
@@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     return typedArrays;
@@ -235,72 +235,72 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >CreateIntegerTypedArraysFromArrayLike : Symbol(CreateIntegerTypedArraysFromArrayLike, Decl(typedArrays.ts, 59, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1198, 1))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, --, --))
 
     var typedArrays = [];
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     return typedArrays;
@@ -332,57 +332,57 @@ function CreateTypedArraysOf2() {
 
     typedArrays[0] = Int8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30))
+>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[1] = Uint8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30))
+>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[2] = Int16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30))
+>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[3] = Uint16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30))
+>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[4] = Int32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30))
+>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[5] = Uint32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30))
+>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[6] = Float32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30))
+>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[7] = Float64Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30))
+>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     typedArrays[8] = Uint8ClampedArray.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30))
+>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, --, --))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
@@ -391,7 +391,7 @@ function CreateTypedArraysOf2() {
 function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:number)=> number) {
 >CreateTypedArraysFromMapFn : Symbol(CreateTypedArraysFromMapFn, Decl(typedArrays.ts, 106, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1198, 1))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, --, --))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 >n : Symbol(n, Decl(typedArrays.ts, 108, 67))
 >v : Symbol(v, Decl(typedArrays.ts, 108, 76))
@@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
@@ -478,7 +478,7 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v:number)=> number, thisArg: {}) {
 >CreateTypedArraysFromThisObj : Symbol(CreateTypedArraysFromThisObj, Decl(typedArrays.ts, 121, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1198, 1))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, --, --))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >n : Symbol(n, Decl(typedArrays.ts, 123, 69))
 >v : Symbol(v, Decl(typedArrays.ts, 123, 78))
@@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
diff --git a/tests/baselines/reference/typeofOperatorWithStringType.symbols b/tests/baselines/reference/typeofOperatorWithStringType.symbols
index 6da22469f83..090e0958e60 100644
--- a/tests/baselines/reference/typeofOperatorWithStringType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithStringType.symbols
@@ -88,9 +88,9 @@ var ResultIsString11 = typeof (STRING + STRING);
 
 var ResultIsString12 = typeof STRING.charAt(0);
 >ResultIsString12 : Symbol(ResultIsString12, Decl(typeofOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 // multiple typeof  operators
 var ResultIsString13 = typeof typeof STRING;
diff --git a/tests/baselines/reference/undefinedAssignableToEveryType.symbols b/tests/baselines/reference/undefinedAssignableToEveryType.symbols
index da2b3ff7c83..f511231515e 100644
--- a/tests/baselines/reference/undefinedAssignableToEveryType.symbols
+++ b/tests/baselines/reference/undefinedAssignableToEveryType.symbols
@@ -41,7 +41,7 @@ var d: boolean = undefined;
 
 var e: Date = undefined;
 >e : Symbol(e, Decl(undefinedAssignableToEveryType.ts, 15, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var f: any = undefined;
@@ -54,7 +54,7 @@ var g: void = undefined;
 
 var h: Object = undefined;
 >h : Symbol(h, Decl(undefinedAssignableToEveryType.ts, 18, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var i: {} = undefined;
@@ -67,7 +67,7 @@ var j: () => {} = undefined;
 
 var k: Function = undefined;
 >k : Symbol(k, Decl(undefinedAssignableToEveryType.ts, 21, 3))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var l: (x: number) => string = undefined;
@@ -106,12 +106,12 @@ var o: <T>(x: T) => T = undefined;
 
 var p: Number = undefined;
 >p : Symbol(p, Decl(undefinedAssignableToEveryType.ts, 29, 3))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 var q: String = undefined;
 >q : Symbol(q, Decl(undefinedAssignableToEveryType.ts, 30, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 function foo<T, U, V extends Date>(x: T, y: U, z: V) {
@@ -119,7 +119,7 @@ function foo<T, U, V extends Date>(x: T, y: U, z: V) {
 >T : Symbol(T, Decl(undefinedAssignableToEveryType.ts, 32, 13))
 >U : Symbol(U, Decl(undefinedAssignableToEveryType.ts, 32, 15))
 >V : Symbol(V, Decl(undefinedAssignableToEveryType.ts, 32, 18))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(undefinedAssignableToEveryType.ts, 32, 35))
 >T : Symbol(T, Decl(undefinedAssignableToEveryType.ts, 32, 13))
 >y : Symbol(y, Decl(undefinedAssignableToEveryType.ts, 32, 40))
diff --git a/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols b/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols
index 1b786e9e524..de4f6f0da05 100644
--- a/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols
+++ b/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols
@@ -40,7 +40,7 @@ class D1A extends Base {
 
     foo: String;
 >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 18, 24))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
@@ -58,7 +58,7 @@ class D2A extends Base {
 
     foo: Number;
 >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 27, 24))
->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
@@ -76,7 +76,7 @@ class D3A extends Base {
 
     foo: Boolean;
 >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 36, 24))
->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11))
+>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
@@ -86,7 +86,7 @@ class D4 extends Base {
 
     foo: RegExp;
 >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 41, 23))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 class D5 extends Base {
@@ -95,7 +95,7 @@ class D5 extends Base {
 
     foo: Date;
 >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 45, 23))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
@@ -235,7 +235,7 @@ class D16 extends Base {
 
     foo: Object;
 >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 112, 24))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 }
 
 
diff --git a/tests/baselines/reference/underscoreTest1.symbols b/tests/baselines/reference/underscoreTest1.symbols
index 1ba7c97d331..9de509de417 100644
--- a/tests/baselines/reference/underscoreTest1.symbols
+++ b/tests/baselines/reference/underscoreTest1.symbols
@@ -14,9 +14,9 @@ _.each([1, 2, 3], (num) => alert(num.toString()));
 >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
->num.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>num.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString()));
 >_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
@@ -28,9 +28,9 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
 >key : Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 6, 52))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
->value.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>value.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 _.map([1, 2, 3], (num) => num * 3);
 >_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75))
@@ -71,9 +71,9 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 13, 3))
 >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32))
 >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34))
->a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>a.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32))
->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34))
 
 var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
@@ -182,9 +182,9 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30))
->Math.sin : Symbol(Math.sin, Decl(lib.d.ts, 615, 29))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->sin : Symbol(Math.sin, Decl(lib.d.ts, 615, 29))
+>Math.sin : Symbol(Math.sin, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>sin : Symbol(Math.sin, Decl(lib.d.ts, --, --))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30))
 
 
@@ -196,9 +196,9 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo
 >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))
 >i : Symbol(i, Decl(underscoreTest1_underscoreTests.ts, 45, 38))
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 45, 50))
->Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
+>Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
 >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))
 
 _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
@@ -206,9 +206,9 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))
->Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11))
->floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27))
+>Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))
 
 _.groupBy(['one', 'two', 'three'], 'length');
@@ -437,7 +437,7 @@ var log = _.bind((message?: string, ...rest: string[]) => { }, Date);
 >bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 548, 68), Decl(underscoreTest1_underscore.ts, 550, 58))
 >message : Symbol(message, Decl(underscoreTest1_underscoreTests.ts, 108, 18))
 >rest : Symbol(rest, Decl(underscoreTest1_underscoreTests.ts, 108, 35))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 _.delay(log, 1000, 'logged later');
 >_.delay : Symbol(Underscore.Static.delay, Decl(underscoreTest1_underscore.ts, 557, 73))
@@ -510,9 +510,9 @@ var renderNotes = _.after(notes.length, render);
 >_.after : Symbol(Underscore.Static.after, Decl(underscoreTest1_underscore.ts, 567, 45))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >after : Symbol(Underscore.Static.after, Decl(underscoreTest1_underscore.ts, 567, 45))
->notes.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>notes.length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >notes : Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3))
->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
+>length : Symbol(Array.length, Decl(lib.d.ts, --, --))
 >render : Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3))
 
 _.each(notes, (note) => note.asyncSave({ success: renderNotes }));
@@ -771,7 +771,7 @@ _.isFinite(-Infinity);
 >_.isFinite : Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 609, 39))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >isFinite : Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 609, 39))
->Infinity : Symbol(Infinity, Decl(lib.d.ts, 22, 11))
+>Infinity : Symbol(Infinity, Decl(lib.d.ts, --, --))
 
 _.isBoolean(null);
 >_.isBoolean : Symbol(Underscore.Static.isBoolean, Decl(underscoreTest1_underscore.ts, 610, 39))
@@ -782,7 +782,7 @@ _.isDate(new Date());
 >_.isDate : Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 611, 40))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >isDate : Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 611, 40))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 _.isRegExp(/moe/);
 >_.isRegExp : Symbol(Underscore.Static.isRegExp, Decl(underscoreTest1_underscore.ts, 612, 37))
@@ -793,10 +793,10 @@ _.isNaN(NaN);
 >_.isNaN : Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 613, 39))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >isNaN : Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 613, 39))
->NaN : Symbol(NaN, Decl(lib.d.ts, 21, 11))
+>NaN : Symbol(NaN, Decl(lib.d.ts, --, --))
 
 isNaN(undefined);
->isNaN : Symbol(isNaN, Decl(lib.d.ts, 43, 52))
+>isNaN : Symbol(isNaN, Decl(lib.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 _.isNaN(undefined);
@@ -1008,7 +1008,7 @@ interface Tuple2<T0, T1> extends Array<any> {
 >Tuple2 : Symbol(Tuple2, Decl(underscoreTest1_underscore.ts, 10, 1))
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 12, 17))
 >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 12, 20))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     0: T0;
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 12, 17))
@@ -1022,7 +1022,7 @@ interface Tuple3<T0, T1, T2> extends Array<any> {
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 17, 17))
 >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 17, 20))
 >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 17, 24))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     0: T0;
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 17, 17))
@@ -1040,7 +1040,7 @@ interface Tuple4<T0, T1, T2, T3> extends Array<any> {
 >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 23, 20))
 >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 23, 24))
 >T3 : Symbol(T3, Decl(underscoreTest1_underscore.ts, 23, 28))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     0: T0;
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 23, 17))
@@ -1173,7 +1173,7 @@ module Underscore {
     export interface WrappedFunction<T extends Function> extends WrappedObject<T> {
 >WrappedFunction : Symbol(WrappedFunction, Decl(underscoreTest1_underscore.ts, 62, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >WrappedObject : Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))
 
@@ -1186,7 +1186,7 @@ module Underscore {
 >bind : Symbol(bind, Decl(underscoreTest1_underscore.ts, 64, 83), Decl(underscoreTest1_underscore.ts, 65, 29))
 >object : Symbol(object, Decl(underscoreTest1_underscore.ts, 66, 13))
 >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 66, 25))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         bindAll(...methodNames: string[]): T;
 >bindAll : Symbol(bindAll, Decl(underscoreTest1_underscore.ts, 66, 52))
@@ -1196,12 +1196,12 @@ module Underscore {
         partial(...args: any[]): Function;
 >partial : Symbol(partial, Decl(underscoreTest1_underscore.ts, 67, 45))
 >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 68, 16))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         memoize(hashFunction?: Function): T;
 >memoize : Symbol(memoize, Decl(underscoreTest1_underscore.ts, 68, 42))
 >hashFunction : Symbol(hashFunction, Decl(underscoreTest1_underscore.ts, 69, 16))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37))
 
         delay(wait: number, ...args: any[]): number;
@@ -1239,15 +1239,15 @@ module Underscore {
         compose(...funcs: Function[]): Function;
 >compose : Symbol(compose, Decl(underscoreTest1_underscore.ts, 75, 59))
 >funcs : Symbol(funcs, Decl(underscoreTest1_underscore.ts, 76, 16))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
     }
 
     export interface WrappedArray<T> extends WrappedObject<Array<T>> {
 >WrappedArray : Symbol(WrappedArray, Decl(underscoreTest1_underscore.ts, 77, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >WrappedObject : Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
         each(iterator: Iterator<T, void>, context?: any): void;
@@ -1434,13 +1434,13 @@ module Underscore {
         where(properties: Object): T[];
 >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 97, 67))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 98, 14))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
         findWhere(properties: Object): T;
 >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 98, 39))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 99, 18))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
         reject(iterator: Iterator<T, boolean>, context?: any): T[];
@@ -1973,13 +1973,13 @@ module Underscore {
         where(properties: Object): T[];
 >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 180, 67))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 181, 14))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
         findWhere(properties: Object): T;
 >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 181, 39))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 182, 18))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
         reject(iterator: Iterator<T, boolean>, context?: any): T[];
@@ -2251,7 +2251,7 @@ module Underscore {
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
         each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
@@ -2456,14 +2456,14 @@ module Underscore {
         where(properties: Object): ChainedArray<T>;
 >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 256, 79))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 257, 14))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
         findWhere(properties: Object): ChainedObject<T>;
 >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 257, 51))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 258, 18))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
@@ -3107,14 +3107,14 @@ module Underscore {
         where(properties: Object): ChainedArray<T>;
 >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 347, 79))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 348, 14))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
         findWhere(properties: Object): ChainedObject<T>;
 >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 348, 51))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 349, 18))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
@@ -3301,15 +3301,15 @@ module Underscore {
 
         evaluate?: RegExp;
 >evaluate : Symbol(evaluate, Decl(underscoreTest1_underscore.ts, 380, 39))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         interpolate?: RegExp;
 >interpolate : Symbol(interpolate, Decl(underscoreTest1_underscore.ts, 381, 26))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         escape?: RegExp;
 >escape : Symbol(escape, Decl(underscoreTest1_underscore.ts, 382, 29))
->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         variable?: string;
 >variable : Symbol(variable, Decl(underscoreTest1_underscore.ts, 383, 24))
@@ -3335,7 +3335,7 @@ module Underscore {
 
         <T extends Function>(func: T): WrappedFunction<T>;
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 390, 9))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 390, 29))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 390, 9))
 >WrappedFunction : Symbol(WrappedFunction, Decl(underscoreTest1_underscore.ts, 62, 5))
@@ -3867,7 +3867,7 @@ module Underscore {
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 439, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 439, 27))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))
 
         where<T>(list: Dictionary<T>, properties: Object): T[];
@@ -3877,7 +3877,7 @@ module Underscore {
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 440, 14))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 440, 37))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 440, 14))
 
         findWhere<T>(list: T[], properties: Object): T;
@@ -3886,7 +3886,7 @@ module Underscore {
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 442, 21))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 442, 18))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 442, 31))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 442, 18))
 
         findWhere<T>(list: Dictionary<T>, properties: Object): T;
@@ -3896,7 +3896,7 @@ module Underscore {
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 443, 18))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 443, 41))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 443, 18))
 
         reject<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
@@ -4570,7 +4570,7 @@ module Underscore {
         bind<T extends Function>(func: T, object: any): T;
 >bind : Symbol(bind, Decl(underscoreTest1_underscore.ts, 548, 68), Decl(underscoreTest1_underscore.ts, 550, 58))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 550, 13))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 550, 33))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 550, 13))
 >object : Symbol(object, Decl(underscoreTest1_underscore.ts, 550, 41))
@@ -4579,10 +4579,10 @@ module Underscore {
         bind(func: Function, object: any, ...args: any[]): Function;
 >bind : Symbol(bind, Decl(underscoreTest1_underscore.ts, 548, 68), Decl(underscoreTest1_underscore.ts, 550, 58))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 551, 13))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >object : Symbol(object, Decl(underscoreTest1_underscore.ts, 551, 28))
 >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 551, 41))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         bindAll<T>(object: T, ...methodNames: string[]): T;
 >bindAll : Symbol(bindAll, Decl(underscoreTest1_underscore.ts, 551, 68))
@@ -4595,37 +4595,37 @@ module Underscore {
         partial(func: Function, ...args: any[]): Function;
 >partial : Symbol(partial, Decl(underscoreTest1_underscore.ts, 553, 59))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 555, 16))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 555, 31))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         memoize<T extends Function>(func: T, hashFunction?: Function): T;
 >memoize : Symbol(memoize, Decl(underscoreTest1_underscore.ts, 555, 58))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 557, 16))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 557, 36))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 557, 16))
 >hashFunction : Symbol(hashFunction, Decl(underscoreTest1_underscore.ts, 557, 44))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 557, 16))
 
         delay(func: Function, wait: number, ...args: any[]): number;
 >delay : Symbol(delay, Decl(underscoreTest1_underscore.ts, 557, 73))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 559, 14))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >wait : Symbol(wait, Decl(underscoreTest1_underscore.ts, 559, 29))
 >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 559, 43))
 
         defer(func: Function, ...args: any[]): number;
 >defer : Symbol(defer, Decl(underscoreTest1_underscore.ts, 559, 68))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 561, 14))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 561, 29))
 
         throttle<T extends Function>(func: T, wait: number): T;
 >throttle : Symbol(throttle, Decl(underscoreTest1_underscore.ts, 561, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 563, 17))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 563, 37))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 563, 17))
 >wait : Symbol(wait, Decl(underscoreTest1_underscore.ts, 563, 45))
@@ -4634,7 +4634,7 @@ module Underscore {
         debounce<T extends Function>(func: T, wait: number, immediate?: boolean): T;
 >debounce : Symbol(debounce, Decl(underscoreTest1_underscore.ts, 563, 63))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 565, 17))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 565, 37))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 565, 17))
 >wait : Symbol(wait, Decl(underscoreTest1_underscore.ts, 565, 45))
@@ -4644,7 +4644,7 @@ module Underscore {
         once<T extends Function>(func: T): T;
 >once : Symbol(once, Decl(underscoreTest1_underscore.ts, 565, 84))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 567, 13))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 567, 33))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 567, 13))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 567, 13))
@@ -4652,7 +4652,7 @@ module Underscore {
         after<T extends Function>(count: number, func: T): T;
 >after : Symbol(after, Decl(underscoreTest1_underscore.ts, 567, 45))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 569, 14))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >count : Symbol(count, Decl(underscoreTest1_underscore.ts, 569, 34))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 569, 48))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 569, 14))
@@ -4661,7 +4661,7 @@ module Underscore {
         wrap<T extends Function>(func: T, wrapper: (func: T, ...args: any[]) => any): T;
 >wrap : Symbol(wrap, Decl(underscoreTest1_underscore.ts, 569, 61))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 571, 13))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 571, 33))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 571, 13))
 >wrapper : Symbol(wrapper, Decl(underscoreTest1_underscore.ts, 571, 41))
@@ -4673,8 +4673,8 @@ module Underscore {
         compose(...funcs: Function[]): Function;
 >compose : Symbol(compose, Decl(underscoreTest1_underscore.ts, 571, 88))
 >funcs : Symbol(funcs, Decl(underscoreTest1_underscore.ts, 573, 16))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         keys(object: any): string[];
 >keys : Symbol(keys, Decl(underscoreTest1_underscore.ts, 573, 48))
diff --git a/tests/baselines/reference/unionTypeCallSignatures2.symbols b/tests/baselines/reference/unionTypeCallSignatures2.symbols
index 35ba9464df0..32ce4c352b8 100644
--- a/tests/baselines/reference/unionTypeCallSignatures2.symbols
+++ b/tests/baselines/reference/unionTypeCallSignatures2.symbols
@@ -11,7 +11,7 @@ interface A {
 
     (x: Date): void;
 >x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 3, 5))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     <T>(x: T[]): T[];
 >T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 4, 5))
@@ -31,7 +31,7 @@ interface B {
 
     (x: Date): void;
 >x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 10, 5))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     <T>(x: T[]): T[];
 >T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 11, 5))
diff --git a/tests/baselines/reference/unionTypeIndexSignature.symbols b/tests/baselines/reference/unionTypeIndexSignature.symbols
index e0228308c16..7295b860f3f 100644
--- a/tests/baselines/reference/unionTypeIndexSignature.symbols
+++ b/tests/baselines/reference/unionTypeIndexSignature.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/union/unionTypeIndexSignature.ts ===
 var numOrDate: number | Date;
 >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var anyVar: number;
 >anyVar : Symbol(anyVar, Decl(unionTypeIndexSignature.ts, 1, 3))
@@ -13,7 +13,7 @@ var unionOfDifferentReturnType: { [a: string]: number; } | { [a: string]: Date;
 >unionOfDifferentReturnType : Symbol(unionOfDifferentReturnType, Decl(unionTypeIndexSignature.ts, 6, 3))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 6, 35))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 6, 62))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 numOrDate = unionOfDifferentReturnType["hello"]; // number | Date
 >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3))
@@ -41,7 +41,7 @@ var unionOfDifferentReturnType1: { [a: number]: number; } | { [a: number]: Date;
 >unionOfDifferentReturnType1 : Symbol(unionOfDifferentReturnType1, Decl(unionTypeIndexSignature.ts, 16, 3))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 16, 36))
 >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 16, 63))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 numOrDate = unionOfDifferentReturnType1["hello"]; // any
 >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3))
diff --git a/tests/baselines/reference/validBooleanAssignments.symbols b/tests/baselines/reference/validBooleanAssignments.symbols
index a13a02a09cc..b7ba6be03c1 100644
--- a/tests/baselines/reference/validBooleanAssignments.symbols
+++ b/tests/baselines/reference/validBooleanAssignments.symbols
@@ -8,12 +8,12 @@ var a: any = x;
 
 var b: Object = x;
 >b : Symbol(b, Decl(validBooleanAssignments.ts, 3, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(validBooleanAssignments.ts, 0, 3))
 
 var c: Boolean = x;
 >c : Symbol(c, Decl(validBooleanAssignments.ts, 4, 3))
->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11))
+>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(validBooleanAssignments.ts, 0, 3))
 
 var d: boolean = x;
diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.symbols b/tests/baselines/reference/validMultipleVariableDeclarations.symbols
index 467c061c6fa..1c3a1feb75c 100644
--- a/tests/baselines/reference/validMultipleVariableDeclarations.symbols
+++ b/tests/baselines/reference/validMultipleVariableDeclarations.symbols
@@ -110,7 +110,7 @@ var a: string[] = [];
 
 var a = new Array<string>();
 >a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 var a: typeof a;
 >a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
diff --git a/tests/baselines/reference/validNumberAssignments.symbols b/tests/baselines/reference/validNumberAssignments.symbols
index 44ab24e33e0..7cb763bc89b 100644
--- a/tests/baselines/reference/validNumberAssignments.symbols
+++ b/tests/baselines/reference/validNumberAssignments.symbols
@@ -8,7 +8,7 @@ var a: any = x;
 
 var b: Object = x;
 >b : Symbol(b, Decl(validNumberAssignments.ts, 3, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(validNumberAssignments.ts, 0, 3))
 
 var c: number = x;
diff --git a/tests/baselines/reference/validStringAssignments.symbols b/tests/baselines/reference/validStringAssignments.symbols
index 750dadefebd..bb24a6c1574 100644
--- a/tests/baselines/reference/validStringAssignments.symbols
+++ b/tests/baselines/reference/validStringAssignments.symbols
@@ -8,7 +8,7 @@ var a: any = x;
 
 var b: Object = x;
 >b : Symbol(b, Decl(validStringAssignments.ts, 3, 3))
->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(validStringAssignments.ts, 0, 3))
 
 var c: string = x;
@@ -17,6 +17,6 @@ var c: string = x;
 
 var d: String = x;
 >d : Symbol(d, Decl(validStringAssignments.ts, 5, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(validStringAssignments.ts, 0, 3))
 
diff --git a/tests/baselines/reference/vardecl.symbols b/tests/baselines/reference/vardecl.symbols
index 979790877c1..0860fc19500 100644
--- a/tests/baselines/reference/vardecl.symbols
+++ b/tests/baselines/reference/vardecl.symbols
@@ -41,9 +41,9 @@ var complicatedArrayVar: { x: number; y: string; }[] ;
 >y : Symbol(y, Decl(vardecl.ts, 18, 37))
 
 complicatedArrayVar.push({ x: 30, y : 'hello world' });
->complicatedArrayVar.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>complicatedArrayVar.push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >complicatedArrayVar : Symbol(complicatedArrayVar, Decl(vardecl.ts, 18, 3))
->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>push : Symbol(Array.push, Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(vardecl.ts, 19, 26))
 >y : Symbol(y, Decl(vardecl.ts, 19, 33))
 
diff --git a/tests/baselines/reference/voidOperatorWithStringType.symbols b/tests/baselines/reference/voidOperatorWithStringType.symbols
index ab834bf1243..64fb0e600e8 100644
--- a/tests/baselines/reference/voidOperatorWithStringType.symbols
+++ b/tests/baselines/reference/voidOperatorWithStringType.symbols
@@ -88,9 +88,9 @@ var ResultIsAny11 = void (STRING + STRING);
 
 var ResultIsAny12 = void STRING.charAt(0);
 >ResultIsAny12 : Symbol(ResultIsAny12, Decl(voidOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 >STRING : Symbol(STRING, Decl(voidOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
 
 // multiple void  operators
 var ResultIsAny13 = void void STRING;
diff --git a/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols b/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols
index 5f3f2d6f854..b0128b37797 100644
--- a/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols
+++ b/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols
@@ -4,7 +4,7 @@
 class C<T extends Date> {
 >C : Symbol(C, Decl(wrappedAndRecursiveConstraints.ts, 0, 0))
 >T : Symbol(T, Decl(wrappedAndRecursiveConstraints.ts, 2, 8))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     constructor(public data: T) { }
 >data : Symbol(data, Decl(wrappedAndRecursiveConstraints.ts, 3, 16))
@@ -24,7 +24,7 @@ class C<T extends Date> {
 
 interface Foo extends Date {
 >Foo : Symbol(Foo, Decl(wrappedAndRecursiveConstraints.ts, 7, 1))
->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
     foo: string;
 >foo : Symbol(foo, Decl(wrappedAndRecursiveConstraints.ts, 9, 28))
diff --git a/tests/cases/compiler/asiAbstract.ts b/tests/cases/compiler/asiAbstract.ts
new file mode 100644
index 00000000000..f9f36b12001
--- /dev/null
+++ b/tests/cases/compiler/asiAbstract.ts
@@ -0,0 +1,14 @@
+abstract
+class NonAbstractClass {
+  abstract s();
+}
+
+class C2 {
+    abstract
+    nonAbstractFunction() {
+    }
+}
+
+class C3 {
+    abstract
+}
diff --git a/tests/cases/compiler/asiPublicPrivateProtected.ts b/tests/cases/compiler/asiPublicPrivateProtected.ts
new file mode 100644
index 00000000000..4ccd4c1c01b
--- /dev/null
+++ b/tests/cases/compiler/asiPublicPrivateProtected.ts
@@ -0,0 +1,39 @@
+public
+class NonPublicClass {
+    public s() {
+    }
+}
+
+class NonPublicClass2 {
+    public
+    private nonPublicFunction() {
+    }
+}
+private
+class NonPrivateClass {
+    private s() {
+    }
+}
+
+class NonPrivateClass2 {
+    private
+    public nonPrivateFunction() {
+    }
+}
+protected
+class NonProtectedClass {
+  protected s() {
+  }
+}
+
+class NonProtectedClass2 {
+    protected
+    public nonProtectedFunction() {
+    }
+}
+
+class ClassWithThreeMembers {
+    public
+    private
+    protected
+}
diff --git a/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts b/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts
new file mode 100644
index 00000000000..956705bd7d3
--- /dev/null
+++ b/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts
@@ -0,0 +1,104 @@
+// @target: ES5
+function foo0() {
+    let a = x;
+    let x;
+}
+
+function foo1() {
+    let a = () => x;
+    let x;
+}
+
+function foo2() {
+    let a = function () { return x; }
+    let x;
+}
+
+function foo3() {
+    class X {
+        m() { return x;}
+    }
+    let x;
+}
+
+function foo4() {
+    let y = class {
+        m() { return x; }
+    };
+    let x;
+}
+
+function foo5() {
+    let x = () => y;
+    let y = () => x;
+}
+
+function foo6() {
+    function f() {
+        return x;
+    }
+    let x;
+}
+
+function foo7() {
+    class A {
+        a = x;
+    }
+    let x;
+}
+
+function foo8() {
+    let y = class {
+        a = x;
+    }
+    let x;
+}
+
+function foo9() {
+    let y = class {
+        static a = x;
+    }
+    let x;
+}
+
+function foo10() {
+    class A {
+        static a = x;
+    }
+    let x;
+}
+
+function foo11() {
+    function f () {
+        let y = class {
+            static a = x;
+        }
+    }
+    let x;
+}
+
+function foo12() {
+    function f () {
+        let y = class {
+            a;
+            constructor() {
+                this.a = x;
+            }
+        }
+    }
+    let x;
+}
+
+function foo13() {
+    let a = {
+        get a() { return x } 
+    }
+    let x
+}
+
+function foo14() {
+    let a = {
+        a: x 
+    }
+    let x
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/constIndexedAccess.ts b/tests/cases/compiler/constIndexedAccess.ts
new file mode 100644
index 00000000000..d71a3cdb9f4
--- /dev/null
+++ b/tests/cases/compiler/constIndexedAccess.ts
@@ -0,0 +1,29 @@
+
+const enum numbers {
+    zero,
+    one
+}
+
+interface indexAccess {
+    0: string;
+    1: number;
+}
+
+let test: indexAccess;
+
+let s = test[0];
+let n = test[1];
+
+let s1 = test[numbers.zero];
+let n1 = test[numbers.one];
+
+let s2 = test[numbers["zero"]];
+let n2 = test[numbers["one"]];
+
+enum numbersNotConst {
+    zero,
+    one
+}
+
+let s3 = test[numbersNotConst.zero];
+let n3 = test[numbersNotConst.one];
diff --git a/tests/cases/compiler/es2015modulekind.ts b/tests/cases/compiler/es2015modulekind.ts
new file mode 100644
index 00000000000..6e1f584844a
--- /dev/null
+++ b/tests/cases/compiler/es2015modulekind.ts
@@ -0,0 +1,17 @@
+// @target: es2015
+// @sourcemap: false
+// @declaration: false
+// @module: es2015
+
+export default class A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+    {
+        return 42;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/es2015modulekindWithES6Target.ts b/tests/cases/compiler/es2015modulekindWithES6Target.ts
new file mode 100644
index 00000000000..78809d3835f
--- /dev/null
+++ b/tests/cases/compiler/es2015modulekindWithES6Target.ts
@@ -0,0 +1,17 @@
+// @target: es6
+// @sourcemap: false
+// @declaration: false
+// @module: es2015
+
+export default class A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+    {
+        return 42;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/es6modulekindWithES2015Target.ts b/tests/cases/compiler/es6modulekindWithES2015Target.ts
new file mode 100644
index 00000000000..aaf79e6607d
--- /dev/null
+++ b/tests/cases/compiler/es6modulekindWithES2015Target.ts
@@ -0,0 +1,17 @@
+// @target: es2015
+// @sourcemap: false
+// @declaration: false
+// @module: es6
+
+export default class A
+{
+    constructor ()
+    {
+
+    }
+
+    public B()
+    {
+        return 42;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/exportedBlockScopedDeclarations.ts b/tests/cases/compiler/exportedBlockScopedDeclarations.ts
new file mode 100644
index 00000000000..f7a0216e8be
--- /dev/null
+++ b/tests/cases/compiler/exportedBlockScopedDeclarations.ts
@@ -0,0 +1,18 @@
+// @module: amd
+const foo = foo; // compile error
+export const bar = bar; // should be compile error
+function f() {
+  const bar = bar; // compile error
+}
+namespace NS {
+  export const bar = bar; // should be compile error
+}
+
+let foo1 = foo1; // compile error
+export let bar1 = bar1; // should be compile error
+function f1() {
+  let bar1 = bar1; // compile error
+}
+namespace NS1 {
+  export let bar1 = bar1; // should be compile error
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/functionsInClassExpressions.ts b/tests/cases/compiler/functionsInClassExpressions.ts
new file mode 100644
index 00000000000..72e0bafd582
--- /dev/null
+++ b/tests/cases/compiler/functionsInClassExpressions.ts
@@ -0,0 +1,10 @@
+let Foo = class {
+    constructor() {
+        this.bar++;
+    }
+    bar = 0;
+    inc = () => {
+        this.bar++;
+    }
+    m() { return this.bar; }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/modulePrologueAMD.ts b/tests/cases/compiler/modulePrologueAMD.ts
new file mode 100644
index 00000000000..d5473798ee0
--- /dev/null
+++ b/tests/cases/compiler/modulePrologueAMD.ts
@@ -0,0 +1,4 @@
+// @module: amd
+"use strict";
+
+export class Foo {}
\ No newline at end of file
diff --git a/tests/cases/compiler/modulePrologueCommonjs.ts b/tests/cases/compiler/modulePrologueCommonjs.ts
new file mode 100644
index 00000000000..d6ef5e820a3
--- /dev/null
+++ b/tests/cases/compiler/modulePrologueCommonjs.ts
@@ -0,0 +1,4 @@
+// @module: commonjs
+"use strict";
+
+export class Foo {}
\ No newline at end of file
diff --git a/tests/cases/compiler/modulePrologueES6.ts b/tests/cases/compiler/modulePrologueES6.ts
new file mode 100644
index 00000000000..a0782891cba
--- /dev/null
+++ b/tests/cases/compiler/modulePrologueES6.ts
@@ -0,0 +1,5 @@
+// @module: es6
+// @target: es6
+"use strict";
+
+export class Foo {}
\ No newline at end of file
diff --git a/tests/cases/compiler/modulePrologueSystem.ts b/tests/cases/compiler/modulePrologueSystem.ts
new file mode 100644
index 00000000000..d336bdb8950
--- /dev/null
+++ b/tests/cases/compiler/modulePrologueSystem.ts
@@ -0,0 +1,4 @@
+// @module: system
+"use strict";
+
+export class Foo {}
\ No newline at end of file
diff --git a/tests/cases/compiler/modulePrologueUmd.ts b/tests/cases/compiler/modulePrologueUmd.ts
new file mode 100644
index 00000000000..2660ca75081
--- /dev/null
+++ b/tests/cases/compiler/modulePrologueUmd.ts
@@ -0,0 +1,4 @@
+// @module: umd
+"use strict";
+
+export class Foo {}
\ No newline at end of file
diff --git a/tests/cases/compiler/recursiveGenericUnionType1.ts b/tests/cases/compiler/recursiveGenericUnionType1.ts
new file mode 100644
index 00000000000..c1c7b3e81ad
--- /dev/null
+++ b/tests/cases/compiler/recursiveGenericUnionType1.ts
@@ -0,0 +1,20 @@
+declare module Test1 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>;
+    };
+    export type IStringContainer = Container<string>;
+}
+
+declare module Test2 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>;
+    };
+    export type IStringContainer = Container<string>;
+}
+
+var x: Test1.Container<number>;
+
+var s1: Test1.IStringContainer;
+var s2: Test2.IStringContainer;
+s1 = s2;
+s2 = s1;
diff --git a/tests/cases/compiler/recursiveGenericUnionType2.ts b/tests/cases/compiler/recursiveGenericUnionType2.ts
new file mode 100644
index 00000000000..784ddefeb1f
--- /dev/null
+++ b/tests/cases/compiler/recursiveGenericUnionType2.ts
@@ -0,0 +1,20 @@
+declare module Test1 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>[];
+    };
+    export type IStringContainer = Container<string>;
+}
+
+declare module Test2 {
+    export type Container<T> = T | {
+        [i: string]: Container<T>[];
+    };
+    export type IStringContainer = Container<string>;
+}
+
+var x: Test1.Container<number>;
+
+var s1: Test1.IStringContainer;
+var s2: Test2.IStringContainer;
+s1 = s2;
+s2 = s1;
diff --git a/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts
new file mode 100644
index 00000000000..9750ea5d161
--- /dev/null
+++ b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts
@@ -0,0 +1,118 @@
+// @target: ES5
+
+
+(function() {
+	var s0;
+	for ({ s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+(function() {
+	var s0;
+	for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1:s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2:s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3:s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	let y;
+	({ y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y;
+	({ y:y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0:y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y1: string;
+	({ y1 = 5 } = {})
+});
+
+(function() {
+	let y1: string;
+	({ y1:y1 = 5 } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2 = 5, y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4 = 5, y5 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
+});
+
+
+(function() {
+	let z;
+	({ z = { x: 5 } } = { z: { x: 1 } });
+});
+
+
+(function() {
+	let z;
+	({ z:z = { x: 5 } } = { z: { x: 1 } });
+});
+
+(function() {
+	let a = { s = 5 };
+});
+
+function foo({a = 4, b = { x: 5 }}) {
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts
new file mode 100644
index 00000000000..d479511b11d
--- /dev/null
+++ b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts
@@ -0,0 +1,118 @@
+// @target: ES6
+
+
+(function() {
+	var s0;
+	for ({ s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+(function() {
+	var s0;
+	for ({ s0:s0 = 5 } of [{ s0: 1 }]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s1;
+	for ({ s1:s1 = 5 } of [{}]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s2;
+	for ({ s2:s2 = 5 } of [{ s2: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	var s3: string;
+	for ({ s3:s3 = 5 } of [{ s3: "" }]) {
+	}
+});
+
+(function() {
+	let y;
+	({ y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y;
+	({ y:y = 5 } = { y: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y0: number;
+	({ y0:y0 = 5 } = { y0: 1 })
+});
+
+(function() {
+	let y1: string;
+	({ y1 = 5 } = {})
+});
+
+(function() {
+	let y1: string;
+	({ y1:y1 = 5 } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2 = 5, y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y2: string, y3: { x: string };
+	({ y2:y2 = 5, y3:y3 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4 = 5, y5 = { x: 1 } } = {})
+});
+
+(function() {
+	let y4: number, y5: { x: number };
+	({ y4:y4 = 5, y5:y5 = { x: 1 } } = {})
+});
+
+
+(function() {
+	let z;
+	({ z = { x: 5 } } = { z: { x: 1 } });
+});
+
+
+(function() {
+	let z;
+	({ z:z = { x: 5 } } = { z: { x: 1 } });
+});
+
+(function() {
+	let a = { s = 5 };
+});
+
+function foo({a = 4, b = { x: 5 }}) {
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts
index bb9f8a54e44..0959ed6c561 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 
 var foo = async foo(): Promise<void> => {
    // Legal to use 'await' in a type context.
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts
index 45e686fd280..83e7413c527 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 
 var foo = async (): Promise<void> => {
 };
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts
index 8d792fdff9c..bf39735d460 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 var f = (await) => {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts
index 9ca200f8d76..4ae27c596f1 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 function f(await = await) {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts
index 4946592c45b..51b34abeca1 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 var await = () => {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts
index 53052368b31..174a619bdf9 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 
 var foo = async (await): Promise<void> => {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts
index 69768429ecf..dace96c4933 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 
 var foo = async (a = await): Promise<void> => {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts
index a034381ba57..b1fd5cc030d 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 
 var bar = async (): Promise<void> => {
   // 'await' here is an identifier, and not an await expression.
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts
index 397e06f703d..5d53338b1bd 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 
 var foo = async (): Promise<void> => {
   var v = { [await]: foo }
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts
index 3f961c9d595..da041fe472b 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 var foo = async (a = await => await): Promise<void> => {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts
index f00d0d16545..8dab2c04086 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 class C {
    method() {
       function other() {}
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts
index a90f08cb9f7..f2c507cbdd6 100644
--- a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 class C {
    method() {
       var fn = async () => await this;      
diff --git a/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts b/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts
index 52694f24118..8e2cfd8c6c5 100644
--- a/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @isolatedModules: true
-// @experimentalAsyncFunctions: true
 import { MyPromise } from "missing";
 
 declare var p: Promise<number>;
diff --git a/tests/cases/conformance/async/es6/asyncAwait_es6.ts b/tests/cases/conformance/async/es6/asyncAwait_es6.ts
index eee2e73d023..8e72197a98d 100644
--- a/tests/cases/conformance/async/es6/asyncAwait_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncAwait_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
-// @experimentalAsyncFunctions: true
 type MyPromise<T> = Promise<T>;
 declare var MyPromise: typeof Promise;
 declare var p: Promise<number>;
diff --git a/tests/cases/conformance/async/es6/asyncClass_es6.ts b/tests/cases/conformance/async/es6/asyncClass_es6.ts
index c4a444ca909..22ffe997b03 100644
--- a/tests/cases/conformance/async/es6/asyncClass_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncClass_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async class C {  
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncConstructor_es6.ts b/tests/cases/conformance/async/es6/asyncConstructor_es6.ts
index 998156f19f4..d769fad0395 100644
--- a/tests/cases/conformance/async/es6/asyncConstructor_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncConstructor_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 class C {  
   async constructor() {    
   }
diff --git a/tests/cases/conformance/async/es6/asyncDeclare_es6.ts b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts
index d83c25a421a..5e0fb536b39 100644
--- a/tests/cases/conformance/async/es6/asyncDeclare_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts
@@ -1,4 +1,3 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare async function foo(): Promise<void>;
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncEnum_es6.ts b/tests/cases/conformance/async/es6/asyncEnum_es6.ts
index d9569bef9d1..4fad7923a8c 100644
--- a/tests/cases/conformance/async/es6/asyncEnum_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncEnum_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async enum E {  
   Value
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncGetter_es6.ts b/tests/cases/conformance/async/es6/asyncGetter_es6.ts
index fe5751ece0b..79fde60fdc4 100644
--- a/tests/cases/conformance/async/es6/asyncGetter_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncGetter_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 class C {
   async get foo() {
   }
diff --git a/tests/cases/conformance/async/es6/asyncInterface_es6.ts b/tests/cases/conformance/async/es6/asyncInterface_es6.ts
index c7bb460ea2b..5d5497d3cd4 100644
--- a/tests/cases/conformance/async/es6/asyncInterface_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncInterface_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async interface I {  
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncModule_es6.ts b/tests/cases/conformance/async/es6/asyncModule_es6.ts
index cf660d25d1f..aa4c295d0e3 100644
--- a/tests/cases/conformance/async/es6/asyncModule_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncModule_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async module M {   
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncSetter_es6.ts b/tests/cases/conformance/async/es6/asyncSetter_es6.ts
index 2ca1c805a45..8eedcbb5288 100644
--- a/tests/cases/conformance/async/es6/asyncSetter_es6.ts
+++ b/tests/cases/conformance/async/es6/asyncSetter_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 class C {
   async set foo(value) {
   }
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts
index df0d0e459d4..46060f309b2 100644
--- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 async function func(): Promise<void> {
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts
index 7678c4b17ab..362f1ecc446 100644
--- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 async function func(): Promise<void> {
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts
index 0b441f063dd..d3b02033252 100644
--- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: number;
 declare var p: Promise<number>;
 async function func(): Promise<void> {
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts
index a0bdf58710f..eba3be31acf 100644
--- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 async function func(): Promise<void> {
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts
index 3276d24ee4b..71b173f9e73 100644
--- a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 async function func(): Promise<void> {
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts
index 02de646112c..d0442f0968d 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts
index 5d2e4046349..6de07ef12ff 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts
index 702e1f4cbcc..2cc0b7b12d0 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts
index aeeb192b4ba..8e349fbc5c3 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts
index 82bb1f88ad2..bbe81ac94b1 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts
index d5778df71ba..09e88f5acbc 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts
index db01f34c825..fe0182da4aa 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts
index b0b10a02a6f..e3280eb7c10 100644
--- a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare var a: boolean;
 declare var p: Promise<boolean>;
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
diff --git a/tests/cases/conformance/async/es6/awaitUnion_es6.ts b/tests/cases/conformance/async/es6/awaitUnion_es6.ts
index 59c5285556c..a132ae01dfd 100644
--- a/tests/cases/conformance/async/es6/awaitUnion_es6.ts
+++ b/tests/cases/conformance/async/es6/awaitUnion_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 declare let a: number | string;
 declare let b: PromiseLike<number> | PromiseLike<string>;
 declare let c: PromiseLike<number | string>;
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts
index d543e424a38..aab1f0013ec 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function foo(a = await => await): Promise<void> {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts
index 23e40a0e5ba..747d20d7ea8 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function await(): Promise<void> {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts
index a457d27073f..bbd77250365 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts
@@ -1,4 +1,3 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 var v = async function await(): Promise<void> { }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts
index 83b6a99579c..8670fa02811 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function foo(): Promise<void> {
    // Legal to use 'await' in a type context.
    var v: await;
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts
index b837e6618d1..ba70c61b492 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function foo(): Promise<void> {
   return;
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts
new file mode 100644
index 00000000000..74018b73678
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts
@@ -0,0 +1,25 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare class Thenable { then(): void; }
+declare let a: any;
+declare let obj: { then: string; };
+declare let thenable: Thenable;
+async function fn1() { } // valid: Promise<void>
+async function fn2(): { } { } // error
+async function fn3(): any { } // error
+async function fn4(): number { } // error
+async function fn5(): PromiseLike<void> { } // error
+async function fn6(): Thenable { } // error
+async function fn7() { return; } // valid: Promise<void>
+async function fn8() { return 1; } // valid: Promise<number>
+async function fn9() { return null; } // valid: Promise<any>
+async function fn10() { return undefined; } // valid: Promise<any>
+async function fn11() { return a; } // valid: Promise<any>
+async function fn12() { return obj; } // valid: Promise<{ then: string; }>
+async function fn13() { return thenable; } // error
+async function fn14() { await 1; } // valid: Promise<void>
+async function fn15() { await null; } // valid: Promise<void>
+async function fn16() { await undefined; } // valid: Promise<void>
+async function fn17() { await a; } // valid: Promise<void>
+async function fn18() { await obj; } // valid: Promise<void>
+async function fn19() { await thenable; } // error
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts
index 3a792140011..289a65bb74f 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function foo(): Promise<void> {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts
index e75ef1d36a3..25a153b4a34 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 function f(await) {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts
index 9ca200f8d76..4ae27c596f1 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 function f(await = await) {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts
index ac4447a0e4d..5d1ec389da3 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 function await() {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts
index 60a0a8f4b74..eb3cd1db556 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function foo(await): Promise<void> {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts
index a3ab64b9d29..89b0445fd2e 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function foo(a = await): Promise<void> {
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts
index cde12c7dbe3..5a964695da5 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function bar(): Promise<void> {
   // 'await' here is an identifier, and not a yield expression.
   async function foo(a = await): Promise<void> {
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts
index 52b6dba2792..764b0f3fb8a 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts
@@ -1,4 +1,3 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 var v = { [await]: foo }
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts
index 662fa017606..7671764ad2a 100644
--- a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts
@@ -1,6 +1,5 @@
 // @target: ES6
 // @noEmitHelpers: true
-// @experimentalAsyncFunctions: true
 async function foo(): Promise<void> {
   var v = { [await]: foo }
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts
similarity index 100%
rename from tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts
rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts
diff --git a/tests/cases/conformance/decorators/decoratorCallGeneric.ts b/tests/cases/conformance/decorators/decoratorCallGeneric.ts
new file mode 100644
index 00000000000..3eeaae6837c
--- /dev/null
+++ b/tests/cases/conformance/decorators/decoratorCallGeneric.ts
@@ -0,0 +1,12 @@
+// @experimentalDecorators: true
+interface I<T> {
+    prototype: T,
+    m: () => T
+}
+function dec<T>(c: I<T>) { }
+
+@dec
+class C {
+    _brand: any;
+    static m() {}
+}
diff --git a/tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts b/tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts
new file mode 100644
index 00000000000..485fbdb011d
--- /dev/null
+++ b/tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts
@@ -0,0 +1,4 @@
+// @target:es6
+export default class {
+    static z: string = "Foo";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts b/tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts
new file mode 100644
index 00000000000..a6761600a1d
--- /dev/null
+++ b/tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts
@@ -0,0 +1,7 @@
+// @module: commonjs
+// @target: ES5
+
+export default function f();
+export default function f(x: string);
+export default function f(...args: any[]) {
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts
new file mode 100644
index 00000000000..16d8f2addf4
--- /dev/null
+++ b/tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts
@@ -0,0 +1,34 @@
+// @target: es6
+// @module: commonjs
+
+// @filename: t1.ts
+var v = 1;
+function f() { }
+class C {
+}
+interface I {
+}
+enum E {
+    A, B, C
+}
+const enum D {
+    A, B, C
+}
+module M {
+    export var x;
+}
+module N {
+    export interface I {
+    }
+}
+type T = number;
+import a = M.x;
+
+export { v, f, C, I, E, D, M, N, T, a };
+
+// @filename: t2.ts
+export { v, f, C, I, E, D, M, N, T, a } from "./t1";
+
+// @filename: t3.ts
+import { v, f, C, I, E, D, M, N, T, a } from "./t1";
+export { v, f, C, I, E, D, M, N, T, a };
diff --git a/tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts
new file mode 100644
index 00000000000..5108b98f749
--- /dev/null
+++ b/tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts
@@ -0,0 +1,13 @@
+// @target: es6
+// @module: commonjs
+
+// @filename: t1.ts
+export var x = "x";
+export var y = "y";
+
+// @filename: t2.ts
+export { x as y, y as x } from "./t1";
+
+// @filename: t3.ts
+import { x, y } from "./t1";
+export { x as y, y as x };
diff --git a/tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts
new file mode 100644
index 00000000000..77cb5b9df9b
--- /dev/null
+++ b/tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts
@@ -0,0 +1,34 @@
+// @target: es6
+// @module: commonjs
+
+// @filename: t1.ts
+export var v = 1;
+export function f() { }
+export class C {
+}
+export interface I {
+}
+export enum E {
+    A, B, C
+}
+export const enum D {
+    A, B, C
+}
+export module M {
+    export var x;
+}
+export module N {
+    export interface I {
+    }
+}
+export type T = number;
+export import a = M.x;
+
+export { v as v1, f as f1, C as C1, I as I1, E as E1, D as D1, M as M1, N as N1, T as T1, a as a1 };
+
+// @filename: t2.ts
+export { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+
+// @filename: t3.ts
+import { v1 as v, f1 as f, C1 as C, I1 as I, E1 as E, D1 as D, M1 as M, N1 as N, T1 as T, a1 as a } from "./t1";
+export { v, f, C, I, E, D, M, N, T, a };
diff --git a/tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts
new file mode 100644
index 00000000000..42994486498
--- /dev/null
+++ b/tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts
@@ -0,0 +1,39 @@
+// @target: es6
+// @module: commonjs
+
+// @filename: t1.ts
+export default "hello";
+
+// @filename: t2.ts
+import a = require("./t1");
+a.default;
+import b from "./t1";
+b;
+import * as c from "./t1";
+c.default;
+import { default as d } from "./t1";
+d;
+import e1, * as e2 from "./t1";
+e1;
+e2.default;
+import f1, { default as f2 } from "./t1";
+f1;
+f2;
+import "./t1";
+
+// @filename: t3.ts
+import a = require("./t1");
+a.default;
+import b from "./t1";
+b;
+import * as c from "./t1";
+c.default;
+import { default as d } from "./t1";
+d;
+import e1, * as e2 from "./t1";
+e1;
+e2.default;
+import f1, { default as f2 } from "./t1";
+f1;
+f2;
+export { a, b, c, d, e1, e2, f1, f2 };
diff --git a/tests/cases/conformance/es6/modules/multipleDefaultExports03.ts b/tests/cases/conformance/es6/modules/multipleDefaultExports03.ts
new file mode 100644
index 00000000000..f2fe7f1a6c3
--- /dev/null
+++ b/tests/cases/conformance/es6/modules/multipleDefaultExports03.ts
@@ -0,0 +1,8 @@
+// @module: commonjs
+// @target: ES5
+
+export default class C {
+}
+
+export default class C {
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/modules/multipleDefaultExports04.ts b/tests/cases/conformance/es6/modules/multipleDefaultExports04.ts
new file mode 100644
index 00000000000..1dec7b8bea5
--- /dev/null
+++ b/tests/cases/conformance/es6/modules/multipleDefaultExports04.ts
@@ -0,0 +1,8 @@
+// @module: commonjs
+// @target: ES5
+
+export default function f() {
+}
+
+export default function f() {
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts
new file mode 100644
index 00000000000..35b434b6bac
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCanBeAssigned1.ts
@@ -0,0 +1,26 @@
+enum E { a, b, c }
+
+var a: any;
+var b: number;
+var c: E;
+
+var x1: any;
+x1 **= a;
+x1 **= b;
+x1 **= c;
+x1 **= null;
+x1 **= undefined;
+
+var x2: number;
+x2 **= a;
+x2 **= b;
+x2 **= c;
+x2 **= null;
+x2 **= undefined;
+
+var x3: E;
+x3 **= a;
+x3 **= b;
+x3 **= c;
+x3 **= null;
+x3 **= undefined;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts
new file mode 100644
index 00000000000..93623f667b8
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSCannotBeAssigned.ts
@@ -0,0 +1,60 @@
+enum E { a, b }
+
+var a: any;
+var b: void;
+
+var x1: boolean;
+x1 **= a;
+x1 **= b;
+x1 **= true;
+x1 **= 0;
+x1 **= ''
+x1 **= E.a;
+x1 **= {};
+x1 **= null;
+x1 **= undefined;
+
+var x2: string;
+x2 **= a;
+x2 **= b;
+x2 **= true;
+x2 **= 0;
+x2 **= ''
+x2 **= E.a;
+x2 **= {};
+x2 **= null;
+x2 **= undefined;
+
+var x3: {};
+x3 **= a;
+x3 **= b;
+x3 **= true;
+x3 **= 0;
+x3 **= ''
+x3 **= E.a;
+x3 **= {};
+x3 **= null;
+x3 **= undefined;
+
+var x4: void;
+x4 **= a;
+x4 **= b;
+x4 **= true;
+x4 **= 0;
+x4 **= ''
+x4 **= E.a;
+x4 **= {};
+x4 **= null;
+x4 **= undefined;
+
+var x5: number;
+x5 **= b;
+x5 **= true;
+x5 **= ''
+x5 **= {};
+
+var x6: E;
+x6 **= b;
+x6 **= true;
+x6 **= ''
+x6 **= {};
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsReference.ts b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsReference.ts
new file mode 100644
index 00000000000..02e6acfa685
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsReference.ts
@@ -0,0 +1,26 @@
+var value;
+
+// identifiers: variable and parameter
+var x1: number;
+x1 **= value;
+
+function fn1(x2: number) {
+    x2 **= value;
+}
+
+// property accesses
+var x3: { a: number };
+x3.a **= value;
+
+x3['a'] **= value;
+
+// parentheses, the contained expression is reference
+(x1) **= value;
+
+function fn2(x4: number) {
+    (x4) **= value;
+}
+
+(x3.a) **= value;
+
+(x3['a']) **= value;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts
new file mode 100644
index 00000000000..0eac581bfe4
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts
@@ -0,0 +1,85 @@
+// expected error for all the LHS of compound assignments (arithmetic and addition)
+var value;
+
+// this
+class C {
+    constructor() {
+        this **= value;
+    }
+    foo() {
+        this **= value;
+    }
+    static sfoo() {
+        this **= value;
+    }
+}
+
+function foo() {
+    this **= value;
+}
+
+this **= value;
+
+// identifiers: module, class, enum, function
+module M { export var a; }
+M **= value;
+
+C **= value;
+
+enum E { }
+E **= value;
+
+foo **= value;
+
+// literals
+null **= value;
+true **= value;
+false **= value;
+0 **= value;
+'' **= value;
+/d+/ **= value;
+
+// object literals
+{ a: 0 } **= value;
+
+// array literals
+['', ''] **= value;
+
+// super
+class Derived extends C {
+    constructor() {
+        super();
+        super **= value;
+    }
+
+    foo() {
+        super **= value;
+    }
+
+    static sfoo() {
+        super **= value;
+    }
+}
+
+// function expression
+function bar1() { } **= value;
+() => { } **= value;
+
+// function calls
+foo() **= value;
+
+// parentheses, the containted expression is value
+(this) **= value;
+(M) **= value;
+(C) **= value;
+(E) **= value;
+(foo) **= value;
+(null) **= value;
+(true) **= value;
+(0) **= value;
+('') **= value;
+(/d+/) **= value;
+({}) **= value;
+([]) **= value;
+(function baz1() { }) **= value;
+(foo()) **= value;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts
new file mode 100644
index 00000000000..7e0a7dc3728
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS1.ts
@@ -0,0 +1,17 @@
+// @target: es5
+
+var array0 = [1, 2, 3]
+var i0 = 0;
+array0[++i0] **= 2;
+
+var array1 = [1, 2, 3]
+var i1 = 0;
+array1[++i1] **= array1[++i1] **= 2;
+
+var array2 = [1, 2, 3]
+var i2 = 0;
+array2[++i2] **= array2[++i2] ** 2;
+
+var array3 = [2, 2, 3];
+var j0 = 0, j1 = 1;
+array3[j0++] **= array3[j1++] **= array3[j0++] **= 1;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts
new file mode 100644
index 00000000000..6a6fdc662c1
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.ts
@@ -0,0 +1,12 @@
+// @target: es5
+var globalCounter = 0;
+function foo() {
+    globalCounter += 1;
+    return { 0: 2 };
+}
+foo()[0] **= foo()[0];
+var result_foo1 = foo()[0] **= foo()[0];
+foo()[0] **= foo()[0] **= 2;
+var result_foo2 = foo()[0] **= foo()[0] **= 2;
+foo()[0] **= foo()[0] ** 2;
+var result_foo3 = foo()[0] **= foo()[0] ** 2;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts
new file mode 100644
index 00000000000..afb12a97563
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.ts
@@ -0,0 +1,14 @@
+// @target: es5
+
+var object = {
+    _0: 2,
+    get 0() {
+        return this._0;
+    },
+    set 0(x: number) {
+        this._0 = x;
+    },
+}
+object[0] **= object[0];
+object[0] **= object[0] **= 2;
+object[0] **= object[0] ** 2;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts
new file mode 100644
index 00000000000..3f4acd74e01
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithIndexingOnLHS4.ts
@@ -0,0 +1,16 @@
+// @target: es5
+
+var globalCounter = 0;
+function incrementIdx(max: number) {
+    globalCounter += 1;
+    let idx = Math.floor(Math.random() * max);
+    return idx;
+}
+
+var array1 = [1, 2, 3, 4, 5];
+
+array1[incrementIdx(array1.length)] **= 3;
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] **= 2;
+
+array1[incrementIdx(array1.length)] **= array1[incrementIdx(array1.length)] ** 2;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts
new file mode 100644
index 00000000000..c4ca205404b
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationAssignmentWithPropertyAccessingOnLHS1.ts
@@ -0,0 +1,13 @@
+// @target: es5
+
+var globalCounter = 0;
+function foo() {
+    globalCounter += 1;
+    return { prop: 2 };
+}
+foo().prop **= 2;
+var result0 = foo().prop **= 2;
+foo().prop **= foo().prop **= 2;
+var result1 = foo().prop **= foo().prop **= 2;
+foo().prop **= foo().prop ** 2;
+var result2 = foo().prop **= foo().prop ** 2;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts
new file mode 100644
index 00000000000..53bbd8e10a7
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator1.ts
@@ -0,0 +1,22 @@
+// @target:es5
+
+var comp: number;
+
+comp **= 1;
+comp **= comp ** comp;
+comp **= comp ** comp ** 2;
+comp **= comp ** comp + 2;
+comp **= comp ** comp - 2;
+comp **= comp ** comp * 2;
+comp **= comp ** comp / 2;
+comp **= comp ** comp % 2;
+comp **= (comp - 2) ** 5;
+comp **= (comp + 2) ** 5;
+comp **= (comp * 2) ** 5;
+comp **= (comp / 2) ** 5;
+comp **= (comp % 2) ** 5;
+comp **= comp ** (5 + 2);
+comp **= comp ** (5 - 2);
+comp **= comp ** (5 * 2);
+comp **= comp ** (5 / 2);
+comp **= comp ** (5 % 2);
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts
new file mode 100644
index 00000000000..216997be8cc
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitCompoundExponentiationOperator2.ts
@@ -0,0 +1,25 @@
+// @target:es5
+
+var comp: number;
+
+comp **= 1;
+comp **= comp **= 1;
+comp **= comp **= 1 + 2;
+comp **= comp **= 1 - 2;
+comp **= comp **= 1 * 2;
+comp **= comp **= 1 / 2;
+
+comp **= comp **= (1 + 2);
+comp **= comp **= (1 - 2);
+comp **= comp **= (1 * 2);
+comp **= comp **= (1 / 2);
+
+comp **= comp **= 1 + 2 ** 3;
+comp **= comp **= 1 - 2 ** 4;
+comp **= comp **= 1 * 2 ** 5;
+comp **= comp **= 1 / 2 ** 6;
+
+comp **= comp **= (1 + 2) ** 3;
+comp **= comp **= (1 - 2) ** 4;
+comp **= comp **= (1 * 2) ** 5;
+comp **= comp **= (1 / 2) ** 6;
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts
new file mode 100644
index 00000000000..2e6c84b6d43
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator1.ts
@@ -0,0 +1,33 @@
+// @target: es5
+
+1 ** -2;
+1 ** 2;
+(-1) ** 2
+1 ** 2 ** 3;
+1 ** 2 ** -3;
+1 ** -(2 ** 3);
+(-(1 ** 2)) ** 3;
+(-(1 ** 2)) ** -3;
+
+1 ** 2 + 3;
+1 ** 2 - 3;
+1 ** 2 * 3;
+1 ** 2 / 3;
+1 ** 2 % 3;
+
+1 ** -2 + 3;
+1 ** -2 - 3;
+1 ** -2 * 3;
+1 ** -2 / 3;
+1 ** -2 % 3;
+
+2 + 3 ** 3;
+2 - 3 ** 3;
+2 * 3 ** 3;
+2 / 3 ** 3;
+2 % 3 ** 3;
+
+(2 + 3) ** 4;
+(2 - 3) ** 4;
+(2 * 3) ** 4;
+(2 / 3) ** 4;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts
new file mode 100644
index 00000000000..146eab550d2
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator2.ts
@@ -0,0 +1,56 @@
+// @target:es5
+
+var temp = 10;
+
+++temp ** 3;
+--temp ** 3;
+temp++ ** 3;
+temp-- ** 3;
+--temp + temp ** 3;
+--temp - temp ** 3;
+--temp * temp ** 3;
+--temp / temp ** 3;
+--temp % temp ** 3;
+temp-- ** 3;
+temp++ ** 3;
+temp-- ** -temp;
+temp++ ** +temp;
+
+temp-- + temp ** 3;
+temp-- - temp ** 3;
+temp-- * temp ** 3;
+temp-- / temp ** 3;
+temp-- % temp ** 3;
+
+--temp + 2 ** 3;
+--temp - 2 ** 3;
+--temp * 2 ** 3;
+--temp / 2 ** 3;
+--temp % 2 ** 3;
+
+++temp + 2 ** 3;
+++temp - 2 ** 3;
+++temp * 2 ** 3;
+++temp / 2 ** 3;
+
+3 ** ++temp;
+3 ** --temp;
+3 ** temp++;
+3 ** temp--;
+
+3 ** ++temp ** 2;
+3 ** --temp ** 2;
+3 ** temp++ ** 2;
+3 ** temp-- ** 2;
+
+3 ** ++temp + 2;
+3 ** ++temp - 2;
+3 ** ++temp * 2;
+3 ** ++temp / 2;
+3 ** ++temp % 2;
+
+3 ** --temp + 2;
+3 ** --temp - 2;
+3 ** --temp * 2;
+3 ** --temp / 2;
+3 ** --temp % 2;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts
new file mode 100644
index 00000000000..597f253d1b8
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator3.ts
@@ -0,0 +1,40 @@
+// @target:es5
+
+var temp = 10;
+
+(-++temp) ** 3;
+(+--temp) ** 3;
+(-temp++) ** 3;
+(+temp--) ** 3;
+(-(1 ** ++temp)) ** 3;
+(-(1 ** --temp)) ** 3;
+(-(1 ** temp++)) ** 3;
+(-(1 ** temp--)) ** 3;
+
+(-3) ** temp++;
+(-3) ** temp--;
+(-3) ** ++temp;
+(-3) ** --temp;
+(+3) ** temp++;
+(+3) ** temp--;
+(+3) ** ++temp;
+(+3) ** --temp;
+(-3) ** temp++ ** 2;
+(-3) ** temp-- ** 2;
+(-3) ** ++temp ** 2;
+(-3) ** --temp ** 2;
+(+3) ** temp++ ** 2;
+(+3) ** temp-- ** 2;
+(+3) ** ++temp ** 2;
+(+3) ** --temp ** 2;
+
+3 ** -temp++;
+3 ** -temp--;
+3 ** -++temp;
+3 ** +--temp;
+3 ** (-temp++) ** 2;
+3 ** (-temp--) ** 2;
+3 ** (+temp++) ** 2;
+3 ** (+temp--) ** 2;
+3 ** (-++temp) ** 2;
+3 ** (+--temp) ** 2;
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts
new file mode 100644
index 00000000000..0e16443d547
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperator4.ts
@@ -0,0 +1,38 @@
+// @target: es5
+var temp: any;
+
+(<number>temp) ** 3;
+(<number>--temp) ** 3;
+(<number>++temp) ** 3;
+(<number>temp--) ** 3;
+(<number>temp++) ** 3;
+
+1 ** (<number>--temp) ** 3;
+1 ** (<number>++temp) ** 3;
+1 ** (<number>temp--) ** 3;
+1 ** (<number>temp++) ** 3;
+
+(void --temp) ** 3;
+(void temp--) ** 3;
+(void 3) ** 4;
+(void temp++) ** 4;
+(void temp--) ** 4;
+
+
+1 ** (void --temp) ** 3;
+1 ** (void temp--) ** 3;
+1 ** (void 3) ** 4;
+1 ** (void temp++) ** 4;
+1 ** (void temp--) ** 4;
+
+(~ --temp) ** 3;
+(~ temp--) ** 3;
+(~ 3) ** 4;
+(~ temp++) ** 4;
+(~ temp--) ** 4;
+
+1 ** (~ --temp) ** 3;
+1 ** (~ temp--) ** 3;
+1 ** (~ 3) ** 4;
+1 ** (~ temp++) ** 4;
+1 ** (~ temp--) ** 4;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts
new file mode 100644
index 00000000000..104033ab579
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4.ts
@@ -0,0 +1,28 @@
+// @target: es5
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+`${(-t1) ** t2 - t1} world`;
+`${(-++t1) ** t2 - t1} world`;
+`${(-t1++) ** t2 - t1} world`;
+`${(~t1) ** t2 ** --t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+`hello ${(-++t1) ** t2 - t1}`;
+`hello ${(-t1++) ** t2 - t1}`;
+`hello ${(~t1) ** t2 ** --t1 }`;
+`hello ${typeof (t1 ** t2 ** t1)}`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts
new file mode 100644
index 00000000000..611860cc5ef
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTempalteString4ES6.ts
@@ -0,0 +1,28 @@
+// @target: es6
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** -t2} world`;
+`${(-t1) ** t2 - t1} world`;
+`${(-++t1) ** t2 - t1} world`;
+`${(-t1++) ** t2 - t1} world`;
+`${(~t1) ** t2 ** --t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+
+// TempateHead & TemplateTail are empt
+`${t1 ** -t2} hello world ${t1 ** -t2}`;
+`${(-t1) ** t2 - t1} hello world ${(-t1) ** t2 - t1}`;
+`${(-++t1) ** t2 - t1} hello world ${t1 ** (-++t1) **- t1}`;
+`${(-t1++) ** t2 - t1} hello world ${t2 ** (-t1++) **  - t1}`;
+`${(~t1) ** t2 ** --t1 } hello world ${(~t1) ** t2 ** --t1 }`;
+`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
+
+// With templateHead
+`hello ${(-t1) ** t2 - t1}`;
+`hello ${(-++t1) ** t2 - t1}`;
+`hello ${(-t1++) ** t2 - t1}`;
+`hello ${(~t1) ** t2 ** --t1 }`;
+`hello ${typeof (t1 ** t2 ** t1)}`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts
new file mode 100644
index 00000000000..744e4ed2698
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1.ts
@@ -0,0 +1,28 @@
+// @target: es5
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+`${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1 }`;
+`${typeof (t1 ** t2 ** t1) }`;
+`${1 + typeof (t1 ** t2 ** t1) }`;
+
+`${t1 ** t2}${t1 ** t2}`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts
new file mode 100644
index 00000000000..90a8b9b26f7
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString1ES6.ts
@@ -0,0 +1,28 @@
+// @target: es6
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// TempateHead & TemplateTail are empty
+`${t1 ** t2}`;
+`${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1 }`;
+`${typeof (t1 ** t2 ** t1) }`;
+`${1 + typeof (t1 ** t2 ** t1) }`;
+
+`${t1 ** t2}${t1 ** t2}`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
+
+`${t1 ** t2} hello world ${t1 ** t2}`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts
new file mode 100644
index 00000000000..0d5f2129861
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2.ts
@@ -0,0 +1,28 @@
+// @target: es5
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With templateHead
+`hello ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1 }`;
+`hello ${typeof (t1 ** t2 ** t1) }`;
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts
new file mode 100644
index 00000000000..7f122d505e7
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString2ES6.ts
@@ -0,0 +1,28 @@
+// @target: es6
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With templateHead
+`hello ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1 }`;
+`hello ${typeof (t1 ** t2 ** t1) }`;
+`hello ${1 + typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2}${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1}${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1}${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1}${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
+
+`hello ${t1 ** t2} hello world ${t1 ** t2}`;
+`hello ${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1}`;
+`hello ${t1 + t2 ** t1} hello world ${t1 + t2 ** t1}`;
+`hello ${t1 ** t2 + t1} hello world ${t1 ** t2 + t1}`;
+`hello ${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1}`;
+`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts
new file mode 100644
index 00000000000..73fc2fcd3a9
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3.ts
@@ -0,0 +1,28 @@
+// @target: es5
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** t2} world`;
+`${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2}${t1 ** t2} world`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
diff --git a/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts
new file mode 100644
index 00000000000..724039acfb2
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/emitExponentiationOperatorInTemplateString3ES6.ts
@@ -0,0 +1,28 @@
+// @target: es6
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// With TemplateTail
+`${t1 ** t2} world`;
+`${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1 } world`;
+`${typeof (t1 ** t2 ** t1) } world`;
+`${1 + typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2}${t1 ** t2} world`;
+`${t1 ** t2 ** t1}${t1 ** t2 ** t1} world`;
+`${t1 + t2 ** t1}${t1 + t2 ** t1} world`;
+`${t1 ** t2 + t1}${t1 ** t2 + t1} world`;
+`${t1 + t2 ** t2 + t1}${t1 + t2 ** t2 + t1} world`;
+`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
+
+`${t1 ** t2} hello world ${t1 ** t2} !!`;
+`${t1 ** t2 ** t1} hello world ${t1 ** t2 ** t1} !!`;
+`${t1 + t2 ** t1} hello world ${t1 + t2 ** t1} !!`;
+`${t1 ** t2 + t1} hello world ${t1 ** t2 + t1} !!`;
+`${t1 + t2 ** t2 + t1} hello world ${t1 + t2 ** t2 + t1} !!`;
+`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts
new file mode 100644
index 00000000000..d61d3c07450
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError1.ts
@@ -0,0 +1,28 @@
+// @target: es5
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// TempateHead & TemplateTail are empty
+`${1 + typeof t1 ** t2 ** t1}`;
+`${-t1 ** t2 - t1}`;
+`${-++t1 ** t2 - t1}`;
+`${-t1++ ** t2 - t1}`;
+`${!t1 ** t2 ** --t1 }`;
+`${typeof t1 ** t2 ** t1}`;
+
+`${-t1 ** t2 - t1}${-t1 ** t2 - t1}`;
+`${-++t1 ** t2 - t1}${-++t1 ** t2 - t1}`;
+`${-t1++ ** t2 - t1}${-t1++ ** t2 - t1}`;
+`${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 }`;
+`${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1}`;
+`${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1}`;
+
+`${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1}`;
+`${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1}`;
+`${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1}`;
+`${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 }`;
+`${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1}`;
+`${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1}`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts
new file mode 100644
index 00000000000..c7ee30a95b8
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError2.ts
@@ -0,0 +1,28 @@
+// @target: es5
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// With templateHead
+`hello ${-t1 ** t2 - t1}`;
+`hello ${-++t1 ** t2 - t1}`;
+`hello ${-t1++ ** t2 - t1}`;
+`hello ${!t1 ** t2 ** --t1 }`;
+`hello ${typeof t1 ** t2 ** t1}`;
+`hello ${1 + typeof t1 ** t2 ** t1}`;
+
+`hello ${-t1 ** t2 - t1}${-t1 ** t2 - t1}`;
+`hello ${-++t1 ** t2 - t1}${-++t1 ** t2 - t1}`;
+`hello ${-t1++ ** t2 - t1}${-t1++ ** t2 - t1}`;
+`hello ${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 }`;
+`hello ${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1}`;
+`hello ${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1}`;
+
+`hello ${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1}`;
+`hello ${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1}`;
+`hello ${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1}`;
+`hello ${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 }`;
+`hello ${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1}`;
+`hello ${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1}`;
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts
new file mode 100644
index 00000000000..18ba31f8965
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorInTemplateStringWithSyntaxError3.ts
@@ -0,0 +1,28 @@
+// @target: es5
+
+var t1 = 10;
+var t2 = 10;
+var s;
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+// With TemplateTail
+`${-t1 ** t2 - t1} world`;
+`${-++t1 ** t2 - t1} world`;
+`${-t1++ ** t2 - t1} world`;
+`${!t1 ** t2 ** --t1 } world`;
+`${typeof t1 ** t2 ** t1} world`;
+`${1 + typeof t1 ** t2 ** t1} world`;
+
+`${-t1 ** t2 - t1}${-t1 ** t2 - t1} world`;
+`${-++t1 ** t2 - t1}${-++t1 ** t2 - t1} world`;
+`${-t1++ ** t2 - t1}${-t1++ ** t2 - t1} world`;
+`${!t1 ** t2 ** --t1 }${!t1 ** t2 ** --t1 } world`;
+`${typeof t1 ** t2 ** t1}${typeof t1 ** t2 ** t1} world`;
+`${1 + typeof t1 ** t2 ** t1}${1 + typeof t1 ** t2 ** t1} world`;
+
+`${-t1 ** t2 - t1} hello world ${-t1 ** t2 - t1} !!`;
+`${-++t1 ** t2 - t1} hello world ${-++t1 ** t2 - t1} !!`;
+`${-t1++ ** t2 - t1} hello world ${-t1++ ** t2 - t1} !!`;
+`${!t1 ** t2 ** --t1 } hello world ${!t1 ** t2 ** --t1 } !!`;
+`${typeof t1 ** t2 ** t1} hello world ${typeof t1 ** t2 ** t1} !!`;
+`${1 + typeof t1 ** t2 ** t1} hello world ${1 + typeof t1 ** t2 ** t1} !!`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts
new file mode 100644
index 00000000000..a70948c23e2
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError1.ts
@@ -0,0 +1,39 @@
+// @target: es5
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+-1 ** 2;
++1 ** 2
+1 ** -2 ** 3;
+1 ** -2 ** -3;
+-1 ** -2 ** -3;
+-(1 ** 2) ** 3;
+
+var temp = 10;
+
+-++temp ** 3;
++--temp ** 3;
+-temp++ ** 3;
++temp-- ** 3;
+1 ** -++temp ** 3;
+1 ** +--temp ** 3;
+1 ** -temp++ ** 3;
+1 ** +temp-- ** 3;
+
+-3 ** temp++;
+-3 ** temp--;
+-3 ** ++temp;
+-3 ** --temp;
++3 ** temp++;
++3 ** temp--;
++3 ** ++temp;
++3 ** --temp;
+-3 ** temp++ ** 2;
+-3 ** temp-- ** 2;
+-3 ** ++temp ** 2;
+-3 ** --temp ** 2;
++3 ** temp++ ** 2;
++3 ** temp-- ** 2;
++3 ** ++temp ** 2;
++3 ** --temp ** 2;
+
+
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts
new file mode 100644
index 00000000000..e5118d18551
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorSyntaxError2.ts
@@ -0,0 +1,69 @@
+// @target: es5
+
+// Error: early syntax error using ES7 SimpleUnaryExpression on left-hand side without ()
+var temp;
+
+delete --temp ** 3;
+delete ++temp ** 3;
+delete temp-- ** 3;
+delete temp++ ** 3;
+
+
+1 ** delete --temp ** 3;
+1 ** delete ++temp ** 3;
+1 ** delete temp-- ** 3;
+1 ** delete temp++ ** 3;
+
+typeof --temp ** 3;
+typeof temp-- ** 3;
+typeof 3 ** 4;
+typeof temp++ ** 4;
+typeof temp-- ** 4;
+
+1 ** typeof --temp ** 3;
+1 ** typeof temp-- ** 3;
+1 ** typeof 3 ** 4;
+1 ** typeof temp++ ** 4;
+1 ** typeof temp-- ** 4;
+
+void --temp ** 3;
+void temp-- ** 3;
+void 3 ** 4;
+void temp++ ** 4;
+void temp-- ** 4;
+
+1 ** void --temp ** 3;
+1 ** void temp-- ** 3;
+1 ** void 3 ** 4;
+1 ** void temp++ ** 4;
+1 ** void temp-- ** 4 ;
+
+~ --temp ** 3;
+~temp-- ** 3;
+~3 ** 4;
+~temp++ ** 4;
+~temp-- ** 4;
+
+1 ** ~ --temp ** 3;
+1 ** ~temp-- ** 3;
+1 ** ~3 ** 4;
+1 ** ~temp++ ** 4;
+1 ** ~temp-- ** 4;
+
+! --temp ** 3;
+!temp-- ** 3;
+!3 ** 4;
+!temp++ ** 4;
+!temp-- ** 4;
+
+1 ** ! --temp ** 3;
+1 ** !temp-- ** 3;
+1 ** !3 ** 4;
+1 ** !temp++ ** 4;
+1 ** !temp-- ** 4;
+
+<number>temp ** 3;
+<number>++temp ** 3;
+<number>--temp ** 3;
+<number>temp++ ** 3;
+<number>temp-- ** 3;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithAnyAndNumber.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithAnyAndNumber.ts
new file mode 100644
index 00000000000..c5652211064
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithAnyAndNumber.ts
@@ -0,0 +1,12 @@
+var a: any;
+var b: number;
+
+// operator **
+var r1 = a ** a;
+var r2 = a ** b;
+var r3 = a ** 0;
+var r4 = 0 ** a;
+var r5 = 0 ** 0;
+var r6 = b ** 0;
+var r7 = 0 ** b;
+var r8 = b ** b;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnum.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnum.ts
new file mode 100644
index 00000000000..dee953c6abb
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnum.ts
@@ -0,0 +1,24 @@
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+var c: E;
+
+// operator **
+var r1 = c ** a;
+var r2 = c ** b;
+var r3 = c ** c;
+var r4 = a ** c;
+var r5 = b ** c;
+var r6 = E.a ** a;
+var r7 = E.a ** b;
+var r8 = E.a ** E.b;
+var r9 = E.a ** 1;
+var r10 = a ** E.b;
+var r11 = b ** E.b;
+var r12 = 1 ** E.b;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnumUnion.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnumUnion.ts
new file mode 100644
index 00000000000..2528027f4cb
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithEnumUnion.ts
@@ -0,0 +1,28 @@
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+    a,
+    b
+}
+enum F {
+    c,
+    d
+}
+
+var a: any;
+var b: number;
+var c: E | F;
+
+// operator **
+var r1 = c ** a;
+var r2 = c ** b;
+var r3 = c ** c;
+var r4 = a ** c;
+var r5 = b ** c;
+var r6 = E.a ** a;
+var r7 = E.a ** b;
+var r8 = E.a ** E.b;
+var r9 = E.a ** 1;
+var r10 = a ** E.b;
+var r11 = b ** E.b;
+var r12 = 1 ** E.b;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts
new file mode 100644
index 00000000000..f16ddc61ed5
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidOperands.ts
@@ -0,0 +1,68 @@
+// these operators require their operands to be of type Any, the Number primitive type, or
+// an enum type
+enum E { a, b, c }
+
+var a: any;
+var b: boolean;
+var c: number;
+var d: string;
+var e: { a: number };
+var f: Number;
+
+// All of the below should be an error unless otherwise noted
+// operator **
+var r1a1 = a ** a; //ok
+var r1a2 = a ** b;
+var r1a3 = a ** c; //ok
+var r1a4 = a ** d;
+var r1a5 = a ** e;
+var r1a6 = a ** f;
+
+var r1b1 = b ** a;
+var r1b2 = b ** b;
+var r1b3 = b ** c;
+var r1b4 = b ** d;
+var r1b5 = b ** e;
+var r1b6 = b ** f;
+
+var r1c1 = c ** a; //ok
+var r1c2 = c ** b;
+var r1c3 = c ** c; //ok
+var r1c4 = c ** d;
+var r1c5 = c ** e;
+var r1c6 = c ** f;
+
+var r1d1 = d ** a;
+var r1d2 = d ** b;
+var r1d3 = d ** c;
+var r1d4 = d ** d;
+var r1d5 = d ** e;
+var r1d6 = d ** f;
+
+var r1e1 = e ** a;
+var r1e2 = e ** b;
+var r1e3 = e ** c;
+var r1e4 = e ** d;
+var r1e5 = e ** e;
+var r1e6 = e ** f;
+
+var r1f1 = f ** a;
+var r1f2 = f ** b;
+var r1f3 = f ** c;
+var r1f4 = f ** d;
+var r1f5 = f ** e;
+var r1f6 = f ** f;
+
+var r1g1 = E.a ** a; //ok
+var r1g2 = E.a ** b;
+var r1g3 = E.a ** c; //ok
+var r1g4 = E.a ** d;
+var r1g5 = E.a ** e;
+var r1g6 = E.a ** f;
+
+var r1h1 = a ** E.b; //ok
+var r1h2 = b ** E.b;
+var r1h3 = c ** E.b; //ok
+var r1h4 = d ** E.b;
+var r1h5 = e ** E.b;
+var r1h6 = f ** E.b
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts
new file mode 100644
index 00000000000..77d7c8b668a
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.ts
@@ -0,0 +1,36 @@
+var temp: any;
+
+// Error: incorrect type on left-hand side 
+(! --temp) ** 3;
+(!temp--) ** 3;
+(!3) ** 4;
+(!temp++) ** 4;
+(!temp--) ** 4;
+
+(! --temp) ** 3 ** 1;
+(!temp--) ** 3 ** 1;
+(!3) ** 4 ** 1;
+(!temp++) ** 4 ** 1;
+(!temp--) ** 4 ** 1;
+
+(typeof --temp) ** 3;
+(typeof temp--) ** 3;
+(typeof 3) ** 4;
+(typeof temp++) ** 4;
+(typeof temp--) ** 4;
+
+1 ** (typeof --temp) ** 3;
+1 ** (typeof temp--) ** 3;
+1 ** (typeof 3) ** 4;
+1 ** (typeof temp++) ** 4;
+1 ** (typeof temp--) ** 4;
+
+(delete --temp) ** 3;
+(delete ++temp) ** 3;
+(delete temp--) ** 3;
+(delete temp++) ** 3;
+
+1 ** (delete --temp) ** 3;
+1 ** (delete ++temp) ** 3;
+1 ** (delete temp--) ** 3;
+1 ** (delete temp++) ** 3;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNew.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNew.ts
new file mode 100644
index 00000000000..c17b26cc88f
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNew.ts
@@ -0,0 +1,6 @@
+var a: any;
+var b: any;
+var c: any;
+new a ** b ** c;
+new a ** new b ** c;
+new (a ** b ** c);
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts
new file mode 100644
index 00000000000..7ecec740d41
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndInvalidOperands.ts
@@ -0,0 +1,23 @@
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+var a: boolean;
+var b: string;
+var c: Object;
+
+// operator **
+var r1a1 = null ** a;
+var r1a2 = null ** b;
+var r1a3 = null ** c;
+
+var r1b1 = a ** null;
+var r1b2 = b ** null;
+var r1b3 = c ** null;
+
+var r1c1 = null ** true;
+var r1c2 = null ** '';
+var r1c3 = null ** {};
+
+var r1d1 = true ** null;
+var r1d2 = '' ** null;
+var r1d3 = {} ** null;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts
new file mode 100644
index 00000000000..acc152ea696
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithNullValueAndValidOperands.ts
@@ -0,0 +1,20 @@
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+
+// operator **
+var r1 = null ** a;
+var r2 = null ** b;
+var r3 = null ** 1;
+var r4 = null ** E.a;
+var r5 = a ** null;
+var r6 = b ** null;
+var r7 = 0 ** null;
+var r8 = E.b ** null;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts
new file mode 100644
index 00000000000..82133ed3914
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.ts
@@ -0,0 +1,5 @@
+// operator **
+var r1 = null ** null;
+var r2 = null ** undefined;
+var r3 = undefined ** null;
+var r4 = undefined ** undefined;
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts
new file mode 100644
index 00000000000..6e055caae04
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalid.ts
@@ -0,0 +1,19 @@
+// @target: es5
+
+var a = 1 ** `${ 3 }`;
+var b = 1 ** `2${ 3 }`;
+var c = 1 ** `${ 3 }4`;
+var d = 1 ** `2${ 3 }4`;
+var e = `${ 3 }` ** 5;
+var f = `2${ 3 }` ** 5;
+var g = `${ 3 }4` ** 5;
+var h = `2${ 3 }4` ** 5;
+
+var k = 10;
+k **= `${ 3 }`;
+k **= `2${ 3 }`;
+k **= `2${ 3 }4`;
+k **= `2${ 3 }4`;
+
+
+ 
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts
new file mode 100644
index 00000000000..1593d1290e4
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTemplateStringInvalidES6.ts
@@ -0,0 +1,16 @@
+// @target: es6
+
+var a = 1 ** `${ 3 }`;
+var b = 1 ** `2${ 3 }`;
+var c = 1 ** `${ 3 }4`;
+var d = 1 ** `2${ 3 }4`;
+var e = `${ 3 }` ** 5;
+var f = `2${ 3 }` ** 5;
+var g = `${ 3 }4` ** 5;
+var h = `2${ 3 }4` ** 5;
+
+var k = 10;
+k **= `${ 3 }`;
+k **= `2${ 3 }`;
+k **= `2${ 3 }4`;
+kj **= `2${ 3 }4`;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts
new file mode 100644
index 00000000000..d028b5c6575
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithTypeParameter.ts
@@ -0,0 +1,20 @@
+// type parameter type is not valid for arithmetic operand
+function foo<T>(t: T) {
+    var a: any;
+    var b: boolean;
+    var c: number;
+    var d: string;
+    var e: {};
+
+    var r1a1 = a ** t;
+    var r2a1 = t ** a;
+    var r1b1 = b ** t;
+    var r2b1 = t ** b;
+    var r1c1 = c ** t;
+    var r2c1 = t ** c;
+    var r1d1 = d ** t;
+    var r2d1 = t ** d;
+    var r1e1 = e ** t;
+    var r2e1 = t ** d;
+    var r1f1 = t ** t;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts
new file mode 100644
index 00000000000..7693e4a83f9
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndInvalidOperands.ts
@@ -0,0 +1,23 @@
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+var a: boolean;
+var b: string;
+var c: Object;
+
+// operator **
+var r1a1 = undefined ** a;
+var r1a2 = undefined ** b;
+var r1a3 = undefined ** c;
+
+var r1b1 = a ** undefined;
+var r1b2 = b ** undefined;
+var r1b3 = c ** undefined;
+
+var r1c1 = undefined ** true;
+var r1c2 = undefined ** '';
+var r1c3 = undefined ** {};
+
+var r1d1 = true ** undefined;
+var r1d2 = '' ** undefined;
+var r1d3 = {} ** undefined;
\ No newline at end of file
diff --git a/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts
new file mode 100644
index 00000000000..c1862f1bbe9
--- /dev/null
+++ b/tests/cases/conformance/es7/exponentiationOperator/exponentiationOperatorWithUndefinedValueAndValidOperands.ts
@@ -0,0 +1,20 @@
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+    a,
+    b
+}
+
+var a: any;
+var b: number;
+
+// operator *
+var rk1 = undefined ** a;
+var rk2 = undefined ** b;
+var rk3 = undefined ** 1;
+var rk4 = undefined ** E.a;
+var rk5 = a ** undefined;
+var rk6 = b ** undefined;
+var rk7 = 0 ** undefined;
+var rk8 = E.b ** undefined;
\ No newline at end of file
diff --git a/tests/cases/conformance/jsx/tsxPreserveEmit1.tsx b/tests/cases/conformance/jsx/tsxPreserveEmit1.tsx
new file mode 100644
index 00000000000..e75a1dbfde2
--- /dev/null
+++ b/tests/cases/conformance/jsx/tsxPreserveEmit1.tsx
@@ -0,0 +1,26 @@
+//@module: amd
+//@jsx: preserve
+//@target: ES5
+
+//@Filename: react.d.ts
+declare module 'react' {
+	var x: any;
+	export = x;
+}
+
+declare module ReactRouter {
+	var Route: any;
+	interface Thing { }
+}
+declare module 'react-router' {
+	export = ReactRouter;
+}
+
+//@Filename: test.tsx
+// Should emit 'react-router' in the AMD dependency list
+import React = require('react');
+import ReactRouter = require('react-router');
+
+import Route = ReactRouter.Route;
+
+var routes = <Route />;
diff --git a/tests/cases/conformance/jsx/tsxReactEmit6.tsx b/tests/cases/conformance/jsx/tsxReactEmit6.tsx
index 2782f90e503..0e8c772a3f1 100644
--- a/tests/cases/conformance/jsx/tsxReactEmit6.tsx
+++ b/tests/cases/conformance/jsx/tsxReactEmit6.tsx
@@ -19,4 +19,8 @@ namespace M {
 	//  and M.React.__spread
 	var foo;
 	var spread1 = <div x='' {...foo} y='' />;
+
+	// Quotes
+	var x = <div>This "quote" thing</div>;
 }
+
diff --git a/tests/cases/fourslash/commentsOverloads.ts b/tests/cases/fourslash/commentsOverloads.ts
index d32c35b0508..1100b55dca8 100644
--- a/tests/cases/fourslash/commentsOverloads.ts
+++ b/tests/cases/fourslash/commentsOverloads.ts
@@ -482,8 +482,8 @@ verify.quickInfoIs("(method) c.prop1(a: number): number (+1 overload)", "");
 goTo.marker('46');
 verify.currentSignatureHelpDocCommentIs("");
 verify.currentParameterHelpArgumentDocCommentIs("");
-//goTo.marker('46q');
-//verify.quickInfoIs("(method) c.prop1(b: string): number (+1 overload)", "");
+goTo.marker('46q');
+verify.quickInfoIs("(method) c.prop1(b: string): number (+1 overload)", "");
 
 goTo.marker('47');
 verify.currentSignatureHelpDocCommentIs("prop2 1");
@@ -494,8 +494,8 @@ verify.quickInfoIs("(method) c.prop2(a: number): number (+1 overload)", "prop2 1
 goTo.marker('48');
 verify.currentSignatureHelpDocCommentIs("");
 verify.currentParameterHelpArgumentDocCommentIs("");
-//goTo.marker('48q');
-//verify.quickInfoIs("(method) c.prop2(b: string): number (+1 overload)", "");
+goTo.marker('48q');
+verify.quickInfoIs("(method) c.prop2(b: string): number (+1 overload)", "");
 
 goTo.marker('49');
 verify.currentSignatureHelpDocCommentIs("");
@@ -506,8 +506,8 @@ verify.quickInfoIs("(method) c.prop3(a: number): number (+1 overload)", "");
 goTo.marker('50');
 verify.currentSignatureHelpDocCommentIs("prop3 2");
 verify.currentParameterHelpArgumentDocCommentIs("");
-//goTo.marker('50q');
-//verify.quickInfoIs("(method) c.prop3(b: string): number (+1 overload)", "prop3 2");
+goTo.marker('50q');
+verify.quickInfoIs("(method) c.prop3(b: string): number (+1 overload)", "prop3 2");
 
 goTo.marker('51');
 verify.currentSignatureHelpDocCommentIs("prop4 1");
@@ -518,8 +518,8 @@ verify.quickInfoIs("(method) c.prop4(a: number): number (+1 overload)", "prop4 1
 goTo.marker('52');
 verify.currentSignatureHelpDocCommentIs("prop4 2");
 verify.currentParameterHelpArgumentDocCommentIs("");
-//goTo.marker('52q');
-//verify.quickInfoIs("(method) c.prop4(b: string): number (+1 overload)", "prop4 2");
+goTo.marker('52q');
+verify.quickInfoIs("(method) c.prop4(b: string): number (+1 overload)", "prop4 2");
 
 goTo.marker('53');
 verify.currentSignatureHelpDocCommentIs("prop5 1");
@@ -530,8 +530,8 @@ verify.quickInfoIs("(method) c.prop5(a: number): number (+1 overload)", "prop5 1
 goTo.marker('54');
 verify.currentSignatureHelpDocCommentIs("prop5 2");
 verify.currentParameterHelpArgumentDocCommentIs("");
-//goTo.marker('54q');
-//verify.quickInfoIs("(method) c.prop5(b: string): number (+1 overload)", "prop5 2");
+goTo.marker('54q');
+verify.quickInfoIs("(method) c.prop5(b: string): number (+1 overload)", "prop5 2");
 
 goTo.marker('55');
 verify.currentSignatureHelpDocCommentIs("");
@@ -730,4 +730,4 @@ goTo.marker('106');
 verify.quickInfoIs("(method) c.prop5(b: string): number (+1 overload)", "prop5 2");
 
 goTo.marker('107');
-verify.quickInfoIs("(method) c.prop5(a: number): number (+1 overload)", "prop5 1");
\ No newline at end of file
+verify.quickInfoIs("(method) c.prop5(a: number): number (+1 overload)", "prop5 1");
diff --git a/tests/cases/fourslash/completionListInstanceProtectedMembers.ts b/tests/cases/fourslash/completionListInstanceProtectedMembers.ts
index e396a71247a..767dd1dff27 100644
--- a/tests/cases/fourslash/completionListInstanceProtectedMembers.ts
+++ b/tests/cases/fourslash/completionListInstanceProtectedMembers.ts
@@ -31,15 +31,15 @@
 
 
 // Same class, everything is visible
-//goTo.marker("1");
-//verify.memberListContains('privateMethod');
-//verify.memberListContains('privateProperty');
-//verify.memberListContains('protectedMethod');
-//verify.memberListContains('protectedProperty');
-//verify.memberListContains('publicMethod');
-//verify.memberListContains('publicProperty');
-//verify.memberListContains('protectedOverriddenMethod');
-//verify.memberListContains('protectedOverriddenProperty');
+goTo.marker("1");
+verify.memberListContains('privateMethod');
+verify.memberListContains('privateProperty');
+verify.memberListContains('protectedMethod');
+verify.memberListContains('protectedProperty');
+verify.memberListContains('publicMethod');
+verify.memberListContains('publicProperty');
+verify.memberListContains('protectedOverriddenMethod');
+verify.memberListContains('protectedOverriddenProperty');
 
 goTo.marker("2");
 verify.memberListContains('privateMethod');
@@ -60,4 +60,4 @@ verify.memberListContains('protectedProperty');
 verify.memberListContains('publicMethod');
 verify.memberListContains('publicProperty');
 verify.not.memberListContains('protectedOverriddenMethod');
-verify.not.memberListContains('protectedOverriddenProperty');
\ No newline at end of file
+verify.not.memberListContains('protectedOverriddenProperty');
diff --git a/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts b/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts
index fed310aba21..c074bc06314 100644
--- a/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts
+++ b/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts
@@ -32,15 +32,15 @@
 
 
 // Same class, everything is visible
-//goTo.marker("1");
-//verify.not.memberListContains('privateMethod');
-//verify.not.memberListContains('privateProperty');
-//verify.memberListContains('protectedMethod');
-//verify.memberListContains('protectedProperty');
-//verify.memberListContains('publicMethod');
-//verify.memberListContains('publicProperty');
-//verify.memberListContains('protectedOverriddenMethod');
-//verify.memberListContains('protectedOverriddenProperty');
+goTo.marker("1");
+verify.not.memberListContains('privateMethod');
+verify.not.memberListContains('privateProperty');
+verify.memberListContains('protectedMethod');
+verify.memberListContains('protectedProperty');
+verify.memberListContains('publicMethod');
+verify.memberListContains('publicProperty');
+verify.memberListContains('protectedOverriddenMethod');
+verify.memberListContains('protectedOverriddenProperty');
 
 // Can not access properties on super
 goTo.marker("2");
diff --git a/tests/cases/fourslash/completionListProtectedMembers.ts b/tests/cases/fourslash/completionListProtectedMembers.ts
index 8ddd8aca4d0..4715a9fb714 100644
--- a/tests/cases/fourslash/completionListProtectedMembers.ts
+++ b/tests/cases/fourslash/completionListProtectedMembers.ts
@@ -18,25 +18,25 @@
 ////var b: Base;
 ////f./*5*/
 
-//goTo.marker("1");
-//verify.memberListContains("y");
-//verify.memberListContains("x");
-//verify.not.memberListContains("z");
+goTo.marker("1");
+verify.memberListContains("y");
+verify.memberListContains("x");
+verify.not.memberListContains("z");
 
-//goTo.marker("2");
-//verify.memberListContains("y");
-//verify.memberListContains("x");
-//verify.memberListContains("z");
+goTo.marker("2");
+verify.memberListContains("y");
+verify.memberListContains("x");
+verify.memberListContains("z");
 
-//goTo.marker("3");
-//verify.memberListContains("y");
-//verify.memberListContains("x");
-//verify.not.memberListContains("z");
+goTo.marker("3");
+verify.memberListContains("y");
+verify.memberListContains("x");
+verify.not.memberListContains("z");
 
-//goTo.marker("4");
-//verify.memberListContains("y");
-//verify.memberListContains("x");
-//verify.memberListContains("z");
+goTo.marker("4");
+verify.memberListContains("y");
+verify.memberListContains("x");
+verify.memberListContains("z");
 
 goTo.marker("5");
 verify.not.memberListContains("x");
diff --git a/tests/cases/fourslash/formatAsyncKeyword.ts b/tests/cases/fourslash/formatAsyncKeyword.ts
new file mode 100644
index 00000000000..305d4ea4244
--- /dev/null
+++ b/tests/cases/fourslash/formatAsyncKeyword.ts
@@ -0,0 +1,13 @@
+/// <reference path="fourslash.ts" />
+
+/////*1*/let x = async         () => 1;
+/////*2*/let y = async() => 1;
+/////*3*/let z = async    function   () { return 1; };
+
+format.document();
+goTo.marker("1");
+verify.currentLineContentIs("let x = async () => 1;");
+goTo.marker("2");
+verify.currentLineContentIs("let y = async () => 1;");
+goTo.marker("3");
+verify.currentLineContentIs("let z = async function() { return 1; };")
\ No newline at end of file
diff --git a/tests/cases/fourslash/formatTemplateLiteral.ts b/tests/cases/fourslash/formatTemplateLiteral.ts
index 6d1352fcf0d..68f2c8c9469 100644
--- a/tests/cases/fourslash/formatTemplateLiteral.ts
+++ b/tests/cases/fourslash/formatTemplateLiteral.ts
@@ -2,12 +2,16 @@
 ////var x = `sadasdasdasdasfegsfd
 /////*1*/rasdesgeryt35t35y35 e4 ergt er 35t 3535 `;
 ////var y = `1${2}/*2*/3`;
-////let z=    `foo`/*3*/
-////let w=  `bar${3}`/*4*/
+////
+/////*formatStart*/
+////let z=    `foo`;/*3*/
+////let w=  `bar${3}`;/*4*/
 ////String.raw
-//// `template`/*5*/
-////String.raw`foo`/*6*/
-////String.raw  `bar${3}`/*7*/
+//// `template`;/*5*/
+////String.raw`foo`;/*6*/
+////String.raw  `bar${3}`;/*7*/
+////`Write ${   JSON.stringify("")   } and ${    (765)   } and ${   346  }`;/*spaceInside*/
+/////*formatEnd*/
 
 
 goTo.marker("1");
@@ -18,19 +22,19 @@ edit.insert("\r\n");
 verify.indentationIs(0);
 verify.currentLineContentIs("3`;")
 
+format.selection("formatStart", "formatEnd");
+
 goTo.marker("3");
-edit.insert(";");
 verify.currentLineContentIs("let z = `foo`;");
 goTo.marker("4");
-edit.insert(";");
 verify.currentLineContentIs("let w = `bar${3}`;");
 
 goTo.marker("5");
-edit.insert(";");
 verify.currentLineContentIs("    `template`;");
 goTo.marker("6");
-edit.insert(";");
 verify.currentLineContentIs("String.raw `foo`;");
 goTo.marker("7");
-edit.insert(";");
-verify.currentLineContentIs("String.raw `bar${3}`;");
\ No newline at end of file
+verify.currentLineContentIs("String.raw `bar${3}`;");
+
+goTo.marker("spaceInside");
+verify.currentLineContentIs('`Write ${JSON.stringify("")} and ${(765)} and ${346}`;');
\ No newline at end of file
diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts
index 42cfc1248b0..41e8d9005f7 100644
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@@ -68,6 +68,13 @@ enum EmitReturnStatus {
     EmitErrorsEncountered = 4           // Emitter errors occurred during emitting process
 }
 
+// This is a duplicate of the indentstyle in services.ts to expose it to testcases in fourslash
+enum IndentStyle {
+    None,
+    Block,
+    Smart,
+}
+
 module FourSlashInterface {
 
     export interface Marker {
@@ -205,7 +212,7 @@ module FourSlashInterface {
         // Verifies the completion list items count to be greater than the specified amount. The
         // completion list is brought up if necessary
         public completionListItemsCountIsGreaterThan(count: number) {
-            FourSlash.currentTestState.verifyCompletionListItemsCountIsGreaterThan(count);
+            FourSlash.currentTestState.verifyCompletionListItemsCountIsGreaterThan(count, this.negative);
         }
 
         public completionListIsEmpty() {
@@ -278,8 +285,8 @@ module FourSlashInterface {
             FourSlash.currentTestState.verifyIndentationAtCurrentPosition(numberOfSpaces);
         }
 
-        public indentationAtPositionIs(fileName: string, position: number, numberOfSpaces: number) {
-            FourSlash.currentTestState.verifyIndentationAtPosition(fileName, position, numberOfSpaces);
+        public indentationAtPositionIs(fileName: string, position: number, numberOfSpaces: number, indentStyle = IndentStyle.Smart) {
+            FourSlash.currentTestState.verifyIndentationAtPosition(fileName, position, numberOfSpaces, indentStyle);
         }
 
         public textAtCaretIs(text: string) {
diff --git a/tests/cases/fourslash/indentationBlock.ts b/tests/cases/fourslash/indentationBlock.ts
new file mode 100644
index 00000000000..e880c4a0957
--- /dev/null
+++ b/tests/cases/fourslash/indentationBlock.ts
@@ -0,0 +1,183 @@
+/// <reference path="fourslash.ts"/>
+
+////
+////module classes {
+////{| "indent": 0 |} 
+////    class Bar {
+////{| "indent": 4 |} 
+////
+////        constructor() {
+////{| "indent": 8 |} 
+////        }
+////
+////        private foo: string = "";
+////{| "indent": 8 |} 
+////
+////        private f() {
+////            var a: any[] = [[1, 2], [3, 4], 5];
+////{| "indent": 12 |} 
+////            return ((1 + 1));
+////        }
+////
+////{| "indent": 8 |} 
+////        private f2() {
+////            if (true) { } { };
+////        }
+////    }
+////}
+////
+////
+////module interfaces {
+////{| "indent": 0 |} 
+////    interface Foo {
+////{| "indent": 4 |} 
+////
+////        x: number;
+////{| "indent": 8 |} 
+////
+////        foo(): number;
+////{| "indent": 8 |} 
+////    }
+////}
+////
+////
+////module nestedModules {
+////    module Foo2 {
+////{| "indent": 4 |} 
+////        function f() {
+////        }
+////{| "indent": 8 |} 
+////        var x: number;
+////{| "indent": 8 |} 
+////    }
+////}
+////
+////
+////module Enums {
+////    enum Foo3 {
+////{| "indent": 4 |} 
+////        val1,
+////{| "indent": 8 |} 
+////        val2,
+////{| "indent": 8 |} 
+////    }
+////{| "indent": 4 |} 
+////}
+////
+////
+////function controlStatements() {
+////    for (var i = 0; i < 10; i++) {
+////{| "indent": 4 |} 
+////    }
+////
+////    for (var e in foo.bar) {
+////{| "indent": 4 |} 
+////    }
+////
+////    with (foo.bar) {
+////{| "indent": 4 |} 
+////    }
+////
+////    while (false) {
+////{| "indent": 4 |} 
+////    }
+////
+////    do {
+////{| "indent": 4 |} 
+////    } while (false);
+////
+////    switch (foo.bar) {
+////{| "indent": 4 |} 
+////    }
+////
+////    switch (foo.bar) {
+////{| "indent": 4 |} 
+////        case 1:
+////{| "indent": 8 |} 
+////            break;
+////        default:
+////{| "indent": 8 |} 
+////            break;
+////    }
+////}
+////
+////
+////function tryCatch() {
+////{| "indent": 0 |} 
+////    try {
+////{| "indent": 4 |} 
+////    }
+////{| "indent": 4 |} 
+////    catch (err) {
+////{| "indent": 4 |} 
+////    }
+////{| "indent": 4 |} 
+////}
+////
+////
+////function tryFinally() {
+////{| "indent": 0 |} 
+////    try {
+////{| "indent": 4 |} 
+////    }
+////{| "indent": 4 |} 
+////    finally {
+////{| "indent": 4 |} 
+////    }
+////{| "indent": 4 |} 
+////}
+////
+////
+////function tryCatchFinally() {
+////{| "indent": 0 |} 
+////    try {
+////{| "indent": 4 |} 
+////    }
+////{| "indent": 4 |} 
+////    catch (err) {
+////{| "indent": 4 |} 
+////    }
+////{| "indent": 4 |} 
+////    finally {
+////{| "indent": 4 |} 
+////    }
+////{| "indent": 4 |} 
+////}
+////
+////
+////class indentBeforeCurly 
+////{| "indent": 0 |} 
+////{| "indent": 0 |}{
+////{| "indent": 0 |} 
+////}
+////
+////
+////function argumentsListIndentation(bar,
+////             blah,
+////             {| "indent": 13 |} 
+////);
+////
+////
+////function blockIndentAfterIndentedParameter1(bar,
+////             blah) {
+////{| "indent": 13 |} 
+////}
+////
+////
+////function blockIndentAfterIndentedParameter2(bar,
+////             blah) {
+////    if (foo) {
+////{| "indent": 4 |} 
+////    }
+////}
+////
+////
+////// Note: Do not add more tests at the end of this file, as
+//////       the purpose of this test is to verity smart indent
+//////       works for unterminated function arguments at the end of a file.
+////function unterminatedListIndentation(a,
+////{| "indent": 0 |}
+
+test.markers().forEach(marker => {
+    verify.indentationAtPositionIs(marker.fileName, marker.position, marker.data.indent, IndentStyle.Block);
+});
diff --git a/tests/cases/fourslash/indentationNone.ts b/tests/cases/fourslash/indentationNone.ts
new file mode 100644
index 00000000000..078f5ab35f6
--- /dev/null
+++ b/tests/cases/fourslash/indentationNone.ts
@@ -0,0 +1,183 @@
+/// <reference path="fourslash.ts"/>
+
+////
+////module classes {
+////{| "indent": 0 |} 
+////    class Bar {
+////{| "indent": 0 |} 
+////
+////        constructor() {
+////{| "indent": 0 |} 
+////        }
+////
+////        private foo: string = "";
+////{| "indent": 0 |} 
+////
+////        private f() {
+////            var a: any[] = [[1, 2], [3, 4], 5];
+////{| "indent": 0 |} 
+////            return ((1 + 1));
+////        }
+////
+////{| "indent": 0 |} 
+////        private f2() {
+////            if (true) { } { };
+////        }
+////    }
+////}
+////
+////
+////module interfaces {
+////{| "indent": 0 |} 
+////    interface Foo {
+////{| "indent": 0 |} 
+////
+////        x: number;
+////{| "indent": 0 |} 
+////
+////        foo(): number;
+////{| "indent": 0 |} 
+////    }
+////}
+////
+////
+////module nestedModules {
+////    module Foo2 {
+////{| "indent": 0 |} 
+////        function f() {
+////        }
+////{| "indent": 0 |} 
+////        var x: number;
+////{| "indent": 0 |} 
+////    }
+////}
+////
+////
+////module Enums {
+////    enum Foo3 {
+////{| "indent": 0 |} 
+////        val1,
+////{| "indent": 0 |} 
+////        val2,
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////}
+////
+////
+////function controlStatements() {
+////    for (var i = 0; i < 10; i++) {
+////{| "indent": 0 |} 
+////    }
+////
+////    for (var e in foo.bar) {
+////{| "indent": 0 |} 
+////    }
+////
+////    with (foo.bar) {
+////{| "indent": 0 |} 
+////    }
+////
+////    while (false) {
+////{| "indent": 0 |} 
+////    }
+////
+////    do {
+////{| "indent": 0 |} 
+////    } while (false);
+////
+////    switch (foo.bar) {
+////{| "indent": 0 |} 
+////    }
+////
+////    switch (foo.bar) {
+////{| "indent": 0 |} 
+////        case 1:
+////{| "indent": 0 |} 
+////            break;
+////        default:
+////{| "indent": 0 |} 
+////            break;
+////    }
+////}
+////
+////
+////function tryCatch() {
+////{| "indent": 0 |} 
+////    try {
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////    catch (err) {
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////}
+////
+////
+////function tryFinally() {
+////{| "indent": 0 |} 
+////    try {
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////    finally {
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////}
+////
+////
+////function tryCatchFinally() {
+////{| "indent": 0 |} 
+////    try {
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////    catch (err) {
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////    finally {
+////{| "indent": 0 |} 
+////    }
+////{| "indent": 0 |} 
+////}
+////
+////
+////class indentBeforeCurly 
+////{| "indent": 0 |} 
+////{| "indent": 0 |}{
+////{| "indent": 0 |} 
+////}
+////
+////
+////function argumentsListIndentation(bar,
+////             blah,
+////             {| "indent": 0 |} 
+////);
+////
+////
+////function blockIndentAfterIndentedParameter1(bar,
+////             blah) {
+////{| "indent": 0 |} 
+////}
+////
+////
+////function blockIndentAfterIndentedParameter2(bar,
+////             blah) {
+////    if (foo) {
+////{| "indent": 0 |} 
+////    }
+////}
+////
+////
+////// Note: Do not add more tests at the end of this file, as
+//////       the purpose of this test is to verity smart indent
+//////       works for unterminated function arguments at the end of a file.
+////function unterminatedListIndentation(a,
+////{| "indent": 0 |}
+
+test.markers().forEach(marker => {
+    verify.indentationAtPositionIs(marker.fileName, marker.position, marker.data.indent, IndentStyle.None);
+});
diff --git a/tests/cases/fourslash/tsxCompletion10.ts b/tests/cases/fourslash/tsxCompletion10.ts
new file mode 100644
index 00000000000..f10e014c282
--- /dev/null
+++ b/tests/cases/fourslash/tsxCompletion10.ts
@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+//@Filename: file.tsx
+//// declare module JSX {
+////     interface Element { }
+////     interface IntrinsicElements {
+////         div: { ONE: string; TWO: number; }
+////     }
+//// }
+//// var x1 = <div><//**/
+
+goTo.marker();
+verify.memberListCount(1);
+verify.completionListContains('div');
diff --git a/tests/cases/fourslash/tsxCompletion9.ts b/tests/cases/fourslash/tsxCompletion9.ts
new file mode 100644
index 00000000000..12542cc6b5b
--- /dev/null
+++ b/tests/cases/fourslash/tsxCompletion9.ts
@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+//@Filename: file.tsx
+//// declare module JSX {
+////     interface Element { }
+////     interface IntrinsicElements {
+////         div: { ONE: string; TWO: number; }
+////     }
+//// }
+//// var x1 = <div> /*1*/ hello /*2*/ world /*3*/</div>;
+//// var x2 = <div> /*4*/ <div></div> /*5*/ world /*6*/</div>;
+//// var x3 = <div>/*7*/<div/>/*8*/world/*9*/</div>;
+//// var x4 = <div>/*10*/</div>;
+//// <div/>
+//// /*end*/
+//// 
+
+for (var i = 1; i <= 10; i++) {
+	goTo.marker(i + '');
+	verify.completionListIsEmpty();
+}
+
+goTo.marker('end');
+verify.not.completionListIsEmpty();
diff --git a/tests/cases/unittests/cachingInServerLSHost.ts b/tests/cases/unittests/cachingInServerLSHost.ts
index ff2da76ba4f..88b44a693b9 100644
--- a/tests/cases/unittests/cachingInServerLSHost.ts
+++ b/tests/cases/unittests/cachingInServerLSHost.ts
@@ -45,6 +45,11 @@ module ts {
                 return {
                     close: () => { }
                 }
+            },
+            watchDirectory: (path, callback, recursive?) => {
+                return {
+                    close: () => { }
+                }
             }
         };
     }
diff --git a/tests/cases/unittests/moduleResolution.ts b/tests/cases/unittests/moduleResolution.ts
index 809782bae6f..b5c2c70e491 100644
--- a/tests/cases/unittests/moduleResolution.ts
+++ b/tests/cases/unittests/moduleResolution.ts
@@ -114,23 +114,22 @@ module ts {
             let containingFile = { name: "/a/b/c/d/e.ts" };
             let moduleFile = { name: "/a/b/node_modules/foo.ts" };
             let resolution = nodeModuleNameResolver("foo", containingFile.name, createModuleResolutionHost(containingFile, moduleFile));
-            assert.equal(resolution.resolvedModule, undefined);
+            assert.equal(resolution.resolvedModule.resolvedFileName, moduleFile.name);
             assert.deepEqual(resolution.failedLookupLocations, [
+                "/a/b/c/d/node_modules/foo.ts",
+                "/a/b/c/d/node_modules/foo.tsx",
                 "/a/b/c/d/node_modules/foo.d.ts",
                 "/a/b/c/d/node_modules/foo/package.json",
+                "/a/b/c/d/node_modules/foo/index.ts",
+                "/a/b/c/d/node_modules/foo/index.tsx",
                 "/a/b/c/d/node_modules/foo/index.d.ts",
+                "/a/b/c/node_modules/foo.ts",
+                "/a/b/c/node_modules/foo.tsx",
                 "/a/b/c/node_modules/foo.d.ts",
                 "/a/b/c/node_modules/foo/package.json",
-                "/a/b/c/node_modules/foo/index.d.ts",
-                "/a/b/node_modules/foo.d.ts",
-                "/a/b/node_modules/foo/package.json",
-                "/a/b/node_modules/foo/index.d.ts",
-                "/a/node_modules/foo.d.ts",
-                "/a/node_modules/foo/package.json",
-                "/a/node_modules/foo/index.d.ts",
-                "/node_modules/foo.d.ts",
-                "/node_modules/foo/package.json",
-                "/node_modules/foo/index.d.ts"
+                "/a/b/c/node_modules/foo/index.ts",
+                "/a/b/c/node_modules/foo/index.tsx",
+                "/a/b/c/node_modules/foo/index.d.ts"
             ])
         });
 
@@ -149,17 +148,33 @@ module ts {
             assert.equal(resolution.resolvedModule.resolvedFileName, moduleFile.name);
             assert.equal(resolution.resolvedModule.isExternalLibraryImport, true);
             assert.deepEqual(resolution.failedLookupLocations, [
+                "/a/node_modules/b/c/node_modules/d/node_modules/foo.ts",
+                "/a/node_modules/b/c/node_modules/d/node_modules/foo.tsx",
                 "/a/node_modules/b/c/node_modules/d/node_modules/foo.d.ts",
                 "/a/node_modules/b/c/node_modules/d/node_modules/foo/package.json",
+                "/a/node_modules/b/c/node_modules/d/node_modules/foo/index.ts",
+                "/a/node_modules/b/c/node_modules/d/node_modules/foo/index.tsx",
                 "/a/node_modules/b/c/node_modules/d/node_modules/foo/index.d.ts",
+                "/a/node_modules/b/c/node_modules/foo.ts",
+                "/a/node_modules/b/c/node_modules/foo.tsx",
                 "/a/node_modules/b/c/node_modules/foo.d.ts",
                 "/a/node_modules/b/c/node_modules/foo/package.json",
+                "/a/node_modules/b/c/node_modules/foo/index.ts",
+                "/a/node_modules/b/c/node_modules/foo/index.tsx",
                 "/a/node_modules/b/c/node_modules/foo/index.d.ts",
+                "/a/node_modules/b/node_modules/foo.ts",
+                "/a/node_modules/b/node_modules/foo.tsx",
                 "/a/node_modules/b/node_modules/foo.d.ts",
                 "/a/node_modules/b/node_modules/foo/package.json",
+                "/a/node_modules/b/node_modules/foo/index.ts",
+                "/a/node_modules/b/node_modules/foo/index.tsx",
                 "/a/node_modules/b/node_modules/foo/index.d.ts",
+                "/a/node_modules/foo.ts",
+                "/a/node_modules/foo.tsx",
                 "/a/node_modules/foo.d.ts",
-                "/a/node_modules/foo/package.json"
+                "/a/node_modules/foo/package.json",
+                "/a/node_modules/foo/index.ts",
+                "/a/node_modules/foo/index.tsx"
             ]);
         });
     });
diff --git a/tests/cases/unittests/transpile.ts b/tests/cases/unittests/transpile.ts
index ca7d1faa4a9..1d688f091a4 100644
--- a/tests/cases/unittests/transpile.ts
+++ b/tests/cases/unittests/transpile.ts
@@ -43,7 +43,7 @@ module ts {
             }
             
             if (canUseOldTranspile) {
-                let diagnostics: Diagnostic[] = [];                
+                let diagnostics: Diagnostic[] = [];
                 let transpileResult = transpile(input, transpileOptions.compilerOptions, transpileOptions.fileName, diagnostics, transpileOptions.moduleName);                
                 checkDiagnostics(diagnostics, testSettings.expectedDiagnosticCodes);
                 if (testSettings.expectedOutput) {
@@ -57,10 +57,10 @@ module ts {
             }
             
             if (!transpileOptions.fileName) {
-                transpileOptions.fileName = "file.ts";
+                transpileOptions.fileName = transpileOptions.compilerOptions.jsx ? "file.tsx" : "file.ts";
             }
             
-            transpileOptions.compilerOptions.sourceMap = true;            
+            transpileOptions.compilerOptions.sourceMap = true;
             let transpileModuleResultWithSourceMap = transpileModule(input, transpileOptions);
             assert.isTrue(transpileModuleResultWithSourceMap.sourceMapText !== undefined);
             
@@ -68,7 +68,7 @@ module ts {
             let expectedSourceMappingUrlLine = `//# sourceMappingURL=${expectedSourceMapFileName}`;
                         
             if (testSettings.expectedOutput !== undefined) {
-                assert.equal(transpileModuleResultWithSourceMap.outputText, testSettings.expectedOutput + expectedSourceMappingUrlLine);    
+                assert.equal(transpileModuleResultWithSourceMap.outputText, testSettings.expectedOutput + expectedSourceMappingUrlLine);
             }
             else {
                 // expected output is not set, just verify that output text has sourceMappingURL as a last line
@@ -78,7 +78,7 @@ module ts {
                     assert.equal(output, expectedSourceMappingUrlLine);
                 }
                 else {
-                    let suffix = getNewLineCharacter(transpileOptions.compilerOptions) + expectedSourceMappingUrlLine                                
+                    let suffix = getNewLineCharacter(transpileOptions.compilerOptions) + expectedSourceMappingUrlLine
                     assert.isTrue(output.indexOf(suffix, output.length - suffix.length) !== -1);
                 }
             }       
@@ -274,5 +274,14 @@ var x = 0;`,
         it("Supports backslashes in file name", () => {
             test("var x", { expectedOutput: "var x;\r\n", options: { fileName: "a\\b.ts" }});
         });
+        
+        it("transpile file as 'tsx' if 'jsx' is specified", () => {
+            let input = `var x = <div/>`;
+            let output = `var x = React.createElement("div", null);\n`;
+            test(input, {
+                expectedOutput: output,
+                options: { compilerOptions: { jsx: JsxEmit.React, newLine: NewLineKind.LineFeed } }
+            })
+        });
     });
 }