tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-decorators.d.ts

@@ -0,0 +1,26 @@
+import { type Decorator, type Node } from './ast.js';
+import { type DiagnosticMessage } from './diagnostics.js';
+import { type Checker } from './checker.js';
+import { type Signature, type Type } from './checker-types.js';
+/** Resolves the decorators of `node` as calls and checks their return types. */
+export declare function checkDecorators(c: Checker, node: Node): void;
+/**
+ * The first element of a class whose emit moves its static elements out of the class body: a decorated
+ * element of a class that ECMAScript decorators transform, or a static block, static private element or
+ * (without standard class fields) initialized static property when they are transformed.
+ */
+export declare function getFirstTransformableStaticClassElement(c: Checker, node: Node): Node | undefined;
+export declare function hasDecorators(node: Node): boolean;
+/** Whether `node` is a valid decorator target. */
+export declare function nodeCanBeDecorated(legacy: boolean, node: Node, parent: Node | undefined, grandparent: Node | undefined): boolean;
+/** Whether every signature takes fewer parameters than the decorator receives, as `@f` for `@f()`. */
+export declare function isPotentiallyUncalledDecorator(c: Checker, decorator: Node, signatures: Signature[]): boolean;
+export declare function getUncalledDecoratorText(node: Decorator): string;
+/** The head message of errors resolving a decorator as a call. */
+export declare function getDiagnosticHeadMessageForDecoratorResolution(node: Node): DiagnosticMessage;
+/** The number of arguments the runtime passes to a decorator. */
+export declare function getDecoratorArgumentCount(c: Checker, node: Node, signature: Signature): number;
+/** The parameter types of a decorator's call, one synthetic argument each. */
+export declare function getEffectiveDecoratorArgumentTypes(c: Checker, node: Node): Type[];
+/** The signature the runtime calls a decorator with, or undefined for an invalid target. */
+export declare function getDecoratorCallSignature(c: Checker, decorator: Node): Signature | undefined;

package/dist/api/compiler/checker-decorators.js

