tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/transformers/async-utilities.d.ts

@@ -0,0 +1,51 @@
+import { Identifier, type Node } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { VisitorBase } from './visitor-base.js';
+export declare const enum FunctionFlags {
+    Normal = 0,
+    Generator = 1,
+    Async = 2,
+    Invalid = 4,
+    AsyncGenerator = 3
+}
+export declare function getFunctionFlags(node: Node): FunctionFlags;
+export declare function isFunctionLikeDeclaration(node: Node): boolean;
+/** Whether every parameter is a plain identifier without an initializer. */
+export declare function isSimpleParameterList(parameters: Node[]): boolean;
+/** The super-access tracking of one async body, saved while a nested one is transformed. */
+export declare class SuperAccessScope {
+    readonly capturedSuperProperties: string[] | undefined;
+    readonly hasSuperElementAccess: boolean;
+    readonly hasSuperPropertyAssignment: boolean;
+    readonly superBinding: Identifier | undefined;
+    readonly superIndexBinding: Identifier | undefined;
+    constructor(capturedSuperProperties: string[] | undefined, hasSuperElementAccess: boolean, hasSuperPropertyAssignment: boolean, superBinding: Identifier | undefined, superIndexBinding: Identifier | undefined);
+}
+/** Tracks `super.x`, `super[x]` and assignments to them in an async body, and rewrites them. */
+export declare class SuperAccess extends VisitorBase {
+    /** Property names read through `super.x`, in order; undefined outside of a method body. */
+    capturedSuperProperties: string[] | undefined;
+    hasSuperElementAccess: boolean;
+    hasSuperPropertyAssignment: boolean;
+    superBinding: Identifier | undefined;
+    superIndexBinding: Identifier | undefined;
+    constructor(context: EmitContext);
+    /** Starts tracking a new method body; returns the enclosing body's state. */
+    enter(): SuperAccessScope;
+    exit(saved: SuperAccessScope): boolean;
+    /** Whether the body accesses `super`, so it needs `_super` or `_superIndex`. */
+    needsHelpers(): boolean;
+    /** Records a super access or assignment for the enclosing method body. */
+    track(node: Node): boolean;
+    /** Replaces super accesses in an async body, which ends up in a generator where `super` is invalid. */
+    visit(node: Node): Node | undefined;
+    /** `super.x(args)` as `_super.x.call(this, args)`, `super[x](args)` as `_superIndex(x).call(this, args)`. */
+    private substituteCallExpression;
+    /** `_superIndex(x)`, or `_superIndex(x).value` when super properties are assigned. */
+    private createSuperElementAccess;
+    /**
+     * `const _super = Object.create(null, { x: { get: () => super.x, set: v => super.x = v } });`,
+     * with setters only when super properties are assigned.
+     */
+    createSuperAccessVariableStatement(): Node;
+}

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

