tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/decorator-metadata.d.ts

@@ -0,0 +1,54 @@
+import { type Node } from '../ast.js';
+import { type CompilerOptions, ScriptTarget } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { EmitResolver } from './emit-resolver.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+export declare class DecoratorMetadata extends Transformer {
+    private readonly legacyDecorators;
+    private readonly facts;
+    private readonly serializer;
+    /** The class whose members are visited. */
+    private parentClass;
+    constructor(context: EmitContext, options: CompilerOptions, resolver: EmitResolver, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private visitClass;
+    /** The modifiers with metadata after the decorators: `export`/`default` first, other modifiers last. */
+    private injectClassTypeMetadata;
+    private injectClassElementTypeMetadata;
+    private metadataOnly;
+    private withRange;
+    /** Metadata decorators for a declaration; none for standard decorators. */
+    private getTypeMetadata;
+}
+/**
+ * Serializes type annotations as the runtime values `Reflect.metadata` records: `Function`,
+ * `Array`, `Boolean`, `String`, `Number`, `BigInt`, `Symbol`, `Object`, `void 0`, or the class a
+ * type reference names. Type references need the resolver to tell classes from other types.
+ */
+export declare class MetadataSerializer {
+    private readonly context;
+    private readonly resolver;
+    private readonly target;
+    private readonly strictNullChecks;
+    currentLexicalScope: Node | undefined;
+    currentNameScope: Node | undefined;
+    private serializingConditionalTypeBranch;
+    constructor(context: EmitContext, resolver: EmitResolver, target: ScriptTarget, strictNullChecks: boolean);
+    serializeTypeOfNode(node: Node, container: Node): Node;
+    serializeParameterTypesOfNode(node: Node, container: Node): Node;
+    serializeReturnTypeOfNode(node: Node): Node;
+    private serializeTypeNode;
+    private serializeUnionOrIntersectionConstituents;
+    private serializeLiteralOfLiteralTypeNode;
+    /** The class a type reference names, or the constructor of what the resolver says it is. */
+    private serializeTypeReferenceNode;
+    private serializeBigIntConstructor;
+    /** An entity name as an expression; identifiers act as parse-tree references for the module transforms. */
+    private serializeEntityNameAsExpression;
+    /** An entity name guarded so that it doesn't throw if it isn't defined at runtime. */
+    private serializeEntityNameAsExpressionFallback;
+    /** `typeof left !== "undefined" && right` */
+    private createCheckedValue;
+    private equateSerializedTypeNodes;
+}

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