@@ -0,0 +1,562 @@
+// Decorators: their applicability, resolution as calls and return types.
+import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { resolvedReturnTypeOf } from './side-state.js';
+import { checkDeprecatedSignature } from './checker-deprecation.js';
+import { FunctionTypeNode, KeywordTypeNode, NodeList, getBody, getDotDotDotToken, getModifiers, getName, getParameters, getText, getType, getInitializer, getMembers, } from './ast.js';
+import { canHaveDecorators } from './ast-utilities.js';
+import { getDeclarationOfKind, getSourceFileOfNode, getSourceTextOfNode, hasStaticModifier, hasSyntacticModifier, isClassLike, isStatic, isPrivateIdentifierClassElementDeclaration, isAutoAccessorPropertyDeclaration, } from './binder-utilities.js';
+import { getSymbolId } from './symbol.js';
+import { createDiagnosticForNode } from './checker.js';
+import { ModuleKind, getEmitModuleKind, ScriptTarget, getUseDefineForClassFields } from './options.js';
+import { getFirstConstructorWithBody, getRestParameterElementType, classElementOrClassElementParameterIsDecorated, classOrConstructorParameterIsDecorated, } from './transformers/decorator-utilities.js';
+import { isTypeOnlyImportOrExportDeclaration } from './checker-modules.js';
+import { getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfSymbol } from './checker-declared-types.js';
+import { checkComputedPropertyName } from './checker-expressions.js';
+import { getFirstIdentifier, getSymbolOfDeclaration, isAliasSymbolDeclaration, resolveName, symbolIsValue, } from './checker-symbols.js';
+import { getAnnotatedAccessorTypeNode, getTypeOfSymbol } from './checker-symbol-types.js';
+import { createAnonymousType, createTypeFromGenericGlobalType, getIntersectionType, getNumberLiteralType, getStringLiteralType, getUnionType, tryCreateTypeReference, } from './checker-type-factory.js';
+import { getLiteralTypeFromPropertyName, isTypeAssignableToKind } from './checker-type-operators.js';
+import { getOrCreateTypeFromSignature, getParameterCount, getReturnTypeOfSignature, getSignatureFromDeclaration, } from './checker-signatures.js';
+import { checkTypeAssignableTo } from './relations.js';
+import { getResolvedSignature } from './checker-calls.js';
+import { getGlobalClassAccessorDecoratorContextType, getGlobalClassAccessorDecoratorResultType, getGlobalClassAccessorDecoratorTargetType, getGlobalClassDecoratorContextType, getGlobalClassFieldDecoratorContextType, getGlobalClassGetterDecoratorContextType, getGlobalClassMethodDecoratorContextType, getGlobalClassSetterDecoratorContextType, getGlobalTypedPropertyDescriptorType, } from './checker-globals.js';
+// ---- Checks
+/** Resolves the decorators of `node` as calls and checks their return types. */
+export function checkDecorators(c, node) {
+    // Decorators on invalid targets were reported by the grammar checks.
+    if (!canHaveDecorators(node) || !hasDecorators(node))
+        return;
+    if (!nodeCanBeDecorated(c.legacyDecorators, node, node.parent, node.parent.parent))
+        return;
+    checkDecoratorEmitHelpers(c, node);
+    checkDecoratorMetadataImports(c, node);
+    for (const modifier of getModifiers(node).nodes)
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+            checkDecorator(c, modifier);
+}
+function firstDecorator(node) {
+    for (const modifier of getModifiers(node).nodes)
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+            return modifier;
+    return undefined;
+}
+/** The emit helpers the decorators of `node` use (checkExternalEmitHelpers). */
+function checkDecoratorEmitHelpers(c, node) {
+    const decorator = firstDecorator(node);
+    if (decorator === undefined)
+        return;
+    if (c.legacyDecorators) {
+        checkExternalEmitHelpers(c, decorator, 2 /* ExternalEmitHelpers.Decorate */);
+        if (node.kind === 170 /* SyntaxKind.Parameter */)
+            checkExternalEmitHelpers(c, decorator, 8 /* ExternalEmitHelpers.Param */);
+    }
+    else if (c.languageVersion < ScriptTarget.ESNext) {
+        checkExternalEmitHelpers(c, decorator, 2 /* ExternalEmitHelpers.ESDecorateAndRunInitializers */);
+        if (node.kind === 264 /* SyntaxKind.ClassDeclaration */) {
+            if (getName(node) === undefined || getFirstTransformableStaticClassElement(c, node) !== undefined)
+                checkExternalEmitHelpers(c, decorator, 65536 /* ExternalEmitHelpers.SetFunctionName */);
+        }
+        else if (node.kind !== 232 /* SyntaxKind.ClassExpression */) {
+            const name = getName(node);
+            if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */ &&
+                (node.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
+                    node.kind === 178 /* SyntaxKind.GetAccessor */ ||
+                    node.kind === 179 /* SyntaxKind.SetAccessor */ ||
+                    isAutoAccessorPropertyDeclaration(node)))
+                checkExternalEmitHelpers(c, decorator, 65536 /* ExternalEmitHelpers.SetFunctionName */);
+            if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+                checkExternalEmitHelpers(c, decorator, 131072 /* ExternalEmitHelpers.PropKey */);
+        }
+    }
+}
+/**
+ * The first element of a class whose emit moves its static elements out of the class body: a decorated
+ * element of a class that ECMAScript decorators transform, or a static block, static private element or
+ * (without standard class fields) initialized static property when they are transformed.
+ */
+export function getFirstTransformableStaticClassElement(c, node) {
+    const willTransformStaticElementsOfDecoratedClass = !c.legacyDecorators &&
+        c.languageVersion < ScriptTarget.ESNext &&
+        classOrConstructorParameterIsDecorated(false, node);
+    const willTransformPrivateElementsOrClassStaticBlocks = c.languageVersion < ScriptTarget.ESNext;
+    const willTransformInitializers = !(getUseDefineForClassFields(c.compilerOptions) && c.languageVersion >= ScriptTarget.ES2022);
+    if (!willTransformStaticElementsOfDecoratedClass && !willTransformPrivateElementsOrClassStaticBlocks)
+        return undefined;
+    for (const member of getMembers(node).nodes) {
+        if (willTransformStaticElementsOfDecoratedClass &&
+            classElementOrClassElementParameterIsDecorated(false, member, node))
+            return firstDecorator(node) ?? node;
+        if (willTransformPrivateElementsOrClassStaticBlocks) {
+            if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                return member;
+            if (isStatic(member) &&
+                (isPrivateIdentifierClassElementDeclaration(member) ||
+                    (willTransformInitializers &&
+                        member.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+                        getInitializer(member) !== undefined)))
+                return member;
+        }
+    }
+    return undefined;
+}
+/**
+ * Under emitDecoratorMetadata, the emitted metadata of a decorated declaration references the types of its
+ * signature at run time. With isolatedModules and an ES module emit, a type imported without `import type`
+ * can't be told apart from a value import in one file, so it is an error (TS1272).
+ */
+function checkDecoratorMetadataImports(c, node) {
+    const options = c.compilerOptions;
+    if (options.emitDecoratorMetadata !== true || options.verbatimModuleSyntax === true)
+        return;
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+        return;
+    checkExternalEmitHelpers(c, firstDecorator(node), 4 /* ExternalEmitHelpers.Metadata */);
+    if (!c.isolatedModules || getEmitModuleKind(options) < ModuleKind.ES2015)
+        return;
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */: {
+            const constructor = getFirstConstructorWithBody(node);
+            if (constructor !== undefined)
+                for (const p of getParameters(constructor).nodes)
+                    checkMetadataTypeImport(c, parameterTypeNode(p));
+            break;
+        }
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */: {
+            const otherKind = node.kind === 178 /* SyntaxKind.GetAccessor */ ? 179 /* SyntaxKind.SetAccessor */ : 178 /* SyntaxKind.GetAccessor */;
+            const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(c, node), otherKind);
+            checkMetadataTypeImport(c, getAnnotatedAccessorTypeNode(node) ?? getAnnotatedAccessorTypeNode(otherAccessor));
+            break;
+        }
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            for (const p of getParameters(node).nodes)
+                checkMetadataTypeImport(c, parameterTypeNode(p));
+            checkMetadataTypeImport(c, getType(node));
+            break;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            checkMetadataTypeImport(c, getType(node));
+            break;
+        case 170 /* SyntaxKind.Parameter */: {
+            checkMetadataTypeImport(c, parameterTypeNode(node));
+            const signature = node.parent;
+            for (const p of getParameters(signature).nodes)
+                checkMetadataTypeImport(c, parameterTypeNode(p));
+            checkMetadataTypeImport(c, getType(signature));
+            break;
+        }
+    }
+}
+/** The type a parameter's metadata serializes: the element type of a rest parameter. */
+function parameterTypeNode(node) {
+    const typeNode = getType(node);
+    return getDotDotDotToken(node) !== undefined ? getRestParameterElementType(typeNode) : typeNode;
+}
+function checkMetadataTypeImport(c, typeNode) {
+    const typeName = entityNameForDecoratorMetadata(c, typeNode);
+    if (typeName === undefined || (typeName.kind !== 79 /* SyntaxKind.Identifier */ && typeName.kind !== 167 /* SyntaxKind.QualifiedName */))
+        return;
+    const rootName = getFirstIdentifier(typeName);
+    const meaning = (typeName.kind === 79 /* SyntaxKind.Identifier */ ? 788968 /* SymbolFlags.Type */ : 1920 /* SymbolFlags.Namespace */) | 2097152 /* SymbolFlags.Alias */;
+    const rootSymbol = resolveName(c, rootName, getText(rootName), meaning, undefined, true, false);
+    if (rootSymbol === undefined || (rootSymbol.flags & 2097152 /* SymbolFlags.Alias */) === 0 || symbolIsValue(c, rootSymbol))
+        return;
+    if (rootSymbol.declarations.some(isTypeOnlyImportOrExportDeclaration))
+        return;
+    const diagnostic = c.error(typeName, 221 /* Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled */);
+    const aliasDeclaration = rootSymbol.declarations.find(isAliasSymbolDeclaration);
+    if (aliasDeclaration !== undefined)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(aliasDeclaration, 305 /* Diagnostics.X_0_was_imported_here */, [getText(rootName)]));
+}
+/** The entity name the metadata of a type node references, as the metadata serializer chooses it. */
+function entityNameForDecoratorMetadata(c, node) {
+    if (node === undefined)
+        return undefined;
+    switch (node.kind) {
+        case 194 /* SyntaxKind.IntersectionType */:
+            return entityNameForDecoratorMetadataFromTypes(c, node.types.nodes);
+        case 193 /* SyntaxKind.UnionType */:
+            return entityNameForDecoratorMetadataFromTypes(c, node.types.nodes);
+        case 195 /* SyntaxKind.ConditionalType */:
+            return entityNameForDecoratorMetadataFromTypes(c, [
+                node.trueType,
+                node.falseType,
+            ]);
+        case 197 /* SyntaxKind.ParenthesizedType */:
+        case 203 /* SyntaxKind.NamedTupleMember */:
+            return entityNameForDecoratorMetadata(c, getType(node));
+        case 184 /* SyntaxKind.TypeReference */:
+            return node.typeName;
+    }
+    return undefined;
+}
+/** The one identifier all of `types` reference, skipping `never` (and `null` and `undefined` without strictNullChecks). */
+function entityNameForDecoratorMetadataFromTypes(c, types) {
+    let common;
+    for (const typeNode of types) {
+        if (typeNode.kind === 146 /* SyntaxKind.NeverKeyword */)
+            continue;
+        if (!c.strictNullChecks &&
+            ((typeNode.kind === 202 /* SyntaxKind.LiteralType */ &&
+                typeNode.literal.kind === 105 /* SyntaxKind.NullKeyword */) ||
+                typeNode.kind === 157 /* SyntaxKind.UndefinedKeyword */))
+            continue;
+        const name = entityNameForDecoratorMetadata(c, typeNode);
+        if (name === undefined)
+            return undefined;
+        if (common === undefined)
+            common = name;
+        else if (common.kind !== 79 /* SyntaxKind.Identifier */ ||
+            name.kind !== 79 /* SyntaxKind.Identifier */ ||
+            getText(common) !== getText(name))
+            return undefined;
+    }
+    return common;
+}
+function checkDecorator(c, node) {
+    const signature = getResolvedSignature(c, node, 0 /* CheckMode.Normal */);
+    checkDeprecatedSignature(c, signature, node);
+    const returnType = getReturnTypeOfSignature(c, signature);
+    if ((returnType.flags & 1 /* TypeFlags.Any */) !== 0)
+        return;
+    // Without a signature, the grammar checks reported an error.
+    const decoratorSignature = getDecoratorCallSignature(c, node);
+    if (decoratorSignature === undefined)
+        return;
+    const expectedReturnType = resolvedReturnTypeOf(c, decoratorSignature);
+    if (expectedReturnType === undefined)
+        return;
+    const parent = node.parent;
+    const headMessage = parent.kind === 170 /* SyntaxKind.Parameter */ || (parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ && c.legacyDecorators)
+        ? 220 /* Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any */
+        : 219 /* Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1 */;
+    checkTypeAssignableTo(c, returnType, expectedReturnType, node.expression, headMessage);
+}
+export function hasDecorators(node) {
+    const modifiers = getModifiers(node);
+    if (modifiers === undefined)
+        return false;
+    for (const modifier of modifiers.nodes)
+        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+            return true;
+    return false;
+}
+/** Whether `node` is a valid decorator target. */
+export function nodeCanBeDecorated(legacy, node, parent, grandparent) {
+    const name = getName(node);
+    // Legacy decorators don't support private names.
+    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 */:
+            if (!legacy || parent === undefined || getBody(parent) === undefined)
+                return false;
+            return ((parent.kind === 177 /* SyntaxKind.Constructor */ ||
+                parent.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
+                parent.kind === 179 /* SyntaxKind.SetAccessor */) &&
+                getThisParameter(parent) !== node &&
+                grandparent !== undefined &&
+                grandparent.kind === 264 /* SyntaxKind.ClassDeclaration */);
+    }
+    return false;
+}
+// ---- Resolution
+/** Whether every signature takes fewer parameters than the decorator receives, as `@f` for `@f()`. */
+export function isPotentiallyUncalledDecorator(c, decorator, signatures) {
+    if (signatures.length === 0)
+        return false;
+    for (const sig of signatures)
+        if (sig.minArgumentCount !== 0 ||
+            sig.hasRestParameter() ||
+            sig.parameters.length >= getDecoratorArgumentCount(c, decorator, sig))
+            return false;
+    return true;
+}
+export function getUncalledDecoratorText(node) {
+    return getSourceTextOfNode(getSourceFileOfNode(node), node.expression);
+}
+/** The head message of errors resolving a decorator as a call. */
+export function getDiagnosticHeadMessageForDecoratorResolution(node) {
+    switch (node.parent.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+            return 188 /* Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression */;
+        case 170 /* SyntaxKind.Parameter */:
+            return 189 /* Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression */;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return 190 /* Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression */;
+    }
+    return 191 /* Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression */;
+}
+/** The number of arguments the runtime passes to a decorator. */
+export function getDecoratorArgumentCount(c, node, signature) {
+    if (!c.legacyDecorators)
+        return Math.min(Math.max(getParameterCount(c, signature), 1), 2);
+    switch (node.parent.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+            return 1;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return hasSyntacticModifier(node.parent, 512 /* ModifierFlags.Accessor */) ? 3 : 2;
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            // Decorators with only two parameters get only two arguments.
+            return signature.parameters.length <= 2 ? 2 : 3;
+    }
+    return 3;
+}
+/** The parameter types of a decorator's call, one synthetic argument each. */
+export function getEffectiveDecoratorArgumentTypes(c, node) {
+    const signature = getDecoratorCallSignature(c, node);
+    if (signature === undefined)
+        throw new Error('decorator signature not found');
+    const types = [];
+    for (const param of signature.parameters)
+        types.push(getTypeOfSymbol(c, param));
+    return types;
+}
+// ---- Decorator call signatures
+/** The signature the runtime calls a decorator with, or undefined for an invalid target. */
+export function getDecoratorCallSignature(c, decorator) {
+    const node = decorator.parent;
+    const links = c.nodeLinks(node);
+    if (links.decoratorSignature === undefined) {
+        links.decoratorSignature = c.anySignature;
+        const signature = c.legacyDecorators
+            ? getLegacyDecoratorCallSignature(c, node)
+            : getESDecoratorCallSignature(c, node);
+        if (signature !== undefined)
+            links.decoratorSignature = signature;
+    }
+    return links.decoratorSignature === c.anySignature ? undefined : links.decoratorSignature;
+}
+function getLegacyDecoratorCallSignature(c, node) {
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */: {
+            // The target of a class decorator is the constructor side of the class.
+            const targetType = getTypeOfSymbol(c, getSymbolOfDeclaration(c, node));
+            const targetParam = newParameter(c, 'target', targetType);
+            return newCallSignature(c, [targetParam], getUnionType(c, [targetType, c.voidType]));
+        }
+        case 170 /* SyntaxKind.Parameter */: {
+            const fn = node.parent;
+            if (fn.kind !== 177 /* SyntaxKind.Constructor */ &&
+                !(fn.kind === 175 /* SyntaxKind.MethodDeclaration */ || (fn.kind === 179 /* SyntaxKind.SetAccessor */ && isClassLike(fn.parent))))
+                return undefined;
+            const thisParameter = getThisParameter(fn);
+            if (thisParameter === node)
+                return undefined;
+            const index = getParameters(fn).nodes.indexOf(node) - (thisParameter !== undefined ? 1 : 0);
+            // A parameter decorator gets the target, the property key and the parameter index.
+            let targetType;
+            let keyType;
+            if (fn.kind === 177 /* SyntaxKind.Constructor */) {
+                targetType = getTypeOfSymbol(c, getSymbolOfDeclaration(c, fn.parent));
+                keyType = c.undefinedType;
+            }
+            else {
+                targetType = getParentTypeOfClassElement(c, fn);
+                keyType = getClassElementPropertyKeyType(c, fn);
+            }
+            const indexType = getNumberLiteralType(c, index);
+            return newCallSignature(c, [
+                newParameter(c, 'target', targetType),
+                newParameter(c, 'propertyKey', keyType),
+                newParameter(c, 'parameterIndex', indexType),
+            ], c.voidType);
+        }
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 173 /* SyntaxKind.PropertyDeclaration */: {
+            if (!isClassLike(node.parent))
+                return undefined;
+            // Method and accessor decorators get two or three arguments, property decorators two.
+            const targetParam = newParameter(c, 'target', getParentTypeOfClassElement(c, node));
+            const keyParam = newParameter(c, 'propertyKey', getClassElementPropertyKeyType(c, node));
+            const isProperty = node.kind === 173 /* SyntaxKind.PropertyDeclaration */;
+            const returnType = isProperty ? c.voidType : newTypedPropertyDescriptorType(c, getTypeOfDeclaration(c, node));
+            if (!isProperty || hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */)) {
+                const descriptorType = newTypedPropertyDescriptorType(c, getTypeOfDeclaration(c, node));
+                const descriptorParam = newParameter(c, 'descriptor', descriptorType);
+                return newCallSignature(c, [targetParam, keyParam, descriptorParam], getUnionType(c, [returnType, c.voidType]));
+            }
+            return newCallSignature(c, [targetParam, keyParam], getUnionType(c, [returnType, c.voidType]));
+        }
+    }
+    return undefined;
+}
+// An ES decorator gets a `target` value (the constructor, method, getter or setter, an
+// `{ get, set }` object for auto-accessors and `undefined` for fields) and a `context` with
+// details of the decorated element. It may return a replacement for the target.
+function getESDecoratorCallSignature(c, node) {
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */: {
+            const targetType = getTypeOfSymbol(c, getSymbolOfDeclaration(c, node));
+            const contextType = tryCreateTypeReference(c, getGlobalClassDecoratorContextType(c), [targetType]);
+            return newESDecoratorCallSignature(c, targetType, contextType, targetType);
+        }
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */: {
+            if (!isClassLike(node.parent))
+                return undefined;
+            const valueType = node.kind === 175 /* SyntaxKind.MethodDeclaration */
+                ? getOrCreateTypeFromSignature(c, getSignatureFromDeclaration(c, node))
+                : getTypeOfDeclaration(c, node);
+            const thisType = getThisTypeOfClassElement(c, node);
+            // Getters are decorated as `() => value` and setters as `(value) => void`.
+            const targetType = node.kind === 178 /* SyntaxKind.GetAccessor */
+                ? newFunctionType(c, [], valueType)
+                : node.kind === 179 /* SyntaxKind.SetAccessor */
+                    ? newFunctionType(c, [newParameter(c, 'value', valueType)], c.voidType)
+                    : valueType;
+            const contextType = newClassMemberDecoratorContextTypeForNode(c, node, thisType, valueType);
+            return newESDecoratorCallSignature(c, targetType, contextType, targetType);
+        }
+        case 173 /* SyntaxKind.PropertyDeclaration */: {
+            if (!isClassLike(node.parent))
+                return undefined;
+            const valueType = getTypeOfDeclaration(c, node);
+            const thisType = getThisTypeOfClassElement(c, node);
+            const isAutoAccessor = hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */);
+            // Fields are installed when initialized, so their target is `undefined`.
+            const targetType = isAutoAccessor
+                ? tryCreateTypeReference(c, getGlobalClassAccessorDecoratorTargetType(c), [thisType, valueType])
+                : c.undefinedType;
+            // Fields return an initializer mutator; auto-accessors may also replace the getter and setter.
+            const returnType = isAutoAccessor
+                ? tryCreateTypeReference(c, getGlobalClassAccessorDecoratorResultType(c), [thisType, valueType])
+                : newFunctionTypeWithThis(c, newParameter(c, 'this', thisType), [newParameter(c, 'value', valueType)], valueType);
+            const contextType = newClassMemberDecoratorContextTypeForNode(c, node, thisType, valueType);
+            return newESDecoratorCallSignature(c, targetType, contextType, returnType);
+        }
+    }
+    return undefined;
+}
+function getThisTypeOfClassElement(c, node) {
+    const classSymbol = getSymbolOfDeclaration(c, node.parent);
+    return hasStaticModifier(node) ? getTypeOfSymbol(c, classSymbol) : getDeclaredTypeOfClassOrInterface(c, classSymbol);
+}
+function newClassMemberDecoratorContextTypeForNode(c, node, thisType, valueType) {
+    const isStaticMember = hasStaticModifier(node);
+    const name = getName(node);
+    const isPrivate = name.kind === 80 /* SyntaxKind.PrivateIdentifier */;
+    const nameType = isPrivate
+        ? getStringLiteralType(c, getText(name))
+        : (getLiteralTypeFromPropertyName(c, name) ?? c.neverType);
+    let globalType;
+    switch (node.kind) {
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            globalType = getGlobalClassMethodDecoratorContextType(c);
+            break;
+        case 178 /* SyntaxKind.GetAccessor */:
+            globalType = getGlobalClassGetterDecoratorContextType(c);
+            break;
+        case 179 /* SyntaxKind.SetAccessor */:
+            globalType = getGlobalClassSetterDecoratorContextType(c);
+            break;
+        default:
+            globalType = hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */)
+                ? getGlobalClassAccessorDecoratorContextType(c)
+                : getGlobalClassFieldDecoratorContextType(c);
+    }
+    const contextType = tryCreateTypeReference(c, globalType, [thisType, valueType]);
+    const overrideType = getClassMemberDecoratorContextOverrideType(c, nameType, isPrivate, isStaticMember);
+    return getIntersectionType(c, [contextType, overrideType]);
+}
+/** A type like `{ name: "foo", private: false, static: true }` intersected with a member's context type. */
+function getClassMemberDecoratorContextOverrideType(c, nameType, isPrivate, isStaticMember) {
+    const key = 'decoratorContext:' + (isPrivate ? 'p' : '') + (isStaticMember ? 's' : '') + ':' + nameType.id;
+    const cached = c.cachedTypes.get(key);
+    if (cached !== undefined)
+        return cached;
+    const members = new Map();
+    members.set('name', newProperty(c, 'name', nameType));
+    members.set('private', newProperty(c, 'private', isPrivate ? c.trueType : c.falseType));
+    members.set('static', newProperty(c, 'static', isStaticMember ? c.trueType : c.falseType));
+    const overrideType = createAnonymousType(c, undefined, members, [], [], []);
+    c.cachedTypes.set(key, overrideType);
+    return overrideType;
+}
+function newESDecoratorCallSignature(c, targetType, contextType, nonOptionalReturnType) {
+    const targetParam = newParameter(c, 'target', targetType);
+    const contextParam = newParameter(c, 'context', contextType);
+    return newCallSignature(c, [targetParam, contextParam], getUnionType(c, [nonOptionalReturnType, c.voidType]));
+}
+function getParentTypeOfClassElement(c, node) {
+    const classSymbol = getSymbolOfDeclaration(c, node.parent);
+    return isStatic(node) ? getTypeOfSymbol(c, classSymbol) : getDeclaredTypeOfSymbol(c, classSymbol);
+}
+function getClassElementPropertyKeyType(c, element) {
+    const name = getName(element);
+    switch (name.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+            return getStringLiteralType(c, getText(name));
+        case 168 /* SyntaxKind.ComputedPropertyName */: {
+            const nameType = checkComputedPropertyName(c, name);
+            return isTypeAssignableToKind(c, nameType, 16896 /* TypeFlags.ESSymbolLike */) ? nameType : c.stringType;
+        }
+    }
+    return c.errorType;
+}
+function getTypeOfDeclaration(c, node) {
+    const symbol = getSymbolOfDeclaration(c, node);
+    return symbol !== undefined ? getTypeOfSymbol(c, symbol) : c.errorType;
+}
+function newTypedPropertyDescriptorType(c, propertyType) {
+    return createTypeFromGenericGlobalType(c, getGlobalTypedPropertyDescriptorType(c), [propertyType]);
+}
+// ---- Synthetic symbols and signatures
+function newParameter(c, name, t) {
+    const symbol = c.newSymbol(1 /* SymbolFlags.FunctionScopedVariable */, name);
+    c.symbolTypes.set(getSymbolId(symbol), t);
+    return symbol;
+}
+function newProperty(c, name, t) {
+    const symbol = c.newSymbol(4 /* SymbolFlags.Property */, name);
+    c.symbolTypes.set(getSymbolId(symbol), t);
+    return symbol;
+}
+/** A call signature declared by a synthetic `(...) => any` type, so that it prints as a function type. */
+function newCallSignature(c, parameters, returnType) {
+    return newCallSignatureWithThis(c, undefined, parameters, returnType);
+}
+function newCallSignatureWithThis(c, thisParameter, parameters, returnType) {
+    const declaration = new FunctionTypeNode(undefined, new NodeList(0, 0, []), new KeywordTypeNode(132 /* SyntaxKind.AnyKeyword */));
+    return c.newSignature(0 /* SignatureFlags.None */, declaration, [], thisParameter, parameters, returnType, parameters.length);
+}
+function newFunctionType(c, parameters, returnType) {
+    return getOrCreateTypeFromSignature(c, newCallSignature(c, parameters, returnType));
+}
+function newFunctionTypeWithThis(c, thisParameter, parameters, returnType) {
+    return getOrCreateTypeFromSignature(c, newCallSignatureWithThis(c, thisParameter, parameters, returnType));
+}
+// ---- Utilities
+function getThisParameter(signature) {
+    const parameters = getParameters(signature);
+    if (parameters === undefined || parameters.nodes.length === 0)
+        return undefined;
+    const first = parameters.nodes[0];
+    const name = getName(first);
+    return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'this' ? first : undefined;
+}

