diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 13f527bd9f..3532c778dd 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -102,7 +102,7 @@ module ts {
         let globalArraySymbol: Symbol;
         let globalESSymbolConstructorSymbol: Symbol;
         
-        let getGlobalPromiseSymbol: () => Symbol;
+        let getGlobalPromiseConstructorSymbol: () => Symbol;
 
         let globalObjectType: ObjectType;
         let globalFunctionType: ObjectType;
@@ -139,7 +139,6 @@ module ts {
         let symbolLinks: SymbolLinks[] = [];
         let nodeLinks: NodeLinks[] = [];
         let potentialThisCollisions: Node[] = [];
-        var potentialArgumentsCollisions: Node[] = [];
 
         let diagnostics = createDiagnosticCollection();
 
@@ -5420,11 +5419,13 @@ module ts {
             // can explicitly bound arguments objects
             let container = getContainingFunction(node);
             if (symbol === argumentsSymbol) {
-                if (container.kind === SyntaxKind.ArrowFunction && languageVersion < ScriptTarget.ES6) {
-                    error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
-                }
-                else if (node.parserContextFlags & ParserContextFlags.Await) {
-                    captureLexicalArguments(node, container);
+                if (container.kind === SyntaxKind.ArrowFunction) {
+                    if (languageVersion < ScriptTarget.ES6) {
+                        error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
+                    }
+                    else if (node.parserContextFlags & ParserContextFlags.Await) {
+                        error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression);
+                    }
                 }
             }
 
@@ -5434,7 +5435,6 @@ module ts {
 
             checkCollisionWithCapturedSuperVariable(node, node);
             checkCollisionWithCapturedThisVariable(node, node);
-            checkCollisionWithCapturedArgumentsVariable(node, node);            
             checkBlockScopedBindingCapturedInLoop(node, symbol);
 
             return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node);
@@ -5516,10 +5516,9 @@ module ts {
                 // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code
                 needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6);
             }
-            
-            if (node.parserContextFlags & ParserContextFlags.Await) {
+            else if (node.parserContextFlags & ParserContextFlags.Await) {
                 // if 'this' is part of an async function, we will need to capture 'this'
-                needToCaptureLexicalThis = true;
+                needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES6);
             }
 
             switch (container.kind) {
@@ -5561,14 +5560,6 @@ module ts {
             return anyType;
         }
 
-        function captureLexicalArguments(node: Node, container: Node): void {
-            if (node.parent.kind !== SyntaxKind.Parameter) {
-                getNodeLinks(node).flags |= NodeCheckFlags.LexicalArguments;
-            }
-            
-            getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments;
-        }
-
         function isInConstructorArgumentInitializer(node: Node, constructorDecl: Node): boolean {
             for (let n = node; n && n !== constructorDecl; n = n.parent) {
                 if (n.kind === SyntaxKind.Parameter) {
@@ -7303,7 +7294,7 @@ module ts {
             let widenedType = getWidenedType(type);
             return isAsync
                 ? createPromiseType(widenedType, func)
-                : type;
+                : widenedType;
         }
 
         /// Returns a set of types relating to every return expression relating to a function block.
@@ -7421,7 +7412,6 @@ module ts {
             if (produceDiagnostics && node.kind !== SyntaxKind.MethodDeclaration && node.kind !== SyntaxKind.MethodSignature) {
                 checkCollisionWithCapturedSuperVariable(node, (<FunctionExpression>node).name);
                 checkCollisionWithCapturedThisVariable(node, (<FunctionExpression>node).name);
-                checkCollisionWithCapturedArgumentsVariable(node, (<FunctionExpression>node).name);
             }
 
             return type;
@@ -7574,13 +7564,7 @@ module ts {
         function checkAwaitExpression(node: AwaitExpression): Type {
             // Grammar checking
             if (!(node.parserContextFlags & ParserContextFlags.Await)) {
-                var parameter = getContainingParameter(node);
-                if (parameter && parameter.parserContextFlags & ParserContextFlags.Await) {
-                    grammarErrorAfterFirstToken(node, Diagnostics._0_expression_is_not_allowed_in_an_initializer, "await");
-                }
-                else {
-                    grammarErrorOnFirstToken(node, Diagnostics.await_expression_must_be_contained_within_an_async_function);
-                }
+                grammarErrorOnFirstToken(node, Diagnostics.await_expression_must_be_contained_within_an_async_function);
             }
 
             var operandType = checkExpression(node.expression);
@@ -7994,13 +7978,7 @@ module ts {
         function checkYieldExpression(node: YieldExpression): void {
             // Grammar checking
             if (!(node.parserContextFlags & ParserContextFlags.Yield)) {
-                let parameter = getContainingParameter(node);
-                if (parameter && (parameter.parserContextFlags & ParserContextFlags.GeneratorParameter)) {
-                    grammarErrorAfterFirstToken(node, Diagnostics._0_expression_is_not_allowed_in_an_initializer, "yield");
-                }
-                else {
-                    grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration);
-                }
+                grammarErrorOnFirstToken(node, Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration);
             }
             else {
                 grammarErrorOnFirstToken(node, Diagnostics.yield_expressions_are_not_currently_supported);
@@ -8907,23 +8885,25 @@ module ts {
             // the "promised type" of a type is the type of the "value" argument of the "onfulfilled" callback.
             let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType();
             if (globalPromiseLikeType !== emptyObjectType && isTypeAssignableTo(type, globalPromiseLikeType)) {
-                let awaitedTypes: Type[] = [];
                 let thenProp = getPropertyOfType(type, "then");
-                let thenType = getTypeOfSymbol(thenProp);
-                let thenSignatures = getSignaturesOfType(thenType, SignatureKind.Call);
-                for (let thenSignature of thenSignatures) {
-                    thenSignature = getErasedSignature(thenSignature);
-                    let onfulfilledParameterType = getTypeAtPosition(thenSignature, 0);
-                    let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call);
-                    for (let onfulfilledParameterSignature of onfulfilledParameterSignatures) {
-                        let valueParameterType = getTypeAtPosition(onfulfilledParameterSignature, 0);
-                        if (valueParameterType !== type) {
-                            awaitedTypes.push(valueParameterType);
+                if (thenProp) {
+                    let awaitedTypes: Type[] = [];
+                    let thenType = getTypeOfSymbol(thenProp);
+                    let thenSignatures = getSignaturesOfType(thenType, SignatureKind.Call);
+                    for (let thenSignature of thenSignatures) {
+                        thenSignature = getErasedSignature(thenSignature);
+                        let onfulfilledParameterType = getTypeAtPosition(thenSignature, 0);
+                        let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call);
+                        for (let onfulfilledParameterSignature of onfulfilledParameterSignatures) {
+                            let valueParameterType = getTypeAtPosition(onfulfilledParameterSignature, 0);
+                            if (valueParameterType !== type) {
+                                awaitedTypes.push(valueParameterType);
+                            }
                         }
                     }
-                }
-                
-                return getUnionType(awaitedTypes);
+
+                    return getUnionType(awaitedTypes);
+                }                
             }
             
             return emptyObjectType;
@@ -9142,7 +9122,6 @@ module ts {
 
                 checkCollisionWithCapturedSuperVariable(node, node.name);
                 checkCollisionWithCapturedThisVariable(node, node.name);
-                checkCollisionWithCapturedArgumentsVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
             }
         }
@@ -9262,12 +9241,6 @@ module ts {
             }
         }
 
-        function checkCollisionWithCapturedArgumentsVariable(node: Node, name: Identifier): void {
-            if (needCollisionCheckForIdentifier(node, name, "_arguments")) {
-                potentialArgumentsCollisions.push(node);
-            }
-        }
-        
         // this function will run after checking the source file so 'CaptureThis' is correct for all nodes
         function checkIfThisIsCapturedInEnclosingScope(node: Node): void {
             let current = node;
@@ -9286,25 +9259,6 @@ module ts {
             }
         }
 
-        function checkIfArgumentsIsCapturedInEnclosingScope(node: Node): void {
-            let current = node;
-            while (current) {
-                if (getNodeCheckFlags(current) & NodeCheckFlags.CaptureArguments) {
-                    let isDeclaration = node.kind !== SyntaxKind.Identifier;
-                    if (isDeclaration) {
-                        error((<Declaration>node).name, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_variable_declaration_arguments_to_capture_arguments_reference);
-                    }
-                    else {
-                        error(node, Diagnostics.Expression_resolves_to_variable_declaration_arguments_that_compiler_uses_to_capture_arguments_reference);
-                    }
-                    
-                    return;
-                }
-                
-                current = current.parent;
-            }
-        }
-        
         function checkCollisionWithCapturedSuperVariable(node: Node, name: Identifier) {
             if (!needCollisionCheckForIdentifier(node, name, "_super")) {
                 return;
@@ -9421,15 +9375,17 @@ module ts {
         }
 
         function getPromiseConstructor(node: SignatureDeclaration): EntityName {
-            if (node.type && node.type.kind === SyntaxKind.TypeReference) {
-                return (<TypeReferenceNode>node.type).typeName;
+            if (isAsyncFunctionLike(node)) {
+                let links = getNodeLinks(node);
+                if (!links.promiseConstructor) {
+                    if (node.type && node.type.kind === SyntaxKind.TypeReference) {
+                        links.promiseConstructor = (<TypeReferenceNode>node.type).typeName;
+                    }
+                }
+
+                return links.promiseConstructor;
             }
-            
-            let globalPromiseSymbol = getGlobalPromiseSymbol();
-            if (globalPromiseSymbol && globalPromiseSymbol === resolveName(node, "Promise", SymbolFlags.Value, undefined, undefined)) {
-                return <Identifier>globalPromiseSymbol.valueDeclaration.name;
-            }
-            
+
             return undefined;
         }
 
@@ -9550,14 +9506,8 @@ module ts {
                 }
                 checkCollisionWithCapturedSuperVariable(node, <Identifier>node.name);
                 checkCollisionWithCapturedThisVariable(node, <Identifier>node.name);
-                checkCollisionWithCapturedArgumentsVariable(node, <Identifier>node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, <Identifier>node.name);
             }
-            
-            if (symbol === argumentsSymbol && (node.parserContextFlags & ParserContextFlags.Await)) {
-                let container = getContainingFunction(node);
-                captureLexicalArguments(node.name, container);
-            }
         }
 
         function checkVariableDeclaration(node: VariableDeclaration) {
@@ -11258,7 +11208,6 @@ module ts {
                 emitDecorate = false;
                 emitParam = false;
                 potentialThisCollisions.length = 0;
-                potentialArgumentsCollisions.length = 0;
 
                 forEach(node.statements, checkSourceElement);
                 checkFunctionExpressionBodies(node);
@@ -11272,11 +11221,6 @@ module ts {
                     potentialThisCollisions.length = 0;
                 }
                 
-                if (potentialArgumentsCollisions.length) {
-                    forEach(potentialArgumentsCollisions, checkIfArgumentsIsCapturedInEnclosingScope);
-                    potentialArgumentsCollisions.length = 0;
-                }
-
                 if (emitExtends) {
                     links.flags |= NodeCheckFlags.EmitExtends;
                 }
@@ -12279,6 +12223,7 @@ module ts {
                 serializeTypeOfNode,
                 serializeParameterTypesOfNode,
                 serializeReturnTypeOfNode,
+                getPromiseConstructor,
             };
         }
 
@@ -12313,10 +12258,10 @@ module ts {
             getGlobalPropertyDecoratorType = memoize(() => getGlobalType("PropertyDecorator"));
             getGlobalMethodDecoratorType = memoize(() => getGlobalType("MethodDecorator"));
             getGlobalParameterDecoratorType = memoize(() => getGlobalType("ParameterDecorator"));
-            getGlobalPromiseSymbol = memoize(() => getGlobalTypeSymbol("Promise"));
-            getGlobalPromiseType = memoize(() => getTypeOfGlobalSymbol(getGlobalPromiseSymbol(), /*arity*/ 1));
+            getGlobalPromiseType = memoize(() => getGlobalType("Promise", /*arity*/ 1));
             getGlobalPromiseLikeType = memoize(() => getGlobalType("PromiseLike", /*arity*/ 1));
             getInstantiatedGlobalPromiseLikeType = memoize(createInstantiatedPromiseLikeType);
+            getGlobalPromiseConstructorSymbol = memoize(() => getGlobalValueSymbol("Promise"));
             getGlobalPromiseConstructorLikeType = memoize(() => getGlobalType("PromiseConstructorLike"));
             getGlobalThenableType = memoize(createThenableType);
 
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index 091cabb448..39492ac534 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -383,8 +383,7 @@ module ts {
         A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." },
         Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." },
         Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." },
-        Duplicate_identifier_arguments_Compiler_uses_variable_declaration_arguments_to_capture_arguments_reference: { code: 2522, category: DiagnosticCategory.Error, key: "Duplicate identifier '_arguments'. Compiler uses variable declaration '_arguments' to capture 'arguments' reference." },
-        Expression_resolves_to_variable_declaration_arguments_that_compiler_uses_to_capture_arguments_reference: { code: 2523, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '_arguments' that compiler uses to capture 'arguments' reference." },
+        The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression." },
         Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 431aec3f53..874c259a3b 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1522,14 +1522,10 @@
         "category": "Error",
         "code": 2521
     },
-    "Duplicate identifier '_arguments'. Compiler uses variable declaration '_arguments' to capture 'arguments' reference.": {
+    "The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression.": {
         "category": "Error",
         "code": 2522
     },
-    "Expression resolves to variable declaration '_arguments' that compiler uses to capture 'arguments' reference.": {
-        "category": "Error",
-        "code": 2523
-    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 5a9a654ce6..e31989e672 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -48,6 +48,21 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };`;
 
+        const awaiterHelper = `
+var __awaiter = (this && this.__awaiter) || function (generator, ctor) {
+    function resolve(value) { return step(generator.next(value)); }
+    function reject(reason) { return step(generator["throw"](reason)); }
+    function step(result) {
+        while (true) {
+            var done = result.done, value = result.value, then;
+            if (done) return value;
+            if (value && typeof (then = value.then) === "function") return then.call(value, resolve, reject);
+            result = generator.next(value);
+        }
+    }
+    return new (ctor || Promise)(function (resolver) { resolver(resolve(undefined)); });
+}`;
+
         let compilerOptions = host.getCompilerOptions();
         let languageVersion = compilerOptions.target || ScriptTarget.ES3;
         let sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
@@ -131,6 +146,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
             let extendsEmitted = false;
             let decorateEmitted = false;
             let paramEmitted = false;
+            let awaiterEmitted = false;
             let tempFlags = 0;
             let tempVariables: Identifier[];
             let tempParameters: Identifier[];
@@ -1350,6 +1366,31 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                     emit(node.expression);
                 }
             }
+            
+            function emitAwaitExpression(node: AwaitExpression) {
+                let needsParenthesis = needsParenthesisForAwaitExpressionAsYield(node);
+                if (needsParenthesis) {
+                    write("(");
+                }
+                write(tokenToString(SyntaxKind.YieldKeyword));
+                write(" ");
+                emit(node.expression);
+                if (needsParenthesis) {
+                    write(")");
+                }
+            }
+
+            function needsParenthesisForAwaitExpressionAsYield(node: AwaitExpression) {
+                for (let current: Node = node; isExpression(current.parent); current = current.parent) {
+                    if (current.parent.kind === SyntaxKind.BinaryExpression) {
+                        if ((<BinaryExpression>current.parent).left === current) {
+                            return true;
+                        }
+                    }
+                }
+                
+                return false;
+            }
 
             function needsParenthesisForPropertyAccessOrInvocation(node: Expression) {
                 switch (node.kind) {
@@ -3280,9 +3321,71 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                     emit(node.parameters[0]);
                     return;
                 }
+                
                 emitSignatureParameters(node);
             }
 
+            function emitAsyncSignatureAndBodyForES6(node: FunctionLikeDeclaration) {                
+                let promiseConstructor = resolver.getPromiseConstructor(node);
+                let resolve = makeUniqueName("resolve");
+                let isArrowFunction = node.kind === SyntaxKind.ArrowFunction;
+                let args: string;
+                if (isArrowFunction) {
+                    if (node.parameters.length) {
+                        args = makeUniqueName("arguments");
+                        write(`(...${args}) => `);
+                    }
+                    else {
+                        write("() => ");
+                    }
+                }
+                else {
+                    args = "arguments";
+                    write("() {");
+                    increaseIndent();
+                    writeLine();
+                    write("return ");
+                }
+                
+                write("__awaiter(function *");
+                
+                emitSignatureParameters(node);
+                emitFunctionBody(node);
+                write(".apply(this");
+                if (args) {
+                    write(`, ${args}`);
+                }
+                write(")");
+                if (promiseConstructor) {
+                    write(", ");
+                    emit(promiseConstructor);
+                }
+                write(")");
+                
+                if (!isArrowFunction) {
+                    write(";");
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                }    
+            }
+                        
+            function emitFunctionBody(node: FunctionLikeDeclaration) {
+                if (!node.body) {
+                    // There can be no body when there are parse errors.  Just emit an empty block 
+                    // in that case.
+                    write(" { }");
+                }
+                else {
+                    if (node.body.kind === SyntaxKind.Block) {
+                        emitBlockFunctionBody(node, <Block>node.body);
+                    }
+                    else {
+                        emitExpressionFunctionBody(node, <Expression>node.body);
+                    }
+                }            
+            }
+
             function emitSignatureAndBody(node: FunctionLikeDeclaration) {
                 let saveTempFlags = tempFlags;
                 let saveTempVariables = tempVariables;
@@ -3291,27 +3394,23 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                 tempVariables = undefined;
                 tempParameters = undefined;
 
-                // When targeting ES6, emit arrow function natively in ES6
-                if (shouldEmitAsArrowFunction(node)) {
-                    emitSignatureParametersForArrow(node);
-                    write(" =>");
+                let isAsync = isAsyncFunctionLike(node);
+                if (isAsync && languageVersion === ScriptTarget.ES6) {
+                    emitAsyncSignatureAndBodyForES6(node);
                 }
                 else {
-                    emitSignatureParameters(node);
+                    // When targeting ES6, emit arrow function natively in ES6
+                    if (shouldEmitAsArrowFunction(node)) {
+                        emitSignatureParametersForArrow(node);
+                        write(" =>");
+                    }
+                    else {
+                        emitSignatureParameters(node);
+                    }
+                    
+                    emitFunctionBody(node);
                 }
-
-                if (!node.body) {
-                    // There can be no body when there are parse errors.  Just emit an empty block 
-                    // in that case.
-                    write(" { }");
-                }
-                else if (node.body.kind === SyntaxKind.Block) {
-                    emitBlockFunctionBody(node, <Block>node.body);
-                }
-                else {
-                    emitExpressionFunctionBody(node, <Expression>node.body);
-                }
-
+                
                 if (!isES6ExportedDeclaration(node)) {
                     emitExportMemberAssignment(node);
                 }
@@ -3329,7 +3428,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
             }
 
             function emitExpressionFunctionBody(node: FunctionLikeDeclaration, body: Expression) {
-                if (languageVersion < ScriptTarget.ES6) {
+                if (languageVersion < ScriptTarget.ES6 || node.flags & NodeFlags.Async) {
                     emitDownLevelExpressionFunctionBody(node, body);
                     return;
                 }
@@ -5636,6 +5735,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                         writeLines(paramHelper);
                         paramEmitted = true;
                     }
+                    
+                    if (!awaiterEmitted && resolver.getNodeCheckFlags(node) & NodeCheckFlags.EmitAwaiter) {
+                        writeLines(awaiterHelper);
+                        awaiterEmitted = true;
+                    }
                 }
 
                 if (isExternalModule(node) || compilerOptions.separateCompilation) {
@@ -5806,6 +5910,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
                         return emitTypeOfExpression(<TypeOfExpression>node);
                     case SyntaxKind.VoidExpression:
                         return emitVoidExpression(<VoidExpression>node);
+                    case SyntaxKind.AwaitExpression:
+                        return emitAwaitExpression(<AwaitExpression>node);
                     case SyntaxKind.PrefixUnaryExpression:
                         return emitPrefixUnaryExpression(<PrefixUnaryExpression>node);
                     case SyntaxKind.PostfixUnaryExpression:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index db95808717..a22ec28ecb 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -568,11 +568,11 @@ module ts {
         }
         
         function doOutsideOfContext<T>(context: ParserContextFlags, func: () => T): T {
-            let currentContextFlags = contextFlags & context;
-            if (currentContextFlags) {
-                setContextFlag(false, currentContextFlags);
+            let setContextFlags = context & contextFlags;
+            if (setContextFlags) {
+                setContextFlag(false, setContextFlags);
                 let result = func();
-                setContextFlag(true, currentContextFlags);
+                setContextFlag(true, setContextFlags);
                 return result;
             }
 
@@ -582,7 +582,7 @@ module ts {
         
         function doInsideOfContext<T>(context: ParserContextFlags, func: () => T): T {
             let unsetContextFlags = context & ~contextFlags;
-            if (!unsetContextFlags) {
+            if (unsetContextFlags) {
                 setContextFlag(true, unsetContextFlags);
                 let result = func();
                 setContextFlag(false, unsetContextFlags);
@@ -594,11 +594,11 @@ module ts {
         }
 
         function allowInAnd<T>(func: () => T): T {
-            return doInsideOfContext(ParserContextFlags.DisallowIn, func);
+            return doOutsideOfContext(ParserContextFlags.DisallowIn, func);
         }
 
         function disallowInAnd<T>(func: () => T): T {
-            return doOutsideOfContext(ParserContextFlags.DisallowIn, func);
+            return doInsideOfContext(ParserContextFlags.DisallowIn, func);
         }
         
         function doInYieldContext<T>(func: () => T): T {
@@ -772,6 +772,12 @@ module ts {
             if (token === SyntaxKind.YieldKeyword && inYieldContext()) {
                 return false;
             }
+            
+            // If we have a 'await' keyword, and we're in the [Await] context, then 'await' is
+            // considered a keyword and is not an identifier.
+            if (token === SyntaxKind.AwaitKeyword && inAwaitContext()) {
+                return false;
+            }
 
             return token > SyntaxKind.LastReservedWord;
         }
@@ -2642,12 +2648,11 @@ module ts {
 
         function tryParseParenthesizedArrowFunctionExpression(): Expression {
             let triState = isParenthesizedArrowFunctionExpression();
-
             if (triState === Tristate.False) {
                 // It's definitely not a parenthesized arrow function expression.
                 return undefined;
             }
-
+            
             // If we definitely have an arrow function, then we can just parse one, not requiring a
             // following => or { token. Otherwise, we *might* have an arrow function.  Try to parse
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index b23b46bc9b..f256c63056 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1304,6 +1304,7 @@ module ts {
         serializeTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[];
         serializeParameterTypesOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): (string | string[])[];
         serializeReturnTypeOfNode(node: Node, getGeneratedNameForNode: (Node: Node) => string): string | string[];
+        getPromiseConstructor(node: SignatureDeclaration): EntityName;
     }
 
     export const enum SymbolFlags {
@@ -1423,22 +1424,20 @@ module ts {
         TypeChecked                 = 0x00000001,  // Node has been type checked
         LexicalThis                 = 0x00000002,  // Lexical 'this' reference
         CaptureThis                 = 0x00000004,  // Lexical 'this' used in body
-        LexicalArguments            = 0x00000008,  // Lexical 'arguments' reference
-        CaptureArguments            = 0x00000010,  // Lexical 'arguments' used in body
-        EmitExtends                 = 0x00000020,  // Emit __extends
-        EmitDecorate                = 0x00000040,  // Emit __decorate
-        EmitParam                   = 0x00000080,  // Emit __param helper for decorators
-        EmitAwaiter                 = 0x00000100,  // Emit __awaiter
-        EmitGenerator               = 0x00000200,  // Emit __generator
-        SuperInstance               = 0x00000400,  // Instance 'super' reference
-        SuperStatic                 = 0x00000800,  // Static 'super' reference
-        ContextChecked              = 0x00001000,  // Contextual types have been assigned
-        PromiseCollision            = 0x00002000,  // Declaration collides with the global 'Promise'
+        EmitExtends                 = 0x00000008,  // Emit __extends
+        EmitDecorate                = 0x00000010,  // Emit __decorate
+        EmitParam                   = 0x00000020,  // Emit __param helper for decorators
+        EmitAwaiter                 = 0x00000040,  // Emit __awaiter
+        EmitGenerator               = 0x00000080,  // Emit __generator
+        SuperInstance               = 0x00000100,  // Instance 'super' reference
+        SuperStatic                 = 0x00000200,  // Static 'super' reference
+        ContextChecked              = 0x00000400,  // Contextual types have been assigned
+        PromiseCollision            = 0x00000800,  // Declaration collides with the global 'Promise'
 
         // Values for enum members have been computed, and any errors have been reported for them.
-        EnumValuesComputed          = 0x00004000,
-        BlockScopedBindingInLoop    = 0x00008000,
-        LexicalModuleMergesWithClass= 0x00010000,  // Instantiated lexical module declaration is merged with a previous class declaration.
+        EnumValuesComputed          = 0x00001000,
+        BlockScopedBindingInLoop    = 0x00002000,
+        LexicalModuleMergesWithClass= 0x00004000,  // Instantiated lexical module declaration is merged with a previous class declaration.
     }
 
     /* @internal */ 
@@ -1456,6 +1455,7 @@ module ts {
         assignmentChecks?: Map<boolean>;  // Cache of assignment checks
         hasReportedStatementInAmbientContext?: boolean;  // Cache boolean if we report statements in ambient context
         importOnRightSide?: Symbol;       // for import declarations - import that appear on the right side
+        promiseConstructor?: EntityName;
     }
 
     export const enum TypeFlags {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index e5856077ed..3536315853 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1705,7 +1705,7 @@ module ts {
             return false;
         }
     }
-
+    
     export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
         return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
             (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt
index 8c6b09c82d..6efd10dce0 100644
--- a/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration10_es6.errors.txt
@@ -1,8 +1,20 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,10): error TS9001: Generators are not currently supported.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,16): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,26): error TS1005: ',' expected.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS1138: Parameter declaration expected.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,29): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts(1,34): error TS1005: ';' expected.
 
 
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (1 errors) ====
+==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts (5 errors) ====
     function * foo(a = yield => yield) {
-             ~
-!!! error TS9001: Generators are not currently supported.
+                   ~~~~~~~~~
+!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
+                             ~~
+!!! error TS1005: ',' expected.
+                                ~~~~~
+!!! error TS1138: Parameter declaration expected.
+                                ~~~~~
+!!! error TS2304: Cannot find name 'yield'.
+                                     ~
+!!! error TS1005: ';' expected.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
index b5ea3f494a..13f69a4765 100644
--- a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS9000: 'yield' expressions are not currently supported.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ====
@@ -7,5 +7,5 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,1
             ~
 !!! error TS9001: Generators are not currently supported.
                      ~~~~~
-!!! error TS2304: Cannot find name 'yield'.
+!!! error TS9000: 'yield' expressions are not currently supported.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
index f129d3fa30..8b15522b13 100644
--- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS9001: Generators are not currently supported.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2304: Cannot find name 'yield'.
+tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS9000: 'yield' expressions are not currently supported.
 
 
 ==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ====
@@ -12,6 +12,6 @@ tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,2
               ~
 !!! error TS9001: Generators are not currently supported.
                        ~~~~~
-!!! error TS2304: Cannot find name 'yield'.
+!!! error TS9000: 'yield' expressions are not currently supported.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression12_es6.errors.txt b/tests/baselines/reference/YieldExpression12_es6.errors.txt
index 10843421a3..04c50ca2c3 100644
--- a/tests/baselines/reference/YieldExpression12_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression12_es6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): error TS1163: 'yield' expression must be contained within a generator declaration.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts (1 errors) ====
@@ -6,6 +6,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts(3,6): erro
       constructor() {
          yield foo
          ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: 'yield' expression must be contained within a generator declaration.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression14_es6.errors.txt b/tests/baselines/reference/YieldExpression14_es6.errors.txt
index baeaf3ba30..ddc427bacb 100644
--- a/tests/baselines/reference/YieldExpression14_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression14_es6.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): error TS1163: 'yield' expression must be contained within a generator declaration.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts (1 errors) ====
@@ -6,6 +6,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts(3,6): erro
       foo() {
          yield foo
          ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: 'yield' expression must be contained within a generator declaration.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression15_es6.errors.txt b/tests/baselines/reference/YieldExpression15_es6.errors.txt
index 5e548799f5..12d16a52d0 100644
--- a/tests/baselines/reference/YieldExpression15_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression15_es6.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts(2,6): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts(2,6): error TS1163: 'yield' expression must be contained within a generator declaration.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts (1 errors) ====
     var v = () => {
          yield foo
          ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: 'yield' expression must be contained within a generator declaration.
       }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression16_es6.errors.txt b/tests/baselines/reference/YieldExpression16_es6.errors.txt
index c0d2e4c8fc..0b3d71c6ae 100644
--- a/tests/baselines/reference/YieldExpression16_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression16_es6.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS9001: Generators are not currently supported.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: 'yield' expression must be contained within a generator declaration.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (2 errors) ====
@@ -9,6 +9,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): erro
       function bar() {
         yield foo;
         ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
+!!! error TS1163: 'yield' expression must be contained within a generator declaration.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression17_es6.errors.txt b/tests/baselines/reference/YieldExpression17_es6.errors.txt
index b39f47b07f..0bcefebede 100644
--- a/tests/baselines/reference/YieldExpression17_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression17_es6.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: 'yield' expression must be contained within a generator declaration.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts (3 errors) ====
@@ -10,4 +10,4 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): err
                   ~~~
 !!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
                           ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
\ No newline at end of file
+!!! error TS1163: 'yield' expression must be contained within a generator declaration.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression18_es6.errors.txt b/tests/baselines/reference/YieldExpression18_es6.errors.txt
index 3a67acdebc..1fae530e44 100644
--- a/tests/baselines/reference/YieldExpression18_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression18_es6.errors.txt
@@ -1,8 +1,8 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts(2,1): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts(2,1): error TS1163: 'yield' expression must be contained within a generator declaration.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts (1 errors) ====
     "use strict";
     yield(foo);
     ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
\ No newline at end of file
+!!! error TS1163: 'yield' expression must be contained within a generator declaration.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression2_es6.errors.txt b/tests/baselines/reference/YieldExpression2_es6.errors.txt
index 553dab51fc..9a3a4d69fa 100644
--- a/tests/baselines/reference/YieldExpression2_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression2_es6.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts(1,1): error TS1163: 'yield' expression must be contained_within a generator declaration.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts(1,1): error TS1163: 'yield' expression must be contained within a generator declaration.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts (1 errors) ====
     yield foo;
     ~~~~~
-!!! error TS1163: 'yield' expression must be contained_within a generator declaration.
\ No newline at end of file
+!!! error TS1163: 'yield' expression must be contained within a generator declaration.
\ No newline at end of file
diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols
index 3b435de2e5..30f541751a 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, 1439, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 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, 1439, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 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, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3))
diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt
new file mode 100644
index 0000000000..2476eaec6e
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,11): error TS2304: Cannot find name 'async'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,17): error TS1005: ',' expected.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,20): error TS1005: '=' expected.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,24): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(4,11): error TS2304: Cannot find name 'await'.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts (5 errors) ====
+    
+    var foo = async foo(): Promise<void> => {
+              ~~~~~
+!!! error TS2304: Cannot find name 'async'.
+                    ~~~
+!!! error TS1005: ',' expected.
+                       ~
+!!! error TS1005: '=' expected.
+                           ~~~~~~~~~~~~~
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+       // Legal to use 'await' in a type context.
+       var v: await;
+              ~~~~~
+!!! error TS2304: Cannot find name 'await'.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.js b/tests/baselines/reference/asyncArrowFunction10_es6.js
new file mode 100644
index 0000000000..23b2c3af80
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction10_es6.js
@@ -0,0 +1,13 @@
+//// [asyncArrowFunction10_es6.ts]
+
+var foo = async foo(): Promise<void> => {
+   // Legal to use 'await' in a type context.
+   var v: await;
+}
+
+
+//// [asyncArrowFunction10_es6.js]
+var foo = async, foo = () => {
+    // Legal to use 'await' in a type context.
+    var v;
+};
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js
new file mode 100644
index 0000000000..78a2899d05
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction1_es6.js
@@ -0,0 +1,8 @@
+//// [asyncArrowFunction1_es6.ts]
+
+var foo = async (): Promise<void> => {
+};
+
+//// [asyncArrowFunction1_es6.js]
+var foo = () => __awaiter(function *() {
+}.apply(this), Promise);
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
new file mode 100644
index 0000000000..dc2ed671c4
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts ===
+
+var foo = async (): Promise<void> => {
+>foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+};
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.types b/tests/baselines/reference/asyncArrowFunction1_es6.types
new file mode 100644
index 0000000000..3ecfdeb791
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction1_es6.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts ===
+
+var foo = async (): Promise<void> => {
+>foo : () => Promise<void>
+>async (): Promise<void> => {} : () => Promise<void>
+>Promise : Promise<T>
+
+};
diff --git a/tests/baselines/reference/asyncArrowFunction2_es6.js b/tests/baselines/reference/asyncArrowFunction2_es6.js
new file mode 100644
index 0000000000..9d7f1d10ea
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction2_es6.js
@@ -0,0 +1,7 @@
+//// [asyncArrowFunction2_es6.ts]
+var f = (await) => {
+}
+
+//// [asyncArrowFunction2_es6.js]
+var f = (await) => {
+};
diff --git a/tests/baselines/reference/asyncArrowFunction2_es6.symbols b/tests/baselines/reference/asyncArrowFunction2_es6.symbols
new file mode 100644
index 0000000000..dd8b4ea239
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction2_es6.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts ===
+var f = (await) => {
+>f : Symbol(f, Decl(asyncArrowFunction2_es6.ts, 0, 3))
+>await : Symbol(await, Decl(asyncArrowFunction2_es6.ts, 0, 9))
+}
diff --git a/tests/baselines/reference/asyncArrowFunction2_es6.types b/tests/baselines/reference/asyncArrowFunction2_es6.types
new file mode 100644
index 0000000000..98808d175f
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction2_es6.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts ===
+var f = (await) => {
+>f : (await: any) => void
+>(await) => {} : (await: any) => void
+>await : any
+}
diff --git a/tests/baselines/reference/asyncArrowFunction3_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction3_es6.errors.txt
new file mode 100644
index 0000000000..d0f56df51d
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction3_es6.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts(1,20): error TS2372: Parameter 'await' cannot be referenced in its initializer.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts (1 errors) ====
+    function f(await = await) {
+                       ~~~~~
+!!! error TS2372: Parameter 'await' cannot be referenced in its initializer.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunction3_es6.js b/tests/baselines/reference/asyncArrowFunction3_es6.js
new file mode 100644
index 0000000000..9616336d76
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction3_es6.js
@@ -0,0 +1,7 @@
+//// [asyncArrowFunction3_es6.ts]
+function f(await = await) {
+}
+
+//// [asyncArrowFunction3_es6.js]
+function f(await = await) {
+}
diff --git a/tests/baselines/reference/asyncArrowFunction4_es6.js b/tests/baselines/reference/asyncArrowFunction4_es6.js
new file mode 100644
index 0000000000..eb89d98bbe
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction4_es6.js
@@ -0,0 +1,7 @@
+//// [asyncArrowFunction4_es6.ts]
+var await = () => {
+}
+
+//// [asyncArrowFunction4_es6.js]
+var await = () => {
+};
diff --git a/tests/baselines/reference/asyncArrowFunction4_es6.symbols b/tests/baselines/reference/asyncArrowFunction4_es6.symbols
new file mode 100644
index 0000000000..1c00104072
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction4_es6.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts ===
+var await = () => {
+>await : Symbol(await, Decl(asyncArrowFunction4_es6.ts, 0, 3))
+}
diff --git a/tests/baselines/reference/asyncArrowFunction4_es6.types b/tests/baselines/reference/asyncArrowFunction4_es6.types
new file mode 100644
index 0000000000..e23ff78610
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction4_es6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts ===
+var await = () => {
+>await : () => void
+>() => {} : () => void
+}
diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
new file mode 100644
index 0000000000..fed2962053
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction5_es6.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,11): error TS2304: Cannot find name 'async'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,18): error TS2304: Cannot find name 'await'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,24): error TS1005: ',' expected.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,26): error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,33): error TS1005: '=' expected.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts(2,40): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts (6 errors) ====
+    
+    var foo = async (await): Promise<void> => {
+              ~~~~~
+!!! error TS2304: Cannot find name 'async'.
+                     ~~~~~
+!!! error TS2304: Cannot find name 'await'.
+                           ~
+!!! error TS1005: ',' expected.
+                             ~~~~~~~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'.
+                                    ~
+!!! error TS1005: '=' expected.
+                                           ~~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.js b/tests/baselines/reference/asyncArrowFunction5_es6.js
new file mode 100644
index 0000000000..ed4035e617
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction5_es6.js
@@ -0,0 +1,9 @@
+//// [asyncArrowFunction5_es6.ts]
+
+var foo = async (await): Promise<void> => {
+}
+
+//// [asyncArrowFunction5_es6.js]
+var foo = async(await), Promise = ;
+{
+}
diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt
new file mode 100644
index 0000000000..3afce3a812
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction6_es6.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts(2,27): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts (1 errors) ====
+    
+    var foo = async (a = await): Promise<void> => {
+                              ~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js
new file mode 100644
index 0000000000..186ecc4cf1
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction6_es6.js
@@ -0,0 +1,8 @@
+//// [asyncArrowFunction6_es6.ts]
+
+var foo = async (a = await): Promise<void> => {
+}
+
+//// [asyncArrowFunction6_es6.js]
+var foo = (...arguments_1) => __awaiter(function *(a = yield ) {
+}.apply(this, arguments_1), Promise);
diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt
new file mode 100644
index 0000000000..db7e634b47
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction7_es6.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts(4,29): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts (1 errors) ====
+    
+    var bar = async (): Promise<void> => {
+      // 'await' here is an identifier, and not an await expression.
+      var foo = async (a = await): Promise<void> => {
+                                ~
+!!! error TS1109: Expression expected.
+      }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js
new file mode 100644
index 0000000000..b1859159c9
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction7_es6.js
@@ -0,0 +1,14 @@
+//// [asyncArrowFunction7_es6.ts]
+
+var bar = async (): Promise<void> => {
+  // 'await' here is an identifier, and not an await expression.
+  var foo = async (a = await): Promise<void> => {
+  }
+}
+
+//// [asyncArrowFunction7_es6.js]
+var bar = () => __awaiter(function *() {
+    // 'await' here is an identifier, and not an await expression.
+    var foo = (...arguments_1) => __awaiter(function *(a = yield ) {
+    }.apply(this, arguments_1), Promise);
+}.apply(this), Promise);
diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt
new file mode 100644
index 0000000000..7252805cdc
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction8_es6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts(3,19): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts (1 errors) ====
+    
+    var foo = async (): Promise<void> => {
+      var v = { [await]: foo }
+                      ~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js
new file mode 100644
index 0000000000..3f98f3a4f6
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction8_es6.js
@@ -0,0 +1,10 @@
+//// [asyncArrowFunction8_es6.ts]
+
+var foo = async (): Promise<void> => {
+  var v = { [await]: foo }
+}
+
+//// [asyncArrowFunction8_es6.js]
+var foo = () => __awaiter(function *() {
+    var v = { [yield ]: foo };
+}.apply(this), Promise);
diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
new file mode 100644
index 0000000000..623095e8a5
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction9_es6.errors.txt
@@ -0,0 +1,23 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,11): error TS2304: Cannot find name 'async'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,18): error TS2304: Cannot find name 'a'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,37): error TS1005: ',' expected.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,39): error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,46): error TS1005: '=' expected.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts(1,53): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts (6 errors) ====
+    var foo = async (a = await => await): Promise<void> => {
+              ~~~~~
+!!! error TS2304: Cannot find name 'async'.
+                     ~
+!!! error TS2304: Cannot find name 'a'.
+                                        ~
+!!! error TS1005: ',' expected.
+                                          ~~~~~~~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'Promise' must be of type 'PromiseConstructor', but here has type 'void'.
+                                                 ~
+!!! error TS1005: '=' expected.
+                                                        ~~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.js b/tests/baselines/reference/asyncArrowFunction9_es6.js
new file mode 100644
index 0000000000..fb2f9d28a1
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunction9_es6.js
@@ -0,0 +1,8 @@
+//// [asyncArrowFunction9_es6.ts]
+var foo = async (a = await => await): Promise<void> => {
+}
+
+//// [asyncArrowFunction9_es6.js]
+var foo = async(a = await => await), Promise = ;
+{
+}
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt
new file mode 100644
index 0000000000..6b80a53f52
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts(4,52): error TS2522: The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression.
+
+
+==== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts (1 errors) ====
+    class C {
+       method() {
+          function other() {}
+          var fn = async () => await other.apply(this, arguments);      
+                                                       ~~~~~~~~~
+!!! error TS2522: The 'arguments' object cannot be referenced in an async arrow function Consider using a standard async function expression.
+       }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js
new file mode 100644
index 0000000000..96926ba8f4
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js
@@ -0,0 +1,16 @@
+//// [asyncArrowFunctionCapturesArguments_es6.ts]
+class C {
+   method() {
+      function other() {}
+      var fn = async () => await other.apply(this, arguments);      
+   }
+}
+
+
+//// [asyncArrowFunctionCapturesArguments_es6.js]
+class C {
+    method() {
+        function other() { }
+        var fn = () => __awaiter(function *() { return yield other.apply(this, arguments); }.apply(this));
+    }
+}
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js
new file mode 100644
index 0000000000..572c5fbe04
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js
@@ -0,0 +1,14 @@
+//// [asyncArrowFunctionCapturesThis_es6.ts]
+class C {
+   method() {
+      var fn = async () => await this;      
+   }
+}
+
+
+//// [asyncArrowFunctionCapturesThis_es6.js]
+class C {
+    method() {
+        var fn = () => __awaiter(function *() { return yield this; }.apply(this));
+    }
+}
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.symbols b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.symbols
new file mode 100644
index 0000000000..ae516bb7fe
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.symbols
@@ -0,0 +1,13 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts ===
+class C {
+>C : Symbol(C, Decl(asyncArrowFunctionCapturesThis_es6.ts, 0, 0))
+
+   method() {
+>method : Symbol(method, Decl(asyncArrowFunctionCapturesThis_es6.ts, 0, 9))
+
+      var fn = async () => await this;      
+>fn : Symbol(fn, Decl(asyncArrowFunctionCapturesThis_es6.ts, 2, 9))
+>this : Symbol(C, Decl(asyncArrowFunctionCapturesThis_es6.ts, 0, 0))
+   }
+}
+
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
new file mode 100644
index 0000000000..f3cd0f2d2d
--- /dev/null
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts ===
+class C {
+>C : C
+
+   method() {
+>method : () => void
+
+      var fn = async () => await this;      
+>fn : () => Promise<C>
+>async () => await this : () => Promise<C>
+>this : C
+   }
+}
+
diff --git a/tests/baselines/reference/asyncClass_es6.errors.txt b/tests/baselines/reference/asyncClass_es6.errors.txt
new file mode 100644
index 0000000000..ee8a3a85db
--- /dev/null
+++ b/tests/baselines/reference/asyncClass_es6.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/async/es6/asyncClass_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here.
+
+
+==== tests/cases/conformance/async/es6/asyncClass_es6.ts (1 errors) ====
+    async class C {  
+    ~~~~~
+!!! error TS1042: 'async' modifier cannot be used here.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncClass_es6.js b/tests/baselines/reference/asyncClass_es6.js
new file mode 100644
index 0000000000..b5e1498f70
--- /dev/null
+++ b/tests/baselines/reference/asyncClass_es6.js
@@ -0,0 +1,7 @@
+//// [asyncClass_es6.ts]
+async class C {  
+}
+
+//// [asyncClass_es6.js]
+class C {
+}
diff --git a/tests/baselines/reference/asyncConstructor_es6.errors.txt b/tests/baselines/reference/asyncConstructor_es6.errors.txt
new file mode 100644
index 0000000000..6eb18cf41a
--- /dev/null
+++ b/tests/baselines/reference/asyncConstructor_es6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/async/es6/asyncConstructor_es6.ts(2,3): error TS1089: 'async' modifier cannot appear on a constructor declaration.
+
+
+==== tests/cases/conformance/async/es6/asyncConstructor_es6.ts (1 errors) ====
+    class C {  
+      async constructor() {    
+      ~~~~~
+!!! error TS1089: 'async' modifier cannot appear on a constructor declaration.
+      }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncConstructor_es6.js b/tests/baselines/reference/asyncConstructor_es6.js
new file mode 100644
index 0000000000..a0cfa7709d
--- /dev/null
+++ b/tests/baselines/reference/asyncConstructor_es6.js
@@ -0,0 +1,11 @@
+//// [asyncConstructor_es6.ts]
+class C {  
+  async constructor() {    
+  }
+}
+
+//// [asyncConstructor_es6.js]
+class C {
+    constructor() {
+    }
+}
diff --git a/tests/baselines/reference/asyncDeclare_es6.errors.txt b/tests/baselines/reference/asyncDeclare_es6.errors.txt
new file mode 100644
index 0000000000..65a4068e14
--- /dev/null
+++ b/tests/baselines/reference/asyncDeclare_es6.errors.txt
@@ -0,0 +1,7 @@
+tests/cases/conformance/async/es6/asyncDeclare_es6.ts(1,9): error TS1040: 'async' modifier cannot be used in an ambient context.
+
+
+==== tests/cases/conformance/async/es6/asyncDeclare_es6.ts (1 errors) ====
+    declare async function foo(): Promise<void>;
+            ~~~~~
+!!! error TS1040: 'async' modifier cannot be used in an ambient context.
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncDeclare_es6.js b/tests/baselines/reference/asyncDeclare_es6.js
new file mode 100644
index 0000000000..096f43a248
--- /dev/null
+++ b/tests/baselines/reference/asyncDeclare_es6.js
@@ -0,0 +1,4 @@
+//// [asyncDeclare_es6.ts]
+declare async function foo(): Promise<void>;
+
+//// [asyncDeclare_es6.js]
diff --git a/tests/baselines/reference/asyncEnum_es6.errors.txt b/tests/baselines/reference/asyncEnum_es6.errors.txt
new file mode 100644
index 0000000000..a50853fd8e
--- /dev/null
+++ b/tests/baselines/reference/asyncEnum_es6.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/async/es6/asyncEnum_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here.
+
+
+==== tests/cases/conformance/async/es6/asyncEnum_es6.ts (1 errors) ====
+    async enum E {  
+    ~~~~~
+!!! error TS1042: 'async' modifier cannot be used here.
+      Value
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncEnum_es6.js b/tests/baselines/reference/asyncEnum_es6.js
new file mode 100644
index 0000000000..074de3dd0a
--- /dev/null
+++ b/tests/baselines/reference/asyncEnum_es6.js
@@ -0,0 +1,10 @@
+//// [asyncEnum_es6.ts]
+async enum E {  
+  Value
+}
+
+//// [asyncEnum_es6.js]
+var E;
+(function (E) {
+    E[E["Value"] = 0] = "Value";
+})(E || (E = {}));
diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt
new file mode 100644
index 0000000000..15ceb3e60c
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.errors.txt
@@ -0,0 +1,26 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,20): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,30): error TS1109: Expression expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS1138: Parameter declaration expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,33): error TS2304: Cannot find name 'await'.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,38): error TS1005: ';' expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,39): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts(1,53): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts (7 errors) ====
+    async function foo(a = await => await): Promise<void> {
+                       ~~~~~~~~~
+!!! error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
+                                 ~~
+!!! error TS1109: Expression expected.
+                                    ~~~~~
+!!! error TS1138: Parameter declaration expected.
+                                    ~~~~~
+!!! error TS2304: Cannot find name 'await'.
+                                         ~
+!!! error TS1005: ';' expected.
+                                          ~
+!!! error TS1128: Declaration or statement expected.
+                                                        ~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.js b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js
new file mode 100644
index 0000000000..141c0cbab5
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.js
@@ -0,0 +1,7 @@
+//// [asyncFunctionDeclaration10_es6.ts]
+async function foo(a = await => await): Promise<void> {
+}
+
+//// [asyncFunctionDeclaration10_es6.js]
+await;
+Promise < void  > {};
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js
new file mode 100644
index 0000000000..39bf2c20e7
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js
@@ -0,0 +1,9 @@
+//// [asyncFunctionDeclaration11_es6.ts]
+async function await(): Promise<void> {
+}
+
+//// [asyncFunctionDeclaration11_es6.js]
+function await() {
+    return __awaiter(function *() {
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
new file mode 100644
index 0000000000..b432029637
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
@@ -0,0 +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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.types b/tests/baselines/reference/asyncFunctionDeclaration11_es6.types
new file mode 100644
index 0000000000..65896e7b3b
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts ===
+async function await(): Promise<void> {
+>await : () => Promise<void>
+>Promise : Promise<T>
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt
new file mode 100644
index 0000000000..978492f074
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,24): error TS1005: '(' expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,29): error TS1005: '=' expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,33): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,47): error TS1005: '=>' expected.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts (4 errors) ====
+    var v = async function await(): Promise<void> { }
+                           ~~~~~
+!!! error TS1005: '(' expected.
+                                ~
+!!! error TS1005: '=' expected.
+                                    ~~~~~~~~~~~~~
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+                                                  ~
+!!! error TS1005: '=>' expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.js b/tests/baselines/reference/asyncFunctionDeclaration12_es6.js
new file mode 100644
index 0000000000..dae33682ce
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.js
@@ -0,0 +1,5 @@
+//// [asyncFunctionDeclaration12_es6.ts]
+var v = async function await(): Promise<void> { }
+
+//// [asyncFunctionDeclaration12_es6.js]
+var v = , await = () => { };
diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration13_es6.errors.txt
new file mode 100644
index 0000000000..6cf65ca4e3
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts(3,11): error TS2304: Cannot find name 'await'.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts (1 errors) ====
+    async function foo(): Promise<void> {
+       // Legal to use 'await' in a type context.
+       var v: await;
+              ~~~~~
+!!! error TS2304: Cannot find name 'await'.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js
new file mode 100644
index 0000000000..9666fb5d7c
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js
@@ -0,0 +1,14 @@
+//// [asyncFunctionDeclaration13_es6.ts]
+async function foo(): Promise<void> {
+   // Legal to use 'await' in a type context.
+   var v: await;
+}
+
+
+//// [asyncFunctionDeclaration13_es6.js]
+function foo() {
+    return __awaiter(function *() {
+        // Legal to use 'await' in a type context.
+        var v;
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js
new file mode 100644
index 0000000000..2f694f0269
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js
@@ -0,0 +1,11 @@
+//// [asyncFunctionDeclaration14_es6.ts]
+async function foo(): Promise<void> {
+  return;
+}
+
+//// [asyncFunctionDeclaration14_es6.js]
+function foo() {
+    return __awaiter(function *() {
+        return;
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
new file mode 100644
index 0000000000..5354c67a19
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
@@ -0,0 +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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+  return;
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.types b/tests/baselines/reference/asyncFunctionDeclaration14_es6.types
new file mode 100644
index 0000000000..7727ffafae
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts ===
+async function foo(): Promise<void> {
+>foo : () => Promise<void>
+>Promise : Promise<T>
+
+  return;
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js
new file mode 100644
index 0000000000..75cb74a68a
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js
@@ -0,0 +1,9 @@
+//// [asyncFunctionDeclaration1_es6.ts]
+async function foo(): Promise<void> {
+}
+
+//// [asyncFunctionDeclaration1_es6.js]
+function foo() {
+    return __awaiter(function *() {
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
new file mode 100644
index 0000000000..241290a489
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
@@ -0,0 +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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.types b/tests/baselines/reference/asyncFunctionDeclaration1_es6.types
new file mode 100644
index 0000000000..5cba25724f
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts ===
+async function foo(): Promise<void> {
+>foo : () => Promise<void>
+>Promise : Promise<T>
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration2_es6.js b/tests/baselines/reference/asyncFunctionDeclaration2_es6.js
new file mode 100644
index 0000000000..1c54b9bc05
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration2_es6.js
@@ -0,0 +1,7 @@
+//// [asyncFunctionDeclaration2_es6.ts]
+function f(await) {
+}
+
+//// [asyncFunctionDeclaration2_es6.js]
+function f(await) {
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration2_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration2_es6.symbols
new file mode 100644
index 0000000000..c709d7f738
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration2_es6.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts ===
+function f(await) {
+>f : Symbol(f, Decl(asyncFunctionDeclaration2_es6.ts, 0, 0))
+>await : Symbol(await, Decl(asyncFunctionDeclaration2_es6.ts, 0, 11))
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration2_es6.types b/tests/baselines/reference/asyncFunctionDeclaration2_es6.types
new file mode 100644
index 0000000000..9c9a19f3e7
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration2_es6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts ===
+function f(await) {
+>f : (await: any) => void
+>await : any
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration3_es6.errors.txt
new file mode 100644
index 0000000000..a480bf3d2b
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration3_es6.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts(1,20): error TS2372: Parameter 'await' cannot be referenced in its initializer.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts (1 errors) ====
+    function f(await = await) {
+                       ~~~~~
+!!! error TS2372: Parameter 'await' cannot be referenced in its initializer.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es6.js b/tests/baselines/reference/asyncFunctionDeclaration3_es6.js
new file mode 100644
index 0000000000..7038858d2c
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration3_es6.js
@@ -0,0 +1,7 @@
+//// [asyncFunctionDeclaration3_es6.ts]
+function f(await = await) {
+}
+
+//// [asyncFunctionDeclaration3_es6.js]
+function f(await = await) {
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration4_es6.js b/tests/baselines/reference/asyncFunctionDeclaration4_es6.js
new file mode 100644
index 0000000000..8bfb7bf642
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration4_es6.js
@@ -0,0 +1,7 @@
+//// [asyncFunctionDeclaration4_es6.ts]
+function await() {
+}
+
+//// [asyncFunctionDeclaration4_es6.js]
+function await() {
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration4_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration4_es6.symbols
new file mode 100644
index 0000000000..cdbe1f5a8d
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration4_es6.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts ===
+function await() {
+>await : Symbol(await, Decl(asyncFunctionDeclaration4_es6.ts, 0, 0))
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration4_es6.types b/tests/baselines/reference/asyncFunctionDeclaration4_es6.types
new file mode 100644
index 0000000000..537661e2c6
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration4_es6.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts ===
+function await() {
+>await : () => void
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt
new file mode 100644
index 0000000000..a6944e0c6e
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,20): error TS1138: Parameter declaration expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,20): error TS2304: Cannot find name 'await'.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,25): error TS1005: ';' expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,26): error TS1128: Declaration or statement expected.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts(1,40): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts (5 errors) ====
+    async function foo(await): Promise<void> {
+                       ~~~~~
+!!! error TS1138: Parameter declaration expected.
+                       ~~~~~
+!!! error TS2304: Cannot find name 'await'.
+                            ~
+!!! error TS1005: ';' expected.
+                             ~
+!!! error TS1128: Declaration or statement expected.
+                                           ~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.js b/tests/baselines/reference/asyncFunctionDeclaration5_es6.js
new file mode 100644
index 0000000000..8d28c37146
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.js
@@ -0,0 +1,7 @@
+//// [asyncFunctionDeclaration5_es6.ts]
+async function foo(await): Promise<void> {
+}
+
+//// [asyncFunctionDeclaration5_es6.js]
+await;
+Promise < void  > {};
diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt
new file mode 100644
index 0000000000..e719ed801e
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts(1,29): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts (1 errors) ====
+    async function foo(a = await): Promise<void> {
+                                ~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js
new file mode 100644
index 0000000000..2a3ffaa94d
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js
@@ -0,0 +1,9 @@
+//// [asyncFunctionDeclaration6_es6.ts]
+async function foo(a = await): Promise<void> {
+}
+
+//// [asyncFunctionDeclaration6_es6.js]
+function foo() {
+    return __awaiter(function *(a = yield ) {
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt
new file mode 100644
index 0000000000..01643ffcdb
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.errors.txt
@@ -0,0 +1,11 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts(3,31): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts (1 errors) ====
+    async function bar(): Promise<void> {
+      // 'await' here is an identifier, and not a yield expression.
+      async function foo(a = await): Promise<void> {
+                                  ~
+!!! error TS1109: Expression expected.
+      }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js
new file mode 100644
index 0000000000..c22870b08f
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js
@@ -0,0 +1,17 @@
+//// [asyncFunctionDeclaration7_es6.ts]
+async function bar(): Promise<void> {
+  // 'await' here is an identifier, and not a yield expression.
+  async function foo(a = await): Promise<void> {
+  }
+}
+
+//// [asyncFunctionDeclaration7_es6.js]
+function bar() {
+    return __awaiter(function *() {
+        // 'await' here is an identifier, and not a yield expression.
+        function foo() {
+            return __awaiter(function *(a = yield ) {
+            }.apply(this, arguments), Promise);
+        }
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration8_es6.errors.txt
new file mode 100644
index 0000000000..c785ae41b1
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration8_es6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts(1,12): error TS2304: Cannot find name 'await'.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts(1,20): error TS2304: Cannot find name 'foo'.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts (2 errors) ====
+    var v = { [await]: foo }
+               ~~~~~
+!!! error TS2304: Cannot find name 'await'.
+                       ~~~
+!!! error TS2304: Cannot find name 'foo'.
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es6.js b/tests/baselines/reference/asyncFunctionDeclaration8_es6.js
new file mode 100644
index 0000000000..a363015f8a
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration8_es6.js
@@ -0,0 +1,5 @@
+//// [asyncFunctionDeclaration8_es6.ts]
+var v = { [await]: foo }
+
+//// [asyncFunctionDeclaration8_es6.js]
+var v = { [await]: foo };
diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration9_es6.errors.txt
new file mode 100644
index 0000000000..235ef165be
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts(2,19): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts (1 errors) ====
+    async function foo(): Promise<void> {
+      var v = { [await]: foo }
+                      ~
+!!! error TS1109: Expression expected.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js
new file mode 100644
index 0000000000..8b5ea4c4b5
--- /dev/null
+++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js
@@ -0,0 +1,11 @@
+//// [asyncFunctionDeclaration9_es6.ts]
+async function foo(): Promise<void> {
+  var v = { [await]: foo }
+}
+
+//// [asyncFunctionDeclaration9_es6.js]
+function foo() {
+    return __awaiter(function *() {
+        var v = { [yield ]: foo };
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/asyncGetter_es6.errors.txt b/tests/baselines/reference/asyncGetter_es6.errors.txt
new file mode 100644
index 0000000000..5f5a9f6b1d
--- /dev/null
+++ b/tests/baselines/reference/asyncGetter_es6.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,3): error TS1042: 'async' modifier cannot be used here.
+tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+
+
+==== tests/cases/conformance/async/es6/asyncGetter_es6.ts (2 errors) ====
+    class C {
+      async get foo() {
+      ~~~~~
+!!! error TS1042: 'async' modifier cannot be used here.
+                ~~~
+!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+      }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncGetter_es6.js b/tests/baselines/reference/asyncGetter_es6.js
new file mode 100644
index 0000000000..606f4d95dc
--- /dev/null
+++ b/tests/baselines/reference/asyncGetter_es6.js
@@ -0,0 +1,11 @@
+//// [asyncGetter_es6.ts]
+class C {
+  async get foo() {
+  }
+}
+
+//// [asyncGetter_es6.js]
+class C {
+    get foo() {
+    }
+}
diff --git a/tests/baselines/reference/asyncInterface_es6.errors.txt b/tests/baselines/reference/asyncInterface_es6.errors.txt
new file mode 100644
index 0000000000..c7519ba040
--- /dev/null
+++ b/tests/baselines/reference/asyncInterface_es6.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/async/es6/asyncInterface_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here.
+
+
+==== tests/cases/conformance/async/es6/asyncInterface_es6.ts (1 errors) ====
+    async interface I {  
+    ~~~~~
+!!! error TS1042: 'async' modifier cannot be used here.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncInterface_es6.js b/tests/baselines/reference/asyncInterface_es6.js
new file mode 100644
index 0000000000..36314fa214
--- /dev/null
+++ b/tests/baselines/reference/asyncInterface_es6.js
@@ -0,0 +1,5 @@
+//// [asyncInterface_es6.ts]
+async interface I {  
+}
+
+//// [asyncInterface_es6.js]
diff --git a/tests/baselines/reference/asyncModule_es6.errors.txt b/tests/baselines/reference/asyncModule_es6.errors.txt
new file mode 100644
index 0000000000..91e5e8ccdd
--- /dev/null
+++ b/tests/baselines/reference/asyncModule_es6.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/conformance/async/es6/asyncModule_es6.ts(1,1): error TS1042: 'async' modifier cannot be used here.
+
+
+==== tests/cases/conformance/async/es6/asyncModule_es6.ts (1 errors) ====
+    async module M {   
+    ~~~~~
+!!! error TS1042: 'async' modifier cannot be used here.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncModule_es6.js b/tests/baselines/reference/asyncModule_es6.js
new file mode 100644
index 0000000000..e3e9306dbc
--- /dev/null
+++ b/tests/baselines/reference/asyncModule_es6.js
@@ -0,0 +1,5 @@
+//// [asyncModule_es6.ts]
+async module M {   
+}
+
+//// [asyncModule_es6.js]
diff --git a/tests/baselines/reference/asyncSetter_es6.errors.txt b/tests/baselines/reference/asyncSetter_es6.errors.txt
new file mode 100644
index 0000000000..e60e05cbc5
--- /dev/null
+++ b/tests/baselines/reference/asyncSetter_es6.errors.txt
@@ -0,0 +1,10 @@
+tests/cases/conformance/async/es6/asyncSetter_es6.ts(2,3): error TS1042: 'async' modifier cannot be used here.
+
+
+==== tests/cases/conformance/async/es6/asyncSetter_es6.ts (1 errors) ====
+    class C {
+      async set foo(value) {
+      ~~~~~
+!!! error TS1042: 'async' modifier cannot be used here.
+      }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncSetter_es6.js b/tests/baselines/reference/asyncSetter_es6.js
new file mode 100644
index 0000000000..303e483f9a
--- /dev/null
+++ b/tests/baselines/reference/asyncSetter_es6.js
@@ -0,0 +1,11 @@
+//// [asyncSetter_es6.ts]
+class C {
+  async set foo(value) {
+  }
+}
+
+//// [asyncSetter_es6.js]
+class C {
+    set foo(value) {
+    }
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.js b/tests/baselines/reference/awaitBinaryExpression1_es6.js
new file mode 100644
index 0000000000..f92324dcda
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.js
@@ -0,0 +1,17 @@
+//// [awaitBinaryExpression1_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p || a;
+    "after";
+}
+
+//// [awaitBinaryExpression1_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = (yield p) || a;
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
new file mode 100644
index 0000000000..373086ecba
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitBinaryExpression1_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = await p || a;
+>b : Symbol(b, Decl(awaitBinaryExpression1_es6.ts, 4, 7))
+>a : Symbol(a, Decl(awaitBinaryExpression1_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.types b/tests/baselines/reference/awaitBinaryExpression1_es6.types
new file mode 100644
index 0000000000..59370dda14
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.types
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = await p || a;
+>b : boolean
+>await p || a : boolean
+>p : any
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.js b/tests/baselines/reference/awaitBinaryExpression2_es6.js
new file mode 100644
index 0000000000..e2d3b3ba46
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.js
@@ -0,0 +1,17 @@
+//// [awaitBinaryExpression2_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p && a;
+    "after";
+}
+
+//// [awaitBinaryExpression2_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = (yield p) && a;
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
new file mode 100644
index 0000000000..9331ad13ce
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitBinaryExpression2_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = await p && a;
+>b : Symbol(b, Decl(awaitBinaryExpression2_es6.ts, 4, 7))
+>a : Symbol(a, Decl(awaitBinaryExpression2_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.types b/tests/baselines/reference/awaitBinaryExpression2_es6.types
new file mode 100644
index 0000000000..c3f33bca2f
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.types
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = await p && a;
+>b : boolean
+>await p && a : boolean
+>p : any
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.js b/tests/baselines/reference/awaitBinaryExpression3_es6.js
new file mode 100644
index 0000000000..08e98d5daf
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.js
@@ -0,0 +1,17 @@
+//// [awaitBinaryExpression3_es6.ts]
+declare var a: number;
+declare var p: Promise<number>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p + a;
+    "after";
+}
+
+//// [awaitBinaryExpression3_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = (yield p) + a;
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
new file mode 100644
index 0000000000..b1acda7013
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts ===
+declare var a: number;
+>a : Symbol(a, Decl(awaitBinaryExpression3_es6.ts, 0, 11))
+
+declare var p: Promise<number>;
+>p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = await p + a;
+>b : Symbol(b, Decl(awaitBinaryExpression3_es6.ts, 4, 7))
+>a : Symbol(a, Decl(awaitBinaryExpression3_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.types b/tests/baselines/reference/awaitBinaryExpression3_es6.types
new file mode 100644
index 0000000000..786eabadae
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.types
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts ===
+declare var a: number;
+>a : number
+
+declare var p: Promise<number>;
+>p : Promise<number>
+>Promise : Promise<T>
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = await p + a;
+>b : number
+>await p + a : number
+>p : any
+>a : number
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.js b/tests/baselines/reference/awaitBinaryExpression4_es6.js
new file mode 100644
index 0000000000..0eec5e990a
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.js
@@ -0,0 +1,17 @@
+//// [awaitBinaryExpression4_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p, a;
+    "after";
+}
+
+//// [awaitBinaryExpression4_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = yield p, a;
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
new file mode 100644
index 0000000000..c1a3bd903f
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitBinaryExpression4_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = await p, a;
+>b : Symbol(b, Decl(awaitBinaryExpression4_es6.ts, 4, 7))
+>a : Symbol(a, Decl(awaitBinaryExpression4_es6.ts, 4, 20))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.types b/tests/baselines/reference/awaitBinaryExpression4_es6.types
new file mode 100644
index 0000000000..73126b7797
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.types
@@ -0,0 +1,23 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = await p, a;
+>b : boolean
+>p : any
+>a : any
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.js b/tests/baselines/reference/awaitBinaryExpression5_es6.js
new file mode 100644
index 0000000000..d725d55404
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.js
@@ -0,0 +1,19 @@
+//// [awaitBinaryExpression5_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var o: { a: boolean; };
+    o.a = await p;
+    "after";
+}
+
+//// [awaitBinaryExpression5_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var o;
+        o.a = yield p;
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
new file mode 100644
index 0000000000..cb74dcff7f
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var o: { a: boolean; };
+>o : Symbol(o, Decl(awaitBinaryExpression5_es6.ts, 4, 7))
+>a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12))
+
+    o.a = await p;
+>o.a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12))
+>o : Symbol(o, Decl(awaitBinaryExpression5_es6.ts, 4, 7))
+>a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.types b/tests/baselines/reference/awaitBinaryExpression5_es6.types
new file mode 100644
index 0000000000..922e5887a7
--- /dev/null
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.types
@@ -0,0 +1,29 @@
+=== tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var o: { a: boolean; };
+>o : { a: boolean; }
+>a : boolean
+
+    o.a = await p;
+>o.a = await p : boolean
+>o.a : boolean
+>o : { a: boolean; }
+>a : boolean
+>p : any
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.js b/tests/baselines/reference/awaitCallExpression1_es6.js
new file mode 100644
index 0000000000..3391274ae7
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression1_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression1_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = fn(a, a, a);
+    "after";
+}
+
+//// [awaitCallExpression1_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = fn(a, a, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols
new file mode 100644
index 0000000000..f9756da176
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols
@@ -0,0 +1,50 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression1_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = fn(a, a, a);
+>b : Symbol(b, Decl(awaitCallExpression1_es6.ts, 8, 7))
+>fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32))
+>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression1_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.types b/tests/baselines/reference/awaitCallExpression1_es6.types
new file mode 100644
index 0000000000..334175b7ed
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression1_es6.types
@@ -0,0 +1,54 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = fn(a, a, a);
+>b : void
+>fn(a, a, a) : void
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>a : boolean
+>a : boolean
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.js b/tests/baselines/reference/awaitCallExpression2_es6.js
new file mode 100644
index 0000000000..fd7129e841
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression2_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression2_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = fn(await p, a, a);
+    "after";
+}
+
+//// [awaitCallExpression2_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = fn(yield p, a, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols
new file mode 100644
index 0000000000..2e5b876116
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols
@@ -0,0 +1,49 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression2_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = fn(await p, a, a);
+>b : Symbol(b, Decl(awaitCallExpression2_es6.ts, 8, 7))
+>fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
+>a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.types b/tests/baselines/reference/awaitCallExpression2_es6.types
new file mode 100644
index 0000000000..6c7f02a578
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression2_es6.types
@@ -0,0 +1,54 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = fn(await p, a, a);
+>b : void
+>fn(await p, a, a) : void
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>p : any
+>a : boolean
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.js b/tests/baselines/reference/awaitCallExpression3_es6.js
new file mode 100644
index 0000000000..4f0d55185e
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression3_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression3_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = fn(a, await p, a);
+    "after";
+}
+
+//// [awaitCallExpression3_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = fn(a, yield p, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols
new file mode 100644
index 0000000000..331fbeb8e6
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols
@@ -0,0 +1,49 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression3_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = fn(a, await p, a);
+>b : Symbol(b, Decl(awaitCallExpression3_es6.ts, 8, 7))
+>fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
+>a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.types b/tests/baselines/reference/awaitCallExpression3_es6.types
new file mode 100644
index 0000000000..24d22db3c8
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression3_es6.types
@@ -0,0 +1,54 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = fn(a, await p, a);
+>b : void
+>fn(a, await p, a) : void
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>a : boolean
+>p : any
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.js b/tests/baselines/reference/awaitCallExpression4_es6.js
new file mode 100644
index 0000000000..7ec6c6ff90
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression4_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression4_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = (await pfn)(a, a, a);
+    "after";
+}
+
+//// [awaitCallExpression4_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = (yield pfn)(a, a, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols
new file mode 100644
index 0000000000..cc3407610b
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols
@@ -0,0 +1,49 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression4_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = (await pfn)(a, a, a);
+>b : Symbol(b, Decl(awaitCallExpression4_es6.ts, 8, 7))
+>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.types b/tests/baselines/reference/awaitCallExpression4_es6.types
new file mode 100644
index 0000000000..0411546642
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression4_es6.types
@@ -0,0 +1,55 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = (await pfn)(a, a, a);
+>b : void
+>(await pfn)(a, a, a) : void
+>(await pfn) : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>pfn : any
+>a : boolean
+>a : boolean
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.js b/tests/baselines/reference/awaitCallExpression5_es6.js
new file mode 100644
index 0000000000..f41d0ae994
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression5_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression5_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = o.fn(a, a, a);
+    "after";
+}
+
+//// [awaitCallExpression5_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = o.fn(a, a, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols
new file mode 100644
index 0000000000..0063434d0f
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols
@@ -0,0 +1,52 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression5_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = o.fn(a, a, a);
+>b : Symbol(b, Decl(awaitCallExpression5_es6.ts, 8, 7))
+>o.fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 3, 16))
+>o : Symbol(o, Decl(awaitCallExpression5_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 3, 16))
+>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression5_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.types b/tests/baselines/reference/awaitCallExpression5_es6.types
new file mode 100644
index 0000000000..5074c00774
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression5_es6.types
@@ -0,0 +1,56 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = o.fn(a, a, a);
+>b : void
+>o.fn(a, a, a) : void
+>o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>a : boolean
+>a : boolean
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.js b/tests/baselines/reference/awaitCallExpression6_es6.js
new file mode 100644
index 0000000000..d6c0e37074
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression6_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression6_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = o.fn(await p, a, a);
+    "after";
+}
+
+//// [awaitCallExpression6_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = o.fn(yield p, a, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols
new file mode 100644
index 0000000000..9f99f55f26
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols
@@ -0,0 +1,51 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression6_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = o.fn(await p, a, a);
+>b : Symbol(b, Decl(awaitCallExpression6_es6.ts, 8, 7))
+>o.fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16))
+>o : Symbol(o, Decl(awaitCallExpression6_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16))
+>a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.types b/tests/baselines/reference/awaitCallExpression6_es6.types
new file mode 100644
index 0000000000..d18377cebb
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression6_es6.types
@@ -0,0 +1,56 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = o.fn(await p, a, a);
+>b : void
+>o.fn(await p, a, a) : void
+>o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>p : any
+>a : boolean
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.js b/tests/baselines/reference/awaitCallExpression7_es6.js
new file mode 100644
index 0000000000..45e8a9fa64
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression7_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression7_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = o.fn(a, await p, a);
+    "after";
+}
+
+//// [awaitCallExpression7_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = o.fn(a, yield p, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols
new file mode 100644
index 0000000000..d9dd6535bc
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols
@@ -0,0 +1,51 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression7_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = o.fn(a, await p, a);
+>b : Symbol(b, Decl(awaitCallExpression7_es6.ts, 8, 7))
+>o.fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16))
+>o : Symbol(o, Decl(awaitCallExpression7_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16))
+>a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.types b/tests/baselines/reference/awaitCallExpression7_es6.types
new file mode 100644
index 0000000000..b213a75dcd
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression7_es6.types
@@ -0,0 +1,56 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = o.fn(a, await p, a);
+>b : void
+>o.fn(a, await p, a) : void
+>o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>a : boolean
+>p : any
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.js b/tests/baselines/reference/awaitCallExpression8_es6.js
new file mode 100644
index 0000000000..3ffac0006a
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression8_es6.js
@@ -0,0 +1,21 @@
+//// [awaitCallExpression8_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = (await po).fn(a, a, a);
+    "after";
+}
+
+//// [awaitCallExpression8_es6.js]
+function func() {
+    return __awaiter(function *() {
+        "before";
+        var b = (yield po).fn(a, a, a);
+        "after";
+    }.apply(this, arguments), Promise);
+}
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols
new file mode 100644
index 0000000000..1a2097d041
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols
@@ -0,0 +1,51 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 2, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 2, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 2, 49))
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : Symbol(o, Decl(awaitCallExpression8_es6.ts, 3, 11))
+>fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 3, 16))
+>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 3, 20))
+>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 3, 34))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 3, 49))
+
+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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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, 4769, 1), Decl(lib.d.ts, 4853, 11))
+>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))
+>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 5, 58))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4853, 11))
+
+    "before";
+    var b = (await po).fn(a, a, a);
+>b : Symbol(b, Decl(awaitCallExpression8_es6.ts, 8, 7))
+>(await po).fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
+>fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
+>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11))
+>a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11))
+
+    "after";
+}
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.types b/tests/baselines/reference/awaitCallExpression8_es6.types
new file mode 100644
index 0000000000..37511a7e3d
--- /dev/null
+++ b/tests/baselines/reference/awaitCallExpression8_es6.types
@@ -0,0 +1,57 @@
+=== tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts ===
+declare var a: boolean;
+>a : boolean
+
+declare var p: Promise<boolean>;
+>p : Promise<boolean>
+>Promise : Promise<T>
+
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+>o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
+>Promise : Promise<T>
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
+>Promise : Promise<T>
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>arg0 : boolean
+>arg1 : boolean
+>arg2 : boolean
+
+async function func(): Promise<void> {
+>func : () => Promise<void>
+>Promise : Promise<T>
+
+    "before";
+>"before" : string
+
+    var b = (await po).fn(a, a, a);
+>b : void
+>(await po).fn(a, a, a) : void
+>(await po).fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>(await po) : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>po : any
+>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>a : boolean
+>a : boolean
+>a : boolean
+
+    "after";
+>"after" : string
+}
diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols
index 94e0b94b00..c29c41bff2 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, 1355, 1))
+>Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 1366, 1))
 >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/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
index 033ad46ece..6a4eb82af9 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
@@ -8,18 +8,18 @@
 
 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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
 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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
 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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36))
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
index d23b624a02..22340c6aa6 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
@@ -8,18 +8,18 @@
 
 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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
 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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
 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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -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, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1450, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index 18e1063f1e..611db6485b 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -5,7 +5,7 @@ function f() {
 
     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, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         let arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index 6885b35941..7a3c262042 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     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, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         const arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index ae6be6f795..c9658b4d90 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     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, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index c8bf211897..df5ab202df 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -9,7 +9,7 @@ function f() {
 
     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, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index cc867dd2c7..c4fc2e434e 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -9,7 +9,7 @@ function f() {
 
     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, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1705, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments;
diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols
index 833ea1d687..bcd19f1a4d 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, 1453, 37))
->values : Symbol(Array.values, Decl(lib.d.ts, 1453, 37))
+>[""].values : Symbol(Array.values, Decl(lib.d.ts, 1464, 37))
+>values : Symbol(Array.values, Decl(lib.d.ts, 1464, 37))
 
diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols
index 2c08338ce7..a61af49253 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 6be3c83964..c2d2d07841 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 97200f93f3..251a5b28fc 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 bbe3504294..0b6b6f23cc 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 4f15b54135..cc4fcf55a7 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 0f409605e2..8c7455a2db 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 44cc83143a..dae7d4bae7 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 0218a8b999..34766b1bc8 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 82918a1998..aa44808cd7 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 }
diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols
index e4324b0577..caf0356df2 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 93f6c4f7dd..73455ff17e 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, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11))
 
 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 fab42d9172..bfbe035730 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, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11))
 
 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 1cd3538f98..ed6ecb128f 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, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11))
 
 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 9c6afa04ad..adcd2ae376 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
 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 9fda4cb4e0..2f4a851114 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, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11))
 
 for ([k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of45.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols
index c176e1aca0..6813cd4eee 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, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11))
 
 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 27aed0777b..e8be8da6f9 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, 1663, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1))
 
 for (let num of iter) { }
 >num : Symbol(num, Decl(for-of57.ts, 1, 8))
diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols
index c602512317..02f2ad6e8e 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 07b1fb52af..9bbe4bfb98 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 001cb99b48..1a8634862e 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 7085fd224f..3c8a8c1ba5 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 09a6984cb3..a28e682c9e 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 4ee65a1082..46087c2f8b 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 0f50713b43..e4c5de1770 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, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1878, 1), Decl(lib.d.ts, 1900, 11))
 
diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols
index aa5ce5783a..2b0c26918e 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 01cfba0f09..90adcfeba9 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 76d94dc292..43c6d7135e 100644
--- a/tests/baselines/reference/iterableContextualTyping1.symbols
+++ b/tests/baselines/reference/iterableContextualTyping1.symbols
@@ -1,7 +1,7 @@
 === 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, 1663, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1))
 >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))
diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols
index f53e8266ba..3c1cf17480 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 b128803aa5..d1eb5420ef 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, 1663, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1674, 1))
 
 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 db8da1bac9..42c7e7e626 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 bdc200c25e..8a7abd3f19 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 c49ea74dc2..03aca3c69b 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 e7fbdac226..e8c6571943 100644
--- a/tests/baselines/reference/iteratorSpreadInArray7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 54ac770c5d..d695457621 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 8b24ba5d1b..58ed5ea493 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 d43a7f9b4f..ac81fdea26 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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 9d86858eb8..da79720409 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
             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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 14, 1))
diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols
index 54d674ea0a..9b0b706077 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols
index 51fdb40efd..f13748e999 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, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols
index 11b6d8de94..cb4ff68a63 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, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols
index b2ffc2c89d..34f550b750 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols
index e896ebbd2a..5257941831 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols
index 1859c954ba..77770a62bd 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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols
index a91a8227ae..3e912a18a2 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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols
index dee98ed1e7..dcf4a037db 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols
index cffbded17e..f706a35e3b 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols
index f24cfe2b78..6b17c421a0 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols
index 375bcf2174..e620614d82 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, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 
     set [Symbol.isConcatSpreadable](x) { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols
index 90290569e0..3cbae021c3 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
     static [Symbol.isConcatSpreadable]() { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 
     static get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
     static set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols
index 66f540a8ca..9e6b00fbc4 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
     set [Symbol.toStringTag](x) { }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols
index 5927b8a6a2..610a6bae9c 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
     get [Symbol.toStringTag]() { return ""; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols
index 3c214bd9c2..e0ba5ffc72 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols
index d3a3a31322..712b233a74 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25))
 
     [Symbol.toPrimitive](x: string);
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25))
 
     [Symbol.toPrimitive](x: any) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols
index d552300b70..3a24de2f0e 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
     set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols
index 7f5fc3cf51..5580b833c0 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, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols
index fe60e2ecc3..10c95ed620 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, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols
index b044c5264d..42f6b86686 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, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols
index 797b422c7f..13331a49dc 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, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols
index deaf1c1bb6..2b6984b6ba 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, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 }
diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols
index f8b758cbf6..bff61ccc01 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols
index 246ca2f085..1b0026c5ea 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols
index 4531b13dca..358819f47b 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols
index 6027f5e797..fe630f8f82 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols
index f7700e3b77..d87416cd43 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols
index bc23c468a2..4597eb81c0 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
     [Symbol.toStringTag]() { return "" },
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
     set [Symbol.toPrimitive](p: boolean) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
 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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
 i[Symbol.toPrimitive] = false;
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols
index a0274f2c76..d3295b6507 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24))
 
     [Symbol.toStringTag]() { return { p: undefined }; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
 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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols
index c6bb74bef3..ea698562ed 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
 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 04c76275b5..714b771b67 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24))
 
     [Symbol.toStringTag](s: number): number;
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 }
diff --git a/tests/baselines/reference/symbolProperty21.symbols b/tests/baselines/reference/symbolProperty21.symbols
index 544813c305..f2061b3bb2 100644
--- a/tests/baselines/reference/symbolProperty21.symbols
+++ b/tests/baselines/reference/symbolProperty21.symbols
@@ -5,15 +5,15 @@ interface I<T, U> {
 >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14))
 
     [Symbol.unscopables]: T;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 >T : Symbol(T, Decl(symbolProperty21.ts, 0, 12))
 
     [Symbol.isConcatSpreadable]: U;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 >U : Symbol(U, Decl(symbolProperty21.ts, 0, 14))
 }
 
@@ -34,18 +34,18 @@ foo({
 >foo : Symbol(foo, Decl(symbolProperty21.ts, 3, 1))
 
     [Symbol.isConcatSpreadable]: "",
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1230, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 1241, 24))
 
     [Symbol.toPrimitive]: 0,
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
     [Symbol.unscopables]: true
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 
 });
diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols
index e9f6761e12..d1bee54bd7 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, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 >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,9 +27,9 @@ 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, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols
index d220f80c0f..94dc416010 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
 
 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, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
         return true;
     }
diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols
index 819b93e614..0850ec9cda 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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
         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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols
index 7ead7b14b3..ed56e55cca 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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
         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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols
index 9f57cd1e2e..e5cdbb0ea6 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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
         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, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
 
diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols
index a6594f5146..8a0d692de2 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, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
     [Symbol()]() { },
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
     get [Symbol()]() {
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols
index 1f0fdaf91a..246d0952c8 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22))
 
     [Symbol.iterator](x: number): number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
 c[Symbol.iterator](0);
 >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols
index d50401a637..2872f6cb13 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
 c[Symbol.iterator]("hello");
 >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols
index 4c3d2595c1..1f691f8827 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, 1222, 32))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1222, 32))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1233, 32))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 1233, 32))
 
         return "";
     }
     get [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols
index a759e09588..e9bda77fd7 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
     [Symbol.toPrimitive]() { },
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols
index ee785ae606..69a695e6c5 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols
index 825f73ebcd..e045d35f13 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols
index e76ad43f43..077199e496 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
 };
 
@@ -14,13 +14,13 @@ module M {
 
     var Symbol: SymbolConstructor;
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1196, 1))
+>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 1207, 1))
 
     // 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, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 }
diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols
index caca4686bb..a76ab0418c 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
 };
 
diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols
index 4e0ce42038..e98cf96380 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
 };
 
 // Should give type 'any'.
 obj[Symbol["nonsense"]];
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
 
diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols
index cedcfe69a9..8b0e62e406 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, 1236, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1247, 31))
 
     [Symbol.unscopables]: number;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 
     [Symbol.toPrimitive]() { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1278, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 1289, 24))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols
index 269a8412d9..a1a4d1d50d 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, 1284, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1284, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 1295, 24))
 
     [Symbol.toPrimitive]();
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1272, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 1283, 18))
 }
diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols
index 4bf91a6112..6c4001fa4c 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, 1208, 42))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1208, 42))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1219, 42))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11))
+>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 1219, 42))
 
 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 1d87ae6a1a..7a54b0efcb 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, 1186, 52), Decl(lib.d.ts, 1292, 11), Decl(symbolType16.ts, 0, 0))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1197, 53), Decl(lib.d.ts, 1303, 11), Decl(symbolType16.ts, 0, 0))
 
     newSymbolProp: number;
 >newSymbolProp : Symbol(newSymbolProp, Decl(symbolType16.ts, 0, 18))
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
index 0cfe0d854b..a6e319c0df 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, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1549, 1))
 
diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols
index 27b72cc54f..ef9f533bb5 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, 2107, 42), Decl(lib.d.ts, 2397, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
 
     typedArrays[1] = Uint8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
 
     typedArrays[2] = Int16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
 
     typedArrays[3] = Uint16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
 
     typedArrays[4] = Int32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
 
     typedArrays[5] = Uint32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
 
     typedArrays[6] = Float32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
 
     typedArrays[7] = Float64Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
 
     typedArrays[8] = Uint8ClampedArray;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
 
     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, 2107, 42), Decl(lib.d.ts, 2397, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
 >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, 2397, 44), Decl(lib.d.ts, 2687, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
 >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, 2977, 60), Decl(lib.d.ts, 3267, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
 >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, 3267, 46), Decl(lib.d.ts, 3557, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
 >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, 3557, 48), Decl(lib.d.ts, 3847, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
 >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, 3847, 46), Decl(lib.d.ts, 4137, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
 >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, 4137, 48), Decl(lib.d.ts, 4427, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
 >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, 4427, 50), Decl(lib.d.ts, 4717, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
 >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, 2687, 46), Decl(lib.d.ts, 2977, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
 >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, 2107, 42), Decl(lib.d.ts, 2397, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
 >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, 2397, 44), Decl(lib.d.ts, 2687, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
 >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, 2977, 60), Decl(lib.d.ts, 3267, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
 >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, 3267, 46), Decl(lib.d.ts, 3557, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
 >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, 3557, 48), Decl(lib.d.ts, 3847, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
 >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, 3847, 46), Decl(lib.d.ts, 4137, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
 >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, 4137, 48), Decl(lib.d.ts, 4427, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
 >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, 4427, 50), Decl(lib.d.ts, 4717, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
 >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, 2687, 46), Decl(lib.d.ts, 2977, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
 >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, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
 >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, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
 >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, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
 >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, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
 >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, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
 >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, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
 >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, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
 >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, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
 >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, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
 >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, 1434, 1))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1))
 
     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, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
 >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, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
 >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, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
 >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, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
 >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, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
 >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, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
 >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, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
 >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, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
 >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, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
 >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, 2381, 30))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2381, 30))
+>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2392, 30))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
+>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2392, 30))
 
     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, 2671, 30))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2671, 30))
+>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2682, 30))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
+>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2682, 30))
 
     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, 3251, 30))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3251, 30))
+>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3262, 30))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
+>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3262, 30))
 
     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, 3541, 30))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3541, 30))
+>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3552, 30))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
+>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3552, 30))
 
     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, 3831, 30))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3831, 30))
+>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3842, 30))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
+>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3842, 30))
 
     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, 4121, 30))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4121, 30))
+>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4132, 30))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
+>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4132, 30))
 
     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, 4411, 30))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4411, 30))
+>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4422, 30))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
+>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4422, 30))
 
     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, 4701, 30))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4701, 30))
+>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4712, 30))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
+>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4712, 30))
 
     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, 2961, 30))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2961, 30))
+>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2972, 30))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
+>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2972, 30))
 
     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, 1434, 1))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1))
 >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, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
 >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, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
 >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, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
 >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, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
 >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, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
 >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, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
 >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, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
 >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, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
 >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, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
 >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, 1434, 1))
+>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1445, 1))
 >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, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2118, 42), Decl(lib.d.ts, 2408, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2398, 38))
 >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, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2408, 44), Decl(lib.d.ts, 2698, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2688, 39))
 >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, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2988, 60), Decl(lib.d.ts, 3278, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3268, 39))
 >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, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3278, 46), Decl(lib.d.ts, 3568, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3558, 40))
 >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, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3568, 48), Decl(lib.d.ts, 3858, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3848, 39))
 >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, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3858, 46), Decl(lib.d.ts, 4148, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4138, 40))
 >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, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4148, 48), Decl(lib.d.ts, 4438, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4428, 41))
 >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, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4438, 50), Decl(lib.d.ts, 4728, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4718, 41))
 >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, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2698, 46), Decl(lib.d.ts, 2988, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2978, 46))
 >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/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts
new file mode 100644
index 0000000000..0959ed6c56
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts
@@ -0,0 +1,7 @@
+// @target: ES6
+// @noEmitHelpers: true
+
+var foo = async foo(): Promise<void> => {
+   // Legal to use 'await' in a type context.
+   var v: await;
+}
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts
new file mode 100644
index 0000000000..83e7413c52
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction1_es6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..bf39735d46
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction2_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..4ae27c596f
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..51b34abeca
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction4_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..174a619bdf
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..dace96c493
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..b1fd5cc030
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts
@@ -0,0 +1,8 @@
+// @target: ES6
+// @noEmitHelpers: true
+
+var bar = async (): Promise<void> => {
+  // 'await' here is an identifier, and not an await expression.
+  var foo = async (a = await): Promise<void> => {
+  }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts
new file mode 100644
index 0000000000..5d53338b1b
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+// @noEmitHelpers: true
+
+var foo = async (): Promise<void> => {
+  var v = { [await]: foo }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts
new file mode 100644
index 0000000000..da041fe472
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..8dab2c0408
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es6.ts
@@ -0,0 +1,8 @@
+// @target: ES6
+// @noEmitHelpers: true
+class C {
+   method() {
+      function other() {}
+      var fn = async () => await other.apply(this, arguments);      
+   }
+}
diff --git a/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts
new file mode 100644
index 0000000000..f2c507cbdd
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunctionCapturesThis_es6.ts
@@ -0,0 +1,7 @@
+// @target: ES6
+// @noEmitHelpers: true
+class C {
+   method() {
+      var fn = async () => await this;      
+   }
+}
diff --git a/tests/cases/conformance/async/es6/asyncClass_es6.ts b/tests/cases/conformance/async/es6/asyncClass_es6.ts
new file mode 100644
index 0000000000..22ffe997b0
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncClass_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..d769fad039
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncConstructor_es6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+// @noEmitHelpers: true
+class C {  
+  async constructor() {    
+  }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncDeclare_es6.ts b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts
new file mode 100644
index 0000000000..5e0fb536b3
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncDeclare_es6.ts
@@ -0,0 +1,3 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..4fad7923a8
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncEnum_es6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..79fde60fdc
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncGetter_es6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+// @noEmitHelpers: true
+class C {
+  async get foo() {
+  }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/asyncInterface_es6.ts b/tests/cases/conformance/async/es6/asyncInterface_es6.ts
new file mode 100644
index 0000000000..5d5497d3cd
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncInterface_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..aa4c295d0e
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncModule_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..8eedcbb528
--- /dev/null
+++ b/tests/cases/conformance/async/es6/asyncSetter_es6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+// @noEmitHelpers: true
+class C {
+  async set foo(value) {
+  }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts
new file mode 100644
index 0000000000..46060f309b
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression1_es6.ts
@@ -0,0 +1,9 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p || a;
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts
new file mode 100644
index 0000000000..362f1ecc44
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression2_es6.ts
@@ -0,0 +1,9 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p && a;
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts
new file mode 100644
index 0000000000..d3b0203325
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression3_es6.ts
@@ -0,0 +1,9 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: number;
+declare var p: Promise<number>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p + a;
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts
new file mode 100644
index 0000000000..eba3be31ac
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression4_es6.ts
@@ -0,0 +1,9 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var b = await p, a;
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts
new file mode 100644
index 0000000000..71b173f9e7
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitBinaryExpression/awaitBinaryExpression5_es6.ts
@@ -0,0 +1,10 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "before";
+    var o: { a: boolean; };
+    o.a = await p;
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts
new file mode 100644
index 0000000000..d0442f0968
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression1_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = fn(a, a, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts
new file mode 100644
index 0000000000..6de07ef12f
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression2_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = fn(await p, a, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts
new file mode 100644
index 0000000000..2cc0b7b12d
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression3_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = fn(a, await p, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts
new file mode 100644
index 0000000000..8e349fbc5c
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression4_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = (await pfn)(a, a, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts
new file mode 100644
index 0000000000..bbe81ac94b
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression5_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = o.fn(a, a, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts
new file mode 100644
index 0000000000..09e88f5acb
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression6_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = o.fn(await p, a, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts
new file mode 100644
index 0000000000..fe0182da4a
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression7_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = o.fn(a, await p, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts
new file mode 100644
index 0000000000..e3280eb7c1
--- /dev/null
+++ b/tests/cases/conformance/async/es6/awaitCallExpression/awaitCallExpression8_es6.ts
@@ -0,0 +1,13 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
+declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
+declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
+async function func(): Promise<void> {
+    "before";
+    var b = (await po).fn(a, a, a);
+    "after";
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts
new file mode 100644
index 0000000000..aab1f0013e
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..747d20d7ea
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..bbd7725036
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts
@@ -0,0 +1,3 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..8670fa0281
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts
@@ -0,0 +1,6 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..ba70c61b49
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+// @noEmitHelpers: true
+async function foo(): Promise<void> {
+  return;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts
new file mode 100644
index 0000000000..289a65bb74
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..25a153b4a3
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration2_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..4ae27c596f
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..5d1ec389da
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration4_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..eb3cd1db55
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..89b0445fd2
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts
@@ -0,0 +1,4 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..5a964695da
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts
@@ -0,0 +1,7 @@
+// @target: ES6
+// @noEmitHelpers: true
+async function bar(): Promise<void> {
+  // 'await' here is an identifier, and not a yield expression.
+  async function foo(a = await): Promise<void> {
+  }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts
new file mode 100644
index 0000000000..764b0f3fb8
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts
@@ -0,0 +1,3 @@
+// @target: ES6
+// @noEmitHelpers: 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
new file mode 100644
index 0000000000..7671764ad2
--- /dev/null
+++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts
@@ -0,0 +1,5 @@
+// @target: ES6
+// @noEmitHelpers: true
+async function foo(): Promise<void> {
+  var v = { [await]: foo }
+}
\ No newline at end of file