tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/named-evaluation.js

@@ -0,0 +1,266 @@
+// NamedEvaluation (https://tc39.es/ecma262/#sec-runtime-semantics-namedevaluation): giving
+// anonymous classes and functions the name they would get from where they are assigned, once a
+// transform moves them somewhere they wouldn't.
+import { BinaryExpression, BindingElement, CallExpression, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ExportAssignment, ExpressionStatement, FunctionExpression, Identifier, NodeList, ParameterDeclaration, PropertyAssignment, PropertyDeclaration, ShorthandPropertyAssignment, StringLiteral, VariableDeclaration, getName, } from '../ast.js';
+import { hasSyntacticModifier, isClassLike, isPropertyNameLiteral } from '../binder-utilities.js';
+import { createPropKeyHelper, createSetFunctionNameHelper } from '../printer/decorator-helpers.js';
+import { getClassMembers, getClassName, isClassThisAssignmentBlock, updateClassMembers } from './class-utilities.js';
+import { skipOuterExpressions } from './utilities.js';
+/** Further narrows which anonymous function definitions a transform names. */
+export class AnonymousFunctionFilter {
+}
+/** A `static {}` block holding only `__setFunctionName(this, name)` for the block's assigned name. */
+export function isClassNamedEvaluationHelperBlock(context, node) {
+    if (!(node instanceof ClassStaticBlockDeclaration))
+        return false;
+    const statements = node.body.statements.nodes;
+    if (statements.length !== 1)
+        return false;
+    const statement = statements[0];
+    if (!(statement instanceof ExpressionStatement))
+        return false;
+    const expression = statement.expression;
+    if (!context.isCallToHelper(expression, '__setFunctionName') || !(expression instanceof CallExpression))
+        return false;
+    const args = expression.arguments.nodes;
+    return args.length >= 2 && args[1] === context.getAssignedName(node);
+}
+/** Whether a class has a NamedEvaluation helper block. */
+export function classHasExplicitlyAssignedName(context, node) {
+    if (context.getAssignedName(node) === undefined)
+        return false;
+    const members = getClassMembers(node).nodes;
+    for (let i = 0; i < members.length; i++)
+        if (isClassNamedEvaluationHelperBlock(context, members[i]))
+            return true;
+    return false;
+}
+export function classHasDeclaredOrExplicitlyAssignedName(context, node) {
+    return getClassName(node) !== undefined || classHasExplicitlyAssignedName(context, node);
+}
+/** https://tc39.es/ecma262/#sec-isanonymousfunctiondefinition */
+export function isAnonymousFunctionDefinition(context, node, filter) {
+    if (node === undefined)
+        return false;
+    node = skipOuterExpressions(node, 63 /* OuterExpressionKinds.All */);
+    switch (node.kind) {
+        case 232 /* SyntaxKind.ClassExpression */:
+            if (classHasDeclaredOrExplicitlyAssignedName(context, node))
+                return false;
+            break;
+        case 219 /* SyntaxKind.FunctionExpression */:
+            if (node instanceof FunctionExpression && node.name !== undefined)
+                return false;
+            break;
+        case 220 /* SyntaxKind.ArrowFunction */:
+            break;
+        default:
+            return false;
+    }
+    return filter === undefined || filter.accepts(node);
+}
+/** Whether `node` may give an assigned name to a class, function or arrow function. */
+export function isNamedEvaluationSource(node) {
+    if (node instanceof PropertyAssignment)
+        return !isProtoSetter(node.name);
+    if (node instanceof ShorthandPropertyAssignment)
+        return node.objectAssignmentInitializer !== undefined;
+    if (node instanceof VariableDeclaration)
+        return node.name instanceof Identifier && node.initializer !== undefined;
+    if (node instanceof ParameterDeclaration)
+        return node.name instanceof Identifier && node.initializer !== undefined && node.dotDotDotToken === undefined;
+    if (node instanceof BindingElement)
+        return node.name instanceof Identifier && node.initializer !== undefined && node.dotDotDotToken === undefined;
+    if (node instanceof PropertyDeclaration)
+        return node.initializer !== undefined;
+    if (node instanceof BinaryExpression) {
+        switch (node.operatorToken.kind) {
+            case 63 /* SyntaxKind.EqualsToken */:
+            case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+            case 75 /* SyntaxKind.BarBarEqualsToken */:
+            case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+                return node.left instanceof Identifier;
+        }
+        return false;
+    }
+    return node instanceof ExportAssignment;
+}
+function isProtoSetter(node) {
+    return ((node instanceof Identifier && node.text === '__proto__') ||
+        (node instanceof StringLiteral && node.text === '__proto__'));
+}
+/** Whether `node` assigns a name to an anonymous function definition accepted by `filter`. */
+export function isNamedEvaluation(context, node, filter) {
+    if (!isNamedEvaluationSource(node))
+        return false;
+    return isAnonymousFunctionDefinition(context, namedEvaluationValue(node), filter);
+}
+/** The anonymous function definition a NamedEvaluation source names. */
+function namedEvaluationValue(node) {
+    if (node instanceof ShorthandPropertyAssignment)
+        return node.objectAssignmentInitializer;
+    if (node instanceof PropertyAssignment)
+        return node.initializer;
+    if (node instanceof VariableDeclaration)
+        return node.initializer;
+    if (node instanceof ParameterDeclaration)
+        return node.initializer;
+    if (node instanceof BindingElement)
+        return node.initializer;
+    if (node instanceof PropertyDeclaration)
+        return node.initializer;
+    if (node instanceof BinaryExpression)
+        return node.right;
+    if (node instanceof ExportAssignment)
+        return node.expression;
+    return undefined;
+}
+function getAssignedNameOfIdentifier(context, name, expression) {
+    const original = context.mostOriginal(skipOuterExpressions(expression, 63 /* OuterExpressionKinds.All */));
+    if ((original.kind === 264 /* SyntaxKind.ClassDeclaration */ || original.kind === 263 /* SyntaxKind.FunctionDeclaration */) &&
+        getName(original) === undefined &&
+        hasSyntacticModifier(original, 2048 /* ModifierFlags.Default */))
+        return context.factory.createStringLiteral('default', 0 /* TokenFlags.None */);
+    return context.factory.createStringLiteralFromNode(name);
+}
+/** The assigned name for a property name, and the name, updated to cache a computed key. */
+class AssignedPropertyName {
+    assignedName;
+    name;
+    constructor(assignedName, name) {
+        this.assignedName = assignedName;
+        this.name = name;
+    }
+}
+function getAssignedNameOfPropertyName(context, name, text) {
+    const factory = context.factory;
+    if (text.length > 0)
+        return new AssignedPropertyName(factory.createStringLiteral(text, 0 /* TokenFlags.None */), name);
+    if (isPropertyNameLiteral(name) || name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        return new AssignedPropertyName(factory.createStringLiteralFromNode(name), name);
+    if (!(name instanceof ComputedPropertyName))
+        throw new Error('Expected a computed property name');
+    const computed = name;
+    const expression = computed.expression;
+    if (isPropertyNameLiteral(expression) && !(expression instanceof Identifier))
+        return new AssignedPropertyName(factory.createStringLiteralFromNode(expression), name);
+    const assignedName = factory.createGeneratedNameForNode(name, 0, '', '');
+    context.addVariableDeclaration(assignedName);
+    const assignment = factory.createAssignment(assignedName, createPropKeyHelper(factory, expression));
+    const updatedName = factory.updateComputedPropertyName(computed, assignment);
+    return new AssignedPropertyName(assignedName, updatedName);
+}
+/** `static { __setFunctionName(this, assignedName); }` for setting a class name at runtime. */
+export function createClassNamedEvaluationHelperBlock(context, assignedName, thisExpression) {
+    const factory = context.factory;
+    const self = thisExpression !== undefined ? thisExpression : factory.createKeywordExpression(109 /* SyntaxKind.ThisKeyword */);
+    const statement = factory.createExpressionStatement(createSetFunctionNameHelper(factory, self, assignedName, ''));
+    const block = factory.created(new ClassStaticBlockDeclaration(undefined, factory.createBlock([statement], false)));
+    context.setAssignedName(block, assignedName);
+    return block;
+}
+/** Adds a NamedEvaluation helper block to a class, after its `_classThis` block, unless it has one. */
+export function injectClassNamedEvaluationHelperBlockIfMissing(context, node, assignedName, thisExpression) {
+    if (classHasExplicitlyAssignedName(context, node))
+        return node;
+    if (!isClassLike(node))
+        return node;
+    const block = createClassNamedEvaluationHelperBlock(context, assignedName, thisExpression);
+    const name = getClassName(node);
+    if (name !== undefined)
+        context.setSourceMapRange(block.body.statements.nodes[0], name.pos, name.end);
+    const memberList = getClassMembers(node);
+    const existing = memberList.nodes;
+    let insertion = 0;
+    for (let i = 0; i < existing.length; i++)
+        if (isClassThisAssignmentBlock(context, existing[i])) {
+            insertion = i + 1;
+            break;
+        }
+    const members = existing.slice(0, insertion);
+    members.push(block);
+    for (let i = insertion; i < existing.length; i++)
+        members.push(existing[i]);
+    const list = new NodeList(memberList.pos, memberList.end, members);
+    const updated = updateClassMembers(context.factory, node, list);
+    context.setAssignedName(updated, assignedName);
+    const classThis = context.getClassThis(node);
+    if (classThis !== undefined)
+        context.setClassThis(updated, classThis);
+    return updated;
+}
+function finishTransformNamedEvaluation(context, expression, assignedName, ignoreEmptyStringLiteral) {
+    if (ignoreEmptyStringLiteral && assignedName instanceof StringLiteral && assignedName.text.length === 0)
+        return expression;
+    const inner = skipOuterExpressions(expression, 63 /* OuterExpressionKinds.All */);
+    const updated = inner instanceof ClassExpression
+        ? injectClassNamedEvaluationHelperBlockIfMissing(context, inner, assignedName, undefined)
+        : createSetFunctionNameHelper(context.factory, inner, assignedName, '');
+    return context.factory.restoreOuterExpressions(expression, updated, 63 /* OuterExpressionKinds.All */);
+}
+function assignedNameOf(context, text, name, expression) {
+    return text.length > 0
+        ? context.factory.createStringLiteral(text, 0 /* TokenFlags.None */)
+        : getAssignedNameOfIdentifier(context, name, expression);
+}
+/**
+ * Transforms a NamedEvaluation source so its anonymous class or function gets its name
+ * explicitly; `assignedNameText` overrides the name.
+ */
+export function transformNamedEvaluation(context, node, ignoreEmptyStringLiteral, assignedNameText) {
+    const factory = context.factory;
+    if (node instanceof PropertyAssignment) {
+        const propertyAssignment = node;
+        const assigned = getAssignedNameOfPropertyName(context, propertyAssignment.name, assignedNameText);
+        const initializer = finishTransformNamedEvaluation(context, propertyAssignment.initializer, assigned.assignedName, ignoreEmptyStringLiteral);
+        return factory.updatePropertyAssignment(propertyAssignment, undefined, assigned.name, undefined, undefined, initializer);
+    }
+    if (node instanceof ShorthandPropertyAssignment) {
+        const shorthandPropertyAssignment = node;
+        const value = shorthandPropertyAssignment.objectAssignmentInitializer;
+        const assignedName = assignedNameOf(context, assignedNameText, shorthandPropertyAssignment.name, value);
+        const initializer = finishTransformNamedEvaluation(context, value, assignedName, ignoreEmptyStringLiteral);
+        return factory.updateShorthandPropertyAssignment(shorthandPropertyAssignment, undefined, shorthandPropertyAssignment.name, undefined, undefined, shorthandPropertyAssignment.equalsToken, initializer);
+    }
+    if (node instanceof VariableDeclaration) {
+        const variableDeclaration = node;
+        const value = variableDeclaration.initializer;
+        const assignedName = assignedNameOf(context, assignedNameText, variableDeclaration.name, value);
+        const initializer = finishTransformNamedEvaluation(context, value, assignedName, ignoreEmptyStringLiteral);
+        return factory.updateVariableDeclaration(variableDeclaration, variableDeclaration.name, undefined, undefined, initializer);
+    }
+    if (node instanceof ParameterDeclaration) {
+        const parameterDeclaration = node;
+        const value = parameterDeclaration.initializer;
+        const assignedName = assignedNameOf(context, assignedNameText, parameterDeclaration.name, value);
+        const initializer = finishTransformNamedEvaluation(context, value, assignedName, ignoreEmptyStringLiteral);
+        return factory.updateParameterDeclaration(parameterDeclaration, undefined, parameterDeclaration.dotDotDotToken, parameterDeclaration.name, undefined, undefined, initializer);
+    }
+    if (node instanceof BindingElement) {
+        const bindingElement = node;
+        const value = bindingElement.initializer;
+        const assignedName = assignedNameOf(context, assignedNameText, bindingElement.name, value);
+        const initializer = finishTransformNamedEvaluation(context, value, assignedName, ignoreEmptyStringLiteral);
+        return factory.updateBindingElement(bindingElement, bindingElement.dotDotDotToken, bindingElement.propertyName, bindingElement.name, initializer);
+    }
+    if (node instanceof PropertyDeclaration) {
+        const propertyDeclaration = node;
+        const assigned = getAssignedNameOfPropertyName(context, propertyDeclaration.name, assignedNameText);
+        const initializer = finishTransformNamedEvaluation(context, propertyDeclaration.initializer, assigned.assignedName, ignoreEmptyStringLiteral);
+        return factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, assigned.name, undefined, undefined, initializer);
+    }
+    if (node instanceof BinaryExpression) {
+        const binaryExpression = node;
+        const assignedName = assignedNameOf(context, assignedNameText, binaryExpression.left, binaryExpression.right);
+        const right = finishTransformNamedEvaluation(context, binaryExpression.right, assignedName, ignoreEmptyStringLiteral);
+        return factory.updateBinaryExpression(binaryExpression, undefined, binaryExpression.left, undefined, binaryExpression.operatorToken, right);
+    }
+    if (node instanceof ExportAssignment) {
+        const exportAssignment = node;
+        // `export =` becomes `module.exports = ...`, which assigns the name `""`.
+        const assignedName = factory.createStringLiteral(assignedNameText.length > 0 ? assignedNameText : exportAssignment.isExportEquals ? '' : 'default', 0 /* TokenFlags.None */);
+        const expression = finishTransformNamedEvaluation(context, exportAssignment.expression, assignedName, ignoreEmptyStringLiteral);
+        return factory.updateExportAssignment(exportAssignment, undefined, exportAssignment.isExportEquals, undefined, expression);
+    }
+    return node;
+}