@@ -0,0 +1,260 @@
+// Shared by the async function and async generator transforms: tracking `super` accesses in
+// async bodies and rewriting them to `_super`/`_superIndex`, which work inside a generator.
+import { ArrayLiteralExpression, BinaryExpression, CallExpression, ElementAccessExpression, Identifier, ObjectLiteralExpression, ParameterDeclaration, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, PropertyAssignment, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, getAsteriskToken, getBody, getModifiers, } from '../ast.js';
+import { isAssignmentOperator } from '../ast-utilities.js';
+import { VisitorBase } from './visitor-base.js';
+export function getFunctionFlags(node) {
+    let flags = 0 /* FunctionFlags.Normal */;
+    switch (node.kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            if (getAsteriskToken(node) !== undefined)
+                flags |= 1 /* FunctionFlags.Generator */;
+            if (hasAsyncModifier(node))
+                flags |= 2 /* FunctionFlags.Async */;
+            break;
+        case 220 /* SyntaxKind.ArrowFunction */:
+            if (hasAsyncModifier(node))
+                flags |= 2 /* FunctionFlags.Async */;
+            break;
+        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            break;
+        default:
+            return 4 /* FunctionFlags.Invalid */;
+    }
+    if (getBody(node) === undefined)
+        flags |= 4 /* FunctionFlags.Invalid */;
+    return flags;
+}
+function hasAsyncModifier(node) {
+    const modifiers = getModifiers(node);
+    return modifiers !== undefined && (modifiers.modifierFlags & 1024 /* ModifierFlags.Async */) !== 0;
+}
+export function isFunctionLikeDeclaration(node) {
+    switch (node.kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return true;
+    }
+    return false;
+}
+/** Whether every parameter is a plain identifier without an initializer. */
+export function isSimpleParameterList(parameters) {
+    for (let i = 0; i < parameters.length; i++) {
+        const parameter = parameters[i];
+        if (!(parameter instanceof ParameterDeclaration))
+            continue;
+        if (parameter.initializer !== undefined || !(parameter.name instanceof Identifier))
+            return false;
+    }
+    return true;
+}
+/** The super-access tracking of one async body, saved while a nested one is transformed. */
+export class SuperAccessScope {
+    capturedSuperProperties;
+    hasSuperElementAccess;
+    hasSuperPropertyAssignment;
+    superBinding;
+    superIndexBinding;
+    constructor(capturedSuperProperties, hasSuperElementAccess, hasSuperPropertyAssignment, superBinding, superIndexBinding) {
+        this.capturedSuperProperties = capturedSuperProperties;
+        this.hasSuperElementAccess = hasSuperElementAccess;
+        this.hasSuperPropertyAssignment = hasSuperPropertyAssignment;
+        this.superBinding = superBinding;
+        this.superIndexBinding = superIndexBinding;
+    }
+}
+/** Tracks `super.x`, `super[x]` and assignments to them in an async body, and rewrites them. */
+export class SuperAccess extends VisitorBase {
+    /** Property names read through `super.x`, in order; undefined outside of a method body. */
+    capturedSuperProperties;
+    hasSuperElementAccess;
+    hasSuperPropertyAssignment;
+    superBinding;
+    superIndexBinding;
+    constructor(context) {
+        super(context);
+        this.capturedSuperProperties = undefined;
+        this.hasSuperElementAccess = false;
+        this.hasSuperPropertyAssignment = false;
+        this.superBinding = undefined;
+        this.superIndexBinding = undefined;
+    }
+    /** Starts tracking a new method body; returns the enclosing body's state. */
+    enter() {
+        const saved = new SuperAccessScope(this.capturedSuperProperties, this.hasSuperElementAccess, this.hasSuperPropertyAssignment, this.superBinding, this.superIndexBinding);
+        const flags = 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */;
+        this.capturedSuperProperties = [];
+        this.hasSuperElementAccess = false;
+        this.hasSuperPropertyAssignment = false;
+        this.superBinding = this.factory.createUniqueName('_super', flags);
+        this.superIndexBinding = this.factory.createUniqueName('_superIndex', flags);
+        return saved;
+    }
+    exit(saved) {
+        this.capturedSuperProperties = saved.capturedSuperProperties;
+        this.hasSuperElementAccess = saved.hasSuperElementAccess;
+        this.hasSuperPropertyAssignment = saved.hasSuperPropertyAssignment;
+        this.superBinding = saved.superBinding;
+        this.superIndexBinding = saved.superIndexBinding;
+        return true;
+    }
+    /** Whether the body accesses `super`, so it needs `_super` or `_superIndex`. */
+    needsHelpers() {
+        return (this.capturedSuperProperties !== undefined &&
+            (this.capturedSuperProperties.length > 0 || this.hasSuperElementAccess));
+    }
+    /** Records a super access or assignment for the enclosing method body. */
+    track(node) {
+        const captured = this.capturedSuperProperties;
+        if (captured === undefined)
+            return false;
+        if (node instanceof PropertyAccessExpression) {
+            if (node.expression.kind === 107 /* SyntaxKind.SuperKeyword */ && node.name instanceof Identifier)
+                if (captured.indexOf(node.name.text) < 0)
+                    captured.push(node.name.text);
+        }
+        else if (node instanceof ElementAccessExpression) {
+            if (node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
+                this.hasSuperElementAccess = true;
+        }
+        else if (node instanceof BinaryExpression) {
+            if (isAssignmentOperator(node.operatorToken.kind) && assignmentTargetContainsSuperProperty(node.left))
+                this.hasSuperPropertyAssignment = true;
+        }
+        else if (node instanceof PrefixUnaryExpression) {
+            if (isUpdateOperator(node.operator) && assignmentTargetContainsSuperProperty(node.operand))
+                this.hasSuperPropertyAssignment = true;
+        }
+        else if (node instanceof PostfixUnaryExpression) {
+            if (isUpdateOperator(node.operator) && assignmentTargetContainsSuperProperty(node.operand))
+                this.hasSuperPropertyAssignment = true;
+        }
+        return true;
+    }
+    /** Replaces super accesses in an async body, which ends up in a generator where `super` is invalid. */
+    visit(node) {
+        switch (node.kind) {
+            case 214 /* SyntaxKind.CallExpression */:
+                if (node instanceof CallExpression && isSuperProperty(node.expression))
+                    return this.substituteCallExpression(node);
+                break;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                if (node instanceof PropertyAccessExpression && node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
+                    return this.factory.createPropertyAccessExpression(this.superBinding, node.name);
+                break;
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+                if (node instanceof ElementAccessExpression && node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
+                    return this.createSuperElementAccess(node.argumentExpression);
+                break;
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 177 /* SyntaxKind.Constructor */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */:
+                return node;
+        }
+        return this.visitEachChild(node);
+    }
+    /** `super.x(args)` as `_super.x.call(this, args)`, `super[x](args)` as `_superIndex(x).call(this, args)`. */
+    substituteCallExpression(call) {
+        const expression = call.expression;
+        const factory = this.factory;
+        let target;
+        if (expression instanceof PropertyAccessExpression)
+            target = factory.createPropertyAccessExpression(this.superBinding, expression.name);
+        else if (expression instanceof ElementAccessExpression)
+            target = this.createSuperElementAccess(expression.argumentExpression);
+        else
+            return this.visitEachChild(call);
+        const args = [factory.createKeywordExpression(109 /* SyntaxKind.ThisKeyword */)];
+        const visited = this.visitNodes(call.arguments);
+        if (visited !== undefined)
+            for (let i = 0; i < visited.nodes.length; i++)
+                args.push(visited.nodes[i]);
+        const result = factory.createCallExpression(factory.createPropertyAccessExpression(target, factory.createIdentifier('call')), args);
+        result.pos = call.pos;
+        result.end = call.end;
+        return result;
+    }
+    /** `_superIndex(x)`, or `_superIndex(x).value` when super properties are assigned. */
+    createSuperElementAccess(argument) {
+        const factory = this.factory;
+        const call = factory.createCallExpression(this.superIndexBinding, [argument]);
+        if (this.hasSuperPropertyAssignment)
+            return factory.createPropertyAccessExpression(call, factory.createIdentifier('value'));
+        return call;
+    }
+    /**
+     * `const _super = Object.create(null, { x: { get: () => super.x, set: v => super.x = v } });`,
+     * with setters only when super properties are assigned.
+     */
+    createSuperAccessVariableStatement() {
+        const factory = this.factory;
+        const accessors = [];
+        const names = this.capturedSuperProperties;
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const descriptor = [];
+            const getter = factory.createArrowFunction([], factory.createPropertyAccessExpression(factory.createKeywordExpression(107 /* SyntaxKind.SuperKeyword */), factory.createIdentifier(name)));
+            descriptor.push(factory.createPropertyAssignment(factory.createIdentifier('get'), getter));
+            if (this.hasSuperPropertyAssignment) {
+                const setter = factory.createArrowFunction([factory.createParameter(factory.createIdentifier('v'))], factory.createAssignment(factory.createPropertyAccessExpression(factory.createKeywordExpression(107 /* SyntaxKind.SuperKeyword */), factory.createIdentifier(name)), factory.createIdentifier('v')));
+                descriptor.push(factory.createPropertyAssignment(factory.createIdentifier('set'), setter));
+            }
+            accessors.push(factory.createPropertyAssignment(factory.createIdentifier(name), factory.createObjectLiteral(descriptor, false)));
+        }
+        const create = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Object'), factory.createIdentifier('create')), [factory.createKeywordExpression(105 /* SyntaxKind.NullKeyword */), factory.createObjectLiteral(accessors, true)]);
+        return factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([factory.createVariableDeclaration(this.superBinding, undefined, undefined, create)]), 2 /* NodeFlags.Const */));
+    }
+}
+function isSuperProperty(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.expression.kind === 107 /* SyntaxKind.SuperKeyword */;
+    if (node instanceof ElementAccessExpression)
+        return node.expression.kind === 107 /* SyntaxKind.SuperKeyword */;
+    return false;
+}
+function isUpdateOperator(operator) {
+    return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */;
+}
+/** Whether an assignment target contains `super.x` or `super[x]`, checked top-down. */
+function assignmentTargetContainsSuperProperty(node) {
+    if (node instanceof PropertyAccessExpression || node instanceof ElementAccessExpression)
+        return isSuperProperty(node);
+    if (node instanceof ParenthesizedExpression)
+        return assignmentTargetContainsSuperProperty(node.expression);
+    if (node instanceof SpreadElement)
+        return assignmentTargetContainsSuperProperty(node.expression);
+    if (node instanceof ArrayLiteralExpression) {
+        const elements = node.elements.nodes;
+        for (let i = 0; i < elements.length; i++)
+            if (assignmentTargetContainsSuperProperty(elements[i]))
+                return true;
+        return false;
+    }
+    if (node instanceof ObjectLiteralExpression) {
+        const properties = node.properties.nodes;
+        for (let i = 0; i < properties.length; i++) {
+            const property = properties[i];
+            if (property instanceof PropertyAssignment && assignmentTargetContainsSuperProperty(property.initializer))
+                return true;
+            if (property instanceof ShorthandPropertyAssignment && assignmentTargetContainsSuperProperty(property.name))
+                return true;
+            if (property instanceof SpreadAssignment && assignmentTargetContainsSuperProperty(property.expression))
+                return true;
+        }
+    }
+    return false;
+}

