tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,347 @@
+// Node predicates the transforms share.
+import { AsExpression, BinaryExpression, ExpressionWithTypeArguments, NonNullExpression, PartiallyEmittedExpression, SatisfiesExpression, TypeAssertion, ExportDeclaration, ExportSpecifier, Identifier, ModuleBlock, ModuleDeclaration, NamedExports, ParameterDeclaration, ParenthesizedExpression, SourceFile, Block, VariableStatement, ShorthandPropertyAssignment, ForStatement, ImportEqualsDeclaration, ConditionalExpression, TaggedTemplateExpression, ImportAttribute, LabeledStatement, VariableDeclarationList, getArguments, getBody, getExpression, getInitializer, getModifiers, getName, getStatements, getTagName, } from '../ast.js';
+export function modifierFlagsOf(node) {
+    const modifiers = getModifiers(node);
+    return modifiers === undefined ? 0 /* ModifierFlags.None */ : modifiers.modifierFlags;
+}
+export function hasSyntacticModifier(node, flags) {
+    return (modifierFlagsOf(node) & flags) !== 0;
+}
+export function hasDecorators(node) {
+    return hasSyntacticModifier(node, 32768 /* ModifierFlags.Decorator */);
+}
+export function isThisParameter(node) {
+    return node instanceof ParameterDeclaration && node.name instanceof Identifier && node.name.text === 'this';
+}
+export function isParameterPropertyDeclaration(node, parent) {
+    return (node instanceof ParameterDeclaration &&
+        hasSyntacticModifier(node, 31 /* ModifierFlags.ParameterPropertyModifier */) &&
+        parent !== undefined &&
+        parent.kind === 177 /* SyntaxKind.Constructor */);
+}
+/** `/** @type {T} *\/ (expr)` in a JavaScript file. */
+export function isJSDocTypeAssertion(node) {
+    if (!(node instanceof ParenthesizedExpression) || (node.flags & 65536 /* NodeFlags.JavaScriptFile */) === 0)
+        return false;
+    const expression = node.expression;
+    return expression instanceof AsExpression && (expression.type.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+}
+export function isExternalModule(file) {
+    return file.externalModuleIndicator !== undefined;
+}
+export function getInnermostModuleDeclaration(node) {
+    let body = node.body;
+    while (body instanceof ModuleDeclaration) {
+        node = body;
+        body = node.body;
+    }
+    return node;
+}
+/** Whether a namespace has runtime content, from its syntax alone. */
+export function getModuleInstanceState(node) {
+    return new ModuleInstanceStates().ofModule(node, []);
+}
+export function isInstantiatedModule(node, preserveConstEnums) {
+    const state = getModuleInstanceState(node);
+    return (state === 2 /* ModuleInstanceState.Instantiated */ || (preserveConstEnums && state === 3 /* ModuleInstanceState.ConstEnumOnly */));
+}
+class ModuleInstanceStates {
+    visited;
+    constructor() {
+        this.visited = new Map();
+    }
+    ofModule(node, ancestors) {
+        const body = node.body;
+        if (body === undefined)
+            return 2 /* ModuleInstanceState.Instantiated */;
+        const self = node;
+        return this.cached(body, ancestors.concat([self]));
+    }
+    cached(node, ancestors) {
+        const cached = this.visited.get(node);
+        if (cached !== undefined)
+            return cached !== 0 /* ModuleInstanceState.Unknown */ ? cached : 1 /* ModuleInstanceState.NonInstantiated */;
+        this.visited.set(node, 0 /* ModuleInstanceState.Unknown */);
+        const result = this.worker(node, ancestors);
+        this.visited.set(node, result);
+        return result;
+    }
+    worker(node, ancestors) {
+        switch (node.kind) {
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+                return 1 /* ModuleInstanceState.NonInstantiated */;
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                if (hasSyntacticModifier(node, 4096 /* ModifierFlags.Const */))
+                    return 3 /* ModuleInstanceState.ConstEnumOnly */;
+                break;
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+                if (!hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+                    return 1 /* ModuleInstanceState.NonInstantiated */;
+                break;
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                if (node instanceof ExportDeclaration &&
+                    node.moduleSpecifier === undefined &&
+                    node.exportClause instanceof NamedExports) {
+                    let state = 1 /* ModuleInstanceState.NonInstantiated */;
+                    const declaration = node;
+                    const clause = node.exportClause;
+                    const inner = ancestors.concat([declaration, clause]);
+                    const elements = node.exportClause.elements.nodes;
+                    for (const specifier of elements) {
+                        if (!(specifier instanceof ExportSpecifier))
+                            continue;
+                        const specifierState = this.ofAliasTarget(specifier, inner);
+                        if (specifierState > state)
+                            state = specifierState;
+                        if (state === 2 /* ModuleInstanceState.Instantiated */)
+                            return state;
+                    }
+                    return state;
+                }
+                break;
+            case 269 /* SyntaxKind.ModuleBlock */:
+                if (node instanceof ModuleBlock) {
+                    let state = 1 /* ModuleInstanceState.NonInstantiated */;
+                    const block = node;
+                    const inner = ancestors.concat([block]);
+                    const statements = node.statements.nodes;
+                    for (const statement of statements) {
+                        const child = this.cached(statement, inner);
+                        if (child === 3 /* ModuleInstanceState.ConstEnumOnly */)
+                            state = child;
+                        else if (child === 2 /* ModuleInstanceState.Instantiated */)
+                            return child;
+                    }
+                    return state;
+                }
+                break;
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                if (node instanceof ModuleDeclaration)
+                    return this.ofModule(node, ancestors);
+                break;
+        }
+        return 2 /* ModuleInstanceState.Instantiated */;
+    }
+    ofAliasTarget(specifier, ancestors) {
+        const name = specifier.propertyName !== undefined ? specifier.propertyName : specifier.name;
+        if (!(name instanceof Identifier))
+            return 2 /* ModuleInstanceState.Instantiated */;
+        for (let a = ancestors.length - 1; a >= 0; a--) {
+            const p = ancestors[a];
+            const statementList = getStatements(p);
+            if (statementList === undefined || !(p instanceof Block || p instanceof ModuleBlock || p instanceof SourceFile))
+                continue;
+            let found = 0 /* ModuleInstanceState.Unknown */;
+            const inner = ancestors.slice(0, a + 1);
+            const statements = statementList.nodes;
+            for (const statement of statements) {
+                if (!nodeHasName(statement, name.text))
+                    continue;
+                const state = this.cached(statement, inner);
+                if (found === 0 /* ModuleInstanceState.Unknown */ || state > found)
+                    found = state;
+                if (found === 2 /* ModuleInstanceState.Instantiated */)
+                    return found;
+                if (statement.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */)
+                    found = 2 /* ModuleInstanceState.Instantiated */;
+            }
+            if (found !== 0 /* ModuleInstanceState.Unknown */)
+                return found;
+        }
+        return 2 /* ModuleInstanceState.Instantiated */;
+    }
+}
+function nodeHasName(statement, text) {
+    const name = getName(statement);
+    if (name !== undefined)
+        return name instanceof Identifier && name.text === text;
+    if (statement instanceof VariableStatement) {
+        const declarations = statement.declarationList.declarations.nodes;
+        for (const declaration of declarations)
+            if (nodeHasName(declaration, text))
+                return true;
+    }
+    return false;
+}
+/** Whether `name` is used as a value in `parent`, rather than declared or as a property name. */
+export function isIdentifierReference(name, parent) {
+    if (parent === undefined)
+        return false;
+    switch (parent.kind) {
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PostfixUnaryExpression */:
+        case 230 /* SyntaxKind.YieldExpression */:
+        case 235 /* SyntaxKind.AsExpression */:
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 231 /* SyntaxKind.SpreadElement */:
+        case 305 /* SyntaxKind.SpreadAssignment */:
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 221 /* SyntaxKind.DeleteExpression */:
+        case 222 /* SyntaxKind.TypeOfExpression */:
+        case 223 /* SyntaxKind.VoidExpression */:
+        case 224 /* SyntaxKind.AwaitExpression */:
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 294 /* SyntaxKind.JsxSpreadAttribute */:
+        case 295 /* SyntaxKind.JsxExpression */:
+        case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+            return true;
+        case 168 /* SyntaxKind.ComputedPropertyName */:
+        case 171 /* SyntaxKind.Decorator */:
+        case 246 /* SyntaxKind.IfStatement */:
+        case 247 /* SyntaxKind.DoStatement */:
+        case 248 /* SyntaxKind.WhileStatement */:
+        case 255 /* SyntaxKind.WithStatement */:
+        case 254 /* SyntaxKind.ReturnStatement */:
+        case 256 /* SyntaxKind.SwitchStatement */:
+        case 297 /* SyntaxKind.CaseClause */:
+        case 258 /* SyntaxKind.ThrowStatement */:
+        case 245 /* SyntaxKind.ExpressionStatement */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 240 /* SyntaxKind.TemplateSpan */:
+            return getExpression(parent) === name;
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 170 /* SyntaxKind.Parameter */:
+        case 209 /* SyntaxKind.BindingElement */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 306 /* SyntaxKind.EnumMember */:
+        case 292 /* SyntaxKind.JsxAttribute */:
+            return getInitializer(parent) === name;
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return parent instanceof ShorthandPropertyAssignment && parent.objectAssignmentInitializer === name;
+        case 249 /* SyntaxKind.ForStatement */:
+            return (parent instanceof ForStatement &&
+                (parent.initializer === name || parent.condition === name || parent.incrementor === name));
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+            return getInitializer(parent) === name || getExpression(parent) === name;
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            return parent instanceof ImportEqualsDeclaration && parent.moduleReference === name;
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return getBody(parent) === name;
+        case 228 /* SyntaxKind.ConditionalExpression */:
+            return (parent instanceof ConditionalExpression &&
+                (parent.condition === name || parent.whenTrue === name || parent.whenFalse === name));
+        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.NewExpression */: {
+            if (getExpression(parent) === name)
+                return true;
+            const args = getArguments(parent);
+            return args !== undefined && args.nodes.indexOf(name) >= 0;
+        }
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            return parent instanceof TaggedTemplateExpression && parent.tag === name;
+        case 302 /* SyntaxKind.ImportAttribute */:
+            return parent instanceof ImportAttribute && parent.value === name;
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+        case 288 /* SyntaxKind.JsxClosingElement */:
+            return getTagName(parent) === name;
+    }
+    return false;
+}
+/** The node itself for one node, else a syntax list of them; undefined for none. */
+export function singleOrMany(nodes, factory) {
+    if (nodes.length === 0)
+        return undefined;
+    if (nodes.length === 1)
+        return nodes[0];
+    return factory.createSyntaxList(nodes);
+}
+/** Whether two optional nodes are the same node. */
+export function isSameNode(a, b) {
+    if (a === undefined)
+        return b === undefined;
+    if (b === undefined)
+        return false;
+    return a === b;
+}
+/** The statement binding a `for...of` head to `boundValue`: a declaration or an assignment. */
+export function createForOfBindingStatement(factory, node, boundValue) {
+    if (node instanceof VariableDeclarationList) {
+        const first = node.declarations.nodes[0];
+        const declaration = factory.updateVariableDeclaration(first, first.name, undefined, undefined, boundValue);
+        const statement = factory.createVariableStatement(undefined, factory.updateVariableDeclarationList(node, factory.createNodeList([declaration]), node.flags));
+        statement.pos = node.pos;
+        statement.end = node.end;
+        return statement;
+    }
+    const assignment = factory.createAssignment(node, boundValue);
+    assignment.pos = node.pos;
+    assignment.end = node.end;
+    const statement = factory.createExpressionStatement(assignment);
+    statement.pos = node.pos;
+    statement.end = node.end;
+    return statement;
+}
+/** `node` wrapped in the labels of `outermost` and the labeled statements nested in it. */
+export function restoreEnclosingLabel(factory, node, outermost) {
+    if (outermost === undefined)
+        return node;
+    const inner = outermost.statement instanceof LabeledStatement ? restoreEnclosingLabel(factory, node, outermost.statement) : node;
+    return factory.updateLabeledStatement(outermost, outermost.label, inner);
+}
+export function isOuterExpression(node, kinds) {
+    switch (node.kind) {
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return ((kinds & 1 /* OuterExpressionKinds.Parentheses */) !== 0 &&
+                !((kinds & 64 /* OuterExpressionKinds.ExcludeJSDocTypeAssertion */) !== 0 && isJSDocTypeAssertion(node)));
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 235 /* SyntaxKind.AsExpression */:
+            return (kinds & 2 /* OuterExpressionKinds.TypeAssertions */) !== 0;
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+            return (kinds & (16 /* OuterExpressionKinds.ExpressionsWithTypeArguments */ | 32 /* OuterExpressionKinds.Satisfies */)) !== 0;
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return (kinds & 16 /* OuterExpressionKinds.ExpressionsWithTypeArguments */) !== 0;
+        case 236 /* SyntaxKind.NonNullExpression */:
+            return (kinds & 4 /* OuterExpressionKinds.NonNullAssertions */) !== 0;
+        case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+            return (kinds & 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */) !== 0;
+        case 227 /* SyntaxKind.BinaryExpression */:
+            if (node instanceof BinaryExpression) {
+                const operator = node.operatorToken.kind;
+                if (operator === 63 /* SyntaxKind.EqualsToken */)
+                    return (kinds & 128 /* OuterExpressionKinds.Assignments */) !== 0;
+                if (operator === 27 /* SyntaxKind.CommaToken */)
+                    return (kinds & 256 /* OuterExpressionKinds.Comma */) !== 0;
+            }
+    }
+    return false;
+}
+/** The expression wrapped by `node`, past the outer expressions of `kinds`. */
+export function skipOuterExpressions(node, kinds) {
+    while (isOuterExpression(node, kinds))
+        node = outerExpressionOperand(node);
+    return node;
+}
+/** The operand of an outer expression. */
+export function outerExpressionOperand(node) {
+    if (node instanceof ParenthesizedExpression)
+        return node.expression;
+    if (node instanceof TypeAssertion)
+        return node.expression;
+    if (node instanceof AsExpression)
+        return node.expression;
+    if (node instanceof SatisfiesExpression)
+        return node.expression;
+    if (node instanceof ExpressionWithTypeArguments)
+        return node.expression;
+    if (node instanceof NonNullExpression)
+        return node.expression;
+    if (node instanceof PartiallyEmittedExpression)
+        return node.expression;
+    if (node instanceof BinaryExpression)
+        return node.right;
+    return node;
+}

package/dist/api/compiler/transformers/visitor-base.d.ts

@@ -0,0 +1,6 @@
+import { type Node } from '../ast.js';
+import { VisitorHooks } from './visitor-hooks.js';
+/** Rebuilds a node from its visited children, in tsgo's order and with its traversal hooks. */
+export declare abstract class VisitorBase extends VisitorHooks {
+    visitEachChild(node: Node): Node;
+}