tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/async.js

@@ -0,0 +1,645 @@
+// ES2017 async functions: the body becomes a generator run by `__awaiter`, with `await` as
+// `yield`, and `this`, `arguments` and `super` accesses captured outside of the generator.
+import { ArrowFunction, BindingPattern, Block, CatchClause, ConstructorDeclaration, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, MethodDeclaration, ParameterDeclaration, SetAccessorDeclaration, SourceFile, VariableDeclaration, VariableDeclarationList, VariableStatement, YieldExpression, getBody, getName, getParameters, ArrayLiteralExpression, SpreadElement, ReturnStatement, AwaitExpression, QualifiedName, Token, getLabel, getPropertyName, } from '../ast.js';
+import { createAwaiterHelper, advancedAsyncSuperHelper, asyncSuperHelper } from '../printer/async-helpers.js';
+import { SuperAccess, getFunctionFlags, isFunctionLikeDeclaration, isSimpleParameterList, } from './async-utilities.js';
+import { convertBindingNameToTarget } from './destructuring.js';
+import { Transformer } from './transformer.js';
+import { VisitorBase } from './visitor-base.js';
+class AsyncModeVisitor extends VisitorBase {
+    owner;
+    mode;
+    constructor(owner, mode) {
+        super(owner.context);
+        this.owner = owner;
+        this.mode = mode;
+    }
+    visit(node) {
+        return this.mode === 0 /* Mode.AsyncBody */ ? this.owner.visitAsyncBodyNode(node) : this.owner.fallback(node);
+    }
+}
+export class AsyncFunctions extends Transformer {
+    facts;
+    superAccess;
+    asyncBodyVisitor;
+    fallbackVisitor;
+    contextFlags;
+    enclosingFunctionParameterNames;
+    /** The `_arguments` binding of the enclosing async function, if any. */
+    argumentsBinding;
+    argumentsUsed;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+        this.superAccess = new SuperAccess(context);
+        this.asyncBodyVisitor = new AsyncModeVisitor(this, 0 /* Mode.AsyncBody */);
+        this.fallbackVisitor = new AsyncModeVisitor(this, 1 /* Mode.Fallback */);
+        this.contextFlags = 0 /* ContextFlags.None */;
+        this.enclosingFunctionParameterNames = undefined;
+        this.argumentsBinding = undefined;
+        this.argumentsUsed = false;
+    }
+    visit(node) {
+        if ((this.context.getEmitFlags(node) & 16777216 /* EmitFlags.NoLexicalThis */) !== 0 &&
+            (this.contextFlags & 2 /* ContextFlags.HasLexicalThis */) !== 0) {
+            this.contextFlags &= ~2 /* ContextFlags.HasLexicalThis */;
+            const result = this.visitWorker(node);
+            this.contextFlags |= 2 /* ContextFlags.HasLexicalThis */;
+            return result;
+        }
+        return this.visitWorker(node);
+    }
+    visitWorker(node) {
+        if (!this.facts.has(node, 512 /* SubtreeFacts.ContainsAnyAwait */ | 32768 /* SubtreeFacts.ContainsAwait */))
+            return this.fallback(node);
+        this.superAccess.track(node);
+        switch (node.kind) {
+            case 133 /* SyntaxKind.AsyncKeyword */:
+                return undefined;
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile)
+                    return this.visitSourceFile(node);
+                break;
+            case 224 /* SyntaxKind.AwaitExpression */:
+                if (node instanceof AwaitExpression)
+                    return this.visitAwaitExpression(node);
+                break;
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 177 /* SyntaxKind.Constructor */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */: {
+                const flags = node.kind === 220 /* SyntaxKind.ArrowFunction */
+                    ? 1 /* ContextFlags.NonTopLevel */
+                    : 1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */;
+                const added = flags & ~this.contextFlags;
+                this.contextFlags |= added;
+                const result = this.visitFunctionOrClass(node);
+                this.contextFlags &= ~added;
+                return result;
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    visitFunctionOrClass(node) {
+        if (node instanceof MethodDeclaration)
+            return this.visitMethodDeclaration(node);
+        if (node instanceof FunctionDeclaration)
+            return this.visitFunctionDeclaration(node);
+        if (node instanceof FunctionExpression)
+            return this.visitFunctionExpression(node);
+        if (node instanceof ArrowFunction)
+            return this.visitArrowFunction(node);
+        if (node instanceof GetAccessorDeclaration)
+            return this.visitGetAccessor(node);
+        if (node instanceof SetAccessorDeclaration)
+            return this.visitSetAccessor(node);
+        if (node instanceof ConstructorDeclaration)
+            return this.visitConstructor(node);
+        return this.visitEachChild(node);
+    }
+    /** Rewrites `arguments` and `super` in subtrees without `await`, when inside an async body. */
+    fallback(node) {
+        if (this.superAccess.capturedSuperProperties === undefined && this.argumentsBinding === undefined)
+            return node;
+        this.superAccess.track(node);
+        switch (node.kind) {
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 177 /* SyntaxKind.Constructor */:
+                return node;
+            case 79 /* SyntaxKind.Identifier */:
+                if (this.argumentsBinding !== undefined &&
+                    node instanceof Identifier &&
+                    node.text === 'arguments' &&
+                    !isIdentifierNameOrLabel(node)) {
+                    this.argumentsUsed = true;
+                    return this.argumentsBinding;
+                }
+                break;
+        }
+        return this.fallbackVisitor.visitEachChild(node);
+    }
+    visitSourceFile(node) {
+        if (node.isDeclarationFile)
+            return node;
+        this.contextFlags &= ~(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */);
+        const visited = this.visitEachChild(node);
+        const helpers = this.context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            this.context.addEmitHelper(visited, helpers[i]);
+        return visited;
+    }
+    // Async bodies
+    visitAsyncBodyNode(node) {
+        switch (node.kind) {
+            case 244 /* SyntaxKind.VariableStatement */:
+                if (node instanceof VariableStatement)
+                    return this.visitVariableStatementInAsyncBody(node);
+                break;
+            case 249 /* SyntaxKind.ForStatement */:
+                if (node instanceof ForStatement)
+                    return this.visitForStatementInAsyncBody(node);
+                break;
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+                if (node instanceof ForInOrOfStatement)
+                    return this.visitForInOrOfStatementInAsyncBody(node);
+                break;
+            case 300 /* SyntaxKind.CatchClause */:
+                if (node instanceof CatchClause)
+                    return this.visitCatchClauseInAsyncBody(node);
+                break;
+            case 242 /* SyntaxKind.Block */:
+            case 256 /* SyntaxKind.SwitchStatement */:
+            case 270 /* SyntaxKind.CaseBlock */:
+            case 297 /* SyntaxKind.CaseClause */:
+            case 298 /* SyntaxKind.DefaultClause */:
+            case 259 /* SyntaxKind.TryStatement */:
+            case 247 /* SyntaxKind.DoStatement */:
+            case 248 /* SyntaxKind.WhileStatement */:
+            case 246 /* SyntaxKind.IfStatement */:
+            case 255 /* SyntaxKind.WithStatement */:
+            case 257 /* SyntaxKind.LabeledStatement */:
+                return this.asyncBodyVisitor.visitEachChild(node);
+        }
+        return this.visit(node);
+    }
+    visitCatchClauseInAsyncBody(node) {
+        const names = [];
+        if (node.variableDeclaration !== undefined)
+            recordDeclarationName(node.variableDeclaration, names);
+        // Names declared by a catch variable are block scoped.
+        let unshadowed = undefined;
+        const enclosing = this.enclosingFunctionParameterNames;
+        for (let i = 0; i < names.length; i++) {
+            if (enclosing !== undefined && enclosing.indexOf(names[i]) >= 0) {
+                if (unshadowed === undefined)
+                    unshadowed = enclosing.slice();
+                const at = unshadowed.indexOf(names[i]);
+                if (at >= 0)
+                    unshadowed.splice(at, 1);
+            }
+        }
+        if (unshadowed === undefined)
+            return this.asyncBodyVisitor.visitEachChild(node);
+        this.enclosingFunctionParameterNames = unshadowed;
+        const result = this.asyncBodyVisitor.visitEachChild(node);
+        this.enclosingFunctionParameterNames = enclosing;
+        return result;
+    }
+    visitVariableStatementInAsyncBody(node) {
+        const list = node.declarationList;
+        if (this.isVariableDeclarationListWithCollidingName(list)) {
+            const expression = this.visitVariableDeclarationListWithCollidingNames(list, false);
+            return expression !== undefined ? this.factory.createExpressionStatement(expression) : undefined;
+        }
+        return this.visitEachChild(node);
+    }
+    visitForInOrOfStatementInAsyncBody(node) {
+        const initializer = node.initializer;
+        const visitedInitializer = initializer instanceof VariableDeclarationList &&
+            this.isVariableDeclarationListWithCollidingName(initializer)
+            ? this.visitVariableDeclarationListWithCollidingNames(initializer, true)
+            : this.visitNode(initializer);
+        return this.factory.updateForInOrOfStatement(node, node.kind === 251 /* SyntaxKind.ForOfStatement */ ? asToken(this.visitNode(node.awaitModifier)) : undefined, visitedInitializer, this.visitNode(node.expression), this.asyncBodyVisitor.visitEmbeddedStatement(node.statement));
+    }
+    visitForStatementInAsyncBody(node) {
+        const initializer = node.initializer;
+        const visitedInitializer = initializer instanceof VariableDeclarationList &&
+            this.isVariableDeclarationListWithCollidingName(initializer)
+            ? this.visitVariableDeclarationListWithCollidingNames(initializer, false)
+            : this.visitNode(initializer);
+        return this.factory.updateForStatement(node, visitedInitializer, this.visitNode(node.condition), this.visitNode(node.incrementor), this.asyncBodyVisitor.visitEmbeddedStatement(node.statement));
+    }
+    /** `await x` as `yield x`, except at the top level, where it's module syntax. */
+    visitAwaitExpression(node) {
+        if ((this.contextFlags & 1 /* ContextFlags.NonTopLevel */) === 0)
+            return this.visitEachChild(node);
+        const result = this.factory.created(new YieldExpression(undefined, this.visitNode(node.expression)));
+        result.pos = node.pos;
+        result.end = node.end;
+        this.context.setOriginal(result, node);
+        return result;
+    }
+    // Functions
+    visitConstructor(node) {
+        const savedBinding = this.argumentsBinding;
+        const savedUsed = this.argumentsUsed;
+        this.argumentsBinding = undefined;
+        this.argumentsUsed = false;
+        const updated = this.factory.updateConstructorDeclaration(node, this.visitModifiers(node.modifiers), undefined, this.visitParameters(node.parameters), undefined, undefined, this.transformMethodBody(node));
+        this.argumentsBinding = savedBinding;
+        this.argumentsUsed = savedUsed;
+        return updated;
+    }
+    visitMethodDeclaration(node) {
+        const savedBinding = this.argumentsBinding;
+        const savedUsed = this.argumentsUsed;
+        this.argumentsBinding = undefined;
+        this.argumentsUsed = false;
+        let parameters;
+        let body;
+        if ((getFunctionFlags(node) & 2 /* FunctionFlags.Async */) !== 0) {
+            parameters = this.transformAsyncFunctionParameterList(node);
+            body = this.transformAsyncFunctionBody(node, parameters);
+        }
+        else {
+            parameters = this.visitParameters(node.parameters);
+            body = this.transformMethodBody(node);
+        }
+        const updated = this.factory.updateMethodDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, node.name, undefined, undefined, parameters, undefined, undefined, body);
+        this.argumentsBinding = savedBinding;
+        this.argumentsUsed = savedUsed;
+        return updated;
+    }
+    visitGetAccessor(node) {
+        const savedBinding = this.argumentsBinding;
+        const savedUsed = this.argumentsUsed;
+        this.argumentsBinding = undefined;
+        this.argumentsUsed = false;
+        const updated = this.factory.updateGetAccessorDeclaration(node, this.visitModifiers(node.modifiers), node.name, undefined, this.visitParameters(node.parameters), undefined, undefined, this.transformMethodBody(node));
+        this.argumentsBinding = savedBinding;
+        this.argumentsUsed = savedUsed;
+        return updated;
+    }
+    visitSetAccessor(node) {
+        const savedBinding = this.argumentsBinding;
+        const savedUsed = this.argumentsUsed;
+        this.argumentsBinding = undefined;
+        this.argumentsUsed = false;
+        const updated = this.factory.updateSetAccessorDeclaration(node, this.visitModifiers(node.modifiers), node.name, undefined, this.visitParameters(node.parameters), undefined, undefined, this.transformMethodBody(node));
+        this.argumentsBinding = savedBinding;
+        this.argumentsUsed = savedUsed;
+        return updated;
+    }
+    visitFunctionDeclaration(node) {
+        const savedBinding = this.argumentsBinding;
+        const savedUsed = this.argumentsUsed;
+        this.argumentsBinding = undefined;
+        this.argumentsUsed = false;
+        let parameters;
+        let body;
+        if ((getFunctionFlags(node) & 2 /* FunctionFlags.Async */) !== 0) {
+            parameters = this.transformAsyncFunctionParameterList(node);
+            body = this.transformAsyncFunctionBody(node, parameters);
+        }
+        else {
+            parameters = this.visitParameters(node.parameters);
+            body = this.visitFunctionBody(node.body);
+        }
+        const updated = this.factory.updateFunctionDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, asIdentifier(this.visitNode(node.name)), undefined, parameters, undefined, undefined, body);
+        this.argumentsBinding = savedBinding;
+        this.argumentsUsed = savedUsed;
+        return updated;
+    }
+    visitFunctionExpression(node) {
+        const savedBinding = this.argumentsBinding;
+        const savedUsed = this.argumentsUsed;
+        this.argumentsBinding = undefined;
+        this.argumentsUsed = false;
+        let parameters;
+        let body;
+        if ((getFunctionFlags(node) & 2 /* FunctionFlags.Async */) !== 0) {
+            parameters = this.transformAsyncFunctionParameterList(node);
+            body = this.transformAsyncFunctionBody(node, parameters);
+        }
+        else {
+            parameters = this.visitParameters(node.parameters);
+            body = this.visitFunctionBody(node.body);
+        }
+        const updated = this.factory.updateFunctionExpression(node, this.visitModifiers(node.modifiers), node.asteriskToken, asIdentifier(this.visitNode(node.name)), undefined, parameters, undefined, undefined, body);
+        this.argumentsBinding = savedBinding;
+        this.argumentsUsed = savedUsed;
+        return updated;
+    }
+    visitArrowFunction(node) {
+        // `arguments` in a class static block is an error; tsgo leaves it as is.
+        if ((this.context.getEmitFlags(node) & 4194304 /* EmitFlags.NoLexicalArguments */) !== 0) {
+            const savedBinding = this.argumentsBinding;
+            const savedUsed = this.argumentsUsed;
+            this.argumentsBinding = undefined;
+            this.argumentsUsed = false;
+            const result = this.visitArrowFunctionWorker(node);
+            this.argumentsBinding = savedBinding;
+            this.argumentsUsed = savedUsed;
+            return result;
+        }
+        return this.visitArrowFunctionWorker(node);
+    }
+    visitArrowFunctionWorker(node) {
+        let parameters;
+        let body;
+        if ((getFunctionFlags(node) & 2 /* FunctionFlags.Async */) !== 0) {
+            parameters = this.transformAsyncFunctionParameterList(node);
+            body = this.transformAsyncFunctionBody(node, parameters);
+        }
+        else {
+            parameters = this.visitParameters(node.parameters);
+            body = this.visitFunctionBody(node.body);
+        }
+        return this.factory.updateArrowFunction(node, this.visitModifiers(node.modifiers), undefined, parameters, undefined, undefined, node.equalsGreaterThanToken, body);
+    }
+    // Variables colliding with parameter names
+    isVariableDeclarationListWithCollidingName(node) {
+        if ((node.flags & 7 /* NodeFlags.BlockScoped */) !== 0)
+            return false;
+        const declarations = node.declarations.nodes;
+        for (let i = 0; i < declarations.length; i++)
+            if (this.collidesWithParameterName(declarations[i]))
+                return true;
+        return false;
+    }
+    collidesWithParameterName(node) {
+        const name = getName(node);
+        if (name instanceof Identifier)
+            return (this.enclosingFunctionParameterNames !== undefined &&
+                this.enclosingFunctionParameterNames.indexOf(name.text) >= 0);
+        if (name instanceof BindingPattern) {
+            const elements = name.elements.nodes;
+            for (let i = 0; i < elements.length; i++)
+                if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */ && this.collidesWithParameterName(elements[i]))
+                    return true;
+        }
+        return false;
+    }
+    visitVariableDeclarationListWithCollidingNames(node, hasReceiver) {
+        const declarations = node.declarations.nodes;
+        for (let i = 0; i < declarations.length; i++)
+            this.hoistVariable(declarations[i]);
+        const expressions = [];
+        for (let i = 0; i < declarations.length; i++) {
+            const declaration = declarations[i];
+            if (declaration instanceof VariableDeclaration && declaration.initializer !== undefined)
+                expressions.push(this.transformInitializedVariable(declaration));
+        }
+        if (expressions.length > 0)
+            return this.factory.inlineExpressions(expressions);
+        if (!hasReceiver)
+            return undefined;
+        const name = getName(declarations[0]);
+        return this.visitNode(convertBindingNameToTarget(this, name));
+    }
+    hoistVariable(node) {
+        const name = getName(node);
+        if (name instanceof Identifier)
+            this.context.addVariableDeclaration(name);
+        else if (name instanceof BindingPattern) {
+            const elements = name.elements.nodes;
+            for (let i = 0; i < elements.length; i++)
+                if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */)
+                    this.hoistVariable(elements[i]);
+        }
+        return true;
+    }
+    transformInitializedVariable(node) {
+        const converted = this.factory.createAssignment(convertBindingNameToTarget(this, node.name), node.initializer);
+        this.context.setSourceMapRange(converted, node.pos, node.end);
+        return this.visitNode(converted);
+    }
+    // Bodies
+    transformMethodBody(node) {
+        const superAccess = this.superAccess;
+        const saved = superAccess.enter();
+        const context = this.context;
+        context.startVariableEnvironment();
+        let updated = this.visitFunctionBody(getBody(node));
+        // Capture `super` accesses for arrows.
+        const emitSuperHelpers = superAccess.needsHelpers() &&
+            (getFunctionFlags(this.getOriginalIfFunctionLike(node)) & 3 /* FunctionFlags.AsyncGenerator */) !==
+                3 /* FunctionFlags.AsyncGenerator */;
+        if (emitSuperHelpers && superAccess.capturedSuperProperties.length > 0)
+            context.addInitializationStatement(superAccess.createSuperAccessVariableStatement());
+        const merged = context.mergeEnvironmentList(updated.statements, context.endVariableEnvironment());
+        if (emitSuperHelpers && superAccess.hasSuperElementAccess && !updated.multiLine) {
+            const block = this.factory.created(new Block(merged, true));
+            block.pos = updated.pos;
+            block.end = updated.end;
+            updated = block;
+        }
+        else
+            updated = this.factory.updateBlock(updated, merged, updated.multiLine);
+        if (emitSuperHelpers && superAccess.hasSuperElementAccess)
+            context.addEmitHelper(updated, superAccess.hasSuperPropertyAssignment ? advancedAsyncSuperHelper : asyncSuperHelper);
+        superAccess.exit(saved);
+        return updated;
+    }
+    createCaptureArgumentsStatement() {
+        const factory = this.factory;
+        const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([
+            factory.createVariableDeclaration(this.argumentsBinding, undefined, undefined, factory.createIdentifier('arguments')),
+        ]), 0 /* NodeFlags.None */));
+        this.context.addEmitFlags(statement, 524288 /* EmitFlags.StartOnNewLine */ | 65536 /* EmitFlags.CustomPrologue */);
+        return statement;
+    }
+    /**
+     * The outer function's parameters: the visited ones if simple, else placeholders up to the
+     * first initializer or rest, which keep `length` (and, for arrows, forward the arguments).
+     */
+    transformAsyncFunctionParameterList(node) {
+        const list = getParameters(node);
+        if (isSimpleParameterList(list.nodes))
+            return this.visitParameters(list);
+        const factory = this.factory;
+        const parameters = [];
+        for (let i = 0; i < list.nodes.length; i++) {
+            const parameter = list.nodes[i];
+            if (parameter.initializer !== undefined || parameter.dotDotDotToken !== undefined) {
+                if (node.kind === 220 /* SyntaxKind.ArrowFunction */)
+                    parameters.push(factory.created(new ParameterDeclaration(undefined, factory.createToken(25 /* SyntaxKind.DotDotDotToken */), factory.createUniqueName('args', 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */), undefined, undefined, undefined)));
+                break;
+            }
+            parameters.push(factory.createParameter(factory.createGeneratedNameForNode(parameter.name, 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */, '', '')));
+        }
+        const result = factory.createNodeList(parameters);
+        result.pos = list.pos;
+        result.end = list.end;
+        return result;
+    }
+    transformAsyncFunctionBody(node, outerParameters) {
+        const isArrow = node.kind === 220 /* SyntaxKind.ArrowFunction */;
+        const factory = this.factory;
+        const context = this.context;
+        const superAccess = this.superAccess;
+        const savedSuper = isArrow ? undefined : superAccess.enter();
+        const parameterList = getParameters(node);
+        const parameters = parameterList.nodes;
+        let innerParameters = isSimpleParameterList(parameters) ? undefined : this.visitParameters(parameterList);
+        const savedBinding = this.argumentsBinding;
+        const savedUsed = this.argumentsUsed;
+        const captureLexicalArguments = this.argumentsBinding === undefined;
+        if (captureLexicalArguments) {
+            this.argumentsBinding = factory.createUniqueName('arguments', 0 /* GeneratedIdentifierFlags.None */);
+            this.argumentsUsed = false;
+        }
+        let argumentsExpression = undefined;
+        if (innerParameters !== undefined) {
+            if (isArrow) {
+                // Forward the placeholders of `transformAsyncFunctionParameterList`.
+                const bindings = [];
+                for (let i = 0; i < parameters.length && i < outerParameters.nodes.length; i++) {
+                    const original = parameters[i];
+                    const outer = outerParameters.nodes[i];
+                    if (original.initializer !== undefined || original.dotDotDotToken !== undefined) {
+                        bindings.push(factory.created(new SpreadElement(outer.name)));
+                        break;
+                    }
+                    bindings.push(outer.name);
+                }
+                argumentsExpression = factory.created(new ArrayLiteralExpression(factory.createNodeList(bindings), false));
+            }
+            else
+                argumentsExpression = factory.createIdentifier('arguments');
+        }
+        // The generator runs in the promise callback, so `this` and `arguments` are passed to `__awaiter`.
+        const savedParameterNames = this.enclosingFunctionParameterNames;
+        const parameterNames = [];
+        for (let i = 0; i < parameters.length; i++)
+            recordDeclarationName(parameters[i], parameterNames);
+        this.enclosingFunctionParameterNames = parameterNames;
+        const hasLexicalThis = (this.contextFlags & 2 /* ContextFlags.HasLexicalThis */) !== 0;
+        let asyncBody = this.transformAsyncFunctionBodyWorker(getBody(node));
+        asyncBody = factory.updateBlock(asyncBody, context.mergeEnvironmentList(asyncBody.statements, context.endVariableEnvironment()), asyncBody.multiLine);
+        const emitSuperHelpers = superAccess.needsHelpers();
+        if (emitSuperHelpers) {
+            innerParameters = superAccess.visitNodes(innerParameters);
+            asyncBody = superAccess.visitNode(asyncBody);
+        }
+        let result;
+        if (!isArrow) {
+            context.startVariableEnvironment();
+            if (emitSuperHelpers && superAccess.capturedSuperProperties.length > 0)
+                context.addInitializationStatement(superAccess.createSuperAccessVariableStatement());
+            if (captureLexicalArguments && this.argumentsUsed)
+                context.addInitializationStatement(this.createCaptureArgumentsStatement());
+            const statements = [
+                factory.createReturnStatement(createAwaiterHelper(factory, hasLexicalThis, argumentsExpression, innerParameters, asyncBody)),
+            ];
+            const block = factory.createBlock(context.mergeEnvironment(statements, context.endVariableEnvironment()), true);
+            const body = getBody(node);
+            block.pos = body.pos;
+            block.end = body.end;
+            if (emitSuperHelpers && superAccess.hasSuperElementAccess)
+                context.addEmitHelper(block, superAccess.hasSuperPropertyAssignment ? advancedAsyncSuperHelper : asyncSuperHelper);
+            result = block;
+        }
+        else {
+            result = createAwaiterHelper(factory, hasLexicalThis, argumentsExpression, innerParameters, asyncBody);
+            if (captureLexicalArguments && this.argumentsUsed) {
+                const block = this.convertToFunctionBlock(result);
+                result = factory.updateBlock(block, context.mergeEnvironmentList(block.statements, [this.createCaptureArgumentsStatement()]), block.multiLine);
+            }
+        }
+        this.enclosingFunctionParameterNames = savedParameterNames;
+        if (savedSuper !== undefined) {
+            superAccess.exit(savedSuper);
+            this.argumentsBinding = savedBinding;
+            this.argumentsUsed = savedUsed;
+        }
+        else if (captureLexicalArguments && !this.argumentsUsed) {
+            this.argumentsBinding = savedBinding;
+            this.argumentsUsed = savedUsed;
+        }
+        else if (captureLexicalArguments) {
+            // Keep the hoisted binding for sibling arrows, without capturing it again.
+            this.argumentsUsed = false;
+        }
+        return result;
+    }
+    transformAsyncFunctionBodyWorker(body) {
+        const factory = this.factory;
+        if (body instanceof Block)
+            return factory.updateBlock(body, this.asyncBodyVisitor.visitNodes(body.statements), body.multiLine);
+        // An expression body becomes `{ return body; }`.
+        const visited = this.asyncBodyVisitor.visitNode(body);
+        const statement = factory.createReturnStatement(visited);
+        statement.pos = body.pos;
+        statement.end = body.end;
+        const block = factory.createBlock([statement], false);
+        block.statements.pos = body.pos;
+        block.statements.end = body.end;
+        block.pos = body.pos;
+        block.end = body.end;
+        return block;
+    }
+    convertToFunctionBlock(node) {
+        if (node instanceof Block)
+            return node;
+        const factory = this.factory;
+        const statement = factory.created(new ReturnStatement(node));
+        statement.pos = node.pos;
+        statement.end = node.end;
+        this.context.setOriginal(statement, node);
+        const block = factory.createBlock([statement], true);
+        block.statements.pos = node.pos;
+        block.statements.end = node.end;
+        block.pos = node.pos;
+        block.end = node.end;
+        return block;
+    }
+    getOriginalIfFunctionLike(node) {
+        const original = this.context.mostOriginal(node);
+        return isFunctionLikeDeclaration(original) ? original : node;
+    }
+}
+function recordDeclarationName(node, names) {
+    const name = getName(node);
+    if (name instanceof Identifier) {
+        if (names.indexOf(name.text) < 0)
+            names.push(name.text);
+    }
+    else if (name instanceof BindingPattern) {
+        const elements = name.elements.nodes;
+        for (let i = 0; i < elements.length; i++)
+            if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */)
+                recordDeclarationName(elements[i], names);
+    }
+    return true;
+}
+/** Whether an identifier is a property name or a label rather than a reference. */
+function isIdentifierNameOrLabel(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return false;
+    switch (parent.kind) {
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 306 /* SyntaxKind.EnumMember */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+            return getName(parent) === node;
+        case 167 /* SyntaxKind.QualifiedName */:
+            return parent instanceof QualifiedName && parent.right === node;
+        case 209 /* SyntaxKind.BindingElement */:
+        case 277 /* SyntaxKind.ImportSpecifier */:
+            return getPropertyName(parent) === node;
+        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 292 /* SyntaxKind.JsxAttribute */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+        case 288 /* SyntaxKind.JsxClosingElement */:
+            return true;
+        case 257 /* SyntaxKind.LabeledStatement */:
+        case 253 /* SyntaxKind.BreakStatement */:
+        case 252 /* SyntaxKind.ContinueStatement */:
+            return getLabel(parent) === node;
+    }
+    return false;
+}
+function asToken(node) {
+    return node instanceof Token ? node : undefined;
+}
+function asIdentifier(node) {
+    return node instanceof Identifier ? node : undefined;
+}