tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker-source-file.js

@@ -10,7 +10,6 @@
 // - grammar: checker-grammar.ts (checks the parser leaves to the checker)
 // - type nodes: `checkTypeNode` below
 import { checkPendingExternalEmitHelpers } from './checker-emit-helpers.js';
-import { produceDeferredCollisionChecks } from './checker-generated-code.js';
 import { resolveUntypedCall } from './checker-calls.js';
 import { NodeVisitor, getComment, getElements, getExpression, getName, getParameters, getText, getNodeId, getStatements, getType, getTypeParameters, getHeritageClauses, getFlowNode, } from './ast.js';
 import { getSourceFileOfNode, isEnumConst, isExternalOrCommonJSModule, isPotentiallyExecutableNode, } from './binder-utilities.js';
@@ -23,23 +22,22 @@ import { nodeIsMissing } from './ast-utilities.js';
 import { getAttachedJSDoc } from './parser.js';
 import { shouldPreserveConstEnums } from './options.js';
 import { isReachableFlowNode } from './checker-narrowing.js';
-import { getTupleElementFlags, getTypeFromIndexedAccessTypeNode, getTypeFromTypeNode } from './checker-type-nodes.js';
+import { getTupleElementFlags, getTypeFromIndexedAccessTypeNode, getTypeFromTypeNode, isAssertionExpression, } from './checker-type-nodes.js';
 import { isArrayLikeType } from './checker-members.js';
 import { checkBlock, checkDoStatement, checkExpressionStatement, checkForInStatement, checkForOfStatement, checkForStatement, checkIfStatement, checkLabeledStatement, checkReturnStatement, checkSwitchStatement, checkThrowStatement, checkTryStatement, checkWhileStatement, } from './checker-statements.js';
 import { checkEnumDeclaration, checkEnumMember, checkExternalModuleExports, checkFunctionDeclaration, checkModuleDeclaration, checkTypeAliasDeclaration, checkTypeArgumentConstraintsOfReference, checkTypeParameter, checkTypeParameterDeferred, checkTypeParameters, checkVariableStatement, checkVariableLikeDeclaration, checkUnusedRenamedBindingElements, isInstantiatedModule, } from './checker-declarations.js';
-import { checkExportAssignment, checkExportDeclaration, checkImportDeclaration, checkImportEqualsDeclaration, resolveJSDocMemberName, } from './checker-modules.js';
+import { checkExportAssignment, checkExportDeclaration, checkImportAttributes, checkImportDeclaration, checkImportEqualsDeclaration, resolveJSDocMemberName, } from './checker-modules.js';
 import { checkAccessorDeclaration, checkClassDeclaration, checkClassLikeDeferred, checkInterfaceDeclaration, } from './checker-classes.js';
 import { checkJsxElementDeferred } from './checker-jsx.js';
-import { checkAssertionDeferred, checkComputedPropertyName, checkExpression, checkIndexedAccessIndexType, } from './checker-expressions.js';
+import { checkAssertionDeferred, checkComputedPropertyName, checkExpression, checkIndexedAccessIndexType, isConstTypeReference, } from './checker-expressions.js';
 import { checkFunctionLikeBody } from './checker-functions.js';
-import { produceDeferredIterationErrors } from './checker-iteration.js';
 import { checkFunctionOrMethodSymbols } from './checker-overloads.js';
 import { checkInferTypeParameterDeclarations, checkTypeLiteralMembers } from './checker-heritage.js';
 import { checkGrammarSourceFile } from './checker-grammar.js';
 import { getTypeOfSymbol, reportImplicitAny } from './checker-symbol-types.js';
 import { getSymbolOfDeclaration } from './checker-symbols.js';
 import { checkUnusedIdentifiers } from './checker-unused.js';
