tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/type-serialization.js

@@ -0,0 +1,347 @@
+// How decorator metadata serializes a type reference, answered from syntax and the binder's
+// symbols. The checker answers from the referenced type itself; this follows its rules for
+// what syntax shows: classes, enums, interfaces, type aliases and type parameters, through
+// imports. Types only the checker can compute (conditional, mapped and indexed access types,
+// inherited members) serialize as `Object`.
+import { ArrayTypeNode, EnumDeclaration, Identifier, ImportClause, InterfaceDeclaration, LiteralTypeNode, ParenthesizedTypeNode, PrefixUnaryExpression, QualifiedName, TypeAliasDeclaration, TypeLiteralNode, TypeOperatorNode, TypeParameterDeclaration, TypeReferenceNode, UnionTypeNode, VariableDeclaration, getIsTypeOnly, } from '../ast.js';
+import { getStrictOptionValue } from '../options.js';
+import { declarationAt, declarationCount, getDeclarations, Symbol } from '../symbol.js';
+/** What an unresolvable alias resolves to, as the checker's unknown symbol. */
+const unknownSymbol = new Symbol(1073741823 /* SymbolFlags.All */, 'unknown');
+/** Nested type aliases followed before giving up. */
+const maxDepth = 16;
+export function getTypeReferenceSerializationKind(resolver, typeName, location) {
+    if (location === undefined)
+        return 0 /* TypeReferenceSerializationKind.Unknown */;
+    // The value must be reachable at runtime.
+    let isTypeOnly = false;
+    if (typeName instanceof QualifiedName) {
+        const root = resolveEntityName(resolver, getFirstIdentifier(typeName), 111551 /* SymbolFlags.Value */, true, location);
+        if (root !== undefined && root !== unknownSymbol && declarationCount(root) > 0) {
+            isTypeOnly = true;
+            for (const declaration of getDeclarations(root))
+                if (!isTypeOnlyImportOrExportDeclaration(declaration)) {
+                    isTypeOnly = false;
+                    break;
+                }
+        }
+    }
+    const valueSymbol = resolveEntityName(resolver, typeName, 111551 /* SymbolFlags.Value */, true, location);
+    const resolvedValue = valueSymbol === undefined ? undefined : resolveAlias(resolver, valueSymbol);
+    if (valueSymbol !== undefined && isTypeOnlyAlias(resolver, valueSymbol))
+        isTypeOnly = true;
+    const typeSymbol = resolveEntityName(resolver, typeName, 788968 /* SymbolFlags.Type */, true, location);
+    const resolvedType = typeSymbol === undefined ? undefined : resolveAlias(resolver, typeSymbol);
+    if (typeSymbol !== undefined && isTypeOnlyAlias(resolver, typeSymbol))
+        isTypeOnly = true;
+    if (resolvedValue !== undefined && resolvedValue === resolvedType && isConstructorSymbol(resolver, resolvedValue))
+        return isTypeOnly
+            ? 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */
+            : 1 /* TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue */;
+    if (resolvedType === undefined || resolvedType === unknownSymbol)
+        return isTypeOnly ? 11 /* TypeReferenceSerializationKind.ObjectType */ : 0 /* TypeReferenceSerializationKind.Unknown */;
+    return new TypeClassifier(resolver).ofSymbol(resolvedType, 0);
+}
+function resolveAlias(resolver, symbol) {
+    if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+        return symbol;
+    const target = resolver.resolveAlias(symbol);
+    return target === undefined ? unknownSymbol : resolver.getMergedSymbol(target);
+}
+function isTypeOnlyAlias(resolver, symbol) {
+    return (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && resolver.isTypeOnlyAliasChain(symbol);
+}
+/** The symbol of an identifier or qualified name with `meaning`, looked up from `location`. */
+function resolveEntityName(resolver, name, meaning, dontResolveAlias, location) {
+    let symbol = undefined;
+    if (name instanceof Identifier) {
+        const found = resolver.resolveName(location, name.text, meaning | 2097152 /* SymbolFlags.Alias */);
+        if (found === undefined)
+            return undefined;
+        symbol = resolver.getMergedSymbol(found);
+        // An alias counts if what it names has the meaning; an unresolved one might.
+        if ((symbol.flags & meaning) === 0 && (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            const target = resolver.resolveAlias(symbol);
+            if (target !== undefined && (resolver.getSymbolFlags(symbol, false, false) & meaning) === 0)
+                return undefined;
+        }
+    }
+    else if (name instanceof QualifiedName) {
+        const namespace = resolveEntityName(resolver, name.left, 1920 /* SymbolFlags.Namespace */, false, location);
+        if (namespace === undefined)
+            return undefined;
+        if (namespace === unknownSymbol)
+            return namespace;
+        let member = resolver.getExportOfSymbol(namespace, name.right.text);
+        if (member === undefined && (namespace.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            const target = resolver.resolveAlias(namespace);
+            if (target !== undefined)
+                member = resolver.getExportOfSymbol(target, name.right.text);
+        }
+        if (member === undefined || (member.flags & (meaning | 2097152 /* SymbolFlags.Alias */)) === 0)
+            return undefined;
+        symbol = member;
+    }
+    else
+        return undefined;
+    if (!dontResolveAlias) {
+        while ((symbol.flags & meaning) === 0 && (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            const target = resolver.resolveAlias(symbol);
+            if (target === undefined)
+                return unknownSymbol;
+            symbol = resolver.getMergedSymbol(target);
+        }
+    }
+    return symbol;
+}
+/** Whether the value of a symbol has construct signatures: a class, or a variable typed with `new` signatures. */
+function isConstructorSymbol(resolver, symbol) {
+    if (symbol === unknownSymbol)
+        return false;
+    if ((symbol.flags & 32 /* SymbolFlags.Class */) !== 0)
+        return true;
+    if ((symbol.flags & 3 /* SymbolFlags.Variable */) === 0)
+        return false;
+    const declaration = symbol.valueDeclaration;
+    if (!(declaration instanceof VariableDeclaration) || declaration.type === undefined)
+        return false;
+    return hasConstructSignature(resolver, declaration.type, declaration, 0);
+}
+function hasConstructSignature(resolver, type, location, depth) {
+    if (depth > maxDepth)
+        return false;
+    while (type instanceof ParenthesizedTypeNode)
+        type = type.type;
+    if (type.kind === 186 /* SyntaxKind.ConstructorType */)
+        return true;
+    if (type instanceof TypeLiteralNode)
+        return hasMember(type.members.nodes, 181 /* SyntaxKind.ConstructSignature */);
+    if (type instanceof TypeReferenceNode) {
+        const symbol = resolveEntityName(resolver, type.typeName, 788968 /* SymbolFlags.Type */, false, location);
+        if (symbol === undefined || symbol === unknownSymbol)
+            return false;
+        for (let i = 0; i < declarationCount(symbol); i++) {
+            const declaration = declarationAt(symbol, i);
+            if (declaration instanceof InterfaceDeclaration &&
+                hasMember(declaration.members.nodes, 181 /* SyntaxKind.ConstructSignature */))
+                return true;
+            if (declaration instanceof TypeAliasDeclaration)
+                return hasConstructSignature(resolver, declaration.type, declaration, depth + 1);
+        }
+    }
+    return false;
+}
+function hasMember(members, kind) {
+    for (let i = 0; i < members.length; i++)
+        if (members[i].kind === kind)
+            return true;
+    return false;
+}
+/** Classifies declared types in the checker's order: void-like, boolean, number, bigint, string, tuple, symbol, function, array. */
+class TypeClassifier {
+    resolver;
+    strictNullChecks;
+    constructor(resolver) {
+        this.resolver = resolver;
+        this.strictNullChecks = getStrictOptionValue(resolver.options, resolver.options.strictNullChecks);
+    }
+    ofSymbol(symbol, depth) {
+        const flags = symbol.flags;
+        if ((flags & 384 /* SymbolFlags.Enum */) !== 0)
+            return this.ofEnum(symbol);
+        if ((flags & 8 /* SymbolFlags.EnumMember */) !== 0) {
+            const declaration = symbol.valueDeclaration;
+            if (declaration === undefined)
+                return 3 /* TypeReferenceSerializationKind.NumberLikeType */;
+            return this.resolver.getEnumMemberValue(declaration).kind === 2 /* ConstantKind.String */
+                ? 5 /* TypeReferenceSerializationKind.StringLikeType */
+                : 3 /* TypeReferenceSerializationKind.NumberLikeType */;
+        }
+        if ((flags & 32 /* SymbolFlags.Class */) !== 0)
+            return 11 /* TypeReferenceSerializationKind.ObjectType */;
+        if ((flags & 524288 /* SymbolFlags.TypeAlias */) !== 0) {
+            for (let i = 0; i < declarationCount(symbol); i++) {
+                const declaration = declarationAt(symbol, i);
+                if (declaration instanceof TypeAliasDeclaration)
+                    return this.ofTypeNode(declaration.type, declaration, depth + 1);
+            }
+            return 11 /* TypeReferenceSerializationKind.ObjectType */;
+        }
+        if ((flags & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
+            const declaration = declarationCount(symbol) > 0 ? symbol.declaration : undefined;
+            if (declaration instanceof TypeParameterDeclaration && declaration.constraint !== undefined)
+                return this.ofTypeNode(declaration.constraint, declaration, depth + 1);
+            return 11 /* TypeReferenceSerializationKind.ObjectType */;
+        }
+        if ((flags & 64 /* SymbolFlags.Interface */) !== 0) {
+            for (let i = 0; i < declarationCount(symbol); i++) {
+                const declaration = declarationAt(symbol, i);
+                if (declaration instanceof InterfaceDeclaration &&
+                    hasMember(declaration.members.nodes, 180 /* SyntaxKind.CallSignature */))
+                    return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
+            }
+        }
+        return 11 /* TypeReferenceSerializationKind.ObjectType */;
+    }
+    /** A union enum of numbers, of strings, or of both; an enum with computed members is numeric. */
+    ofEnum(symbol) {
+        let strings = false;
+        let numbers = false;
+        for (let i = 0; i < declarationCount(symbol); i++) {
+            const declaration = declarationAt(symbol, i);
+            if (!(declaration instanceof EnumDeclaration))
+                continue;
+            const members = declaration.members.nodes;
+            for (let j = 0; j < members.length; j++) {
+                if (this.resolver.getEnumMemberValue(members[j]).kind === 2 /* ConstantKind.String */)
+                    strings = true;
+                else
+                    numbers = true;
+            }
+        }
+        if (strings && numbers)
+            return 11 /* TypeReferenceSerializationKind.ObjectType */;
+        return strings ? 5 /* TypeReferenceSerializationKind.StringLikeType */ : 3 /* TypeReferenceSerializationKind.NumberLikeType */;
+    }
+    ofTypeNode(node, location, depth) {
+        if (depth > maxDepth)
+            return 11 /* TypeReferenceSerializationKind.ObjectType */;
+        while (node instanceof ParenthesizedTypeNode)
+            node = node.type;
+        switch (node.kind) {
+            case 132 /* SyntaxKind.AnyKeyword */:
+            case 159 /* SyntaxKind.UnknownKeyword */:
+                return 11 /* TypeReferenceSerializationKind.ObjectType */;
+            case 115 /* SyntaxKind.VoidKeyword */:
+            case 157 /* SyntaxKind.UndefinedKeyword */:
+            case 146 /* SyntaxKind.NeverKeyword */:
+                return 2 /* TypeReferenceSerializationKind.VoidNullableOrNeverType */;
+            case 135 /* SyntaxKind.BooleanKeyword */:
+                return 6 /* TypeReferenceSerializationKind.BooleanType */;
+            case 150 /* SyntaxKind.NumberKeyword */:
+                return 3 /* TypeReferenceSerializationKind.NumberLikeType */;
+            case 163 /* SyntaxKind.BigIntKeyword */:
+                return 4 /* TypeReferenceSerializationKind.BigIntLikeType */;
+            case 154 /* SyntaxKind.StringKeyword */:
+            case 204 /* SyntaxKind.TemplateLiteralType */:
+                return 5 /* TypeReferenceSerializationKind.StringLikeType */;
+            case 190 /* SyntaxKind.TupleType */:
+                return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
+            case 155 /* SyntaxKind.SymbolKeyword */:
+                return 8 /* TypeReferenceSerializationKind.ESSymbolType */;
+            case 185 /* SyntaxKind.FunctionType */:
+                return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
+            case 189 /* SyntaxKind.ArrayType */:
+                return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
+            case 202 /* SyntaxKind.LiteralType */:
+                if (node instanceof LiteralTypeNode)
+                    return ofLiteral(node.literal);
+                break;
+            case 199 /* SyntaxKind.TypeOperator */:
+                if (node instanceof TypeOperatorNode) {
+                    if (node.operator === 158 /* SyntaxKind.UniqueKeyword */)
+                        return 8 /* TypeReferenceSerializationKind.ESSymbolType */;
+                    if (node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ && node.type instanceof ArrayTypeNode)
+                        return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
+                    if (node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ && node.type.kind === 190 /* SyntaxKind.TupleType */)
+                        return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
+                }
+                break;
+            case 188 /* SyntaxKind.TypeLiteral */:
+                if (node instanceof TypeLiteralNode && hasMember(node.members.nodes, 180 /* SyntaxKind.CallSignature */))
+                    return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
+                break;
+            case 184 /* SyntaxKind.TypeReference */:
+                if (node instanceof TypeReferenceNode) {
+                    const symbol = resolveEntityName(this.resolver, node.typeName, 788968 /* SymbolFlags.Type */, false, location);
+                    if (symbol === undefined || symbol === unknownSymbol)
+                        return 11 /* TypeReferenceSerializationKind.ObjectType */;
+                    return this.ofSymbol(symbol, depth + 1);
+                }
+                break;
+            case 193 /* SyntaxKind.UnionType */:
+                if (node instanceof UnionTypeNode)
+                    return this.ofUnion(node.types.nodes, location, depth);
+                break;
+        }
+        return 11 /* TypeReferenceSerializationKind.ObjectType */;
+    }
+    /** A union is of a kind when all its members are; without strict null checks, `null` and `undefined` fit any kind. */
+    ofUnion(types, location, depth) {
+        let kind = 0 /* TypeReferenceSerializationKind.Unknown */;
+        let nullable = false;
+        for (let i = 0; i < types.length; i++) {
+            const member = this.ofTypeNode(types[i], location, depth + 1);
+            if (member === 2 /* TypeReferenceSerializationKind.VoidNullableOrNeverType */) {
+                if (types[i].kind !== 146 /* SyntaxKind.NeverKeyword */)
+                    nullable = true;
+                continue;
+            }
+            if (kind === 0 /* TypeReferenceSerializationKind.Unknown */)
+                kind = member;
+            else if (kind !== member)
+                return 11 /* TypeReferenceSerializationKind.ObjectType */;
+        }
+        if (kind === 0 /* TypeReferenceSerializationKind.Unknown */)
+            return 2 /* TypeReferenceSerializationKind.VoidNullableOrNeverType */;
+        if (nullable && this.strictNullChecks)
+            return 11 /* TypeReferenceSerializationKind.ObjectType */;
+        switch (kind) {
+            case 6 /* TypeReferenceSerializationKind.BooleanType */:
+            case 3 /* TypeReferenceSerializationKind.NumberLikeType */:
+            case 4 /* TypeReferenceSerializationKind.BigIntLikeType */:
+            case 5 /* TypeReferenceSerializationKind.StringLikeType */:
+            case 8 /* TypeReferenceSerializationKind.ESSymbolType */:
+                return kind;
+        }
+        return 11 /* TypeReferenceSerializationKind.ObjectType */;
+    }
+}
+function ofLiteral(literal) {
+    switch (literal.kind) {
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return 5 /* TypeReferenceSerializationKind.StringLikeType */;
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return 3 /* TypeReferenceSerializationKind.NumberLikeType */;
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return 4 /* TypeReferenceSerializationKind.BigIntLikeType */;
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+            return 6 /* TypeReferenceSerializationKind.BooleanType */;
+        case 105 /* SyntaxKind.NullKeyword */:
+            return 2 /* TypeReferenceSerializationKind.VoidNullableOrNeverType */;
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            if (literal instanceof PrefixUnaryExpression)
+                return ofLiteral(literal.operand);
+            break;
+    }
+    return 11 /* TypeReferenceSerializationKind.ObjectType */;
+}
+function getFirstIdentifier(node) {
+    while (node instanceof QualifiedName)
+        node = node.left;
+    return node;
+}
+/** Whether an alias declaration is type-only, itself or through its import clause. */
+function isTypeOnlyImportOrExportDeclaration(node) {
+    switch (node.kind) {
+        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 282 /* SyntaxKind.ExportSpecifier */: {
+            if (getIsTypeOnly(node))
+                return true;
+            const clause = node.parent === undefined ? undefined : node.parent.parent;
+            return clause !== undefined && isTypeOnlyImportClause(clause);
+        }
+        case 275 /* SyntaxKind.NamespaceImport */:
+            return node.parent !== undefined && isTypeOnlyImportClause(node.parent);
+        case 274 /* SyntaxKind.ImportClause */:
+            return isTypeOnlyImportClause(node);
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            return getIsTypeOnly(node);
+    }
+    return false;
+}
+function isTypeOnlyImportClause(node) {
+    return node instanceof ImportClause && node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
+}

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

@@ -0,0 +1,56 @@
+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 UsingTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    /** `export { x }` specifiers for hoisted exports, by local name in first-export order. */
+    private exportBindings;
+    private exportVars;
+    private defaultExportBinding;
+    private exportEqualsBinding;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    /**
+     * Hoists imports, exports, functions and the bindings of other top-level declarations out of
+     * the `try`, keeping the statements before the first `using` in place:
+     *
+     *   import { w } from "mod";      import { w } from "mod";
+     *   const x = expr1;              const x = expr1;
+     *   using y = expr2;         ->   var y, z;
+     *   const z = expr3;              const env_1 = { stack: [], error: void 0, hasError: false };
+     *                                 try { y = __addDisposableResource(env_1, expr2, false); z = expr3; } ...
+     */
+    private visitSourceFile;
+    private pushVisited;
+    private visitBlock;
+    /** `for (using x = e; c; i) s` -> `{ using x = e; for (; c; i) s }`, then lowered. */
+    private visitForStatement;
+    /** `for (using x of y) s` -> `for (const x_1 of y) { using x = x_1; s }`, then lowered. */
+    private visitForOfStatement;
+    /** The statements with each `using` declaration's values passed to `__addDisposableResource`. */
+    private transformUsingDeclarations;
+    private hoistOrAppend;
+    /** What stays in the `try` of a visited top-level statement, once its bindings are hoisted. */
+    private hoist;
+    private createDefaultBinding;
+    private hoistExportAssignment;
+    /** `class C {}` -> `C = class C {}` in the `try`, with `C` hoisted (and exported if it was). */
+    private hoistClassDeclaration;
+    private convertClassDeclarationToClassExpression;
+    private hoistVariableStatement;
+    private hoistInitializedVariable;
+    private hoistBindingElement;
+    private hoistBindingIdentifier;
+    private createEnvBinding;
+    /**
+     *   const env_1 = { stack: [], error: void 0, hasError: false };
+     *   try { body }
+     *   catch (e_1) { env_1.error = e_1; env_1.hasError = true; }
+     *   finally { __disposeResources(env_1); }
+     *
+     * With `async`, the `finally` awaits the result: `const result_1 = __disposeResources(env_1); if (result_1) await result_1;`.
+     * Two properties record the error since `throw undefined` is legal.
+     */
+    private createDownlevelUsingStatements;
+}