tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,238 @@
+// Which declarations decorators apply to, and the accessor pairs and ranges decorator
+// transforms need.
+import { ArrayTypeNode, ComputedPropertyName, ParenthesizedTypeNode, TypeReferenceNode, Decorator, PrefixUnaryExpression, getBody, getMembers, getModifiers, getName, getParameters, getText, } from '../ast.js';
+import { nodeIsPresent } from '../ast-utilities.js';
+import { TextRange, hasDynamicName, isClassLike, isSignedNumericLiteral, isStatic, isStringOrNumericLiteralLike, } from '../binder-utilities.js';
+import { positionIsSynthesized } from '../printer/utilities.js';
+import { isSimpleCopiableExpression } from './destructuring.js';
+import { hasDecorators, hasSyntacticModifier, isThisParameter } from './utilities.js';
+/** The decorators among the modifiers of `node`. */
+export function getDecorators(node) {
+    const modifiers = getModifiers(node);
+    const decorators = [];
+    if (modifiers === undefined)
+        return decorators;
+    for (let i = 0; i < modifiers.nodes.length; i++)
+        if (modifiers.nodes[i] instanceof Decorator)
+            decorators.push(modifiers.nodes[i]);
+    return decorators;
+}
+export function isAccessor(node) {
+    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+}
+export function getFirstConstructorWithBody(node) {
+    const members = getMembers(node);
+    if (members === undefined)
+        return undefined;
+    for (let i = 0; i < members.nodes.length; i++) {
+        const member = members.nodes[i];
+        if (member.kind === 177 /* SyntaxKind.Constructor */ && nodeIsPresent(getBody(member)))
+            return member;
+    }
+    return undefined;
+}
+/** Whether decorators on `node` take effect, as opposed to being a grammar error. */
+export function nodeCanBeDecorated(legacy, node, parent, grandparent) {
+    const name = getName(node);
+    // Private names can't be decorated with legacy decorators.
+    if (legacy && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        return false;
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+            return true;
+        case 232 /* SyntaxKind.ClassExpression */:
+            return !legacy;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return (parent !== undefined &&
+                (legacy
+                    ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */
+                    : isClassLike(parent) && !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */ | 128 /* ModifierFlags.Ambient */)));
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            return (parent !== undefined &&
+                getBody(node) !== undefined &&
+                (legacy ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
+        case 170 /* SyntaxKind.Parameter */: {
+            // Parameter decorators aren't standard yet.
+            if (!legacy || parent === undefined || getBody(parent) === undefined)
+                return false;
+            if (parent.kind !== 177 /* SyntaxKind.Constructor */ &&
+                parent.kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
+                parent.kind !== 179 /* SyntaxKind.SetAccessor */)
+                return false;
+            const parameters = getParameters(parent);
+            const thisParameter = parameters !== undefined && parameters.nodes.length > 0 && isThisParameter(parameters.nodes[0])
+                ? parameters.nodes[0]
+                : undefined;
+            return thisParameter !== node && grandparent !== undefined && grandparent.kind === 264 /* SyntaxKind.ClassDeclaration */;
+        }
+    }
+    return false;
+}
+export function nodeIsDecorated(legacy, node, parent, grandparent) {
+    return hasDecorators(node) && nodeCanBeDecorated(legacy, node, parent, grandparent);
+}
+export function nodeOrChildIsDecorated(legacy, node, parent, grandparent) {
+    return nodeIsDecorated(legacy, node, parent, grandparent) || childIsDecorated(legacy, node, parent);
+}
+/** Whether a member of a class, or a parameter of a method, setter or constructor, is decorated. */
+export function childIsDecorated(legacy, node, parent) {
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */: {
+            const members = getMembers(node).nodes;
+            for (let i = 0; i < members.length; i++)
+                if (nodeOrChildIsDecorated(legacy, members[i], node, parent))
+                    return true;
+            return false;
+        }
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 177 /* SyntaxKind.Constructor */: {
+            const parameters = getParameters(node).nodes;
+            for (let i = 0; i < parameters.length; i++)
+                if (nodeIsDecorated(legacy, parameters[i], node, parent))
+                    return true;
+            return false;
+        }
+    }
+    return false;
+}
+export function classOrConstructorParameterIsDecorated(legacy, node) {
+    if (nodeIsDecorated(legacy, node, undefined, undefined))
+        return true;
+    const constructor = getFirstConstructorWithBody(node);
+    return constructor !== undefined && childIsDecorated(legacy, constructor, node);
+}
+export function classElementOrClassElementParameterIsDecorated(legacy, node, parent) {
+    let parameters = undefined;
+    if (isAccessor(node)) {
+        const accessors = getAllAccessorDeclarations(getMembers(parent).nodes, node);
+        const first = accessors.firstWithDecorators();
+        if (first === undefined || node !== first)
+            return false;
+        if (accessors.setAccessor !== undefined)
+            parameters = getParameters(accessors.setAccessor).nodes;
+    }
+    else if (node.kind === 175 /* SyntaxKind.MethodDeclaration */)
+        parameters = getParameters(node).nodes;
+    if (nodeIsDecorated(legacy, node, parent, undefined))
+        return true;
+    if (parameters !== undefined)
+        for (let i = 0; i < parameters.length; i++) {
+            const parameter = parameters[i];
+            if (!isThisParameter(parameter) && nodeIsDecorated(legacy, parameter, node, parent))
+                return true;
+        }
+    return false;
+}
+/** The get and set accessors declaring one property, in source order. */
+export class AllAccessorDeclarations {
+    firstAccessor;
+    secondAccessor;
+    getAccessor;
+    setAccessor;
+    constructor(firstAccessor, secondAccessor, getAccessor, setAccessor) {
+        this.firstAccessor = firstAccessor;
+        this.secondAccessor = secondAccessor;
+        this.getAccessor = getAccessor;
+        this.setAccessor = setAccessor;
+    }
+    /** The first of the pair with decorators: legacy decorators apply to both. */
+    firstWithDecorators() {
+        if (hasDecorators(this.firstAccessor))
+            return this.firstAccessor;
+        if (this.secondAccessor !== undefined && hasDecorators(this.secondAccessor))
+            return this.secondAccessor;
+        return undefined;
+    }
+}
+/** `accessor` and the other accessor among `members` with the same name and staticness. */
+export function getAllAccessorDeclarations(members, accessor) {
+    const otherKind = accessor.kind === 179 /* SyntaxKind.SetAccessor */ ? 178 /* SyntaxKind.GetAccessor */ : 179 /* SyntaxKind.SetAccessor */;
+    let other = undefined;
+    // Dynamic names only match through the checker's symbols.
+    if (!hasDynamicName(accessor)) {
+        const name = getPropertyNameForPropertyNameNode(getName(accessor));
+        const accessorStatic = isStatic(accessor);
+        for (let i = 0; i < members.length && other === undefined; i++) {
+            const member = members[i];
+            if (member.kind !== otherKind || isStatic(member) !== accessorStatic)
+                continue;
+            if (getPropertyNameForPropertyNameNode(getName(member)) === name)
+                other = member;
+        }
+    }
+    const otherFirst = other !== undefined && other.pos < accessor.pos;
+    const first = otherFirst ? other : accessor;
+    const second = otherFirst ? accessor : other;
+    return accessor.kind === 179 /* SyntaxKind.SetAccessor */
+        ? new AllAccessorDeclarations(first, second, other, accessor)
+        : new AllAccessorDeclarations(first, second, accessor, other);
+}
+/** The property name a name node declares; computed names other than literals are missing. */
+export function getPropertyNameForPropertyNameNode(name) {
+    if (name instanceof ComputedPropertyName) {
+        const expression = name.expression;
+        if (isStringOrNumericLiteralLike(expression))
+            return getText(expression);
+        if (isSignedNumericLiteral(expression) && expression instanceof PrefixUnaryExpression) {
+            const text = getText(expression.operand);
+            return expression.operator === 40 /* SyntaxKind.MinusToken */ ? '-' + text : text;
+        }
+        return "\uFFFEmissing" /* InternalSymbolName.Missing */;
+    }
+    return getText(name);
+}
+/** The range of `node` after its modifiers, for source maps of what replaces it. */
+export function moveRangePastModifiers(node) {
+    if (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ || node.kind === 175 /* SyntaxKind.MethodDeclaration */)
+        return new TextRange(getName(node).pos, node.end);
+    const modifiers = getModifiers(node);
+    if (modifiers !== undefined && modifiers.nodes.length > 0) {
+        const last = modifiers.nodes[modifiers.nodes.length - 1];
+        if (!positionIsSynthesized(last.end))
+            return new TextRange(last.end, node.end);
+    }
+    return moveRangePastDecorators(node);
+}
+/** The range of `node` after its decorators. */
+export function moveRangePastDecorators(node) {
+    const modifiers = getModifiers(node);
+    if (modifiers !== undefined)
+        for (let i = modifiers.nodes.length - 1; i >= 0; i--) {
+            const modifier = modifiers.nodes[i];
+            if (modifier instanceof Decorator) {
+                if (!positionIsSynthesized(modifier.end))
+                    return new TextRange(modifier.end, node.end);
+                break;
+            }
+        }
+    return new TextRange(node.pos, node.end);
+}
+/** A literal or keyword: evaluated in place rather than cached. */
+export function isSimpleInlineableExpression(node) {
+    return node.kind !== 79 /* SyntaxKind.Identifier */ && isSimpleCopiableExpression(node);
+}
+export function getSetAccessorValueParameter(node) {
+    const parameters = getParameters(node).nodes;
+    if (parameters.length === 0)
+        return undefined;
+    if (parameters.length >= 2 && isThisParameter(parameters[0]))
+        return parameters[1];
+    return parameters[0];
+}
+/** `T` of a rest parameter's `T[]` or `Array<T>`. */
+export function getRestParameterElementType(node) {
+    if (node instanceof ArrayTypeNode)
+        return node.elementType;
+    if (node instanceof TypeReferenceNode && node.typeArguments !== undefined && node.typeArguments.nodes.length > 0)
+        return node.typeArguments.nodes[0];
+    return undefined;
+}
+export function skipTypeParentheses(node) {
+    while (node instanceof ParenthesizedTypeNode)
+        node = node.type;
+    return node;
+}

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

