tsc-ts 0.0.10 → 0.1.0

package/src/compiler/checker-narrowing.ts

@@ -89,6 +89,7 @@ import {
   createArrayType,
   isTupleType,
   newObjectType,
+  unionContainsTypeOrPrimitive,
 } from './checker-type-factory.js';
 import {
   areTypesComparable,
@@ -119,7 +120,7 @@ import {
   getInferenceContext,
   isContextSensitiveFunctionOrObjectLiteralMethod,
 } from './checker-contextual.js';
-import { instantiateType } from './instantiation.js';
+import { instantiateType, isNodeDescendantOf } from './instantiation.js';
 import { IterationUse, checkIteratedTypeOrElementType } from './checker-iteration.js';
 import { checkSuperExpression } from './checker-super.js';
 import { getSymbolNameForPrivateIdentifier } from './binder.js';
@@ -160,7 +161,7 @@ import {
   getRangeOfTokenAtPosition,
   getSourceFileOfNode,
 } from './binder-utilities.js';
-import { getDeclaredTypeOfSymbol, isConstructorType } from './checker-declared-types.js';
+import { getDeclaredTypeOfSymbol, getParentOfSymbol, isConstructorType } from './checker-declared-types.js';
 import {
   getErasedSignature,
   getReturnTypeFromAnnotation,
@@ -946,6 +947,16 @@ function getTypeOfDottedName(c: Checker, node: Node): Type | undefined {
 
 function getExplicitTypeOfSymbol(c: Checker, original: Symbol): Type | undefined {
   const symbol = resolveSymbol(c, original) ?? original;
+  // `for (const x of x.y)` asks for the explicit type of `x` while finding it.
+  const resolving = c.resolvingExplicitTypeOfSymbol;
+  if (resolving.has(symbol)) return undefined;
+  resolving.add(symbol);
+  const result = getExplicitTypeOfResolvedSymbol(c, symbol);
+  resolving.delete(symbol);
+  return result;
+}
+
+function getExplicitTypeOfResolvedSymbol(c: Checker, symbol: Symbol): Type | undefined {
   if ((symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.ValueModule)) !== 0)
     return getTypeOfSymbol(c, symbol);
   if ((symbol.flags & (SymbolFlags.Variable | SymbolFlags.Property)) !== 0) {
@@ -1194,7 +1205,7 @@ function writeFlowCacheKey(
       return writeFlowCacheKey(c, getExpression(node)!, declaredType, initialType, flowContainer);
     case SyntaxKind.QualifiedName: {
       const left = writeFlowCacheKey(c, (node as QualifiedName).left, declaredType, initialType, flowContainer);
-      return left === undefined ? undefined : left + '.' + (node as QualifiedName).right.text;
+      return left === undefined ? undefined : left + '.' + getText((node as QualifiedName).right);
     }
     case SyntaxKind.PropertyAccessExpression:
     case SyntaxKind.ElementAccessExpression: {
@@ -1556,6 +1567,10 @@ function narrowTypeByEqualityWorker(
         return valueType;
       if ((valueType.flags & TypeFlags.Object) !== 0) return c.nonPrimitiveType;
     }
+    if (!doubleEquals && (valueType.flags & TypeFlags.Primitive) !== 0 && isUniformUnionType(c, t)) {
+      const regularType = getRegularTypeOfLiteralType(c, valueType);
+      if (unionContainsTypeOrPrimitive(c, t as UnionType, regularType, false)) return regularType;
+    }
     const filtered = filterType(
       c,
       t,
@@ -1563,11 +1578,47 @@ function narrowTypeByEqualityWorker(
     );
     return replacePrimitivesWithLiterals(c, filtered, valueType);
   }
-  if (isUnitType(valueType))
+  if (isUnitType(valueType)) {
+    if (isUniformUnionType(c, t)) {
+      const filtered = removeType(c, t, getRegularTypeOfLiteralType(c, valueType));
+      if (filtered !== t) return filtered;
+    }
     return filterType(c, t, (u) => !(isUnitLikeType(u) && areTypesComparable(c, u, valueType)));
+  }
   return t;
 }
 
+/**
+ * Whether `t` is a primitive union in which no two literal constituents are comparable: it has no
+ * literals of two enums, and not both enum literals and string or number literals. Comparing such a
+ * union with one of its literals matches only that literal.
+ */
+function isUniformUnionType(c: Checker, t: Type): boolean {
+  if ((t.objectFlags & ObjectFlags.PrimitiveUnion) === 0) return false;
+  const side = sideOf(c, t);
+  if ((side.objectFlags & ObjectFlags.IsUniformEnumComputed) === 0)
+    side.objectFlags |=
+      ObjectFlags.IsUniformEnumComputed | (computeIsUniformUnionType(c, typesOf(t)) ? ObjectFlags.IsUniformEnum : 0);
+  return (side.objectFlags & ObjectFlags.IsUniformEnum) !== 0;
+}
+
+function computeIsUniformUnionType(c: Checker, types: readonly Type[]): boolean {
+  let enumSymbol: Symbol | undefined;
+  let hasStringOrNumberLiteral = false;
+  for (const t of types) {
+    if ((t.flags & TypeFlags.EnumLike) !== 0) {
+      if (hasStringOrNumberLiteral) return false;
+      const parent = getParentOfSymbol(c, t.symbol!);
+      if (enumSymbol === undefined) enumSymbol = parent;
+      else if (enumSymbol !== parent) return false;
+    } else if ((t.flags & TypeFlags.StringOrNumberLiteral) !== 0) {
+      if (enumSymbol !== undefined) return false;
+      hasStringOrNumberLiteral = true;
+    }
+  }
+  return true;
+}
+
 function isCoercibleUnderDoubleEquals(source: Type, target: Type): boolean {
   return (
     (source.flags & (TypeFlags.Number | TypeFlags.String | TypeFlags.BooleanLiteral)) !== 0 &&
@@ -2184,14 +2235,20 @@ function narrowTypeBySwitchOnDiscriminantWorker(c: Checker, t: Type, flow: FlowS
     return getUnionType(c, ground);
   }
   const discriminantType = getUnionType(c, clauseTypes);
-  const caseType =
-    (discriminantType.flags & TypeFlags.Never) !== 0
-      ? c.neverType
-      : replacePrimitivesWithLiterals(
-          c,
-          filterType(c, t, (u) => areTypesComparable(c, discriminantType, u)),
-          discriminantType,
-        );
+  let caseType: Type | undefined;
+  if ((discriminantType.flags & TypeFlags.Never) !== 0) caseType = c.neverType;
+  else {
+    if ((discriminantType.flags & TypeFlags.Primitive) !== 0 && isUniformUnionType(c, t)) {
+      const regularType = getRegularTypeOfLiteralType(c, discriminantType);
+      if (unionContainsTypeOrPrimitive(c, t as UnionType, regularType, false)) caseType = regularType;
+    }
+    if (caseType === undefined)
+      caseType = replacePrimitivesWithLiterals(
+        c,
+        filterType(c, t, (u) => areTypesComparable(c, discriminantType, u)),
+        discriminantType,
+      );
+  }
   if (!hasDefaultClause) return caseType;
   const defaultType = filterType(c, t, (u) => {
     const unit = extractUnitType(u);
@@ -2400,7 +2457,7 @@ export function isMatchingReference(c: Checker, source: Node, target: Node): boo
         const targetName = getAccessedPropertyName(c, target);
         if (targetName !== undefined)
           return (
-            (source as QualifiedName).right.text === targetName &&
+            getText((source as QualifiedName).right) === targetName &&
             isMatchingReference(c, (source as QualifiedName).left, getExpression(target)!)
           );
       }
@@ -2416,10 +2473,16 @@ export function isMatchingReference(c: Checker, source: Node, target: Node): boo
 
 /** Whether `expr` is `reference.constructor`. */
 function isMatchingConstructorReference(c: Checker, f: FlowState, expr: Node): boolean {
+  // Only a literal name is read here; resolving an entity name argument could start a circularity.
+  let name: Node | undefined = undefined;
+  if (expr.kind === SyntaxKind.PropertyAccessExpression) name = (expr as PropertyAccessExpression).name;
+  else if (
+    expr.kind === SyntaxKind.ElementAccessExpression &&
+    isStringLiteralLike((expr as ElementAccessExpression).argumentExpression)
+  )
+    name = (expr as ElementAccessExpression).argumentExpression;
   return (
-    isAccessExpression(expr) &&
-    getAccessedPropertyName(c, expr) === 'constructor' &&
-    isMatchingReference(c, f.reference, getExpression(expr)!)
+    name !== undefined && getText(name) === 'constructor' && isMatchingReference(c, f.reference, getExpression(expr)!)
   );
 }
 
@@ -2646,7 +2709,11 @@ function isCallChain(node: Node): boolean {
 // ---- Reachability
 
 export function isReachableFlowNode(c: Checker, flow: FlowNode): boolean {
+  // The reduce labels of an enclosing flow analysis don't apply.
+  const outerReduceLabels = c.flowReduceLabels;
+  if (outerReduceLabels.length !== 0) c.flowReduceLabels = [];
   const result = isReachableFlowNodeWorker(c, flow, false);
+  c.flowReduceLabels = outerReduceLabels;
   c.lastFlowNode = flow;
   c.lastFlowNodeReachable = result;
   return result;
@@ -2659,7 +2726,8 @@ function isReachableFlowNodeWorker(c: Checker, start: FlowNode, noCacheCheckIn:
     if (flow === c.lastFlowNode) return c.lastFlowNodeReachable;
     const flags = flow.flags;
     if ((flags & FlowFlags.Shared) !== 0) {
-      if (!noCacheCheck) {
+      // A result found through a reduce label holds only for that label's antecedents.
+      if (!noCacheCheck && c.flowReduceLabels.length === 0) {
         const cached = c.flowNodeReachable.get(flow);
         if (cached !== undefined) return cached;
         const reachable = isReachableFlowNodeWorker(c, flow, true);
@@ -2829,7 +2897,6 @@ function findFunctionOrSourceFile(node: Node | undefined): Node | undefined {
 }
 
 function ensureAssignmentsMarked(c: Checker, symbol: Symbol): void {
-  if (c.symbolLinks(symbol).lastAssignmentPos !== 0) return;
   const parent = findFunctionOrSourceFile(symbol.valueDeclaration);
   if (parent === undefined) return;
   const links = c.nodeLinks(parent);
@@ -3142,12 +3209,25 @@ export function getNarrowedTypeOfSymbol(c: Checker, symbol: Symbol, location: No
     )
   )
     return t;
+  // A reference in the declaration's own initializer would need the declaration's type; defaults of
+  // the binding elements and nested functions are narrowed.
+  const rootInitializer = getInitializer(rootDeclaration);
+  if (
+    rootInitializer !== undefined &&
+    location.pos >= rootInitializer.pos &&
+    location.end <= rootInitializer.end &&
+    isNodeDescendantOf(location, rootInitializer) &&
+    getControlFlowContainer(declaration) === getControlFlowContainer(location)
+  )
+    return t;
   const links = c.nodeLinks(parent);
   if ((links.flags & NodeCheckFlags.InCheckIdentifier) !== 0) return t;
   links.flags |= NodeCheckFlags.InCheckIdentifier;
   let result = t;
   const parentType = getTypeForBindingElementParent(c, parent, CheckMode.Normal);
   const parentTypeConstraint = parentType !== undefined ? mapToBaseConstraintOrType(c, parentType) : undefined;
+  // Only the parent's type is guarded; flow analysis may narrow the binding elements again.
+  links.flags &= ~NodeCheckFlags.InCheckIdentifier;
   if (
     parentTypeConstraint !== undefined &&
     (parentTypeConstraint.flags & TypeFlags.Union) !== 0 &&
@@ -3167,7 +3247,6 @@ export function getNarrowedTypeOfSymbol(c: Checker, symbol: Symbol, location: No
         ? c.neverType
         : getBindingElementTypeFromParentType(c, declaration as BindingElement, narrowedType, true);
   }
-  links.flags &= ~NodeCheckFlags.InCheckIdentifier;
   return result;
 }
 

package/src/compiler/checker-object-literals.ts

@@ -77,6 +77,7 @@ import {
 import { addIntraExpressionInferenceSite } from './checker-inference.js';
 import { isEmptyObjectType } from './checker-type-factory.js';
 import { getTypeOfExpandoObjectLiteral, isJSObjectLiteral } from './checker-javascript.js';
+import { checkNodeDeferred } from './checker-source-file.js';
 import {
   CheckFlags,
   copyDeclarations,
@@ -153,6 +154,8 @@ class ObjectLiteralBuilder {
 export function checkObjectLiteral(c: Checker, node: Node, checkMode: CheckMode): Type {
   const expandoType = getTypeOfExpandoObjectLiteral(c, node);
   if (expandoType !== undefined) return expandoType;
+  // Deprecated properties of the contextual type are reported once the file is checked.
+  checkNodeDeferred(c, node);
   const inDestructuringPattern = isAssignmentTarget(node);
   checkGrammarObjectLiteralOfExpression(c, node as ObjectLiteralExpression, inDestructuringPattern);
   const allProperties = c.strictNullChecks ? new Map<string, Symbol>() : undefined;

package/src/compiler/checker-operators.ts

@@ -260,10 +260,11 @@ export function errorAndMaybeSuggestAwait(
   message: DiagnosticMessage,
   args: string[],
 ): Diagnostic {
-  const diagnostic = createDiagnosticForNode(location, message, args);
+  // The related information goes on the reported diagnostic after it is added, as tsgo attaches it,
+  // so a later equal report compares unequal to it and is kept.
+  const diagnostic = c.error(location, message, ...args);
   if (maybeMissingAwait)
     diagnostic.addRelatedInfo(createDiagnosticForNode(location, Diagnostics.Did_you_forget_to_use_await, []));
-  c.addDiagnostic(diagnostic);
   return diagnostic;
 }
 
@@ -1145,9 +1146,15 @@ function getSyntacticNullishnessSemantics(c: Checker, nodeIn: Node): PredicateSe
         // The right operand decides.
         case SyntaxKind.CommaToken:
         case SyntaxKind.EqualsToken:
-        case SyntaxKind.QuestionQuestionToken:
-        case SyntaxKind.QuestionQuestionEqualsToken:
           return getSyntacticNullishnessSemantics(c, binary.right);
+        // The left operand when it isn't nullish, otherwise the right operand.
+        case SyntaxKind.QuestionQuestionToken:
+        case SyntaxKind.QuestionQuestionEqualsToken: {
+          const left = getSyntacticNullishnessSemantics(c, binary.left);
+          let result = left & PredicateSemantics.Never;
+          if ((left & PredicateSemantics.Always) !== 0) result |= getSyntacticNullishnessSemantics(c, binary.right);
+          return result;
+        }
       }
       return PredicateSemantics.Never;
     }

package/src/compiler/checker-property-access.ts

@@ -195,7 +195,12 @@ export function checkPropertyAccessExpressionOrQualifiedName(
           );
         return c.anyType;
       }
-      if (name !== '') reportNonexistentProperty(c, right, isThisTypeParameter(leftType) ? apparentType : leftType);
+      if (name !== '') {
+        // Deferred, since printing the containing type can resolve it completely, and report circularities
+        // while it is being resolved.
+        const containingType = isThisTypeParameter(leftType) ? apparentType : leftType;
+        c.deferDiagnostic(right, () => reportNonexistentProperty(c, right, containingType));
+      }
       return c.errorType;
     }
     if (indexInfo.isReadonly && (assignmentKind !== AssignmentKind.None || isDeleteTarget(node)))
@@ -547,7 +552,7 @@ function checkPropertyAccessibilityAtLocation(
           errorNode,
           Diagnostics.Property_0_is_private_and_only_accessible_within_class_1,
           symbolToString(c, prop),
-          typeToString(c, getDeclaringClass(c, prop)!),
+          typeToString(c, getDeclaringClass(c, prop) ?? containingTypeIn),
         );
       return false;
     }

package/src/compiler/checker-services.ts

@@ -36,6 +36,7 @@ import {
   type ShorthandPropertyAssignment,
   type SourceFile,
   type TypeParameterDeclaration,
+  type ImportAttributes as ImportAttributesNode,
 } from './ast.js';
 import {
   compareNodePositions,
@@ -44,9 +45,11 @@ import {
   isFunctionLike,
   isImportCall,
   isLiteralImportTypeNode,
+  isNameOfHeritageClauseTypeReference,
   isStringLiteralLike,
   isTypeDeclaration,
   nodeIsMissing,
+  isImportPhaseMetaProperty,
 } from './ast-utilities.js';
 import {
   getNameOfDeclaration,
@@ -93,6 +96,8 @@ import {
   getTargetOfAliasDeclaration,
   resolveExternalModuleName,
   resolveJSDocMemberName,
+  checkImportAttributesExpression,
+  getImportAttributesTypeForModuleSpecifier,
 } from './checker-modules.js';
 import { getSymbolHasInstanceMethodOfObjectType } from './checker-operators.js';
 import { getSymbolForPrivateIdentifierExpression } from './checker-property-access.js';
@@ -217,7 +222,13 @@ export function getSymbolAtLocationWorker(c: Checker, node: Node, ignoreErrors:
           isLiteralImportTypeNode(grandParent) &&
           (grandParent as ImportTypeNode).argument === parent)
       )
-        return resolveExternalModuleName(c, node, node, ignoreErrors);
+        return resolveExternalModuleName(
+          c,
+          node,
+          node,
+          ignoreErrors,
+          getImportAttributesTypeForModuleSpecifier(c, node),
+        );
       if (
         parent.kind === SyntaxKind.CallExpression &&
         isBindableObjectDefinePropertyCall(parent) &&
@@ -243,7 +254,7 @@ export function getSymbolAtLocationWorker(c: Checker, node: Node, ignoreErrors:
     case SyntaxKind.ExportKeyword:
       return parent.kind === SyntaxKind.ExportAssignment ? getSymbol(parent) : undefined;
     case SyntaxKind.ImportKeyword:
-      if (parent.kind === SyntaxKind.MetaProperty && (parent as MetaProperty).name.text === 'defer') return undefined;
+      if (isImportPhaseMetaProperty(parent)) return undefined;
       return parent.kind === SyntaxKind.MetaProperty ? checkMetaPropertyKeyword(c).symbol : undefined;
     case SyntaxKind.NewKeyword:
       return parent.kind === SyntaxKind.MetaProperty ? checkMetaPropertyKeyword(c).symbol : undefined;
@@ -312,10 +323,13 @@ function getSymbolOfNameOrPropertyAccessExpression(c: Checker, nameIn: Node): Sy
     }
   }
   while (isRightSideOfQualifiedNameOrPropertyAccess(name)) name = name.parent!;
-  if (isInNameOfExpressionWithTypeArguments(name)) {
+  if (isInNameOfExpressionWithTypeArgumentsOrHeritageTypeReference(name)) {
     let meaning: SymbolFlags;
-    if (name.parent!.kind === SyntaxKind.ExpressionWithTypeArguments) {
-      // `extends Bar<T>` in an interface is a type, `foo<T>` a value, and a class `extends` both.
+    if (
+      name.parent!.kind === SyntaxKind.ExpressionWithTypeArguments ||
+      name.parent!.kind === SyntaxKind.TypeReference
+    ) {
+      // A heritage element name is a type, `foo<T>` a value, and a class `extends` both.
       meaning = isPartOfTypeNode(name) ? SymbolFlags.Type : SymbolFlags.Value;
       if (isExpressionWithTypeArgumentsInClassExtendsClause(name.parent!)) meaning |= SymbolFlags.Value;
     } else meaning = SymbolFlags.Namespace;
@@ -377,6 +391,7 @@ function getSymbolOfNameOrPropertyAccessExpression(c: Checker, nameIn: Node): Sy
     const meaning = name.parent!.kind === SyntaxKind.TypeReference ? SymbolFlags.Type : SymbolFlags.Namespace;
     const symbol = resolveEntityName(c, name, meaning, true, true, undefined);
     if (symbol !== undefined && symbol !== c.unknownSymbol) return symbol;
+    if (isNameOfHeritageClauseTypeReference(name)) return undefined;
     return getUnresolvedSymbolForEntityName(c, name);
   }
   if (name.parent!.kind === SyntaxKind.TypePredicate)
@@ -436,11 +451,11 @@ export function getTypeAtLocation(c: Checker, node: Node): Type {
   return getTypeOfNode(c, getReparsedNodeForNode(node));
 }
 
-function getTypeOfNode(c: Checker, node: Node): Type {
+export function getTypeOfNode(c: Checker, node: Node): Type {
   if (node.kind === SyntaxKind.SourceFile && !isExternalOrCommonJSModule(node as SourceFile)) return c.errorType;
   // Semantic questions inside `with` blocks have no answer.
   if ((node.flags & NodeFlags.InWithStatement) !== 0) return c.errorType;
-  const heritage = getClassOfHeritageExpression(node);
+  const heritage = getClassOfHeritageElement(node);
   const classType =
     heritage !== undefined ? getDeclaredTypeOfClassOrInterface(c, getSymbolOfDeclaration(c, heritage)!) : undefined;
   if (isPartOfTypeNode(node)) {
@@ -484,7 +499,8 @@ function getTypeOfNode(c: Checker, node: Node): Type {
     (parent as MetaProperty).keywordToken === node.kind
   )
     return checkMetaPropertyKeyword(c);
-  if (node.kind === SyntaxKind.ImportAttributes) return getCachedGlobalType(c, 'ImportAttributes', 0, true);
+  if (node.kind === SyntaxKind.ImportAttributes)
+    return checkImportAttributesExpression(c, node as ImportAttributesNode);
   return c.errorType;
 }
 
@@ -803,10 +819,11 @@ function isImportTypeQualifierPart(nodeIn: Node): Node | undefined {
   return undefined;
 }
 
-function isInNameOfExpressionWithTypeArguments(nodeIn: Node): boolean {
+function isInNameOfExpressionWithTypeArgumentsOrHeritageTypeReference(nodeIn: Node): boolean {
   let node = nodeIn;
-  while (node.parent!.kind === SyntaxKind.PropertyAccessExpression) node = node.parent!;
-  return node.parent!.kind === SyntaxKind.ExpressionWithTypeArguments;
+  while (node.parent!.kind === SyntaxKind.PropertyAccessExpression || node.parent!.kind === SyntaxKind.QualifiedName)
+    node = node.parent!;
+  return node.parent!.kind === SyntaxKind.ExpressionWithTypeArguments || isNameOfHeritageClauseTypeReference(node);
 }
 
 export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node): boolean {
@@ -851,7 +868,13 @@ export function isJSDocNameReferenceContext(node: Node): boolean {
 
 /** The class of an expression with type arguments in its heritage clause. */
 function getClassOfHeritageExpression(node: Node): Node | undefined {
-  if (node.kind !== SyntaxKind.ExpressionWithTypeArguments) return undefined;
+  return node.kind === SyntaxKind.ExpressionWithTypeArguments ? getClassOfHeritageElement(node) : undefined;
+}
+
+/** The class of a heritage clause element: an expression with type arguments, or a type reference in
+ * `implements`. */
+function getClassOfHeritageElement(node: Node): Node | undefined {
+  if (node.kind !== SyntaxKind.ExpressionWithTypeArguments && node.kind !== SyntaxKind.TypeReference) return undefined;
   const parent = node.parent!;
   return parent.kind === SyntaxKind.HeritageClause && isClassLike(parent.parent!) ? parent.parent : undefined;
 }
@@ -1088,6 +1111,10 @@ function isInExpressionContext(node: Node): boolean {
       return getExpression(parent) === node && !isPartOfTypeNode(parent);
     case SyntaxKind.ShorthandPropertyAssignment:
       return (parent as ShorthandPropertyAssignment).objectAssignmentInitializer === node;
+    case SyntaxKind.FunctionExpression:
+    case SyntaxKind.ClassExpression:
+      // The name of a function or class expression is a declaration name, not an expression.
+      return getName(parent) !== node;
   }
   return isExpressionNode(parent);
 }

package/src/compiler/checker-signatures.ts

@@ -282,7 +282,20 @@ function getReturnTypesOfSignatures(c: Checker, signatures: readonly Signature[]
 export function getReturnTypeOfSignature(c: Checker, sig: Signature): Type {
   if (sig.resolvedReturnType !== undefined) return sig.resolvedReturnType;
   const side = signatureSideOf(c, sig);
-  if (side.resolvedReturnType !== undefined) return side.resolvedReturnType;
+  if (side.resolvedReturnType !== undefined) {
+    if (c.threadSharing !== undefined) noteReturnTypeUse(c, sig);
+    return side.resolvedReturnType;
+  }
+  // TSC_TS_SHARE: checker threads share the return types of declared signatures (shared-results.ts).
+  if (c.threadSharing !== undefined && isSharedReturnSignature(c, sig)) {
+    const sharing = c.threadSharing;
+    if (sharing.computingSignature === sig) sharing.computingSignature = undefined;
+    else {
+      const t = threadReturnType(c, sig);
+      if (side.resolvedReturnType === undefined) side.resolvedReturnType = t;
+      return side.resolvedReturnType;
+    }
+  }
   if (!pushTypeResolution(c, sig, TypeSystemPropertyName.ResolvedReturnType)) return c.errorType;
   let t: Type;
   if (sig.target !== undefined) t = instantiateType(c, getReturnTypeOfSignature(c, sig.target), sig.mapper);
@@ -335,6 +348,7 @@ export function getReturnTypeOfSignature(c: Checker, sig: Signature): Type {
 }
 
 import { getOptionalType as getOptionalTypeLocal, addOptionalTypeMarker } from './checker-symbol-types.js';
+import { isSharedReturnSignature, noteReturnTypeUse, threadReturnType } from './shared-results.js';
 
 export function isResolvingReturnTypeOfSignature(c: Checker, sig: Signature): boolean {
   if (sig.composite !== undefined)

package/src/compiler/checker-source-file.ts

@@ -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 {
   type ImportTypeNode,
@@ -58,7 +57,12 @@ 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,
@@ -94,6 +98,7 @@ import {
 import {
   checkExportAssignment,
   checkExportDeclaration,
+  checkImportAttributes,
   checkImportDeclaration,
   checkImportEqualsDeclaration,
   resolveJSDocMemberName,
@@ -110,9 +115,9 @@ import {
   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';
@@ -120,7 +125,7 @@ import { Diagnostics } from './diagnostic-messages.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
@@ -140,7 +145,6 @@ export function checkSourceFile(c: Checker, file: SourceFile, checkUnused = fals
 
 function checkSourceFileWorker(c: Checker, file: SourceFile): void {
   c.fileBeingChecked = file;
-  c.saveDeferredDiagnostics = true;
   for (const statement of getStatements(file)!.nodes) checkSourceElement(c, statement);
   checkDeferredNodes(c, file);
   if (isExternalOrCommonJSModule(file)) checkExternalModuleExports(c, file);
@@ -152,9 +156,7 @@ function checkSourceFileWorker(c: Checker, file: SourceFile): void {
   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;
@@ -175,7 +177,6 @@ function checkSourceFileWorker(c: Checker, file: SourceFile): void {
 export function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean {
   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);
   const whole = end === statements.length;
@@ -187,14 +188,24 @@ export function checkSourceFileRange(c: Checker, file: SourceFile, start: number
     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: Checker): void {
+  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: Checker, node: Node | undefined): void {
   if (node === undefined) return;
@@ -445,9 +456,12 @@ function checkTypeNodeWorker(c: Checker, node: Node): void {
       break;
     case SyntaxKind.TypeReference:
     case 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 === SyntaxKind.ImportType) checkImportAttributes(c, node);
       break;
     }
     case SyntaxKind.IndexedAccessType:
@@ -522,6 +536,8 @@ function checkMappedType(c: Checker, node: MappedTypeNode): void {
 }
 
 function checkTypePredicate(c: Checker, node: TypePredicateNode): void {
+  // 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, Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
@@ -530,7 +546,6 @@ function checkTypePredicate(c: Checker, node: TypePredicateNode): void {
   const signature = getSignatureFromDeclaration(c, parent);
   const typePredicate = getTypePredicateOfSignature(c, signature);
   if (typePredicate === undefined) return;
-  checkTypeNodeIfPresent(c, node.type);
   if (typePredicate.kind === TypePredicateKind.This || typePredicate.kind === TypePredicateKind.AssertsThis) return;
   const parameterName = node.parameterName;
   if (typePredicate.parameterIndex >= 0) {
@@ -747,6 +762,17 @@ function checkDeferredNode(c: Checker, node: Node): void {
     case SyntaxKind.ClassExpression:
       checkClassLikeDeferred(c, node);
       break;
+    case 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 SyntaxKind.JsxAttributes:
+      checkContextualDeprecations(c, node);
+      break;
     case SyntaxKind.AsExpression:
     case SyntaxKind.TypeAssertionExpression:
       checkAssertionDeferred(c, node);

package/src/compiler/checker-statements.ts

@@ -189,15 +189,16 @@ export function checkRightHandSideOfForOf(c: Checker, statement: Node): Type {
 
 export function checkReturnStatement(c: Checker, node: Node): void {
   const s = node as ReturnStatement;
+  // The expression is checked also where a return statement is a grammar error.
+  const exprNode = s.expression;
+  const exprType = exprNode !== undefined ? checkExpressionCached(c, exprNode) : c.undefinedType;
   const container = getContainingFunction(node);
   // Returns outside functions and in static blocks are grammar errors.
   if (container === undefined) return;
   const signature = getSignatureFromDeclaration(c, container);
   const returnType = getReturnTypeOfSignature(c, signature);
   const functionFlags = getFunctionFlags(container);
-  const exprNode = s.expression;
   if (c.strictNullChecks || exprNode !== undefined || (returnType.flags & TypeFlags.Never) !== 0) {
-    const exprType = exprNode !== undefined ? checkExpressionCached(c, exprNode) : c.undefinedType;
     if (container.kind === SyntaxKind.SetAccessor) {
       if (exprNode !== undefined) c.error(node, Diagnostics.Setters_cannot_return_a_value);
     } else if (container.kind === SyntaxKind.Constructor) {