-import { checkDeprecatedTypeReference } from './checker-deprecation.js';
+import { checkContextualDeprecations, checkDeprecatedTypeReference } from './checker-deprecation.js';
 /**
  * Checks `file` once; diagnostics accumulate in the checker. `checkUnused` also reports unused
  * identifiers, which need the whole file checked first.
@@ -57,7 +55,6 @@ export function checkSourceFile(c, file, checkUnused = false) {
 }
 function checkSourceFileWorker(c, file) {
     c.fileBeingChecked = file;
-    c.saveDeferredDiagnostics = true;
     for (const statement of getStatements(file).nodes)
         checkSourceElement(c, statement);
     checkDeferredNodes(c, file);
@@ -73,9 +70,7 @@ function checkSourceFileWorker(c, file) {
     checkDeferredNodes(c, file);
     checkPendingExternalEmitHelpers(c, file);
     c.fileBeingChecked = undefined;
-    c.saveDeferredDiagnostics = false;
-    produceDeferredIterationErrors(c);
-    produceDeferredCollisionChecks(c);
+    produceDeferredDiagnostics(c);
     // The file's deferred nodes are all checked; later ones are not queued (checkNodeDeferred).
     const links = c.nodeLinks(file);
     links.typeChecked = true;
@@ -95,7 +90,6 @@ function checkSourceFileWorker(c, file) {
 export function checkSourceFileRange(c, file, start, end) {
     const statements = getStatements(file).nodes;
     c.fileBeingChecked = file;
-    c.saveDeferredDiagnostics = true;
     for (let i = start; i < end; i++)
         checkSourceElement(c, statements[i]);
     checkDeferredNodes(c, file);
@@ -109,13 +103,24 @@ export function checkSourceFileRange(c, file, start, end) {
         checkPendingExternalEmitHelpers(c, file);
     }
     c.fileBeingChecked = undefined;
-    c.saveDeferredDiagnostics = false;
-    produceDeferredIterationErrors(c);
-    produceDeferredCollisionChecks(c);
+    produceDeferredDiagnostics(c);
     // Deferred nodes of a later range are queued again (checkNodeDeferred).
     c.nodeLinks(file).deferredNodes = undefined;
     return c.diagnostics.forFile(file.fileName).length > 0;
 }
+/**
+ * Reports the deferred diagnostics, in the order they were deferred. Diagnostics deferred while they
+ * are reported are dropped.
+ */
+export function produceDeferredDiagnostics(c) {
+    const callbacks = c.deferredDiagnostics;
+    if (callbacks.length === 0)
+        return;
+    const count = callbacks.length;
+    for (let i = 0; i < count; i++)
+        callbacks[i]();
+    c.deferredDiagnostics = [];
+}
 /** Checks a statement, declaration, class member or type node. */
 export function checkSourceElement(c, node) {
     if (node === undefined)
@@ -154,16 +159,16 @@ function checkSourceElementUnreachable(c, node) {
     }
     // A missing statement starts where it ends, before the trivia of the next token.
     const start = nodeIsMissing(node) ? node.pos : skipTrivia(file.text, node.pos);
-    const diagnostic = new Diagnostic(file.diagnosticFile(), start, endNode.end, 1698 /* Diagnostics.Unreachable_code_detected */, []);
+    const diagnostic = new Diagnostic(file.diagnosticFile(), start, endNode.end, 1717 /* Diagnostics.Unreachable_code_detected */, []);
     c.addErrorOrSuggestion(c.compilerOptions.allowUnreachableCode === false, diagnostic);
     return true;
 }
 function isSourceElementUnreachable(c, node) {
     if ((node.flags & 134217728 /* NodeFlags.Unreachable */) !== 0) {
         // The binder knows the code is unreachable; const enums only count when preserved.
-        if (node.kind === 267 /* SyntaxKind.EnumDeclaration */)
+        if (node.kind === 268 /* SyntaxKind.EnumDeclaration */)
             return !isEnumConst(node) || shouldPreserveConstEnums(c.compilerOptions);
-        if (node.kind === 268 /* SyntaxKind.ModuleDeclaration */)
+        if (node.kind === 269 /* SyntaxKind.ModuleDeclaration */)
             return isInstantiatedModule(node, shouldPreserveConstEnums(c.compilerOptions));
         return true;
     }
@@ -186,98 +191,98 @@ function checkSourceElementWorker(c, node) {
         c.withinUnreachableCode = true;
     switch (node.kind) {
         // Statements
-        case 242 /* SyntaxKind.Block */:
-        case 269 /* SyntaxKind.ModuleBlock */:
+        case 243 /* SyntaxKind.Block */:
+        case 270 /* SyntaxKind.ModuleBlock */:
             checkBlock(c, node);
             return;
-        case 243 /* SyntaxKind.EmptyStatement */:
-        case 260 /* SyntaxKind.DebuggerStatement */:
-        case 253 /* SyntaxKind.BreakStatement */:
-        case 252 /* SyntaxKind.ContinueStatement */:
+        case 244 /* SyntaxKind.EmptyStatement */:
+        case 261 /* SyntaxKind.DebuggerStatement */:
+        case 254 /* SyntaxKind.BreakStatement */:
+        case 253 /* SyntaxKind.ContinueStatement */:
             return;
-        case 244 /* SyntaxKind.VariableStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
             checkVariableStatement(c, node);
             return;
-        case 245 /* SyntaxKind.ExpressionStatement */:
+        case 246 /* SyntaxKind.ExpressionStatement */:
             checkExpressionStatement(c, node);
             return;
-        case 246 /* SyntaxKind.IfStatement */:
+        case 247 /* SyntaxKind.IfStatement */:
             checkIfStatement(c, node);
             return;
-        case 247 /* SyntaxKind.DoStatement */:
+        case 248 /* SyntaxKind.DoStatement */:
             checkDoStatement(c, node);
             return;
-        case 248 /* SyntaxKind.WhileStatement */:
+        case 249 /* SyntaxKind.WhileStatement */:
             checkWhileStatement(c, node);
             return;
-        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
             checkForStatement(c, node);
             return;
-        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
             checkForInStatement(c, node);
             return;
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             checkForOfStatement(c, node);
             return;
-        case 254 /* SyntaxKind.ReturnStatement */:
+        case 255 /* SyntaxKind.ReturnStatement */:
             checkReturnStatement(c, node);
             return;
-        case 256 /* SyntaxKind.SwitchStatement */:
+        case 257 /* SyntaxKind.SwitchStatement */:
             checkSwitchStatement(c, node);
             return;
-        case 257 /* SyntaxKind.LabeledStatement */:
+        case 258 /* SyntaxKind.LabeledStatement */:
             checkLabeledStatement(c, node);
             return;
-        case 258 /* SyntaxKind.ThrowStatement */:
+        case 259 /* SyntaxKind.ThrowStatement */:
             checkThrowStatement(c, node);
             return;
-        case 259 /* SyntaxKind.TryStatement */:
+        case 260 /* SyntaxKind.TryStatement */:
             checkTryStatement(c, node);
             return;
-        case 255 /* SyntaxKind.WithStatement */:
+        case 256 /* SyntaxKind.WithStatement */:
             // The body isn't checked: every name in it has type `any`.
             checkExpression(c, getExpression(node));
             return;
         // Declarations
-        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
             checkFunctionDeclaration(c, node);
             return;
-        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
             checkClassDeclaration(c, node);
             return;
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
             checkInterfaceDeclaration(c, node);
             return;
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
             checkTypeAliasDeclaration(c, node);
             return;
-        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             checkEnumDeclaration(c, node);
             return;
-        case 306 /* SyntaxKind.EnumMember */:
+        case 307 /* SyntaxKind.EnumMember */:
             checkEnumMember(c, node);
             return;
-        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
             checkModuleDeclaration(c, node);
             return;
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
             checkImportDeclaration(c, node);
             return;
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             checkImportEqualsDeclaration(c, node);
             return;
-        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
             checkExportDeclaration(c, node);
             return;
-        case 278 /* SyntaxKind.ExportAssignment */:
+        case 279 /* SyntaxKind.ExportAssignment */:
             checkExportAssignment(c, node);
             return;
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
             return;
-        case 169 /* SyntaxKind.TypeParameter */:
+        case 170 /* SyntaxKind.TypeParameter */:
             checkTypeParameter(c, node);
             return;
     }
@@ -287,7 +292,7 @@ function checkSourceElementWorker(c, node) {
 /** Resolves the names of `{@link}` tags in a JSDoc comment and its tags, which references them. */
 function checkJSDocLinks(c, jsDoc) {
     checkJSDocCommentLinks(c, getComment(jsDoc));
-    const tags = jsDoc.kind === 315 /* SyntaxKind.JSDoc */ ? jsDoc.tags : undefined;
+    const tags = jsDoc.kind === 316 /* SyntaxKind.JSDoc */ ? jsDoc.tags : undefined;
     if (tags !== undefined)
         for (const tag of tags.nodes)
             checkJSDocCommentLinks(c, getComment(tag));
@@ -296,9 +301,9 @@ function checkJSDocCommentLinks(c, comments) {
     if (comments === undefined)
         return;
     for (const comment of comments.nodes)
-        if (comment.kind === 319 /* SyntaxKind.JSDocLink */ ||
-            comment.kind === 320 /* SyntaxKind.JSDocLinkCode */ ||
-            comment.kind === 321 /* SyntaxKind.JSDocLinkPlain */)
+        if (comment.kind === 320 /* SyntaxKind.JSDocLink */ ||
+            comment.kind === 321 /* SyntaxKind.JSDocLinkCode */ ||
+            comment.kind === 322 /* SyntaxKind.JSDocLinkPlain */)
             resolveJSDocMemberName(c, getName(comment));
 }
 // ---- Type nodes
@@ -311,12 +316,12 @@ export function checkTypeNodeIfPresent(c, node) {
 function checkSignatureMember(c, node) {
     if (getType(node) !== undefined || !c.noImplicitAny)
         return;
-    if (node.kind === 174 /* SyntaxKind.MethodSignature */)
+    if (node.kind === 175 /* SyntaxKind.MethodSignature */)
         reportImplicitAny(c, node, c.anyType);
-    else if (node.kind === 180 /* SyntaxKind.CallSignature */)
-        c.error(node, 1692 /* Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type */);
+    else if (node.kind === 181 /* SyntaxKind.CallSignature */)
+        c.error(node, 1711 /* Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type */);
     else
-        c.error(node, 1685 /* Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type */);
+        c.error(node, 1704 /* Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type */);
 }
 function checkTypeNode(c, node) {
     const saveCurrentNode = c.currentNode;
@@ -327,10 +332,10 @@ function checkTypeNode(c, node) {
 }
 function isTypeReferenceHeritageElement(node) {
     const clause = node.parent;
-    if (clause === undefined || clause.kind !== 299 /* SyntaxKind.HeritageClause */)
+    if (clause === undefined || clause.kind !== 300 /* SyntaxKind.HeritageClause */)
         return false;
     const token = clause.token;
-    if ((token === 118 /* SyntaxKind.ImplementsKeyword */) === (clause.parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */))
+    if ((token === 118 /* SyntaxKind.ImplementsKeyword */) === (clause.parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */))
         return false;
     // Only the first clause of each kind counts.
     for (const other of getHeritageClauses(clause.parent).nodes)
@@ -340,73 +345,78 @@ function isTypeReferenceHeritageElement(node) {
 }
 function checkTypeNodeWorker(c, node) {
     switch (node.kind) {
-        case 183 /* SyntaxKind.TypePredicate */:
+        case 184 /* SyntaxKind.TypePredicate */:
             checkTypePredicate(c, node);
             return;
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */: {
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */: {
             checkTypeParameters(c, getTypeParameters(node));
             checkSignatureMember(c, node);
             const name = getName(node);
-            if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
                 checkComputedPropertyName(c, name);
             break;
         }
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
             checkTypeParameters(c, getTypeParameters(node));
             break;
-        case 184 /* SyntaxKind.TypeReference */:
-        case 206 /* SyntaxKind.ImportType */: {
+        case 185 /* SyntaxKind.TypeReference */:
+        case 207 /* SyntaxKind.ImportType */: {
+            // `const` in `x as const` is not checked as a type: its type is the type of `x`.
+            if (isConstTypeReference(node) && isAssertionExpression(node.parent))
+                break;
             const type = getTypeFromTypeNode(c, node);
             checkTypeArgumentConstraintsOfReference(c, node, type);
             checkDeprecatedTypeReference(c, node, type);
+            if (node.kind === 207 /* SyntaxKind.ImportType */)
+                checkImportAttributes(c, node);
             break;
         }
-        case 200 /* SyntaxKind.IndexedAccessType */:
+        case 201 /* SyntaxKind.IndexedAccessType */:
             // The indexed access type itself, not the substitution type of a conditional type's true branch.
             checkIndexedAccessIndexType(c, getTypeFromIndexedAccessTypeNode(c, node), node);
             break;
-        case 190 /* SyntaxKind.TupleType */:
+        case 191 /* SyntaxKind.TupleType */:
             checkTupleRestElements(c, node);
             getTypeFromTypeNode(c, node);
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             // Implemented types and interface base types are type references; class base types are
             // checked with the base constructor's type parameters.
             if (isTypeReferenceHeritageElement(node))
                 checkTypeArgumentConstraintsOfReference(c, node, getTypeFromTypeNode(c, node));
             break;
-        case 187 /* SyntaxKind.TypeQuery */:
-        case 199 /* SyntaxKind.TypeOperator */:
-        case 202 /* SyntaxKind.LiteralType */:
-        case 198 /* SyntaxKind.ThisType */:
+        case 188 /* SyntaxKind.TypeQuery */:
+        case 200 /* SyntaxKind.TypeOperator */:
+        case 203 /* SyntaxKind.LiteralType */:
+        case 199 /* SyntaxKind.ThisType */:
             getTypeFromTypeNode(c, node);
             break;
     }
     // Type arguments of an import type are only resolved with its type.
-    if (node.kind === 206 /* SyntaxKind.ImportType */) {
+    if (node.kind === 207 /* SyntaxKind.ImportType */) {
         checkTypeNode(c, node.argument);
         return;
     }
     // Type arguments of a type query are checked with its type.
-    if (node.kind === 187 /* SyntaxKind.TypeQuery */)
+    if (node.kind === 188 /* SyntaxKind.TypeQuery */)
         return;
-    if (node.kind === 201 /* SyntaxKind.MappedType */) {
+    if (node.kind === 202 /* SyntaxKind.MappedType */) {
         checkMappedType(c, node);
         return;
     }
-    if (node.kind === 204 /* SyntaxKind.TemplateLiteralType */) {
+    if (node.kind === 205 /* SyntaxKind.TemplateLiteralType */) {
         checkTemplateLiteralType(c, node);
         return;
     }
     node.forEachChild(c.typeNodeVisitor);
     // Unions and intersections are resolved after their constituents.
-    if (node.kind === 193 /* SyntaxKind.UnionType */ || node.kind === 194 /* SyntaxKind.IntersectionType */)
+    if (node.kind === 194 /* SyntaxKind.UnionType */ || node.kind === 195 /* SyntaxKind.IntersectionType */)
         getTypeFromTypeNode(c, node);
-    if (node.kind === 174 /* SyntaxKind.MethodSignature */)
+    if (node.kind === 175 /* SyntaxKind.MethodSignature */)
         checkFunctionOrMethodSymbols(c, node);
-    else if (node.kind === 188 /* SyntaxKind.TypeLiteral */)
+    else if (node.kind === 189 /* SyntaxKind.TypeLiteral */)
         checkTypeLiteralMembers(c, node);
 }
 /** Checks that each span of a template literal type can be written in a template, then its type. */
@@ -433,6 +443,8 @@ function checkMappedType(c, node) {
         checkTypeAssignableTo(c, getConstraintTypeFromMappedType(c, t), c.stringNumberSymbolType, node.typeParameter.constraint, undefined);
 }
 function checkTypePredicate(c, node) {
+    // The predicate's type is checked also in a position a predicate can't have.
+    checkTypeNodeIfPresent(c, node.type);
     const parent = getTypePredicateParent(node);
     if (parent === undefined) {
         c.error(node, 178 /* Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods */);
@@ -442,7 +454,6 @@ function checkTypePredicate(c, node) {
     const typePredicate = getTypePredicateOfSignature(c, signature);
     if (typePredicate === undefined)
         return;
-    checkTypeNodeIfPresent(c, node.type);
     if (typePredicate.kind === 0 /* TypePredicateKind.This */ || typePredicate.kind === 2 /* TypePredicateKind.AssertsThis */)
         return;
     const parameterName = node.parameterName;
@@ -452,13 +463,13 @@ function checkTypePredicate(c, node) {
         else if (typePredicate.type !== undefined) {
             const diagnostics = [];
             if (!checkTypeRelatedTo(c, typePredicate.type, getTypeOfSymbol(c, signature.parameters[typePredicate.parameterIndex]), c.assignableRelation, node.type, undefined, diagnostics))
-                c.addDiagnostic(chainDiagnostic(diagnostics[0], 811 /* Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type */));
+                c.addDiagnostic(chainDiagnostic(diagnostics[0], 818 /* Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type */));
         }
         return;
     }
     for (const param of getParameters(parent).nodes) {
         const name = getName(param);
-        if ((name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */) &&
+        if ((name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */) &&
             checkIfTypePredicateVariableIsDeclaredInBindingPattern(c, name, parameterName, typePredicate.parameterName))
             return;
     }
@@ -468,13 +479,13 @@ function checkTypePredicate(c, node) {
 function getTypePredicateParent(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
             if (getType(parent) === node)
                 return parent;
     }
@@ -489,7 +500,7 @@ function checkIfTypePredicateVariableIsDeclaredInBindingPattern(c, pattern, pred
             c.error(predicateVariableNode, 180 /* Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern */, predicateVariableName);
             return true;
         }
-        if ((name.kind === 208 /* SyntaxKind.ArrayBindingPattern */ || name.kind === 207 /* SyntaxKind.ObjectBindingPattern */) &&
+        if ((name.kind === 209 /* SyntaxKind.ArrayBindingPattern */ || name.kind === 208 /* SyntaxKind.ObjectBindingPattern */) &&
             checkIfTypePredicateVariableIsDeclaredInBindingPattern(c, name, predicateVariableNode, predicateVariableName))
             return true;
     }
@@ -498,7 +509,7 @@ function checkIfTypePredicateVariableIsDeclaredInBindingPattern(c, pattern, pred
 /** Checks an accessor of a type literal or interface. */
 function checkTypeMemberAccessor(c, node) {
     const name = getName(node);
-    if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         checkComputedPropertyName(c, name);
     const symbol = getSymbolOfDeclaration(c, node);
     if (symbol !== undefined)
@@ -512,7 +523,7 @@ function checkTupleRestElements(c, node) {
         if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) === 0)
             continue;
         if (!isArrayLikeType(c, getTypeFromTypeNode(c, getType(e)))) {
-            c.error(e, 725 /* Diagnostics.A_rest_element_type_must_be_an_array_type */);
+            c.error(e, 732 /* Diagnostics.A_rest_element_type_must_be_an_array_type */);
             return;
         }
     }
@@ -529,42 +540,42 @@ export class TypeNodeVisitor extends NodeVisitor {
         checkJSDocLinksOfNode(this.c, node);
         switch (node.kind) {
             case 79 /* SyntaxKind.Identifier */:
-            case 167 /* SyntaxKind.QualifiedName */:
+            case 168 /* SyntaxKind.QualifiedName */:
             case 10 /* SyntaxKind.StringLiteral */:
             case 8 /* SyntaxKind.NumericLiteral */:
                 return false;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 checkVariableLikeDeclaration(this.c, node);
                 return false;
-            case 174 /* SyntaxKind.MethodSignature */:
-            case 180 /* SyntaxKind.CallSignature */:
-            case 181 /* SyntaxKind.ConstructSignature */:
+            case 175 /* SyntaxKind.MethodSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
                 checkTypeNode(this.c, node);
                 return false;
-            case 172 /* SyntaxKind.PropertySignature */:
+            case 173 /* SyntaxKind.PropertySignature */:
                 checkVariableLikeDeclaration(this.c, node);
                 return false;
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 checkTypeMemberAccessor(this.c, node);
                 return false;
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 node.forEachChild(this);
                 return false;
-            case 169 /* SyntaxKind.TypeParameter */:
+            case 170 /* SyntaxKind.TypeParameter */:
                 // Lists of signatures are checked as a whole; `infer` and mapped type parameters alone.
-                if (node.parent.kind === 196 /* SyntaxKind.InferType */ || node.parent.kind === 201 /* SyntaxKind.MappedType */)
+                if (node.parent.kind === 197 /* SyntaxKind.InferType */ || node.parent.kind === 202 /* SyntaxKind.MappedType */)
                     checkTypeParameter(this.c, node);
-                if (node.parent.kind === 196 /* SyntaxKind.InferType */) {
+                if (node.parent.kind === 197 /* SyntaxKind.InferType */) {
                     const symbol = getSymbolOfDeclaration(this.c, node);
                     if (symbol !== undefined)
                         checkInferTypeParameterDeclarations(this.c, symbol);
                 }
                 return false;
         }
-        if (node.kind >= 183 /* SyntaxKind.FirstTypeNode */ && node.kind <= 206 /* SyntaxKind.LastTypeNode */)
+        if (node.kind >= 184 /* SyntaxKind.FirstTypeNode */ && node.kind <= 207 /* SyntaxKind.LastTypeNode */)
             checkTypeNode(this.c, node);
-        else if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+        else if (node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */)
             checkTypeNode(this.c, node);
         return false;
     }
@@ -603,7 +614,7 @@ function checkDeferredNodes(c, file) {
 }
 /** Resolves the type of an object literal accessor, which reports accessors implicitly typed `any`. */
 function checkObjectLiteralAccessorType(c, node) {
-    if (node.parent.kind !== 211 /* SyntaxKind.ObjectLiteralExpression */)
+    if (node.parent.kind !== 212 /* SyntaxKind.ObjectLiteralExpression */)
         return;
     const symbol = getSymbolOfDeclaration(c, node);
     if (symbol !== undefined)
@@ -614,39 +625,52 @@ function checkDeferredNode(c, node) {
     c.currentNode = node;
     c.instantiationCount = 0;
     switch (node.kind) {
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
             // Deferred when overload resolution fails, so that the arguments are checked once.
             resolveUntypedCall(c, node);
             break;
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             checkFunctionLikeBody(c, node);
             break;
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             checkObjectLiteralAccessorType(c, node);
             checkFunctionLikeBody(c, node);
-            if (node.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+            if (node.parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
                 checkAccessorDeclaration(c, node);
             break;
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             checkClassLikeDeferred(c, node);
             break;
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */: {
+            // Reported only as suggestions, which are computed when they are asked for (`getSuggestionDiagnostics`).
+            const file = getSourceFileOfNode(node);
+            const pending = c.objectLiteralsForDeprecations.get(file);
+            if (pending === undefined)
+                c.objectLiteralsForDeprecations.set(file, [node]);
+            else
+                pending.push(node);
+            break;
+        }
+        case 294 /* SyntaxKind.JsxAttributes */:
+            checkContextualDeprecations(c, node);
+            break;
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
             checkAssertionDeferred(c, node);
             break;
-        case 169 /* SyntaxKind.TypeParameter */:
+        case 170 /* SyntaxKind.TypeParameter */:
             checkTypeParameterDeferred(c, node);
             break;
-        case 285 /* SyntaxKind.JsxElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
             checkJsxElementDeferred(c, node);
             break;
-        case 223 /* SyntaxKind.VoidExpression */:
+        case 224 /* SyntaxKind.VoidExpression */:
             checkExpression(c, getExpression(node));
             break;
     }