package/dist/api/compiler/transformers/nullish-coalescing.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 NullishCoalescingTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+}

package/dist/api/compiler/transformers/nullish-coalescing.js

@@ -0,0 +1,26 @@
+// Lowers `a ?? b` to `a !== null && a !== void 0 ? a : b` (ES2020).
+import { BinaryExpression } from '../ast.js';
+import { isSimpleCopiableExpression } from './destructuring.js';
+import { Transformer } from './transformer.js';
+export class NullishCoalescingTransformer extends Transformer {
+    facts;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 16 /* SubtreeFacts.ContainsNullishCoalescing */))
+            return node;
+        if (node instanceof BinaryExpression && node.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) {
+            const factory = this.factory;
+            let left = this.visitNode(node.left);
+            let right = left;
+            if (!isSimpleCopiableExpression(left)) {
+                right = this.context.addVariableDeclaration(factory.createTempVariable(0));
+                left = factory.createAssignment(right, left);
+            }
+            return factory.createConditionalExpression(factory.createNotNullCondition(left, right, false), right, this.visitNode(node.right));
+        }
+        return this.visitEachChild(node);
+    }
+}

package/dist/api/compiler/transformers/object-rest-spread.d.ts

@@ -0,0 +1,34 @@
+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 ObjectRestSpreadTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    private inExportedVariableStatement;
+    private expressionResultIsUnused;
+    /** Parameters after the first one with an object rest element, in the current parameter list. */
+    private parametersWithPrecedingObjectRestOrSpread;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private visitWorker;
+    private visitSourceFile;
+    private visitParameter;
+    private collectParametersWithPrecedingObjectRestOrSpread;
+    private visitFunctionLike;
+    private updateFunctionLike;
+    /** The visited body, with the destructuring of parameters with object rest elements prepended. */
+    private transformFunctionBody;
+    private collectObjectRestAssignments;
+    /** `if (x === void 0) { x = initializer; }` for a parameter after one with an object rest. */
+    private createDefaultValueStatement;
+    /** `var` of flattened declarations, as a custom prologue. */
+    private createPrologueVariableStatement;
+    private visitCatchClause;
+    private visitVariableStatement;
+    private visitVariableDeclaration;
+    private visitForOfStatement;
+    private visitBinaryExpression;
+    private visitObjectLiteralExpression;
+    private createAssign;
+    private chunkObjectLiteralElements;
+}