tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/object-rest-spread.js

@@ -0,0 +1,411 @@
+// Lowers object spread to `Object.assign` and object rest elements to `__rest`, for targets
+// before ES2018.
+import { ArrowFunction, BindingPattern, Block, ConstructorDeclaration, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, MethodDeclaration, NodeList, PropertyAssignment, SetAccessorDeclaration, SpreadAssignment, SyntaxList, getBody, getParameters, } from '../ast.js';
+import { isDestructuringAssignment, skipParentheses } from '../binder-utilities.js';
+import { isPrologueDirective } from '../printer/utilities.js';
+import { flattenDestructuringBinding, flattenObjectRestAssignment } from './destructuring.js';
+import { Transformer } from './transformer.js';
+import { createForOfBindingStatement, hasSyntacticModifier } from './utilities.js';
+export class ObjectRestSpreadTransformer extends Transformer {
+    facts;
+    inExportedVariableStatement;
+    expressionResultIsUnused;
+    /** Parameters after the first one with an object rest element, in the current parameter list. */
+    parametersWithPrecedingObjectRestOrSpread;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+        this.inExportedVariableStatement = false;
+        this.expressionResultIsUnused = false;
+        this.parametersWithPrecedingObjectRestOrSpread = undefined;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 128 /* SubtreeFacts.ContainsESObjectRestOrSpread */) &&
+            this.parametersWithPrecedingObjectRestOrSpread === undefined)
+            return node;
+        // Children see `false` unless a case below says otherwise.
+        const expressionResultIsUnused = this.expressionResultIsUnused;
+        this.expressionResultIsUnused = false;
+        const result = this.visitWorker(node, expressionResultIsUnused);
+        this.expressionResultIsUnused = expressionResultIsUnused;
+        return result;
+    }
+    visitWorker(node, expressionResultIsUnused) {
+        switch (node.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+                return this.visitSourceFile(node);
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+                return this.visitObjectLiteralExpression(node);
+            case 227 /* SyntaxKind.BinaryExpression */:
+                return this.visitBinaryExpression(node, expressionResultIsUnused);
+            case 245 /* SyntaxKind.ExpressionStatement */:
+                this.expressionResultIsUnused = true;
+                return this.visitEachChild(node);
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                this.expressionResultIsUnused = expressionResultIsUnused;
+                return this.visitEachChild(node);
+            case 251 /* SyntaxKind.ForOfStatement */:
+                return this.visitForOfStatement(node);
+            case 244 /* SyntaxKind.VariableStatement */:
+                return this.visitVariableStatement(node);
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                return this.visitVariableDeclaration(node);
+            case 300 /* SyntaxKind.CatchClause */:
+                return this.visitCatchClause(node);
+            case 170 /* SyntaxKind.Parameter */:
+                return this.visitParameter(node);
+            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+                return this.visitFunctionLike(node);
+        }
+        return this.visitEachChild(node);
+    }
+    visitSourceFile(node) {
+        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;
+    }
+    visitParameter(node) {
+        const factory = this.factory;
+        const preceding = this.parametersWithPrecedingObjectRestOrSpread;
+        if (preceding !== undefined && preceding.has(node)) {
+            const name = node.name instanceof BindingPattern ? factory.createGeneratedNameForNode(node, 0, '', '') : node.name;
+            return factory.updateParameterDeclaration(node, undefined, node.dotDotDotToken, name, undefined, undefined, undefined);
+        }
+        // A pattern with an object rest becomes a generated name, destructured in the body.
+        if (this.facts.has(node, 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */))
+            return factory.updateParameterDeclaration(node, undefined, node.dotDotDotToken, factory.createGeneratedNameForNode(node, 0, '', ''), undefined, undefined, this.visitNode(node.initializer));
+        return this.visitEachChild(node);
+    }
+    collectParametersWithPrecedingObjectRestOrSpread(node) {
+        let result = undefined;
+        const parameters = getParameters(node).nodes;
+        for (let i = 0; i < parameters.length; i++) {
+            if (result !== undefined)
+                result.add(parameters[i]);
+            else if (this.facts.has(parameters[i], 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */))
+                result = new Set();
+        }
+        return result;
+    }
+    visitFunctionLike(node) {
+        const saved = this.parametersWithPrecedingObjectRestOrSpread;
+        this.parametersWithPrecedingObjectRestOrSpread = this.collectParametersWithPrecedingObjectRestOrSpread(node);
+        const result = this.updateFunctionLike(node);
+        this.parametersWithPrecedingObjectRestOrSpread = saved;
+        return result;
+    }
+    updateFunctionLike(node) {
+        const factory = this.factory;
+        if (node instanceof ConstructorDeclaration) {
+            const parameters = this.visitNodes(node.parameters);
+            return factory.updateConstructorDeclaration(node, node.modifiers, undefined, parameters, undefined, undefined, this.transformFunctionBody(node));
+        }
+        if (node instanceof GetAccessorDeclaration) {
+            const name = this.visitNode(node.name);
+            const parameters = this.visitNodes(node.parameters);
+            return factory.updateGetAccessorDeclaration(node, node.modifiers, name, undefined, parameters, undefined, undefined, this.transformFunctionBody(node));
+        }
+        if (node instanceof SetAccessorDeclaration) {
+            const name = this.visitNode(node.name);
+            const parameters = this.visitNodes(node.parameters);
+            return factory.updateSetAccessorDeclaration(node, node.modifiers, name, undefined, parameters, undefined, undefined, this.transformFunctionBody(node));
+        }
+        if (node instanceof MethodDeclaration) {
+            const name = this.visitNode(node.name);
+            const parameters = this.visitNodes(node.parameters);
+            return factory.updateMethodDeclaration(node, node.modifiers, node.asteriskToken, name, node.postfixToken, undefined, parameters, undefined, undefined, this.transformFunctionBody(node));
+        }
+        if (node instanceof FunctionDeclaration) {
+            const name = node.name === undefined ? undefined : this.visitNode(node.name);
+            const parameters = this.visitNodes(node.parameters);
+            return factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, name, undefined, parameters, undefined, undefined, this.transformFunctionBody(node));
+        }
+        if (node instanceof ArrowFunction) {
+            const parameters = this.visitNodes(node.parameters);
+            return factory.updateArrowFunction(node, node.modifiers, undefined, parameters, undefined, undefined, node.equalsGreaterThanToken, this.transformFunctionBody(node));
+        }
+        if (node instanceof FunctionExpression) {
+            const name = node.name === undefined ? undefined : this.visitNode(node.name);
+            const parameters = this.visitNodes(node.parameters);
+            return factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, name, undefined, parameters, undefined, undefined, this.transformFunctionBody(node));
+        }
+        return this.visitEachChild(node);
+    }
+    /** The visited body, with the destructuring of parameters with object rest elements prepended. */
+    transformFunctionBody(node) {
+        const factory = this.factory;
+        const context = this.context;
+        // Not `visitFunctionBody`: the rest assignments go between the body and the hoisted variables.
+        context.startVariableEnvironment();
+        let body = this.visitNode(getBody(node));
+        let extras = context.endVariableEnvironment();
+        context.startVariableEnvironment();
+        const newStatements = this.collectObjectRestAssignments(node);
+        extras = context.mergeEnvironment(extras, context.endVariableEnvironment());
+        if (newStatements.length === 0 && extras.length === 0)
+            return body;
+        if (body === undefined)
+            body = factory.createBlock([], true);
+        const prefix = [];
+        let suffix = [];
+        let block;
+        if (body instanceof Block) {
+            block = body;
+            const statements = body.statements.nodes;
+            let custom = false;
+            for (let i = 0; i < statements.length; i++) {
+                const statement = statements[i];
+                if (!custom && isPrologueDirective(statement))
+                    prefix.push(statement);
+                else if ((context.getEmitFlags(statement) & 65536 /* EmitFlags.CustomPrologue */) !== 0) {
+                    custom = true;
+                    prefix.push(statement);
+                }
+                else {
+                    suffix = statements.slice(i);
+                    break;
+                }
+            }
+        }
+        else {
+            const statement = factory.createReturnStatement(body);
+            statement.pos = body.pos;
+            statement.end = body.end;
+            const list = factory.createNodeList([]);
+            list.pos = body.pos;
+            list.end = body.end;
+            block = factory.created(new Block(list, true));
+            suffix.push(statement);
+        }
+        const statements = prefix.concat(extras, newStatements, suffix);
+        return factory.updateBlock(block, new NodeList(block.statements.pos, block.statements.end, statements), block.multiLine);
+    }
+    collectObjectRestAssignments(node) {
+        const factory = this.factory;
+        const context = this.context;
+        const results = [];
+        let containsPrecedingObjectRestOrSpread = false;
+        const parameters = getParameters(node).nodes;
+        for (let i = 0; i < parameters.length; i++) {
+            const parameter = parameters[i];
+            if (containsPrecedingObjectRestOrSpread) {
+                if (parameter.name instanceof BindingPattern) {
+                    // `[]` and `{}` declare nothing, but an initializer may have side effects.
+                    if (parameter.name.elements.nodes.length > 0) {
+                        const declarations = flattenDestructuringBinding(this, undefined, parameter, factory.createGeneratedNameForNode(parameter, 0, '', ''), false, false);
+                        if (declarations !== undefined)
+                            results.push(this.createPrologueVariableStatement(declarations));
+                    }
+                    else if (parameter.initializer !== undefined) {
+                        const name = factory.createGeneratedNameForNode(parameter, 0, '', '');
+                        const statement = factory.createExpressionStatement(factory.createAssignment(name, this.visitNode(parameter.initializer)));
+                        context.addEmitFlags(statement, 65536 /* EmitFlags.CustomPrologue */);
+                        results.push(statement);
+                    }
+                }
+                else if (parameter.initializer !== undefined)
+                    results.push(this.createDefaultValueStatement(parameter));
+            }
+            else if (this.facts.has(parameter, 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */)) {
+                containsPrecedingObjectRestOrSpread = true;
+                const declarations = flattenDestructuringBinding(this, this.facts, parameter, factory.createGeneratedNameForNode(parameter, 0, '', ''), false, true);
+                if (declarations !== undefined)
+                    results.push(this.createPrologueVariableStatement(declarations));
+            }
+        }
+        return results;
+    }
+    /** `if (x === void 0) { x = initializer; }` for a parameter after one with an object rest. */
+    createDefaultValueStatement(parameter) {
+        const factory = this.factory;
+        const context = this.context;
+        const original = parameter.name;
+        const name = factory.cloneNode(original, original.deepClone());
+        name.pos = original.pos;
+        name.end = original.end;
+        context.addEmitFlags(name, 12 /* EmitFlags.NoSourceMap */);
+        const initializer = this.visitNode(parameter.initializer);
+        context.addEmitFlags(initializer, 12 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoComments */);
+        const assignment = factory.createAssignment(name, initializer);
+        assignment.pos = parameter.pos;
+        assignment.end = parameter.end;
+        context.addEmitFlags(assignment, 384 /* EmitFlags.NoComments */);
+        const block = factory.createBlock([factory.createExpressionStatement(assignment)], false);
+        block.pos = parameter.pos;
+        block.end = parameter.end;
+        context.addEmitFlags(block, 1 /* EmitFlags.SingleLine */ | 8 /* EmitFlags.NoTrailingSourceMap */ | 96 /* EmitFlags.NoTokenSourceMaps */ | 384 /* EmitFlags.NoComments */);
+        const statement = factory.createIfStatement(factory.createTypeCheck(factory.cloneNode(name, name.deepClone()), 'undefined'), block, undefined);
+        statement.pos = parameter.pos;
+        statement.end = parameter.end;
+        context.addEmitFlags(statement, 96 /* EmitFlags.NoTokenSourceMaps */ |
+            8 /* EmitFlags.NoTrailingSourceMap */ |
+            65536 /* EmitFlags.CustomPrologue */ |
+            384 /* EmitFlags.NoComments */ |
+            524288 /* EmitFlags.StartOnNewLine */);
+        return statement;
+    }
+    /** `var` of flattened declarations, as a custom prologue. */
+    createPrologueVariableStatement(declarations) {
+        const factory = this.factory;
+        const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList(declarationsOf(declarations)), 0 /* NodeFlags.None */));
+        this.context.addEmitFlags(statement, 65536 /* EmitFlags.CustomPrologue */);
+        return statement;
+    }
+    visitCatchClause(node) {
+        const declaration = node.variableDeclaration;
+        if (declaration === undefined ||
+            !(declaration.name instanceof BindingPattern) ||
+            !this.facts.has(declaration.name, 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */))
+            return this.visitEachChild(node);
+        const factory = this.factory;
+        const name = factory.createGeneratedNameForNode(declaration.name, 0, '', '');
+        const updated = factory.updateVariableDeclaration(declaration, declaration.name, undefined, undefined, name);
+        const bindings = flattenDestructuringBinding(this, this.facts, updated, undefined, false, false);
+        let block = this.visitNode(node.block);
+        if (bindings !== undefined) {
+            const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList(declarationsOf(bindings)), 0 /* NodeFlags.None */));
+            const statements = [statement];
+            for (let i = 0; i < block.statements.nodes.length; i++)
+                statements.push(block.statements.nodes[i]);
+            block = factory.updateBlock(block, new NodeList(block.statements.pos, block.statements.end, statements), block.multiLine);
+        }
+        return factory.updateCatchClause(node, factory.updateVariableDeclaration(declaration, name, undefined, undefined, undefined), block);
+    }
+    visitVariableStatement(node) {
+        if (!hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+            return this.visitEachChild(node);
+        const saved = this.inExportedVariableStatement;
+        this.inExportedVariableStatement = true;
+        const result = this.visitEachChild(node);
+        this.inExportedVariableStatement = saved;
+        return result;
+    }
+    visitVariableDeclaration(node) {
+        const exported = this.inExportedVariableStatement;
+        this.inExportedVariableStatement = false;
+        let result;
+        // Only reached for a binding pattern with an object rest somewhere in it.
+        if (node.name instanceof BindingPattern && this.facts.has(node, 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */))
+            result = flattenDestructuringBinding(this, this.facts, node, undefined, exported, false);
+        else
+            result = this.visitEachChild(node);
+        this.inExportedVariableStatement = exported;
+        return result;
+    }
+    visitForOfStatement(node) {
+        const factory = this.factory;
+        const initializer = node.initializer;
+        if (!this.facts.has(initializer, 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */) &&
+            !(isAssignmentPattern(initializer) && this.facts.containsObjectRestOrSpread(initializer)))
+            return this.visitEachChild(node);
+        const head = skipParentheses(initializer);
+        if (head.kind !== 262 /* SyntaxKind.VariableDeclarationList */ && !isAssignmentPattern(head))
+            return this.visitEachChild(node);
+        const temp = factory.createTempVariable(0);
+        const statements = [];
+        const binding = this.visitNode(createForOfBindingStatement(factory, head, temp));
+        if (binding !== undefined)
+            statements.push(binding);
+        let bodyPos = -1;
+        let bodyEnd = -1;
+        let statementsPos = -1;
+        let statementsEnd = -1;
+        const body = node.statement;
+        if (body instanceof Block) {
+            const nodes = body.statements.nodes;
+            for (let i = 0; i < nodes.length; i++)
+                statements.push(this.visitEachChild(nodes[i]));
+            bodyPos = body.pos;
+            bodyEnd = body.end;
+            statementsPos = body.statements.pos;
+            statementsEnd = body.statements.end;
+        }
+        else {
+            statements.push(this.visitEachChild(body));
+            bodyPos = body.pos;
+            bodyEnd = body.end;
+            statementsPos = body.pos;
+            statementsEnd = body.end;
+        }
+        const list = factory.createVariableDeclarationList(factory.createNodeList([factory.createVariableDeclaration(temp, undefined, undefined, undefined)]), 1 /* NodeFlags.Let */);
+        list.pos = initializer.pos;
+        list.end = initializer.end;
+        const expression = this.visitEachChild(node.expression);
+        const block = factory.created(new Block(new NodeList(statementsPos, statementsEnd, statements), true));
+        block.pos = bodyPos;
+        block.end = bodyEnd;
+        return factory.updateForInOrOfStatement(node, node.awaitModifier, list, expression, block);
+    }
+    visitBinaryExpression(node, expressionResultIsUnused) {
+        if (isDestructuringAssignment(node) && this.facts.containsObjectRestOrSpread(node.left))
+            return flattenObjectRestAssignment(this, this.facts, node, !expressionResultIsUnused);
+        if (node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) {
+            this.expressionResultIsUnused = true;
+            const left = this.visitNode(node.left);
+            this.expressionResultIsUnused = expressionResultIsUnused;
+            const right = this.visitNode(node.right);
+            return this.factory.updateBinaryExpression(node, undefined, left, undefined, node.operatorToken, right);
+        }
+        return this.visitEachChild(node);
+    }
+    visitObjectLiteralExpression(node) {
+        if ((this.facts.of(node) & 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */) === 0)
+            return this.visitEachChild(node);
+        // Elements between spreads are chunked into object literals, each merged with one more
+        // `Object.assign` call so side effects run in order: `{ a, ...o, b }` becomes
+        // `Object.assign(Object.assign({ a }, o), { b })`.
+        const factory = this.factory;
+        const objects = this.chunkObjectLiteralElements(node.properties.nodes);
+        if (objects.length > 0 && objects[0].kind !== 211 /* SyntaxKind.ObjectLiteralExpression */)
+            objects.unshift(factory.createObjectLiteral([], false));
+        let expression = objects[0];
+        if (objects.length > 1) {
+            for (let i = 1; i < objects.length; i++)
+                expression = this.createAssign([expression, objects[i]]);
+            return expression;
+        }
+        return this.createAssign(objects);
+    }
+    createAssign(args) {
+        return this.factory.createGlobalMethodCall('Object', 'assign', args);
+    }
+    chunkObjectLiteralElements(elements) {
+        const factory = this.factory;
+        const objects = [];
+        let chunk = [];
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            if (element instanceof SpreadAssignment) {
+                if (chunk.length > 0) {
+                    objects.push(factory.createObjectLiteral(chunk, false));
+                    chunk = [];
+                }
+                objects.push(this.visitNode(element.expression));
+            }
+            else if (element instanceof PropertyAssignment)
+                chunk.push(factory.createPropertyAssignment(element.name, this.visitNode(element.initializer)));
+            else {
+                const visited = this.visitNode(element);
+                if (visited !== undefined)
+                    chunk.push(visited);
+            }
+        }
+        if (chunk.length > 0)
+            objects.push(factory.createObjectLiteral(chunk, false));
+        return objects;
+    }
+}
+function isAssignmentPattern(node) {
+    return node.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || node.kind === 210 /* SyntaxKind.ArrayLiteralExpression */;
+}
+function declarationsOf(node) {
+    return node instanceof SyntaxList ? node.children : [node];
+}

