Move 'use strict' directive out of generator for async function.

src/compiler/transformers/generators.ts

@@ -572,10 +572,12 @@ namespace ts {
             operationLocations = undefined;
             state = createTempVariable(/*recordTempVariable*/ undefined);
 
+            const statementOffset = addPrologueDirectives(statements, body.statements);
+
             // Build the generator
             startLexicalEnvironment();
 
-            transformAndEmitStatements(body.statements);
+            transformAndEmitStatements(body.statements, statementOffset);
 
             const buildResult = build();
             addNodes(statements, endLexicalEnvironment());
@@ -1117,9 +1119,10 @@ namespace ts {
             return visitEachChild(node, visitor, context);
         }
 
-        function transformAndEmitStatements(statements: Statement[]) {
-            for (const statement of statements) {
-                transformAndEmitStatement(statement);
+        function transformAndEmitStatements(statements: Statement[], start = 0) {
+            const numStatements = statements.length;
+            for (let i = start; i < numStatements; i++) {
+                transformAndEmitStatement(statements[i]);
             }
         }
 

src/compiler/transformers/ts.ts

@@ -2181,11 +2181,13 @@ namespace ts {
             return transformFunctionBodyWorker(node.body);
         }
 
-        function transformFunctionBodyWorker(body: Block) {
+        function transformFunctionBodyWorker(body: Block, start = 0) {
             const savedCurrentScope = currentScope;
             currentScope = body;
             startLexicalEnvironment();
-            const visited = visitEachChild(body, visitor, context);
+
+            const statements = visitNodes(body.statements, visitor, isStatement, start);
+            const visited = updateBlock(body, statements);
             const declarations = endLexicalEnvironment();
             currentScope = savedCurrentScope;
             return mergeFunctionBodyLexicalEnvironment(visited, declarations);
@@ -2233,14 +2235,14 @@ namespace ts {
 
             if (!isArrowFunction) {
                 const statements: Statement[] = [];
-
+                const statementOffset = addPrologueDirectives(statements, (<Block>node.body).statements);
                 statements.push(
                     createReturn(
                         createAwaiterHelper(
                             currentSourceFileExternalHelpersModuleName,
                             hasLexicalArguments,
                             promiseConstructor,
-                            transformFunctionBodyWorker(<Block>node.body)
+                            transformFunctionBodyWorker(<Block>node.body, statementOffset)
                         )
                     )
                 );

tests/baselines/reference/asyncUseStrict_es6.js

@@ -0,0 +1,15 @@
+//// [asyncUseStrict_es6.ts]
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "use strict";
+    var b = await p || a;
+}
+
+//// [asyncUseStrict_es6.js]
+function func() {
+    "use strict";
+    return __awaiter(this, void 0, void 0, function* () {
+        var b = (yield p) || a;
+    });
+}

tests/baselines/reference/asyncUseStrict_es6.symbols

@@ -0,0 +1,18 @@
+=== tests/cases/conformance/async/es6/asyncUseStrict_es6.ts ===
+declare var a: boolean;
+>a : Symbol(a, Decl(asyncUseStrict_es6.ts, 0, 11))
+
+declare var p: Promise<boolean>;
+>p : Symbol(p, Decl(asyncUseStrict_es6.ts, 1, 11))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+async function func(): Promise<void> {
+>func : Symbol(func, Decl(asyncUseStrict_es6.ts, 1, 32))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+    "use strict";
+    var b = await p || a;
+>b : Symbol(b, Decl(asyncUseStrict_es6.ts, 4, 7))
+>p : Symbol(p, Decl(asyncUseStrict_es6.ts, 1, 11))
+>a : Symbol(a, Decl(asyncUseStrict_es6.ts, 0, 11))
+}

tests/baselines/reference/asyncUseStrict_es6.types

@@ -0,0 +1,22 @@
+=== tests/cases/conformance/async/es6/asyncUseStrict_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>
+
+    "use strict";
+>"use strict" : string
+
+    var b = await p || a;
+>b : boolean
+>await p || a : boolean
+>await p : boolean
+>p : Promise<boolean>
+>a : boolean
+}

tests/cases/conformance/async/es6/asyncUseStrict_es6.ts

@@ -0,0 +1,8 @@
+// @target: ES6
+// @noEmitHelpers: true
+declare var a: boolean;
+declare var p: Promise<boolean>;
+async function func(): Promise<void> {
+    "use strict";
+    var b = await p || a;
+}