@@ -0,0 +1,25 @@
+import { Identifier, type Node, VariableDeclaration } from '../ast.js';
+import type { SyntaxFacts } from './syntax-facts.js';
+import type { VisitorHooks } from './visitor-hooks.js';
+/** Creates the assignment of a flattened value to an identifier, such as `exports.x = value`. */
+export declare abstract class AssignmentFactory {
+    abstract createAssignment(name: Identifier, value: Node, pos: number, end: number): Node;
+}
+/** Flattens `node`, a destructuring assignment or variable declaration, into a comma expression. */
+export declare function flattenDestructuringAssignment(visitor: VisitorHooks, node: Node, needsValue: boolean, assignments: AssignmentFactory | undefined): Node;
+/** Flattens a destructuring assignment only as far as needed to lower its object rest elements. */
+export declare function flattenObjectRestAssignment(visitor: VisitorHooks, facts: SyntaxFacts, node: Node, needsValue: boolean): Node;
+/**
+ * Flattens the binding pattern of a variable declaration, parameter or binding element into
+ * variable declarations: a `VariableDeclaration`, a `SyntaxList` of them, or undefined. With
+ * `facts`, patterns are only decomposed as far as needed to lower object rest elements.
+ */
+export declare function flattenDestructuringBinding(visitor: VisitorHooks, facts: SyntaxFacts | undefined, node: Node, rval: Node | undefined, hoistTempVariables: boolean, skipInitializer: boolean): Node | undefined;
+/** Strings, numbers, keywords and identifiers: copied rather than cached in a temporary. */
+export declare function isSimpleCopiableExpression(node: Node): boolean;
+export declare function getElementsOfBindingOrAssignmentPattern(node: Node): Node[];
+export declare function getTargetOfBindingOrAssignmentElement(element: Node): Node | undefined;
+/** `pattern = initializer` for a variable declaration, with binding patterns as assignment patterns. */
+export declare function convertVariableDeclarationToAssignment(visitor: VisitorHooks, node: VariableDeclaration): Node | undefined;
+/** A binding name as an assignment target, with binding patterns as assignment patterns. */
+export declare function convertBindingNameToTarget(visitor: VisitorHooks, name: Node): Node;