tsc-ts 0.0.10 → 0.1.0

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

@@ -31,12 +31,12 @@ export function checkDecorators(c, node) {
     checkDecoratorEmitHelpers(c, node);
     checkDecoratorMetadataImports(c, node);
     for (const modifier of getModifiers(node).nodes)
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */)
             checkDecorator(c, modifier);
 }
 function firstDecorator(node) {
     for (const modifier of getModifiers(node).nodes)
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */)
             return modifier;
     return undefined;
 }
@@ -47,24 +47,24 @@ function checkDecoratorEmitHelpers(c, node) {
         return;
     if (c.legacyDecorators) {
         checkExternalEmitHelpers(c, decorator, 2 /* ExternalEmitHelpers.Decorate */);
-        if (node.kind === 170 /* SyntaxKind.Parameter */)
+        if (node.kind === 171 /* 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 (node.kind === 265 /* SyntaxKind.ClassDeclaration */) {
             if (getName(node) === undefined || getFirstTransformableStaticClassElement(c, node) !== undefined)
                 checkExternalEmitHelpers(c, decorator, 65536 /* ExternalEmitHelpers.SetFunctionName */);
         }
-        else if (node.kind !== 232 /* SyntaxKind.ClassExpression */) {
+        else if (node.kind !== 233 /* 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 */ ||
+                (node.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                    node.kind === 179 /* SyntaxKind.GetAccessor */ ||
+                    node.kind === 180 /* SyntaxKind.SetAccessor */ ||
                     isAutoAccessorPropertyDeclaration(node)))
                 checkExternalEmitHelpers(c, decorator, 65536 /* ExternalEmitHelpers.SetFunctionName */);
-            if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
                 checkExternalEmitHelpers(c, decorator, 131072 /* ExternalEmitHelpers.PropKey */);
         }
     }
@@ -87,12 +87,12 @@ export function getFirstTransformableStaticClassElement(c, node) {
             classElementOrClassElementParameterIsDecorated(false, member, node))
             return firstDecorator(node) ?? node;
         if (willTransformPrivateElementsOrClassStaticBlocks) {
-            if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+            if (member.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
                 return member;
             if (isStatic(member) &&
                 (isPrivateIdentifierClassElementDeclaration(member) ||
                     (willTransformInitializers &&
-                        member.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+                        member.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
                         getInitializer(member) !== undefined)))
                 return member;
         }
@@ -108,35 +108,35 @@ 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 */)
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && node.kind !== 174 /* 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 */: {
+        case 265 /* 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 */;
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */: {
+            const otherKind = node.kind === 179 /* SyntaxKind.GetAccessor */ ? 180 /* SyntaxKind.SetAccessor */ : 179 /* SyntaxKind.GetAccessor */;
             const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(c, node), otherKind);
             checkMetadataTypeImport(c, getAnnotatedAccessorTypeNode(node) ?? getAnnotatedAccessorTypeNode(otherAccessor));
             break;
         }
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             for (const p of getParameters(node).nodes)
                 checkMetadataTypeImport(c, parameterTypeNode(p));
             checkMetadataTypeImport(c, getType(node));
             break;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             checkMetadataTypeImport(c, getType(node));
             break;
-        case 170 /* SyntaxKind.Parameter */: {
+        case 171 /* SyntaxKind.Parameter */: {
             checkMetadataTypeImport(c, parameterTypeNode(node));
             const signature = node.parent;
             for (const p of getParameters(signature).nodes)
@@ -153,7 +153,7 @@ function parameterTypeNode(node) {
 }
 function checkMetadataTypeImport(c, typeNode) {
     const typeName = entityNameForDecoratorMetadata(c, typeNode);
-    if (typeName === undefined || (typeName.kind !== 79 /* SyntaxKind.Identifier */ && typeName.kind !== 167 /* SyntaxKind.QualifiedName */))
+    if (typeName === undefined || (typeName.kind !== 79 /* SyntaxKind.Identifier */ && typeName.kind !== 168 /* SyntaxKind.QualifiedName */))
         return;
     const rootName = getFirstIdentifier(typeName);
     const meaning = (typeName.kind === 79 /* SyntaxKind.Identifier */ ? 788968 /* SymbolFlags.Type */ : 1920 /* SymbolFlags.Namespace */) | 2097152 /* SymbolFlags.Alias */;
@@ -172,19 +172,19 @@ function entityNameForDecoratorMetadata(c, node) {
     if (node === undefined)
         return undefined;
     switch (node.kind) {
-        case 194 /* SyntaxKind.IntersectionType */:
+        case 195 /* SyntaxKind.IntersectionType */:
             return entityNameForDecoratorMetadataFromTypes(c, node.types.nodes);
-        case 193 /* SyntaxKind.UnionType */:
+        case 194 /* SyntaxKind.UnionType */:
             return entityNameForDecoratorMetadataFromTypes(c, node.types.nodes);
-        case 195 /* SyntaxKind.ConditionalType */:
+        case 196 /* SyntaxKind.ConditionalType */:
             return entityNameForDecoratorMetadataFromTypes(c, [
                 node.trueType,
                 node.falseType,
             ]);
-        case 197 /* SyntaxKind.ParenthesizedType */:
-        case 203 /* SyntaxKind.NamedTupleMember */:
+        case 198 /* SyntaxKind.ParenthesizedType */:
+        case 204 /* SyntaxKind.NamedTupleMember */:
             return entityNameForDecoratorMetadata(c, getType(node));
-        case 184 /* SyntaxKind.TypeReference */:
+        case 185 /* SyntaxKind.TypeReference */:
             return node.typeName;
     }
     return undefined;
@@ -196,7 +196,7 @@ function entityNameForDecoratorMetadataFromTypes(c, types) {
         if (typeNode.kind === 146 /* SyntaxKind.NeverKeyword */)
             continue;
         if (!c.strictNullChecks &&
-            ((typeNode.kind === 202 /* SyntaxKind.LiteralType */ &&
+            ((typeNode.kind === 203 /* SyntaxKind.LiteralType */ &&
                 typeNode.literal.kind === 105 /* SyntaxKind.NullKeyword */) ||
                 typeNode.kind === 157 /* SyntaxKind.UndefinedKeyword */))
             continue;
@@ -226,7 +226,7 @@ function checkDecorator(c, node) {
     if (expectedReturnType === undefined)
         return;
     const parent = node.parent;
-    const headMessage = parent.kind === 170 /* SyntaxKind.Parameter */ || (parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ && c.legacyDecorators)
+    const headMessage = parent.kind === 171 /* SyntaxKind.Parameter */ || (parent.kind === 174 /* 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);
@@ -236,7 +236,7 @@ export function hasDecorators(node) {
     if (modifiers === undefined)
         return false;
     for (const modifier of modifiers.nodes)
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */)
             return true;
     return false;
 }
@@ -247,30 +247,30 @@ export function nodeCanBeDecorated(legacy, node, parent, grandparent) {
     if (legacy && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
         return false;
     switch (node.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
             return true;
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return !legacy;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return (parent !== undefined &&
                 (legacy
-                    ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */
+                    ? parent.kind === 265 /* SyntaxKind.ClassDeclaration */
                     : isClassLike(parent) && !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */ | 128 /* ModifierFlags.Ambient */)));
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return (parent !== undefined &&
                 getBody(node) !== undefined &&
-                (legacy ? parent.kind === 264 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
-        case 170 /* SyntaxKind.Parameter */:
+                (legacy ? parent.kind === 265 /* SyntaxKind.ClassDeclaration */ : isClassLike(parent)));
+        case 171 /* 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 */) &&
+            return ((parent.kind === 178 /* SyntaxKind.Constructor */ ||
+                parent.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                parent.kind === 180 /* SyntaxKind.SetAccessor */) &&
                 getThisParameter(parent) !== node &&
                 grandparent !== undefined &&
-                grandparent.kind === 264 /* SyntaxKind.ClassDeclaration */);
+                grandparent.kind === 265 /* SyntaxKind.ClassDeclaration */);
     }
     return false;
 }
@@ -292,12 +292,12 @@ export function getUncalledDecoratorText(node) {
 /** 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 */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return 188 /* Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression */;
-        case 170 /* SyntaxKind.Parameter */:
+        case 171 /* SyntaxKind.Parameter */:
             return 189 /* Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression */;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* 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 */;
@@ -307,16 +307,16 @@ 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 */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return 1;
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return hasSyntacticModifier(node.parent, 512 /* ModifierFlags.Accessor */) ? 3 : 2;
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             // Decorators with only two parameters get only two arguments.
-            return signature.parameters.length <= 2 ? 2 : 3;
+            return getParameterCount(c, signature) <= 2 ? 2 : 3;
     }
     return 3;
 }
@@ -347,17 +347,17 @@ export function getDecoratorCallSignature(c, decorator) {
 }
 function getLegacyDecoratorCallSignature(c, node) {
     switch (node.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 232 /* SyntaxKind.ClassExpression */: {
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* 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 */: {
+        case 171 /* 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))))
+            if (fn.kind !== 178 /* SyntaxKind.Constructor */ &&
+                !(fn.kind === 176 /* SyntaxKind.MethodDeclaration */ || (fn.kind === 180 /* SyntaxKind.SetAccessor */ && isClassLike(fn.parent))))
                 return undefined;
             const thisParameter = getThisParameter(fn);
             if (thisParameter === node)
@@ -366,7 +366,7 @@ function getLegacyDecoratorCallSignature(c, node) {
             // A parameter decorator gets the target, the property key and the parameter index.
             let targetType;
             let keyType;
-            if (fn.kind === 177 /* SyntaxKind.Constructor */) {
+            if (fn.kind === 178 /* SyntaxKind.Constructor */) {
                 targetType = getTypeOfSymbol(c, getSymbolOfDeclaration(c, fn.parent));
                 keyType = c.undefinedType;
             }
@@ -381,16 +381,16 @@ function getLegacyDecoratorCallSignature(c, node) {
                 newParameter(c, 'parameterIndex', indexType),
             ], c.voidType);
         }
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 173 /* SyntaxKind.PropertyDeclaration */: {
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 174 /* 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 isProperty = node.kind === 174 /* 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));
@@ -407,31 +407,31 @@ function getLegacyDecoratorCallSignature(c, node) {
 // 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 */: {
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* 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 */: {
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */: {
             if (!isClassLike(node.parent))
                 return undefined;
-            const valueType = node.kind === 175 /* SyntaxKind.MethodDeclaration */
+            const valueType = node.kind === 176 /* 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 */
+            const targetType = node.kind === 179 /* SyntaxKind.GetAccessor */
                 ? newFunctionType(c, [], valueType)
-                : node.kind === 179 /* SyntaxKind.SetAccessor */
+                : node.kind === 180 /* 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 */: {
+        case 174 /* SyntaxKind.PropertyDeclaration */: {
             if (!isClassLike(node.parent))
                 return undefined;
             const valueType = getTypeOfDeclaration(c, node);
@@ -464,13 +464,13 @@ function newClassMemberDecoratorContextTypeForNode(c, node, thisType, valueType)
         : (getLiteralTypeFromPropertyName(c, name) ?? c.neverType);
     let globalType;
     switch (node.kind) {
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             globalType = getGlobalClassMethodDecoratorContextType(c);
             break;
-        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.GetAccessor */:
             globalType = getGlobalClassGetterDecoratorContextType(c);
             break;
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             globalType = getGlobalClassSetterDecoratorContextType(c);
             break;
         default:
@@ -512,7 +512,7 @@ function getClassElementPropertyKeyType(c, element) {
         case 8 /* SyntaxKind.NumericLiteral */:
         case 10 /* SyntaxKind.StringLiteral */:
             return getStringLiteralType(c, getText(name));
-        case 168 /* SyntaxKind.ComputedPropertyName */: {
+        case 169 /* SyntaxKind.ComputedPropertyName */: {
             const nameType = checkComputedPropertyName(c, name);
             return isTypeAssignableToKind(c, nameType, 16896 /* TypeFlags.ESSymbolLike */) ? nameType : c.stringType;
         }

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

@@ -1,4 +1,4 @@
-import { type JsxAttribute, type Node } from './ast.js';
+import { type Node, type SourceFile } from './ast.js';
 import { type Checker } from './checker.js';
 import { type Signature, type Type } from './checker-types.js';
 import { type Diagnostic } from './diagnostics.js';
@@ -29,5 +29,10 @@ export declare function checkDeprecatedIndexedAccess(c: Checker, accessNode: Nod
 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;
+/** Reports the deprecated properties the checked object literals of `file` set (`checkContextualDeprecations`). */
+export declare function checkObjectLiteralDeprecations(c: Checker, file: SourceFile): void;
+/**
+ * Reports the members of an object literal or the attributes of a JSX element that set a deprecated
+ * property of its contextual type. Deferred, so the contextual type of the final check is used.
+ */
+export declare function checkContextualDeprecations(c: Checker, node: Node): void;

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

@@ -1,6 +1,6 @@
 // Deprecation suggestions: uses of declarations marked `@deprecated` in JSDoc report
 // `'X' is deprecated.` with the tag as related information.
-import { JSDoc, JSDocDeprecatedTag, getExpression, getName, getTagName, getText, } from './ast.js';
+import { JSDoc, JSDocDeprecatedTag, getExpression, getName, getProperties, getTagName, getText, } from './ast.js';
 import { isTypeDeclaration } from './ast-utilities.js';
 import { isAccessExpression, getCombinedNodeFlags, getSourceFileOfNode, skipParentheses } from './binder-utilities.js';
 import { createDiagnosticForNode } from './checker.js';
@@ -11,6 +11,7 @@ import { hasMatchingArgument } from './checker-narrowing.js';
 import { entityNameToString } from './checker-expressions.js';
 import { isErrorType } from './checker-type-factory.js';
 import { getPropertyOfType } from './checker-members.js';
+import { getApparentTypeOfContextualType } from './checker-contextual.js';
 import { signatureToString } from './type-printer.js';
 import { declarationAt, declarationCount, getDeclarations } from './symbol.js';
 /** Whether `declaration`, or the statement it belongs to, has a `@deprecated` JSDoc tag. */
@@ -60,14 +61,14 @@ function everyDeprecatedDeclaration(symbol) {
     return true;
 }
 export function addDeprecatedSuggestion(c, location, declarations, deprecatedEntity) {
-    const diagnostic = createDiagnosticForNode(location, 1475 /* Diagnostics.X_0_is_deprecated */, [deprecatedEntity]);
+    const diagnostic = createDiagnosticForNode(location, 1486 /* Diagnostics.X_0_is_deprecated */, [deprecatedEntity]);
     return addDeprecatedSuggestionWorker(c, declarations, diagnostic);
 }
 function addDeprecatedSuggestionWorker(c, declarations, diagnostic) {
     for (const declaration of declarations) {
         const deprecatedTag = getJSDocDeprecatedTag(declaration);
         if (deprecatedTag !== undefined) {
-            diagnostic.addRelatedInfo(createDiagnosticForNode(deprecatedTag, 930 /* Diagnostics.The_declaration_was_marked_as_deprecated_here */, []));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(deprecatedTag, 937 /* Diagnostics.The_declaration_was_marked_as_deprecated_here */, []));
             break;
         }
     }
@@ -84,41 +85,41 @@ export function checkDeprecatedSignature(c, signature, node) {
     const name = tryGetPropertyAccessOrIdentifierToString(getInvokedExpression(node));
     const signatureString = signatureToString(c, signature);
     const diagnostic = name !== ''
-        ? createDiagnosticForNode(getDeprecatedSuggestionNode(node), 1477 /* Diagnostics.The_signature_0_of_1_is_deprecated */, [
+        ? createDiagnosticForNode(getDeprecatedSuggestionNode(node), 1488 /* Diagnostics.The_signature_0_of_1_is_deprecated */, [
             signatureString,
             name,
         ])
-        : createDiagnosticForNode(getDeprecatedSuggestionNode(node), 1475 /* Diagnostics.X_0_is_deprecated */, [signatureString]);
+        : createDiagnosticForNode(getDeprecatedSuggestionNode(node), 1486 /* Diagnostics.X_0_is_deprecated */, [signatureString]);
     addDeprecatedSuggestionWorker(c, [declaration], diagnostic);
 }
 function getInvokedExpression(node) {
     switch (node.kind) {
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
             return node.tag;
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
             return getTagName(node);
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return node.right;
-        case 290 /* SyntaxKind.JsxOpeningFragment */:
+        case 291 /* SyntaxKind.JsxOpeningFragment */:
             return node;
     }
     return getExpression(node);
 }
 function tryGetPropertyAccessOrIdentifierToString(expr) {
     switch (expr.kind) {
-        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */: {
             const base = tryGetPropertyAccessOrIdentifierToString(getExpression(expr));
             return base !== '' ? base + '.' + entityNameToString(getName(expr)) : '';
         }
-        case 213 /* SyntaxKind.ElementAccessExpression */: {
+        case 214 /* SyntaxKind.ElementAccessExpression */: {
             const base = tryGetPropertyAccessOrIdentifierToString(getExpression(expr));
             const argument = expr.argumentExpression;
             return base !== '' && isPropertyNameLiteral(argument) ? base + '.' + getText(argument) : '';
         }
         case 79 /* SyntaxKind.Identifier */:
             return getText(expr);
-        case 296 /* SyntaxKind.JsxNamespacedName */: {
+        case 297 /* SyntaxKind.JsxNamespacedName */: {
             const name = expr;
             return getText(name.namespace) + ':' + getText(name.name);
         }
@@ -141,22 +142,22 @@ function isPropertyNameLiteral(node) {
 export function getDeprecatedSuggestionNode(node) {
     const current = skipParentheses(node);
     switch (current.kind) {
-        case 214 /* SyntaxKind.CallExpression */:
-        case 171 /* SyntaxKind.Decorator */:
-        case 215 /* SyntaxKind.NewExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 172 /* SyntaxKind.Decorator */:
+        case 216 /* SyntaxKind.NewExpression */:
             return getDeprecatedSuggestionNode(getExpression(current));
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
             return getDeprecatedSuggestionNode(current.tag);
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
             return getDeprecatedSuggestionNode(getTagName(current));
-        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
             return current.argumentExpression;
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return getName(current);
-        case 184 /* SyntaxKind.TypeReference */: {
+        case 185 /* SyntaxKind.TypeReference */: {
             const typeName = current.typeName;
-            if (typeName.kind === 167 /* SyntaxKind.QualifiedName */)
+            if (typeName.kind === 168 /* SyntaxKind.QualifiedName */)
                 return typeName.right;
         }
     }
@@ -175,7 +176,7 @@ function isUncalledFunctionReference(c, node, symbol) {
     if (parent === undefined)
         parent = node.parent;
     if (isCallLikeExpression(parent))
-        return ((parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.kind === 215 /* SyntaxKind.NewExpression */) &&
+        return ((parent.kind === 215 /* SyntaxKind.CallExpression */ || parent.kind === 216 /* SyntaxKind.NewExpression */) &&
             node.kind === 79 /* SyntaxKind.Identifier */ &&
             hasMatchingArgument(c, parent, node));
     for (const d of getDeclarations(symbol))
@@ -185,35 +186,35 @@ function isUncalledFunctionReference(c, node, symbol) {
 }
 function isCallLikeExpression(node) {
     switch (node.kind) {
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 290 /* SyntaxKind.JsxOpeningFragment */:
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
-        case 171 /* SyntaxKind.Decorator */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 291 /* SyntaxKind.JsxOpeningFragment */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 172 /* SyntaxKind.Decorator */:
             return true;
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return node.operatorToken.kind === 103 /* SyntaxKind.InstanceOfKeyword */;
     }
     return false;
 }
 function isFunctionLikeKind(kind) {
     switch (kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 318 /* SyntaxKind.JSDocSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 319 /* SyntaxKind.JSDocSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
             return true;
     }
     return false;
@@ -276,9 +277,9 @@ export function checkDeprecatedIndexSignature(c, right, declaration) {
 export function checkDeprecatedIndexedAccess(c, accessNode, prop, propName) {
     if (declarationCount(prop) === 0 || !isDeprecatedSymbol(c, prop) || !isUncalledFunctionReference(c, accessNode, prop))
         return;
-    const deprecatedNode = accessNode.kind === 213 /* SyntaxKind.ElementAccessExpression */
+    const deprecatedNode = accessNode.kind === 214 /* SyntaxKind.ElementAccessExpression */
         ? accessNode.argumentExpression
-        : accessNode.kind === 200 /* SyntaxKind.IndexedAccessType */
+        : accessNode.kind === 201 /* SyntaxKind.IndexedAccessType */
             ? accessNode.indexType
             : accessNode;
     addDeprecatedSuggestion(c, deprecatedNode, getDeclarations(prop), propName);
@@ -304,12 +305,32 @@ export function checkDeprecatedImportSpecifier(c, node, symbol) {
     if (isDeprecatedSymbol(c, targetSymbol) && declarationCount(targetSymbol) !== 0)
         addDeprecatedSuggestion(c, node, getDeclarations(targetSymbol), targetSymbol.name);
 }
-/** Reports a JSX attribute setting a deprecated property of the element's contextual props type. */
-export function checkDeprecatedJsxAttribute(c, contextualType, attribute) {
-    const name = attribute.name;
-    if (name.kind !== 79 /* SyntaxKind.Identifier */)
+/** Reports the deprecated properties the checked object literals of `file` set (`checkContextualDeprecations`). */
+export function checkObjectLiteralDeprecations(c, file) {
+    const pending = c.objectLiteralsForDeprecations.get(file);
+    if (pending === undefined)
         return;
-    const prop = getPropertyOfType(c, contextualType, getText(name));
-    if (prop !== undefined && declarationCount(prop) !== 0 && isDeprecatedSymbol(c, prop))
-        addDeprecatedSuggestion(c, name, getDeclarations(prop), getText(name));
+    c.objectLiteralsForDeprecations.delete(file);
+    for (const node of pending)
+        checkContextualDeprecations(c, node);
+}
+/**
+ * Reports the members of an object literal or the attributes of a JSX element that set a deprecated
+ * property of its contextual type. Deferred, so the contextual type of the final check is used.
+ */
+export function checkContextualDeprecations(c, node) {
+    const contextualType = getApparentTypeOfContextualType(c, node);
+    if (contextualType === undefined)
+        return;
+    for (const property of getProperties(node).nodes) {
+        const name = getName(property);
+        if (name === undefined || name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
+            continue;
+        const text = name.kind === 297 /* SyntaxKind.JsxNamespacedName */
+            ? name.namespace.text + ':' + name.name.text
+            : getText(name);
+        const prop = getPropertyOfType(c, contextualType, text);
+        if (prop !== undefined && declarationCount(prop) !== 0 && isDeprecatedSymbol(c, prop))
+            addDeprecatedSuggestion(c, name, getDeclarations(prop), text);
+    }
 }