@@ -0,0 +1,554 @@
+// `emitDecoratorMetadata`: adds `__metadata("design:type", ...)`, `"design:paramtypes"` and
+// `"design:returntype"` decorators to decorated declarations, from their type annotations.
+// Runs before types are erased; the legacy decorator transform emits them.
+import { ArrayLiteralExpression, BinaryExpression, ClassDeclaration, ClassExpression, ConditionalExpression, ConditionalTypeNode, Decorator, GetAccessorDeclaration, Identifier, IntersectionTypeNode, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, LiteralTypeNode, MethodDeclaration, ParameterDeclaration, ParenthesizedExpression, PrefixUnaryExpression, PropertyAccessExpression, PropertyDeclaration, QualifiedName, SetAccessorDeclaration, SourceFile, StringLiteral, TypeOfExpression, TypeOperatorNode, TypePredicateNode, TypeReferenceNode, UnionTypeNode, VoidExpression, getBody, getMembers, getParameters, getText, getType, } from '../ast.js';
+import { isFunctionLike } from '../ast-utilities.js';
+import { isAsyncFunction, isClassLike } from '../binder-utilities.js';
+import { ScriptTarget, getEmitScriptTarget, getStrictOptionValue } from '../options.js';
+import { createMetadataHelper } from '../printer/decorator-helpers.js';
+import { isModifier } from '../printer/utilities.js';
+import { getRestParameterElementType, getSetAccessorValueParameter, skipTypeParentheses, classElementOrClassElementParameterIsDecorated, classOrConstructorParameterIsDecorated, getAllAccessorDeclarations, getFirstConstructorWithBody, } from './decorator-utilities.js';
+import { Transformer } from './transformer.js';
+import { hasDecorators, isThisParameter } from './utilities.js';
+export class DecoratorMetadata extends Transformer {
+    legacyDecorators;
+    facts;
+    serializer;
+    /** The class whose members are visited. */
+    parentClass;
+    constructor(context, options, resolver, facts) {
+        super(context);
+        this.legacyDecorators = options.experimentalDecorators === true;
+        this.facts = facts;
+        this.serializer = new MetadataSerializer(context, resolver, getEmitScriptTarget(options), getStrictOptionValue(options, options.strictNullChecks));
+        this.parentClass = undefined;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 262144 /* SubtreeFacts.ContainsDecorators */))
+            return node;
+        switch (node.kind) {
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */:
+                return this.visitClass(node);
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                if (node instanceof PropertyDeclaration) {
+                    if (!hasDecorators(node))
+                        return this.visitEachChild(node);
+                    return this.factory.updatePropertyDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), this.visitNode(node.name), node.postfixToken, this.visitNode(node.type), this.visitNode(node.initializer));
+                }
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                if (node instanceof MethodDeclaration) {
+                    if (!hasDecorators(node) && !hasDecoratedParameter(node))
+                        return this.visitEachChild(node);
+                    return this.factory.updateMethodDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), node.asteriskToken, this.visitNode(node.name), node.postfixToken, this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitNode(node.body));
+                }
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                if (node instanceof SetAccessorDeclaration) {
+                    if (!hasDecorators(node) && !hasDecoratedParameter(node))
+                        return this.visitEachChild(node);
+                    return this.factory.updateSetAccessorDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), this.visitNode(node.name), this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitNode(node.body));
+                }
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (node instanceof GetAccessorDeclaration) {
+                    if (!hasDecorators(node))
+                        return this.visitEachChild(node);
+                    return this.factory.updateGetAccessorDeclaration(node, this.injectClassElementTypeMetadata(this.visitModifiers(node.modifiers), node), this.visitNode(node.name), this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitNode(node.body));
+                }
+                break;
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile) {
+                    this.parentClass = undefined;
+                    this.serializer.currentLexicalScope = node;
+                    const updated = this.visitEachChild(node);
+                    const helpers = this.context.readEmitHelpers();
+                    for (let i = 0; i < helpers.length; i++)
+                        this.context.addEmitHelper(updated, helpers[i]);
+                    this.serializer.currentLexicalScope = undefined;
+                    return updated;
+                }
+                break;
+            case 269 /* SyntaxKind.ModuleBlock */:
+            case 242 /* SyntaxKind.Block */:
+            case 270 /* SyntaxKind.CaseBlock */: {
+                const saved = this.serializer.currentLexicalScope;
+                this.serializer.currentLexicalScope = node;
+                const updated = this.visitEachChild(node);
+                this.serializer.currentLexicalScope = saved;
+                return updated;
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    visitClass(node) {
+        const saved = this.parentClass;
+        this.parentClass = node;
+        let result = node;
+        if (!classOrConstructorParameterIsDecorated(this.legacyDecorators, node))
+            result = this.visitEachChild(node);
+        else if (node instanceof ClassDeclaration)
+            result = this.factory.updateClassDeclaration(node, this.injectClassTypeMetadata(this.visitModifiers(node.modifiers), node), node.name, this.visitNodes(node.typeParameters), this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
+        else if (node instanceof ClassExpression)
+            result = this.factory.updateClassExpression(node, this.injectClassTypeMetadata(this.visitModifiers(node.modifiers), node), node.name, this.visitNodes(node.typeParameters), this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
+        this.parentClass = saved;
+        return result;
+    }
+    /** The modifiers with metadata after the decorators: `export`/`default` first, other modifiers last. */
+    injectClassTypeMetadata(list, node) {
+        const metadata = this.getTypeMetadata(node, node);
+        if (metadata.length === 0)
+            return list;
+        if (list === undefined || list.nodes.length === 0)
+            return this.metadataOnly(list, metadata);
+        const original = list.nodes;
+        const modifiers = [];
+        if (isExportOrDefault(original[0])) {
+            modifiers.push(original[0]);
+            if (original.length > 1 && isExportOrDefault(original[1]))
+                modifiers.push(original[1]);
+        }
+        const rest = modifiers.length;
+        for (let i = 0; i < original.length; i++)
+            if (original[i] instanceof Decorator)
+                modifiers.push(original[i]);
+        for (let i = 0; i < metadata.length; i++)
+            modifiers.push(metadata[i]);
+        for (let i = rest; i < original.length; i++)
+            if (isModifier(original[i]))
+                modifiers.push(original[i]);
+        return this.withRange(modifiers, list);
+    }
+    injectClassElementTypeMetadata(list, node) {
+        const container = this.parentClass;
+        if (container === undefined || !isClassLike(container))
+            return list;
+        if (!classElementOrClassElementParameterIsDecorated(this.legacyDecorators, node, container))
+            return list;
+        const metadata = this.getTypeMetadata(node, container);
+        if (metadata.length === 0)
+            return list;
+        if (list === undefined || list.nodes.length === 0)
+            return this.metadataOnly(list, metadata);
+        const original = list.nodes;
+        const modifiers = [];
+        for (let i = 0; i < original.length; i++)
+            if (original[i] instanceof Decorator)
+                modifiers.push(original[i]);
+        for (let i = 0; i < metadata.length; i++)
+            modifiers.push(metadata[i]);
+        for (let i = 0; i < original.length; i++)
+            if (isModifier(original[i]))
+                modifiers.push(original[i]);
+        return this.withRange(modifiers, list);
+    }
+    metadataOnly(list, metadata) {
+        const result = this.factory.createModifierList(metadata);
+        if (list !== undefined) {
+            result.pos = list.pos;
+            result.end = list.end;
+        }
+        return result;
+    }
+    withRange(modifiers, list) {
+        const result = this.factory.createModifierList(modifiers);
+        result.pos = list.pos;
+        result.end = list.end;
+        return result;
+    }
+    /** Metadata decorators for a declaration; none for standard decorators. */
+    getTypeMetadata(node, container) {
+        const decorators = [];
+        if (!this.legacyDecorators)
+            return decorators;
+        const factory = this.factory;
+        const serializer = this.serializer;
+        serializer.currentNameScope = container;
+        switch (node.kind) {
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                decorators.push(factory.created(new Decorator(createMetadataHelper(factory, 'design:type', serializer.serializeTypeOfNode(node, container)))));
+        }
+        if (shouldAddParamTypesMetadata(node))
+            decorators.push(factory.created(new Decorator(createMetadataHelper(factory, 'design:paramtypes', serializer.serializeParameterTypesOfNode(node, container)))));
+        if (node.kind === 175 /* SyntaxKind.MethodDeclaration */)
+            decorators.push(factory.created(new Decorator(createMetadataHelper(factory, 'design:returntype', serializer.serializeReturnTypeOfNode(node)))));
+        serializer.currentNameScope = undefined;
+        return decorators;
+    }
+}
+function shouldAddParamTypesMetadata(node) {
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+            return getFirstConstructorWithBody(node) !== undefined;
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            return true;
+    }
+    return false;
+}
+function isExportOrDefault(node) {
+    return node.kind === 94 /* SyntaxKind.ExportKeyword */ || node.kind === 89 /* SyntaxKind.DefaultKeyword */;
+}
+function hasDecoratedParameter(node) {
+    const parameters = getParameters(node).nodes;
+    const first = parameters.length > 0 && isThisParameter(parameters[0]) ? 1 : 0;
+    for (let i = first; i < parameters.length; i++)
+        if (hasDecorators(parameters[i]))
+            return true;
+    return false;
+}
+/**
+ * Serializes type annotations as the runtime values `Reflect.metadata` records: `Function`,
+ * `Array`, `Boolean`, `String`, `Number`, `BigInt`, `Symbol`, `Object`, `void 0`, or the class a
+ * type reference names. Type references need the resolver to tell classes from other types.
+ */
+export class MetadataSerializer {
+    context;
+    resolver;
+    target;
+    strictNullChecks;
+    currentLexicalScope;
+    currentNameScope;
+    serializingConditionalTypeBranch;
+    constructor(context, resolver, target, strictNullChecks) {
+        this.context = context;
+        this.resolver = resolver;
+        this.target = target;
+        this.strictNullChecks = strictNullChecks;
+        this.currentLexicalScope = undefined;
+        this.currentNameScope = undefined;
+        this.serializingConditionalTypeBranch = false;
+    }
+    serializeTypeOfNode(node, container) {
+        const factory = this.context.factory;
+        switch (node.kind) {
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 170 /* SyntaxKind.Parameter */:
+                return this.serializeTypeNode(getType(node));
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+                return this.serializeTypeNode(getAccessorTypeNode(node, container));
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                return factory.createIdentifier('Function');
+        }
+        return factory.createVoidZero();
+    }
+    serializeParameterTypesOfNode(node, container) {
+        const factory = this.context.factory;
+        let declaration = undefined;
+        if (isClassLike(node))
+            declaration = getFirstConstructorWithBody(node);
+        else if (isFunctionLike(node) && getBody(node) !== undefined)
+            declaration = node;
+        const expressions = [];
+        if (declaration !== undefined) {
+            const parameters = getParametersOfDecoratedDeclaration(declaration, container);
+            for (let i = 0; i < parameters.length; i++) {
+                const parameter = parameters[i];
+                if (i === 0 && isThisParameter(parameter))
+                    continue;
+                if (parameter instanceof ParameterDeclaration && parameter.dotDotDotToken !== undefined)
+                    expressions.push(this.serializeTypeNode(getRestParameterElementType(parameter.type)));
+                else
+                    expressions.push(this.serializeTypeOfNode(parameter, container));
+            }
+        }
+        return factory.created(new ArrayLiteralExpression(factory.createNodeList(expressions), false));
+    }
+    serializeReturnTypeOfNode(node) {
+        const factory = this.context.factory;
+        const type = getType(node);
+        if (isFunctionLike(node) && type !== undefined)
+            return this.serializeTypeNode(type);
+        if (isAsyncFunction(node))
+            return factory.createIdentifier('Promise');
+        return factory.createVoidZero();
+    }
+    serializeTypeNode(type) {
+        const factory = this.context.factory;
+        if (type === undefined)
+            return factory.createIdentifier('Object');
+        const node = skipTypeParentheses(type);
+        switch (node.kind) {
+            case 115 /* SyntaxKind.VoidKeyword */:
+            case 157 /* SyntaxKind.UndefinedKeyword */:
+            case 146 /* SyntaxKind.NeverKeyword */:
+                return factory.createVoidZero();
+            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.ConstructorType */:
+                return factory.createIdentifier('Function');
+            case 189 /* SyntaxKind.ArrayType */:
+            case 190 /* SyntaxKind.TupleType */:
+                return factory.createIdentifier('Array');
+            case 183 /* SyntaxKind.TypePredicate */:
+                if (node instanceof TypePredicateNode && node.assertsModifier !== undefined)
+                    return factory.createVoidZero();
+                return factory.createIdentifier('Boolean');
+            case 135 /* SyntaxKind.BooleanKeyword */:
+                return factory.createIdentifier('Boolean');
+            case 204 /* SyntaxKind.TemplateLiteralType */:
+            case 154 /* SyntaxKind.StringKeyword */:
+                return factory.createIdentifier('String');
+            case 151 /* SyntaxKind.ObjectKeyword */:
+                return factory.createIdentifier('Object');
+            case 202 /* SyntaxKind.LiteralType */:
+                if (node instanceof LiteralTypeNode)
+                    return this.serializeLiteralOfLiteralTypeNode(node.literal);
+                break;
+            case 150 /* SyntaxKind.NumberKeyword */:
+                return factory.createIdentifier('Number');
+            case 163 /* SyntaxKind.BigIntKeyword */:
+                return this.serializeBigIntConstructor();
+            case 155 /* SyntaxKind.SymbolKeyword */:
+                return factory.createIdentifier('Symbol');
+            case 184 /* SyntaxKind.TypeReference */:
+                if (node instanceof TypeReferenceNode)
+                    return this.serializeTypeReferenceNode(node);
+                break;
+            case 194 /* SyntaxKind.IntersectionType */:
+                if (node instanceof IntersectionTypeNode)
+                    return this.serializeUnionOrIntersectionConstituents(node.types.nodes, true);
+                break;
+            case 193 /* SyntaxKind.UnionType */:
+                if (node instanceof UnionTypeNode)
+                    return this.serializeUnionOrIntersectionConstituents(node.types.nodes, false);
+                break;
+            case 195 /* SyntaxKind.ConditionalType */:
+                if (node instanceof ConditionalTypeNode) {
+                    const saved = this.serializingConditionalTypeBranch;
+                    this.serializingConditionalTypeBranch = true;
+                    const result = this.serializeUnionOrIntersectionConstituents([node.trueType, node.falseType], false);
+                    this.serializingConditionalTypeBranch = saved;
+                    return result;
+                }
+                break;
+            case 199 /* SyntaxKind.TypeOperator */:
+                // `unique symbol` falls back to `Object` as in tsgo.
+                if (node instanceof TypeOperatorNode && node.operator === 148 /* SyntaxKind.ReadonlyKeyword */)
+                    return this.serializeTypeNode(node.type);
+                break;
+            case 311 /* SyntaxKind.JSDocNullableType */:
+                if (node instanceof JSDocNullableType)
+                    return this.serializeTypeNode(node.type);
+                break;
+            case 312 /* SyntaxKind.JSDocNonNullableType */:
+                if (node instanceof JSDocNonNullableType)
+                    return this.serializeTypeNode(node.type);
+                break;
+            case 313 /* SyntaxKind.JSDocOptionalType */:
+                if (node instanceof JSDocOptionalType)
+                    return this.serializeTypeNode(node.type);
+                break;
+        }
+        return factory.createIdentifier('Object');
+    }
+    serializeUnionOrIntersectionConstituents(types, isIntersection) {
+        const factory = this.context.factory;
+        let serialized = undefined;
+        for (let i = 0; i < types.length; i++) {
+            const type = skipTypeParentheses(types[i]);
+            if (type.kind === 146 /* SyntaxKind.NeverKeyword */) {
+                // `never` reduces an intersection and is elided from a union.
+                if (isIntersection)
+                    return factory.createVoidZero();
+                continue;
+            }
+            if (type.kind === 159 /* SyntaxKind.UnknownKeyword */) {
+                if (!isIntersection)
+                    return factory.createIdentifier('Object');
+                continue;
+            }
+            if (type.kind === 132 /* SyntaxKind.AnyKeyword */)
+                return factory.createIdentifier('Object');
+            // Without strict null checks, `null` and `undefined` are elided as before they existed.
+            if (!this.strictNullChecks && (isNullLiteralType(type) || type.kind === 157 /* SyntaxKind.UndefinedKeyword */))
+                continue;
+            const constituent = this.serializeTypeNode(type);
+            if (constituent instanceof Identifier && constituent.text === 'Object')
+                return constituent;
+            if (serialized === undefined)
+                serialized = constituent;
+            else if (!this.equateSerializedTypeNodes(serialized, constituent))
+                return factory.createIdentifier('Object');
+        }
+        return serialized !== undefined ? serialized : factory.createVoidZero();
+    }
+    serializeLiteralOfLiteralTypeNode(node) {
+        const factory = this.context.factory;
+        switch (node.kind) {
+            case 10 /* SyntaxKind.StringLiteral */:
+            case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+                return factory.createIdentifier('String');
+            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+                if (node instanceof PrefixUnaryExpression)
+                    return this.serializeLiteralOfLiteralTypeNode(node.operand);
+                break;
+            case 8 /* SyntaxKind.NumericLiteral */:
+                return factory.createIdentifier('Number');
+            case 9 /* SyntaxKind.BigIntLiteral */:
+                return this.serializeBigIntConstructor();
+            case 111 /* SyntaxKind.TrueKeyword */:
+            case 96 /* SyntaxKind.FalseKeyword */:
+                return factory.createIdentifier('Boolean');
+            case 105 /* SyntaxKind.NullKeyword */:
+                return factory.createVoidZero();
+        }
+        return factory.createIdentifier('Object');
+    }
+    /** The class a type reference names, or the constructor of what the resolver says it is. */
+    serializeTypeReferenceNode(node) {
+        const factory = this.context.factory;
+        const scope = this.currentNameScope !== undefined ? this.currentNameScope : this.currentLexicalScope;
+        const location = scope === undefined ? undefined : this.context.parseNode(scope);
+        const typeName = this.context.parseNode(node.typeName);
+        const kind = typeName === undefined
+            ? 0 /* TypeReferenceSerializationKind.Unknown */
+            : this.resolver.getTypeReferenceSerializationKind(typeName, location);
+        switch (kind) {
+            case 0 /* TypeReferenceSerializationKind.Unknown */: {
+                // An unresolved reference in a conditional type branch is like `any`.
+                if (this.serializingConditionalTypeBranch)
+                    return factory.createIdentifier('Object');
+                // `typeof (_a = typeof A !== "undefined" && A) === "function" ? _a : Object`
+                const serialized = this.serializeEntityNameAsExpressionFallback(node.typeName);
+                const temp = factory.createTempVariable(0);
+                this.context.addVariableDeclaration(temp);
+                return factory.createConditionalExpression(factory.createTypeCheck(factory.createAssignment(temp, serialized), 'function'), temp, factory.createIdentifier('Object'));
+            }
+            case 1 /* TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue */:
+                return this.serializeEntityNameAsExpression(node.typeName);
+            case 2 /* TypeReferenceSerializationKind.VoidNullableOrNeverType */:
+                return factory.createVoidZero();
+            case 4 /* TypeReferenceSerializationKind.BigIntLikeType */:
+                return this.serializeBigIntConstructor();
+            case 6 /* TypeReferenceSerializationKind.BooleanType */:
+                return factory.createIdentifier('Boolean');
+            case 3 /* TypeReferenceSerializationKind.NumberLikeType */:
+                return factory.createIdentifier('Number');
+            case 5 /* TypeReferenceSerializationKind.StringLikeType */:
+                return factory.createIdentifier('String');
+            case 7 /* TypeReferenceSerializationKind.ArrayLikeType */:
+                return factory.createIdentifier('Array');
+            case 8 /* TypeReferenceSerializationKind.ESSymbolType */:
+                return factory.createIdentifier('Symbol');
+            case 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */:
+                return factory.createIdentifier('Function');
+            case 9 /* TypeReferenceSerializationKind.Promise */:
+                return factory.createIdentifier('Promise');
+        }
+        return factory.createIdentifier('Object');
+    }
+    serializeBigIntConstructor() {
+        const factory = this.context.factory;
+        if (this.target >= ScriptTarget.ES2020)
+            return factory.createIdentifier('BigInt');
+        return factory.createConditionalExpression(factory.createTypeCheck(factory.createIdentifier('BigInt'), 'function'), factory.createIdentifier('BigInt'), factory.createIdentifier('Object'));
+    }
+    /** An entity name as an expression; identifiers act as parse-tree references for the module transforms. */
+    serializeEntityNameAsExpression(node) {
+        const factory = this.context.factory;
+        if (node instanceof Identifier) {
+            const name = factory.cloneIdentifier(node);
+            name.pos = node.pos;
+            name.end = node.end;
+            this.context.unsetOriginal(name);
+            const scope = this.currentLexicalScope;
+            name.parent = scope === undefined ? undefined : this.context.parseNode(scope);
+            return name;
+        }
+        if (node instanceof QualifiedName)
+            return factory.createPropertyAccessExpression(this.serializeEntityNameAsExpression(node.left), node.right);
+        return node;
+    }
+    /** An entity name guarded so that it doesn't throw if it isn't defined at runtime. */
+    serializeEntityNameAsExpressionFallback(node) {
+        const factory = this.context.factory;
+        // A -> typeof A !== "undefined" && A
+        if (node instanceof Identifier) {
+            const copied = this.serializeEntityNameAsExpression(node);
+            return this.createCheckedValue(copied, copied);
+        }
+        if (!(node instanceof QualifiedName))
+            return node;
+        // A.B -> typeof A !== "undefined" && A.B
+        if (node.left instanceof Identifier)
+            return this.createCheckedValue(this.serializeEntityNameAsExpression(node.left), this.serializeEntityNameAsExpression(node));
+        // A.B.C -> typeof A !== "undefined" && (_a = A.B) !== void 0 && _a.C
+        const left = this.serializeEntityNameAsExpressionFallback(node.left);
+        const temp = factory.createTempVariable(0);
+        this.context.addVariableDeclaration(temp);
+        const check = left instanceof BinaryExpression ? left.left : left;
+        const value = left instanceof BinaryExpression ? left.right : left;
+        return factory.createBinaryExpression(factory.createBinaryExpression(check, 55 /* SyntaxKind.AmpersandAmpersandToken */, factory.createBinaryExpression(factory.createAssignment(temp, value), 37 /* SyntaxKind.ExclamationEqualsEqualsToken */, factory.createVoidZero())), 55 /* SyntaxKind.AmpersandAmpersandToken */, factory.createPropertyAccessExpression(temp, node.right));
+    }
+    /** `typeof left !== "undefined" && right` */
+    createCheckedValue(left, right) {
+        const factory = this.context.factory;
+        return factory.createBinaryExpression(factory.createBinaryExpression(factory.created(new TypeOfExpression(left)), 37 /* SyntaxKind.ExclamationEqualsEqualsToken */, factory.createStringLiteral('undefined', 0 /* TokenFlags.None */)), 55 /* SyntaxKind.AmpersandAmpersandToken */, right);
+    }
+    equateSerializedTypeNodes(left, right) {
+        // Temporaries of fallbacks.
+        if (left instanceof Identifier && this.context.hasAutoGenerateInfo(left))
+            return right instanceof Identifier && this.context.hasAutoGenerateInfo(right);
+        if (left instanceof Identifier)
+            return right instanceof Identifier && left.text === right.text;
+        if (left instanceof PropertyAccessExpression)
+            return (right instanceof PropertyAccessExpression &&
+                this.equateSerializedTypeNodes(left.expression, right.expression) &&
+                this.equateSerializedTypeNodes(left.name, right.name));
+        if (left instanceof VoidExpression)
+            return (right instanceof VoidExpression &&
+                left.expression.kind === 8 /* SyntaxKind.NumericLiteral */ &&
+                right.expression.kind === 8 /* SyntaxKind.NumericLiteral */ &&
+                getText(left.expression) === '0' &&
+                getText(right.expression) === '0');
+        if (left instanceof StringLiteral)
+            return right instanceof StringLiteral && left.text === right.text;
+        if (left instanceof TypeOfExpression)
+            return right instanceof TypeOfExpression && this.equateSerializedTypeNodes(left.expression, right.expression);
+        if (left instanceof ParenthesizedExpression)
+            return (right instanceof ParenthesizedExpression && this.equateSerializedTypeNodes(left.expression, right.expression));
+        if (left instanceof ConditionalExpression)
+            return (right instanceof ConditionalExpression &&
+                this.equateSerializedTypeNodes(left.condition, right.condition) &&
+                this.equateSerializedTypeNodes(left.whenTrue, right.whenTrue) &&
+                this.equateSerializedTypeNodes(left.whenFalse, right.whenFalse));
+        if (left instanceof BinaryExpression)
+            return (right instanceof BinaryExpression &&
+                left.operatorToken.kind === right.operatorToken.kind &&
+                this.equateSerializedTypeNodes(left.left, right.left) &&
+                this.equateSerializedTypeNodes(left.right, right.right));
+        return false;
+    }
+}
+/** The type annotation of an accessor pair: the setter's parameter, else the getter's return. */
+function getAccessorTypeNode(node, container) {
+    const accessors = getAllAccessorDeclarations(getMembers(container).nodes, node);
+    if (accessors.setAccessor !== undefined) {
+        const parameter = getSetAccessorValueParameter(accessors.setAccessor);
+        return parameter === undefined ? undefined : getType(parameter);
+    }
+    if (accessors.getAccessor !== undefined)
+        return getType(accessors.getAccessor);
+    return undefined;
+}
+/** A getter's metadata uses the parameters of its setter. */
+function getParametersOfDecoratedDeclaration(node, container) {
+    if (node.kind === 178 /* SyntaxKind.GetAccessor */) {
+        const accessors = getAllAccessorDeclarations(getMembers(container).nodes, node);
+        if (accessors.setAccessor !== undefined)
+            return getParameters(accessors.setAccessor).nodes;
+    }
+    return getParameters(node).nodes;
+}
+function isNullLiteralType(node) {
+    return node instanceof LiteralTypeNode && node.literal.kind === 105 /* SyntaxKind.NullKeyword */;
+}

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

@@ -0,0 +1,38 @@
+import { type Node } from '../ast.js';
+import { TextRange } from '../binder-utilities.js';
+/** The decorators among the modifiers of `node`. */
+export declare function getDecorators(node: Node): Node[];
+export declare function isAccessor(node: Node): boolean;
+export declare function getFirstConstructorWithBody(node: Node): Node | undefined;
+/** Whether decorators on `node` take effect, as opposed to being a grammar error. */
+export declare function nodeCanBeDecorated(legacy: boolean, node: Node, parent: Node | undefined, grandparent: Node | undefined): boolean;
+export declare function nodeIsDecorated(legacy: boolean, node: Node, parent: Node | undefined, grandparent: Node | undefined): boolean;
+export declare function nodeOrChildIsDecorated(legacy: boolean, node: Node, parent: Node | undefined, grandparent: Node | undefined): boolean;
+/** Whether a member of a class, or a parameter of a method, setter or constructor, is decorated. */
+export declare function childIsDecorated(legacy: boolean, node: Node, parent: Node | undefined): boolean;
+export declare function classOrConstructorParameterIsDecorated(legacy: boolean, node: Node): boolean;
+export declare function classElementOrClassElementParameterIsDecorated(legacy: boolean, node: Node, parent: Node): boolean;
+/** The get and set accessors declaring one property, in source order. */
+export declare class AllAccessorDeclarations {
+    readonly firstAccessor: Node;
+    readonly secondAccessor: Node | undefined;
+    readonly getAccessor: Node | undefined;
+    readonly setAccessor: Node | undefined;
+    constructor(firstAccessor: Node, secondAccessor: Node | undefined, getAccessor: Node | undefined, setAccessor: Node | undefined);
+    /** The first of the pair with decorators: legacy decorators apply to both. */
+    firstWithDecorators(): Node | undefined;
+}
+/** `accessor` and the other accessor among `members` with the same name and staticness. */
+export declare function getAllAccessorDeclarations(members: Node[], accessor: Node): AllAccessorDeclarations;
+/** The property name a name node declares; computed names other than literals are missing. */
+export declare function getPropertyNameForPropertyNameNode(name: Node): string;
+/** The range of `node` after its modifiers, for source maps of what replaces it. */
+export declare function moveRangePastModifiers(node: Node): TextRange;
+/** The range of `node` after its decorators. */
+export declare function moveRangePastDecorators(node: Node): TextRange;
+/** A literal or keyword: evaluated in place rather than cached. */
+export declare function isSimpleInlineableExpression(node: Node): boolean;
+export declare function getSetAccessorValueParameter(node: Node): Node | undefined;
+/** `T` of a rest parameter's `T[]` or `Array<T>`. */
+export declare function getRestParameterElementType(node: Node | undefined): Node | undefined;
+export declare function skipTypeParentheses(node: Node): Node;