package/dist/api/compiler/transformers/optional-catch.d.ts

@@ -0,0 +1,9 @@
+import { type Node } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+export declare class OptionalCatchTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+}

package/dist/api/compiler/transformers/optional-catch.js

@@ -0,0 +1,20 @@
+// Gives `catch` clauses without a binding a temporary one (ES2019).
+import { Block, CatchClause } from '../ast.js';
+import { Transformer } from './transformer.js';
+export class OptionalCatchTransformer extends Transformer {
+    facts;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 64 /* SubtreeFacts.ContainsMissingCatchClauseVariable */))
+            return node;
+        if (node instanceof CatchClause && node.variableDeclaration === undefined) {
+            const factory = this.factory;
+            const block = this.visitNode(node.block);
+            return factory.created(new CatchClause(factory.createVariableDeclaration(factory.createTempVariable(0), undefined, undefined, undefined), block instanceof Block ? block : node.block));
+        }
+        return this.visitEachChild(node);
+    }
+}

package/dist/api/compiler/transformers/optional-chain.d.ts

@@ -0,0 +1,14 @@
+import { type Node } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+export declare class OptionalChainTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private visitCallExpression;
+    private visitParenthesizedExpression;
+    private visitPropertyOrElementAccessExpression;
+    private visitNonOptionalExpression;
+    private visitOptionalExpression;
+}

