tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/printer/factory.js

@@ -0,0 +1,542 @@
+// Creates synthesized nodes for transforms and the printer. Created nodes are flagged
+// `Synthesized` and have no range; updated nodes keep the original's flags, range and emit data.
+import { ArrowFunction, AsExpression, DeleteExpression, ExpressionWithTypeArguments, NonNullExpression, PartiallyEmittedExpression, SatisfiesExpression, SyntheticReferenceExpression, TypeAssertion, BinaryExpression, ElementAccessExpression, FunctionExpression, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, QualifiedName, Block, CallExpression, ConditionalExpression, ExpressionStatement, Identifier, IfStatement, KeywordExpression, ModifierList, NodeList, NumericLiteral, ParenthesizedExpression, PrivateIdentifier, PropertyAccessExpression, ReturnStatement, SetAccessorDeclaration, SourceFile, StringLiteral, SyntaxList, Token, TypeOfExpression, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, } from '../ast.js';
+import { modifierToFlag } from '../ast-utilities.js';
+import { getNameOfDeclaration, getNonAssignedNameOfDeclaration, hasSyntacticModifier } from '../binder-utilities.js';
+import { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
+import { NodeFactoryBase } from './factory-base.js';
+import { addDisposableResourceHelper, classPrivateFieldGetHelper, classPrivateFieldInHelper, classPrivateFieldSetHelper, disposeResourcesHelper, exportStarHelper, importDefaultHelper, importStarHelper, makeTemplateObjectHelper, rewriteRelativeImportExtensionsHelper, } from './helpers.js';
+import { formatGeneratedName, isMemberName, nodeIsSynthesized } from './utilities.js';
+import { isOuterExpression, outerExpressionOperand } from '../transformers/utilities.js';
+/**
+ * The node factory of an emit context. The context is the factory (`EmitContext` extends it), so the two are one
+ * object: a factory and a context that pointed at each other made every context a reference cycle.
+ */
+export class NodeFactory extends NodeFactoryBase {
+    finishUpdate(updated, original) {
+        updated.flags = original.flags;
+        updated.pos = original.pos;
+        updated.end = original.end;
+        this.context.setOriginal(updated, original);
+        return true;
+    }
+    /** Flags a node built with its constructor as synthesized. */
+    created(node) {
+        node.flags |= 16 /* NodeFlags.Synthesized */;
+        return node;
+    }
+    /** A shallow copy of `node` with the same range and flags, its original set to `node`. */
+    cloneNode(node, copy) {
+        this.finishUpdate(copy, node);
+        if (node instanceof Identifier || node instanceof PrivateIdentifier) {
+            const info = this.context.autoGenerate.get(node);
+            if (info !== undefined)
+                this.context.autoGenerate.set(copy, new AutoGenerateInfo(info.flags, info.id, info.prefix, info.suffix, info.node));
+        }
+        return copy;
+    }
+    cloneIdentifier(node) {
+        return this.cloneNode(node, new Identifier(node.text));
+    }
+    createNodeList(nodes) {
+        return new NodeList(-1, -1, nodes);
+    }
+    createModifierList(nodes) {
+        let flags = 0;
+        for (let i = 0; i < nodes.length; i++)
+            flags |= modifierToFlag(nodes[i].kind);
+        return new ModifierList(-1, -1, nodes, flags);
+    }
+    /** A copy of `list` with other nodes, keeping its range. */
+    updateNodeList(list, nodes) {
+        const updated = new NodeList(list.pos, list.end, nodes);
+        return updated;
+    }
+    createToken(kind) {
+        return this.created(new Token(kind));
+    }
+    createIdentifier(text) {
+        return this.created(new Identifier(text));
+    }
+    createKeywordExpression(kind) {
+        return this.created(new KeywordExpression(kind));
+    }
+    createStringLiteral(text, tokenFlags) {
+        return this.created(new StringLiteral(text, tokenFlags));
+    }
+    createNumericLiteral(text) {
+        return this.created(new NumericLiteral(text, 0 /* TokenFlags.None */));
+    }
+    /** A string literal printed from the text of another node, e.g. an identifier. */
+    createStringLiteralFromNode(textSource) {
+        const node = this.createStringLiteral(textOfLiteralLike(textSource), 0 /* TokenFlags.None */);
+        this.context.textSource.set(node, textSource);
+        return node;
+    }
+    createSyntaxList(children) {
+        return this.created(new SyntaxList(children));
+    }
+    createParenthesizedExpression(expression) {
+        return this.created(new ParenthesizedExpression(expression));
+    }
+    createPropertyAccessExpression(expression, name) {
+        return this.created(new PropertyAccessExpression(expression, undefined, name, 0 /* NodeFlags.None */));
+    }
+    createCallExpression(expression, args) {
+        return this.created(new CallExpression(expression, undefined, undefined, this.createNodeList(args), 0 /* NodeFlags.None */));
+    }
+    createBinaryExpression(left, operator, right) {
+        return this.created(new BinaryExpression(undefined, left, undefined, this.createToken(operator), right));
+    }
+    createAssignment(left, right) {
+        return this.createBinaryExpression(left, 63 /* SyntaxKind.EqualsToken */, right);
+    }
+    createStrictEquality(left, right) {
+        return this.createBinaryExpression(left, 36 /* SyntaxKind.EqualsEqualsEqualsToken */, right);
+    }
+    createConditionalExpression(condition, whenTrue, whenFalse) {
+        return this.created(new ConditionalExpression(condition, this.createToken(57 /* SyntaxKind.QuestionToken */), whenTrue, this.createToken(58 /* SyntaxKind.ColonToken */), whenFalse));
+    }
+    createVoidZero() {
+        return this.created(new VoidExpression(this.createNumericLiteral('0')));
+    }
+    /** `typeof value === "tag"` */
+    createTypeCheck(value, tag) {
+        if (tag === 'undefined')
+            return this.createStrictEquality(value, this.createVoidZero());
+        return this.createStrictEquality(this.created(new TypeOfExpression(value)), this.createStringLiteral(tag, 0 /* TokenFlags.None */));
+    }
+    createBlock(statements, multiLine) {
+        return this.created(new Block(this.createNodeList(statements), multiLine));
+    }
+    createExpressionStatement(expression) {
+        return this.created(new ExpressionStatement(expression));
+    }
+    createReturnStatement(expression) {
+        return this.created(new ReturnStatement(expression));
+    }
+    createIfStatement(expression, thenStatement, elseStatement) {
+        return this.created(new IfStatement(expression, thenStatement, elseStatement));
+    }
+    createVariableDeclaration(name, exclamationToken, type, initializer) {
+        return this.created(new VariableDeclaration(name, exclamationToken, type, initializer));
+    }
+    createVariableDeclarationList(declarations, flags) {
+        return this.created(new VariableDeclarationList(declarations, flags));
+    }
+    createVariableStatement(modifiers, list) {
+        return this.created(new VariableStatement(modifiers, list));
+    }
+    createElementAccessExpression(expression, argument) {
+        return this.created(new ElementAccessExpression(expression, undefined, argument, 0 /* NodeFlags.None */));
+    }
+    createCommaExpression(left, right) {
+        return this.createBinaryExpression(left, 27 /* SyntaxKind.CommaToken */, right);
+    }
+    createLogicalOr(left, right) {
+        return this.createBinaryExpression(left, 56 /* SyntaxKind.BarBarToken */, right);
+    }
+    createPrefixUnaryExpression(operator, operand) {
+        return this.created(new PrefixUnaryExpression(operator, operand));
+    }
+    createTrue() {
+        return this.createKeywordExpression(111 /* SyntaxKind.TrueKeyword */);
+    }
+    createObjectLiteral(properties, multiLine) {
+        return this.created(new ObjectLiteralExpression(this.createNodeList(properties), multiLine));
+    }
+    createPropertyAssignment(name, initializer) {
+        return this.created(new PropertyAssignment(undefined, name, undefined, undefined, initializer));
+    }
+    createParameter(name) {
+        return this.created(new ParameterDeclaration(undefined, undefined, name, undefined, undefined, undefined));
+    }
+    createFunctionExpression(parameters, body) {
+        return this.created(new FunctionExpression(undefined, undefined, undefined, undefined, this.createNodeList(parameters), undefined, undefined, body));
+    }
+    createArrowFunction(parameters, body) {
+        return this.created(new ArrowFunction(undefined, undefined, this.createNodeList(parameters), undefined, undefined, this.createToken(38 /* SyntaxKind.EqualsGreaterThanToken */), body));
+    }
+    /** The expressions joined with commas, or undefined if there are none. */
+    inlineExpressions(expressions) {
+        if (expressions.length === 0)
+            return undefined;
+        if (expressions.length === 1)
+            return expressions[0];
+        const flattened = [];
+        for (const e of expressions)
+            flattenCommaElement(e, flattened);
+        let expression = flattened[0];
+        for (let i = 1; i < flattened.length; i++)
+            expression = this.createCommaExpression(expression, flattened[i]);
+        return expression;
+    }
+    /** `a.b.c` as a property access chain, from the qualified name `a.b.c`. */
+    createExpressionFromEntityName(node) {
+        if (node instanceof QualifiedName) {
+            const left = this.createExpressionFromEntityName(node.left);
+            const right = this.cloneIdentifier(node.right);
+            right.pos = node.right.pos;
+            right.end = node.right.end;
+            right.parent = node.right.parent;
+            const access = this.createPropertyAccessExpression(left, right);
+            access.pos = node.pos;
+            access.end = node.end;
+            return access;
+        }
+        if (!(node instanceof Identifier))
+            return node;
+        const result = this.cloneIdentifier(node);
+        result.parent = node.parent;
+        return result;
+    }
+    // Declaration names
+    getName(node, emitFlags, options) {
+        const name = (options & 4 /* NameOptions.IgnoreAssignedName */) !== 0
+            ? getNonAssignedNameOfDeclaration(node)
+            : getNameOfDeclaration(node);
+        if (!(name instanceof Identifier))
+            return this.createGeneratedNameForNode(node, 0, '', '');
+        const clone = this.cloneIdentifier(name);
+        if ((options & 1 /* NameOptions.AllowComments */) === 0)
+            emitFlags |= 384 /* EmitFlags.NoComments */;
+        if ((options & 2 /* NameOptions.AllowSourceMaps */) === 0)
+            emitFlags |= 12 /* EmitFlags.NoSourceMap */;
+        this.context.addEmitFlags(clone, emitFlags);
+        return clone;
+    }
+    /** A name referring to the declaration in its own scope, never prefixed with its export. */
+    getLocalName(node, options) {
+        return this.getName(node, 4096 /* EmitFlags.LocalName */, options);
+    }
+    /** A name referring to the declaration that is prefixed with its export when it has one. */
+    getExportName(node, options) {
+        return this.getName(node, 2048 /* EmitFlags.ExportName */, options);
+    }
+    getDeclarationName(node, options) {
+        return this.getName(node, 0 /* EmitFlags.None */, options & ~4 /* NameOptions.IgnoreAssignedName */);
+    }
+    /** `ns.name` */
+    getNamespaceMemberName(namespace, name, options) {
+        const member = this.context.hasAutoGenerateInfo(name) ? name : this.cloneIdentifier(name);
+        const access = this.createPropertyAccessExpression(namespace, member);
+        this.context.assignCommentAndSourceMapRanges(access, member);
+        if ((options & 1 /* NameOptions.AllowComments */) === 0)
+            this.context.addEmitFlags(access, 384 /* EmitFlags.NoComments */);
+        if ((options & 2 /* NameOptions.AllowSourceMaps */) === 0)
+            this.context.addEmitFlags(access, 12 /* EmitFlags.NoSourceMap */);
+        return access;
+    }
+    /** `ns.name` for an exported declaration in a namespace, else its export name. */
+    getExternalModuleOrNamespaceExportName(namespace, node, options) {
+        if (namespace !== undefined && hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+            return this.getNamespaceMemberName(namespace, this.getDeclarationName(node, options), options);
+        return this.getExportName(node, options);
+    }
+    /** A copy of a source file with other statements. */
+    updateSourceFile(node, statements, endOfFileToken) {
+        if (statements === node.statements && endOfFileToken === node.endOfFileToken)
+            return node;
+        const updated = new SourceFile(node.fileName, node.path, node.text, node.externalModuleIndicatorOptions, statements, endOfFileToken);
+        updated.diagnostics = node.diagnostics;
+        updated.jsDiagnostics = node.jsDiagnostics;
+        updated.jsDocDiagnostics = node.jsDocDiagnostics;
+        updated.languageVariant = node.languageVariant;
+        updated.scriptKind = node.scriptKind;
+        updated.isDeclarationFile = node.isDeclarationFile;
+        updated.usesUriStyleNodeCoreModules = node.usesUriStyleNodeCoreModules;
+        updated.identifierTexts = node.identifierTexts;
+        updated.identifierCount = node.identifierCount;
+        updated.nodeCount = node.nodeCount;
+        updated.textCount = node.textCount;
+        updated.imports = node.imports;
+        updated.moduleAugmentations = node.moduleAugmentations;
+        updated.ambientModuleNames = node.ambientModuleNames;
+        updated.commentDirectives = node.commentDirectives;
+        updated.pragmas = node.pragmas;
+        updated.referencedFiles = node.referencedFiles;
+        updated.typeReferenceDirectives = node.typeReferenceDirectives;
+        updated.libReferenceDirectives = node.libReferenceDirectives;
+        updated.checkJsDirective = node.checkJsDirective;
+        updated.commonJSModuleIndicator = node.commonJSModuleIndicator;
+        updated.externalModuleIndicator = node.externalModuleIndicator;
+        updated.reparsedClones = node.reparsedClones;
+        updated.hasLazyJSDoc = node.hasLazyJSDoc;
+        this.finishUpdate(updated, node);
+        return updated;
+    }
+    // Generated names
+    createGeneratedIdentifier(kind, text, node, flags, prefix, suffix) {
+        const id = newAutoGenerateId();
+        if (text.length === 0) {
+            if (node === undefined)
+                text = '(auto@' + id + ')';
+            else if (isMemberName(node))
+                text = textOfLiteralLike(node);
+            else
+                text = '(generated@' + id + ')';
+            text = formatGeneratedName(false, prefix, text, suffix);
+        }
+        const name = this.createIdentifier(text);
+        this.context.autoGenerate.set(name, new AutoGenerateInfo(kind | (flags & ~7 /* GeneratedIdentifierFlags.KindMask */), id, prefix, suffix, node));
+        return name;
+    }
+    /** A temporary variable such as `_a`; add it to an environment with `addVariableDeclaration`. */
+    createTempVariable(flags) {
+        return this.createGeneratedIdentifier(1 /* GeneratedIdentifierFlags.Auto */, '', undefined, flags, '', '');
+    }
+    createLoopVariable(flags) {
+        return this.createGeneratedIdentifier(2 /* GeneratedIdentifierFlags.Loop */, '', undefined, flags, '', '');
+    }
+    createUniqueName(text, flags) {
+        return this.createGeneratedIdentifier(3 /* GeneratedIdentifierFlags.Unique */, text, undefined, flags, '', '');
+    }
+    createGeneratedNameForNode(node, flags, prefix, suffix) {
+        if (prefix.length > 0 || suffix.length > 0)
+            flags |= 16 /* GeneratedIdentifierFlags.Optimistic */;
+        return this.createGeneratedIdentifier(4 /* GeneratedIdentifierFlags.Node */, '', node, flags, prefix, suffix);
+    }
+    /** A private name such as `#x_accessor_storage`, unique within its class and based on `node`. */
+    createGeneratedPrivateNameForNode(node, prefix, suffix) {
+        const id = newAutoGenerateId();
+        const text = formatGeneratedName(true, prefix, isMemberName(node) ? textOfLiteralLike(node) : '(generated@' + id + ')', suffix);
+        const name = this.created(new PrivateIdentifier(text));
+        const flags = prefix.length > 0 || suffix.length > 0 ? 16 /* GeneratedIdentifierFlags.Optimistic */ : 0;
+        this.context.autoGenerate.set(name, new AutoGenerateInfo(4 /* GeneratedIdentifierFlags.Node */ | flags, id, prefix, suffix, node));
+        return name;
+    }
+    /** The name of an unscoped emit helper such as `__decorate`. */
+    createUnscopedHelperName(name) {
+        const node = this.createIdentifier(name);
+        this.context.setEmitFlags(node, 1024 /* EmitFlags.HelperName */);
+        return node;
+    }
+    /** `__importDefault(expression)` */
+    createImportDefaultHelper(expression) {
+        this.context.requestEmitHelper(importDefaultHelper);
+        return this.createCallExpression(this.createUnscopedHelperName('__importDefault'), [expression]);
+    }
+    /** `__importStar(expression)` */
+    createImportStarHelper(expression) {
+        this.context.requestEmitHelper(importStarHelper);
+        return this.createCallExpression(this.createUnscopedHelperName('__importStar'), [expression]);
+    }
+    /** `__exportStar(moduleExpression, exportsExpression)` */
+    createExportStarHelper(moduleExpression, exportsExpression) {
+        this.context.requestEmitHelper(exportStarHelper);
+        return this.createCallExpression(this.createUnscopedHelperName('__exportStar'), [
+            moduleExpression,
+            exportsExpression,
+        ]);
+    }
+    /** `__rewriteRelativeImportExtension(argument)`, with `true` to keep `.jsx`. */
+    createRewriteRelativeImportExtensionsHelper(argument, preserveJsx) {
+        this.context.requestEmitHelper(rewriteRelativeImportExtensionsHelper);
+        const args = preserveJsx ? [argument, this.createToken(111 /* SyntaxKind.TrueKeyword */)] : [argument];
+        return this.createCallExpression(this.createUnscopedHelperName('__rewriteRelativeImportExtension'), args);
+    }
+    isCallToHelper(node, helperName) {
+        if (!(node instanceof CallExpression))
+            return false;
+        const callee = node.expression;
+        return (callee instanceof Identifier &&
+            (this.context.getEmitFlags(callee) & 1024 /* EmitFlags.HelperName */) !== 0 &&
+            callee.text === helperName);
+    }
+    // Downlevel expressions
+    /** `__makeTemplateObject(cooked, raw)` */
+    createTemplateObjectHelper(cooked, raw) {
+        this.context.requestEmitHelper(makeTemplateObjectHelper);
+        return this.createCallExpression(this.createUnscopedHelperName('__makeTemplateObject'), [cooked, raw]);
+    }
+    createThisExpression() {
+        return this.createKeywordExpression(109 /* SyntaxKind.ThisKeyword */);
+    }
+    createDeleteExpression(expression) {
+        return this.created(new DeleteExpression(expression));
+    }
+    createSyntheticReferenceExpression(expression, thisArg) {
+        return this.created(new SyntheticReferenceExpression(expression, thisArg));
+    }
+    /** `object.method(...args)`, keeping an optional call chain `object` optional. */
+    createMethodCall(object, method, args) {
+        const callee = this.createPropertyAccessExpression(object, this.createIdentifier(method));
+        const flags = object instanceof CallExpression ? object.flags & 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */;
+        return this.created(new CallExpression(callee, undefined, undefined, this.createNodeList(args), flags));
+    }
+    /** `Global.method(...args)`, such as `Math.pow(a, b)`. */
+    createGlobalMethodCall(global, method, args) {
+        return this.createMethodCall(this.createIdentifier(global), method, args);
+    }
+    /** `target.call(thisArg, ...args)` */
+    createFunctionCallCall(target, thisArg, args) {
+        const all = [thisArg];
+        for (const arg of args)
+            all.push(arg);
+        return this.createMethodCall(target, 'call', all);
+    }
+    /** `left !== null && right !== void 0`, or with `invert`, `left === null || right === void 0`. */
+    createNotNullCondition(left, right, invert) {
+        const equality = invert ? 36 /* SyntaxKind.EqualsEqualsEqualsToken */ : 37 /* SyntaxKind.ExclamationEqualsEqualsToken */;
+        return this.createBinaryExpression(this.createBinaryExpression(left, equality, this.createKeywordExpression(105 /* SyntaxKind.NullKeyword */)), invert ? 56 /* SyntaxKind.BarBarToken */ : 55 /* SyntaxKind.AmpersandAmpersandToken */, this.createBinaryExpression(right, equality, this.createVoidZero()));
+    }
+    /** `inner` wrapped again in the outer expressions of `kinds` that wrapped what it replaces in `outer`. */
+    restoreOuterExpressions(outer, inner, kinds) {
+        if (outer === undefined || !isOuterExpression(outer, kinds) || this.isIgnorableParen(outer))
+            return inner;
+        return this.updateOuterExpression(outer, this.restoreOuterExpressions(outerExpressionOperand(outer), inner, 63 /* OuterExpressionKinds.All */));
+    }
+    /** A synthesized parenthesized expression without ranges, which the printer recreates as needed. */
+    isIgnorableParen(node) {
+        const context = this.context;
+        return (node instanceof ParenthesizedExpression &&
+            nodeIsSynthesized(node) &&
+            (context.sourceMapPos(node) < 0 || context.sourceMapEnd(node) < 0) &&
+            (context.commentPos(node) < 0 || context.commentEnd(node) < 0));
+    }
+    updateOuterExpression(outer, expression) {
+        if (outer instanceof ParenthesizedExpression)
+            return this.updateParenthesizedExpression(outer, expression);
+        if (outer instanceof TypeAssertion)
+            return this.updateTypeAssertion(outer, outer.type, expression);
+        if (outer instanceof AsExpression)
+            return this.updateAsExpression(outer, expression, outer.type);
+        if (outer instanceof SatisfiesExpression)
+            return this.updateSatisfiesExpression(outer, expression, outer.type);
+        if (outer instanceof NonNullExpression)
+            return this.updateNonNullExpression(outer, expression, outer.flags);
+        if (outer instanceof ExpressionWithTypeArguments)
+            return this.updateExpressionWithTypeArguments(outer, expression, outer.typeArguments);
+        if (outer instanceof PartiallyEmittedExpression)
+            return this.updatePartiallyEmittedExpression(outer, expression);
+        throw new Error('Unexpected outer expression');
+    }
+    // Class fields
+    /** A unique name based on `text`, with `suffix` added when the name is made unique. */
+    createUniqueNameWithSuffix(text, flags, suffix) {
+        return this.createGeneratedIdentifier(3 /* GeneratedIdentifierFlags.Unique */, text, undefined, flags, '', suffix);
+    }
+    /** The modifiers for `flags`, in canonical order. */
+    createModifiersFromFlags(flags) {
+        const kinds = [];
+        if ((flags & 32 /* ModifierFlags.Export */) !== 0)
+            kinds.push(94 /* SyntaxKind.ExportKeyword */);
+        if ((flags & 128 /* ModifierFlags.Ambient */) !== 0)
+            kinds.push(137 /* SyntaxKind.DeclareKeyword */);
+        if ((flags & 2048 /* ModifierFlags.Default */) !== 0)
+            kinds.push(89 /* SyntaxKind.DefaultKeyword */);
+        if ((flags & 4096 /* ModifierFlags.Const */) !== 0)
+            kinds.push(86 /* SyntaxKind.ConstKeyword */);
+        if ((flags & 1 /* ModifierFlags.Public */) !== 0)
+            kinds.push(124 /* SyntaxKind.PublicKeyword */);
+        if ((flags & 2 /* ModifierFlags.Private */) !== 0)
+            kinds.push(122 /* SyntaxKind.PrivateKeyword */);
+        if ((flags & 4 /* ModifierFlags.Protected */) !== 0)
+            kinds.push(123 /* SyntaxKind.ProtectedKeyword */);
+        if ((flags & 64 /* ModifierFlags.Abstract */) !== 0)
+            kinds.push(127 /* SyntaxKind.AbstractKeyword */);
+        if ((flags & 256 /* ModifierFlags.Static */) !== 0)
+            kinds.push(125 /* SyntaxKind.StaticKeyword */);
+        if ((flags & 16 /* ModifierFlags.Override */) !== 0)
+            kinds.push(164 /* SyntaxKind.OverrideKeyword */);
+        if ((flags & 8 /* ModifierFlags.Readonly */) !== 0)
+            kinds.push(148 /* SyntaxKind.ReadonlyKeyword */);
+        if ((flags & 512 /* ModifierFlags.Accessor */) !== 0)
+            kinds.push(128 /* SyntaxKind.AccessorKeyword */);
+        if ((flags & 1024 /* ModifierFlags.Async */) !== 0)
+            kinds.push(133 /* SyntaxKind.AsyncKeyword */);
+        if ((flags & 8192 /* ModifierFlags.In */) !== 0)
+            kinds.push(102 /* SyntaxKind.InKeyword */);
+        if ((flags & 16384 /* ModifierFlags.Out */) !== 0)
+            kinds.push(147 /* SyntaxKind.OutKeyword */);
+        const nodes = [];
+        for (const kind of kinds)
+            nodes.push(this.createToken((kind | 0)));
+        return this.createModifierList(nodes);
+    }
+    /** `target.bind(thisArg, ...args)` */
+    createFunctionBindCall(target, thisArg, args) {
+        return this.createMethodCall(target, 'bind', [thisArg].concat(args));
+    }
+    /** `Object.defineProperty(target, name, descriptor)` */
+    createObjectDefinePropertyCall(target, name, descriptor) {
+        return this.createMethodCall(this.createIdentifier('Object'), 'defineProperty', [target, name, descriptor]);
+    }
+    /** `Reflect.get(target, propertyKey, receiver)` */
+    createReflectGetCall(target, propertyKey, receiver) {
+        return this.createMethodCall(this.createIdentifier('Reflect'), 'get', [target, propertyKey, receiver]);
+    }
+    /** `Reflect.set(target, propertyKey, value, receiver)` */
+    createReflectSetCall(target, propertyKey, value, receiver) {
+        return this.createMethodCall(this.createIdentifier('Reflect'), 'set', [target, propertyKey, value, receiver]);
+    }
+    /** `(() => { ...statements })()` */
+    createImmediatelyInvokedArrowFunction(statements) {
+        const arrow = this.createArrowFunction([], this.createBlock(statements, true));
+        return this.createCallExpression(this.createParenthesizedExpression(arrow), []);
+    }
+    /** `({ set value(parameter) { expression; } }).value`, a destructuring target running `expression`. */
+    createAssignmentTargetWrapper(parameter, expression) {
+        const setter = this.created(new SetAccessorDeclaration(undefined, this.createIdentifier('value'), undefined, this.createNodeList([this.createParameter(parameter)]), undefined, undefined, this.createBlock([this.createExpressionStatement(expression)], false)));
+        // Parenthesized for a V8 bug: https://bugs.chromium.org/p/v8/issues/detail?id=9560
+        return this.createPropertyAccessExpression(this.createParenthesizedExpression(this.createObjectLiteral([setter], false)), this.createIdentifier('value'));
+    }
+    /** `__classPrivateFieldGet(receiver, state, kind, f)`; `kind` is `"f"`, `"m"` or `"a"`. */
+    createClassPrivateFieldGetHelper(receiver, state, kind, f) {
+        this.context.requestEmitHelper(classPrivateFieldGetHelper);
+        const args = [receiver, state, this.createStringLiteral(kind, 0 /* TokenFlags.None */)];
+        if (f !== undefined)
+            args.push(f);
+        return this.createCallExpression(this.createUnscopedHelperName('__classPrivateFieldGet'), args);
+    }
+    /** `__classPrivateFieldSet(receiver, state, value, kind, f)` */
+    createClassPrivateFieldSetHelper(receiver, state, value, kind, f) {
+        this.context.requestEmitHelper(classPrivateFieldSetHelper);
+        const args = [receiver, state, value, this.createStringLiteral(kind, 0 /* TokenFlags.None */)];
+        if (f !== undefined)
+            args.push(f);
+        return this.createCallExpression(this.createUnscopedHelperName('__classPrivateFieldSet'), args);
+    }
+    /** `__classPrivateFieldIn(state, receiver)` */
+    createClassPrivateFieldInHelper(state, receiver) {
+        this.context.requestEmitHelper(classPrivateFieldInHelper);
+        return this.createCallExpression(this.createUnscopedHelperName('__classPrivateFieldIn'), [state, receiver]);
+    }
+    // `using` helpers
+    /** `__addDisposableResource(env, value, async)` */
+    createAddDisposableResourceHelper(env, value, async) {
+        this.context.requestEmitHelper(addDisposableResourceHelper);
+        return this.createCallExpression(this.createUnscopedHelperName('__addDisposableResource'), [
+            env,
+            value,
+            this.createKeywordExpression(async ? 111 /* SyntaxKind.TrueKeyword */ : 96 /* SyntaxKind.FalseKeyword */),
+        ]);
+    }
+    /** `__disposeResources(env)` */
+    createDisposeResourcesHelper(env) {
+        this.context.requestEmitHelper(disposeResourcesHelper);
+        return this.createCallExpression(this.createUnscopedHelperName('__disposeResources'), [env]);
+    }
+}
+function flattenCommaElement(node, expressions) {
+    if (node instanceof BinaryExpression &&
+        (node.flags & 16 /* NodeFlags.Synthesized */) !== 0 &&
+        node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) {
+        flattenCommaElement(node.left, expressions);
+        flattenCommaElement(node.right, expressions);
+    }
+    else
+        expressions.push(node);
+    return true;
+}
+function textOfLiteralLike(node) {
+    if (node instanceof Identifier)
+        return node.text;
+    if (node instanceof PrivateIdentifier)
+        return node.text;
+    if (node instanceof StringLiteral)
+        return node.text;
+    if (node instanceof NumericLiteral)
+        return node.text;
+    return '';
+}

package/dist/api/compiler/printer/helpers.d.ts

@@ -0,0 +1,27 @@
+/** A runtime helper such as `__decorate`, emitted once at the top of a file or scope. */
+export declare class EmitHelper {
+    readonly name: string;
+    /** Emitted in the scope that uses it rather than at the top of the file. */
+    readonly scoped: boolean;
+    readonly text: string;
+    /** Lower values are emitted first; helpers without a priority come last. */
+    readonly priority: number;
+    readonly dependencies: readonly EmitHelper[];
+    readonly importName: string;
+    /** For helpers that declare a file-level unique name: the base name, written in place of each `{name}` in `text`. */
+    readonly uniqueName: string;
+    constructor(name: string, scoped: boolean, text: string, priority: number, dependencies: readonly EmitHelper[], importName: string, uniqueName: string);
+}
+export declare const noPriority = -1;
+export declare function compareEmitHelpers(x: EmitHelper, y: EmitHelper): number;
+export declare const importStarHelper: EmitHelper;
+export declare const importDefaultHelper: EmitHelper;
+export declare const exportStarHelper: EmitHelper;
+export declare const rewriteRelativeImportExtensionsHelper: EmitHelper;
+export declare const restHelper: EmitHelper;
+export declare const classPrivateFieldGetHelper: EmitHelper;
+export declare const classPrivateFieldSetHelper: EmitHelper;
+export declare const classPrivateFieldInHelper: EmitHelper;
+export declare const makeTemplateObjectHelper: EmitHelper;
+export declare const addDisposableResourceHelper: EmitHelper;
+export declare const disposeResourcesHelper: EmitHelper;