package/dist/api/compiler/checker-deprecation.d.ts

@@ -0,0 +1,33 @@
+import { type JsxAttribute, type Node } from './ast.js';
+import { type Checker } from './checker.js';
+import { type Signature, type Type } from './checker-types.js';
+import { type Diagnostic } from './diagnostics.js';
+import { type Symbol } from './symbol.js';
+/** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
+export declare function isDeprecatedDeclaration(declaration: Node): boolean;
+/**
+ * Whether `symbol` is deprecated: an interface member when any declaration is, other merged
+ * members when all are.
+ */
+export declare function isDeprecatedSymbol(c: Checker, symbol: Symbol): boolean;
+export declare function addDeprecatedSuggestion(c: Checker, location: Node, declarations: readonly Node[], deprecatedEntity: string): Diagnostic;
+/** Reports a call, `new`, tagged template, decorator or JSX element resolved to a deprecated signature. */
+export declare function checkDeprecatedSignature(c: Checker, signature: Signature, node: Node): void;
+/** The part of a use that a deprecation suggestion underlines. */
+export declare function getDeprecatedSuggestionNode(node: Node): Node;
+/** Resolves an alias, reporting the first deprecated alias along the way to its target. */
+export declare function resolveAliasWithDeprecationCheck(c: Checker, symbol: Symbol, location: Node): Symbol;
+/** Resolves the alias an identifier refers to and reports a deprecated target. */
+export declare function checkDeprecatedIdentifier(c: Checker, node: Node, localOrExportSymbol: Symbol): void;
+/** Reports a property access to a deprecated property. */
+export declare function checkDeprecatedProperty(c: Checker, node: Node, right: Node, prop: Symbol): void;
+/** Reports a property access resolved through a deprecated index signature. */
+export declare function checkDeprecatedIndexSignature(c: Checker, right: Node, declaration: Node | undefined): void;
+/** Reports an element access or indexed access type selecting a deprecated property. */
+export declare function checkDeprecatedIndexedAccess(c: Checker, accessNode: Node, prop: Symbol, propName: string): void;
+/** Reports a type reference or import type naming a deprecated type. */
+export declare function checkDeprecatedTypeReference(c: Checker, node: Node, type: Type): void;
+/** Reports an import specifier importing a deprecated declaration. */
+export declare function checkDeprecatedImportSpecifier(c: Checker, node: Node, symbol: Symbol): void;
+/** Reports a JSX attribute setting a deprecated property of the element's contextual props type. */
+export declare function checkDeprecatedJsxAttribute(c: Checker, contextualType: Type, attribute: JsxAttribute): void;