package/dist/api/compiler/transformers/optional-chain.js

@@ -0,0 +1,188 @@
+// Lowers optional chains such as `a?.b.c()` to conditionals on `null` and `undefined` (ES2020).
+import { CallExpression, DeleteExpression, ElementAccessExpression, ParenthesizedExpression, PropertyAccessExpression, SyntheticReferenceExpression, TaggedTemplateExpression, } from '../ast.js';
+import { skipParentheses } from '../binder-utilities.js';
+import { skipPartiallyEmittedExpressions } from '../printer/utilities.js';
+import { isSimpleCopiableExpression } from './destructuring.js';
+import { Transformer } from './transformer.js';
+export class OptionalChainTransformer extends Transformer {
+    facts;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 32 /* SubtreeFacts.ContainsOptionalChaining */))
+            return node;
+        switch (node.kind) {
+            case 214 /* SyntaxKind.CallExpression */:
+                return this.visitCallExpression(node, false);
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+                if ((node.flags & 32 /* NodeFlags.OptionalChain */) !== 0)
+                    return this.visitOptionalExpression(node, false, false);
+                break;
+            case 221 /* SyntaxKind.DeleteExpression */:
+                if (node instanceof DeleteExpression &&
+                    (skipParentheses(node.expression).flags & 32 /* NodeFlags.OptionalChain */) !== 0)
+                    return this.visitNonOptionalExpression(node.expression, false, true);
+                break;
+        }
+        return this.visitEachChild(node);
+    }
+    visitCallExpression(node, captureThisArg) {
+        // An optional call chain is the outermost link of an optional expression.
+        if ((node.flags & 32 /* NodeFlags.OptionalChain */) !== 0)
+            return this.visitOptionalExpression(node, captureThisArg, false);
+        const callee = node.expression;
+        if (callee instanceof ParenthesizedExpression && (skipParentheses(callee).flags & 32 /* NodeFlags.OptionalChain */) !== 0) {
+            // `(a?.b)()` calls with `a` as this.
+            const expression = this.visitParenthesizedExpression(callee, true, false);
+            const args = this.visitNodes(node.arguments);
+            if (expression instanceof SyntheticReferenceExpression) {
+                const call = this.factory.createFunctionCallCall(expression.expression, expression.thisArg, args.nodes);
+                call.pos = node.pos;
+                call.end = node.end;
+                this.context.setOriginal(call, node);
+                return call;
+            }
+            return this.factory.updateCallExpression(node, expression, undefined, undefined, args, node.flags);
+        }
+        return this.visitEachChild(node);
+    }
+    visitParenthesizedExpression(node, captureThisArg, isDelete) {
+        const expression = this.visitNonOptionalExpression(node.expression, captureThisArg, isDelete);
+        if (expression instanceof SyntheticReferenceExpression) {
+            // `(a.b)` -> `((_a = a).b)` with this `_a`
+            const reference = this.factory.createSyntheticReferenceExpression(this.factory.updateParenthesizedExpression(node, expression.expression), expression.thisArg);
+            this.context.setOriginal(reference, node);
+            return reference;
+        }
+        return this.factory.updateParenthesizedExpression(node, expression);
+    }
+    visitPropertyOrElementAccessExpression(node, captureThisArg, isDelete) {
+        if ((node.flags & 32 /* NodeFlags.OptionalChain */) !== 0)
+            return this.visitOptionalExpression(node, captureThisArg, isDelete);
+        const factory = this.factory;
+        let expression = this.visitNode(accessedExpression(node));
+        let thisArg = undefined;
+        if (captureThisArg) {
+            if (isSimpleCopiableExpression(expression))
+                thisArg = expression;
+            else {
+                thisArg = this.context.addVariableDeclaration(factory.createTempVariable(0));
+                expression = factory.createAssignment(thisArg, expression);
+            }
+        }
+        if (node instanceof PropertyAccessExpression)
+            expression = factory.updatePropertyAccessExpression(node, expression, undefined, this.visitNode(node.name), node.flags);
+        else if (node instanceof ElementAccessExpression)
+            expression = factory.updateElementAccessExpression(node, expression, undefined, this.visitNode(node.argumentExpression), node.flags);
+        if (thisArg === undefined)
+            return expression;
+        const reference = factory.createSyntheticReferenceExpression(expression, thisArg);
+        this.context.setOriginal(reference, node);
+        return reference;
+    }
+    visitNonOptionalExpression(node, captureThisArg, isDelete) {
+        switch (node.kind) {
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                return this.visitParenthesizedExpression(node, captureThisArg, isDelete);
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                return this.visitPropertyOrElementAccessExpression(node, captureThisArg, isDelete);
+            case 214 /* SyntaxKind.CallExpression */:
+                return this.visitCallExpression(node, captureThisArg);
+        }
+        return this.visitNode(node);
+    }
+    visitOptionalExpression(node, captureThisArg, isDelete) {
+        const factory = this.factory;
+        const context = this.context;
+        // The links of the chain, from the one with `?.` outwards, and the expression they start from.
+        const chain = [node];
+        let link = node;
+        while (!(link instanceof TaggedTemplateExpression) && questionDotTokenOf(link) === undefined) {
+            link = skipPartiallyEmittedExpressions(accessedExpression(link));
+            chain.unshift(link);
+        }
+        const expression = accessedExpression(link);
+        const left = this.visitNonOptionalExpression(skipPartiallyEmittedExpressions(expression), chain[0].kind === 214 /* SyntaxKind.CallExpression */ && (chain[0].flags & 32 /* NodeFlags.OptionalChain */) !== 0, false);
+        let leftThisArg = undefined;
+        let capturedLeft = left;
+        if (left instanceof SyntheticReferenceExpression) {
+            leftThisArg = left.thisArg;
+            capturedLeft = left.expression;
+        }
+        let leftExpression = factory.restoreOuterExpressions(expression, capturedLeft, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */);
+        if (!isSimpleCopiableExpression(capturedLeft)) {
+            capturedLeft = context.addVariableDeclaration(factory.createTempVariable(0));
+            leftExpression = factory.createAssignment(capturedLeft, leftExpression);
+        }
+        let rightExpression = capturedLeft;
+        let thisArg = undefined;
+        for (let i = 0; i < chain.length; i++) {
+            const segment = chain[i];
+            const access = segment.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || segment.kind === 213 /* SyntaxKind.ElementAccessExpression */;
+            if (access) {
+                if (i === chain.length - 1 && captureThisArg) {
+                    if (isSimpleCopiableExpression(rightExpression))
+                        thisArg = rightExpression;
+                    else {
+                        thisArg = context.addVariableDeclaration(factory.createTempVariable(0));
+                        rightExpression = factory.createAssignment(thisArg, rightExpression);
+                    }
+                }
+                if (segment instanceof ElementAccessExpression)
+                    rightExpression = factory.createElementAccessExpression(rightExpression, this.visitNode(segment.argumentExpression));
+                else if (segment instanceof PropertyAccessExpression)
+                    rightExpression = factory.createPropertyAccessExpression(rightExpression, this.visitNode(segment.name));
+            }
+            else if (segment instanceof CallExpression) {
+                if (i === 0 && leftThisArg !== undefined) {
+                    if (!context.hasAutoGenerateInfo(leftThisArg)) {
+                        leftThisArg = factory.cloneNode(leftThisArg, leftThisArg.deepClone());
+                        context.addEmitFlags(leftThisArg, 384 /* EmitFlags.NoComments */);
+                    }
+                    const callThisArg = leftThisArg.kind === 107 /* SyntaxKind.SuperKeyword */ ? factory.createThisExpression() : leftThisArg;
+                    rightExpression = factory.createFunctionCallCall(rightExpression, callThisArg, this.visitNodes(segment.arguments).nodes);
+                }
+                else
+                    rightExpression = factory.created(new CallExpression(rightExpression, undefined, undefined, this.visitNodes(segment.arguments), 0 /* NodeFlags.None */));
+            }
+            context.setOriginal(rightExpression, segment);
+        }
+        const condition = factory.createNotNullCondition(leftExpression, capturedLeft, true);
+        let target = isDelete
+            ? factory.createConditionalExpression(condition, factory.createTrue(), factory.createDeleteExpression(rightExpression))
+            : factory.createConditionalExpression(condition, factory.createVoidZero(), rightExpression);
+        target.pos = node.pos;
+        target.end = node.end;
+        if (thisArg !== undefined)
+            target = factory.createSyntheticReferenceExpression(target, thisArg);
+        context.setOriginal(target, node);
+        return target;
+    }
+}
+function questionDotTokenOf(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.questionDotToken;
+    if (node instanceof ElementAccessExpression)
+        return node.questionDotToken;
+    if (node instanceof CallExpression)
+        return node.questionDotToken;
+    return undefined;
+}
+/** The expression a link of a chain accesses or calls. */
+function accessedExpression(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.expression;
+    if (node instanceof ElementAccessExpression)
+        return node.expression;
+    if (node instanceof CallExpression)
+        return node.expression;
+    if (node instanceof TaggedTemplateExpression)
+        return node.tag;
+    if (node instanceof ParenthesizedExpression)
+        return node.expression;
+    return node;
+}