package/dist/api/compiler/transformers/async.d.ts

@@ -0,0 +1,53 @@
+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 AsyncFunctions extends Transformer {
+    private readonly facts;
+    private readonly superAccess;
+    private readonly asyncBodyVisitor;
+    private readonly fallbackVisitor;
+    private contextFlags;
+    private enclosingFunctionParameterNames;
+    /** The `_arguments` binding of the enclosing async function, if any. */
+    private argumentsBinding;
+    private argumentsUsed;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private visitWorker;
+    private visitFunctionOrClass;
+    /** Rewrites `arguments` and `super` in subtrees without `await`, when inside an async body. */
+    fallback(node: Node): Node | undefined;
+    private visitSourceFile;
+    visitAsyncBodyNode(node: Node): Node | undefined;
+    private visitCatchClauseInAsyncBody;
+    private visitVariableStatementInAsyncBody;
+    private visitForInOrOfStatementInAsyncBody;
+    private visitForStatementInAsyncBody;
+    /** `await x` as `yield x`, except at the top level, where it's module syntax. */
+    private visitAwaitExpression;
+    private visitConstructor;
+    private visitMethodDeclaration;
+    private visitGetAccessor;
+    private visitSetAccessor;
+    private visitFunctionDeclaration;
+    private visitFunctionExpression;
+    private visitArrowFunction;
+    private visitArrowFunctionWorker;
+    private isVariableDeclarationListWithCollidingName;
+    private collidesWithParameterName;
+    private visitVariableDeclarationListWithCollidingNames;
+    private hoistVariable;
+    private transformInitializedVariable;
+    private transformMethodBody;
+    private createCaptureArgumentsStatement;
+    /**
+     * 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).
+     */
+    private transformAsyncFunctionParameterList;
+    private transformAsyncFunctionBody;
+    private transformAsyncFunctionBodyWorker;
+    private convertToFunctionBlock;
+    private getOriginalIfFunctionLike;
+}