tsc-ts 0.0.9 → 0.1.0

package/src/compiler/checker-type-nodes.ts

@@ -54,6 +54,7 @@ import {
   UniqueESSymbolType,
   emptyTypes,
   newTypeMapper,
+  TypeParameter,
 } from './checker-types.js';
 import {
   createArrayType,
@@ -115,6 +116,7 @@ import { checkExpressionWithTypeArguments } from './checker-calls.js';
 import { getIntendedTypeFromJSDocTypeReference } from './checker-jsdoc.js';
 import { getCombinedNodeFlags, hasSyntacticModifier } from './binder-utilities.js';
 import { CheckFlags, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
+import { isStatement } from './printer/utilities.js';
 
 export function getTypeFromTypeNode(c: Checker, node: Node): Type {
   return getConditionalFlowTypeOfType(c, getTypeFromTypeNodeWorker(c, node), node);
@@ -417,13 +419,19 @@ function isValidESSymbolDeclaration(node: Node): boolean {
   return false;
 }
 
+/** tsgo's ast.BlockIdOffset, the first id of the symbols a checker numbers. */
+const symbolBlockIdOffset = 2 ** 48;
+
 export function getESSymbolLikeTypeForNode(c: Checker, node: Node): Type {
   if (isValidESSymbolDeclaration(node)) {
     const symbol = getSymbolOfDeclaration(c, node);
     if (symbol !== undefined) {
       let uniqueType = c.uniqueESSymbolTypes.get(symbol);
       if (uniqueType === undefined) {
-        uniqueType = new UniqueESSymbolType(c.nextTypeId(), symbol, '￾@' + symbol.name + '@' + getSymbolId(symbol));
+        // tsgo numbers the symbols its checker keeps links for from 2^48 (ast.BlockIdOffset), and the name's length
+        // counts toward the node builder's truncation.
+        const name = '￾@' + symbol.name + '@' + (symbolBlockIdOffset + getSymbolId(symbol));
+        uniqueType = new UniqueESSymbolType(c.nextTypeId(), symbol, name);
         c.uniqueESSymbolTypes.set(symbol, uniqueType);
       }
       return uniqueType;
@@ -442,7 +450,7 @@ function isConstTypeReference(node: Node): boolean {
   );
 }
 
-function isAssertionExpression(node: Node | undefined): boolean {
+export function isAssertionExpression(node: Node | undefined): boolean {
   return (
     node !== undefined && (node.kind === SyntaxKind.AsExpression || node.kind === SyntaxKind.TypeAssertionExpression)
   );
@@ -456,12 +464,47 @@ export function getTypeFromTypeReference(c: Checker, node: Node): Type {
     else
       type =
         getIntendedTypeFromJSDocTypeReference(c, node) ??
-        getTypeReferenceType(c, node, getSymbolFromTypeReference(c, node));
+        getDistributedTypeParameter(c, node, getTypeReferenceType(c, node, getSymbolFromTypeReference(c, node)));
     c.resolvedTypes.set(node.id, type);
   }
   return type;
 }
 
+/**
+ * The distributed form of a type parameter `t` that `node` references inside a distributive conditional type on
+ * it (one whose check type is a bare reference to the type parameter), up to the enclosing statement; otherwise `t`.
+ */
+function getDistributedTypeParameter(c: Checker, node: Node, t: Type): Type {
+  if ((t.flags & TypeFlags.TypeParameter) === 0 || (t as TypeParameter).isDistributed) return t;
+  for (let n = node.parent; n !== undefined && !isStatement(n); n = n.parent) {
+    if (n.kind !== SyntaxKind.ConditionalType) continue;
+    const checkTypeNode = (n as ConditionalTypeNode).checkType;
+    if (isSimpleIdentifierTypeReference(checkTypeNode) && getSymbolFromTypeReference(c, checkTypeNode) === t.symbol)
+      return getDistributedTypeFromTypeParameter(c, t as TypeParameter);
+  }
+  return t;
+}
+
+function getDistributedTypeFromTypeParameter(c: Checker, t: TypeParameter): TypeParameter {
+  let distributed = t.distributedType;
+  if (distributed === undefined) {
+    distributed = c.newTypeParameter(t.symbol);
+    distributed.isDistributed = true;
+    distributed.constraint = t;
+    t.distributedType = distributed;
+  }
+  return distributed;
+}
+
+/** A type reference that is a bare identifier without type arguments. */
+function isSimpleIdentifierTypeReference(node: Node): boolean {
+  return (
+    node.kind === SyntaxKind.TypeReference &&
+    (node as TypeReferenceNode).typeName.kind === SyntaxKind.Identifier &&
+    (node as TypeReferenceNode).typeArguments === undefined
+  );
+}
+
 export function getSymbolFromTypeReference(c: Checker, node: Node): Symbol {
   let symbol = c.resolvedSymbols.get(node.id);
   if (symbol === undefined) {

package/src/compiler/checker-type-operators.ts

@@ -37,6 +37,8 @@ import {
   IndexFlags,
   IndexInfo,
   type IndexType,
+  ConditionalResultKey,
+  DistributedConditional,
   IndexedAccessType,
   type IntersectionType,
   type LiteralType,
@@ -61,6 +63,8 @@ import {
   ReferenceArgs,
   type TypeReference,
   VarianceFlags,
+  getMappedType,
+  getNonDistributedTypeParameter,
 } from './checker-types.js';
 import {
   UnionReduction,
@@ -119,7 +123,6 @@ import {
   getIndexTypeOfType,
   hasPropertiesOfType,
   keepPropertiesOnly,
-  memberResolutionFlags,
 } from './checker-members.js';
 import {
   getLateBoundSymbol,
@@ -328,13 +331,7 @@ function getIndexTypeForGenericType(c: Checker, t: Type, indexFlags: IndexFlags)
 }
 
 export function getLiteralTypeFromProperties(c: Checker, t: Type, include: TypeFlags, includeOrigin: boolean): Type {
-  const key =
-    'props' +
-    t.id +
-    ':' +
-    include +
-    (includeOrigin ? 'o' : '') +
-    ((memberResolutionFlags(c, t) & ObjectFlags.UnresolvedMembers) !== 0 ? 'u' : '');
+  const key = 'props' + t.id + ':' + include + (includeOrigin ? 'o' : '');
   const cached = c.cachedTypes.get(key);
   if (cached !== undefined) return cached;
   const origin =
@@ -594,6 +591,7 @@ export function getIndexedAccessTypeOrUndefinedEx(
     let t = c.indexedAccessTypes.get(key);
     if (t === undefined) {
       t = newIndexedAccessType(c, objectType, indexType, persistent);
+      if (c.indexedAccessKeyFlags !== undefined) c.indexedAccessKeyFlags.set(t, accessFlags);
       t.alias = alias;
       c.indexedAccessTypes.set(key, t);
     }
@@ -1193,11 +1191,36 @@ export function getSimplifiedType(c: Checker, t: Type, writing: boolean): Type {
   if ((t.flags & TypeFlags.IndexedAccess) !== 0)
     return getSimplifiedIndexedAccessType(c, t as IndexedAccessType, writing);
   if ((t.flags & TypeFlags.Conditional) !== 0) return getSimplifiedConditionalType(c, t as ConditionalType, writing);
+  if ((t.flags & TypeFlags.Index) !== 0) return getSimplifiedIndexType(c, t as IndexType);
+  return t;
+}
+
+/** Simplifies `keyof` a generic mapped type with an `as` clause to the type of the keys it produces. */
+function getSimplifiedIndexType(c: Checker, t: IndexType): Type {
+  const target = t.target;
+  if (
+    isGenericMappedType(c, target) &&
+    getNameTypeFromMappedType(c, target as MappedType) !== undefined &&
+    !isMappedTypeWithKeyofConstraintDeclaration(c, target as MappedType)
+  )
+    return getIndexForMappedType(c, target as MappedType, IndexFlags.None);
   return t;
 }
 
 /** Simplifies `T extends U ? T : never` and `T extends U ? never : T` when the outcome is known. */
 function getSimplifiedConditionalType(c: Checker, t: ConditionalType, writing: boolean): Type {
+  const key = cachedTypeKey(
+    writing ? CachedTypeKind.SimplifiedConditionalForWriting : CachedTypeKind.SimplifiedConditionalForReading,
+    t.id,
+  );
+  const cached = c.cachedTypesById.get(key);
+  if (cached !== undefined) return cached;
+  const result = getSimplifiedConditionalTypeWorker(c, t, writing);
+  c.cachedTypesById.set(key, result);
+  return result;
+}
+
+function getSimplifiedConditionalTypeWorker(c: Checker, t: ConditionalType, writing: boolean): Type {
   const checkType = t.checkType;
   const extendsType = t.extendsType;
   const trueType = getTrueTypeFromConditionalType(c, t);
@@ -1561,7 +1584,9 @@ export function getModifiersTypeFromMappedType(c: Checker, t: MappedType): Type
       const declaredType = getTypeFromMappedTypeNode(c, t.declaration!) as MappedType;
       const constraint = getConstraintTypeFromMappedType(c, declaredType);
       const extended =
-        (constraint.flags & TypeFlags.TypeParameter) !== 0 ? getConstraintOfTypeParameter(c, constraint) : constraint;
+        (constraint.flags & TypeFlags.TypeParameter) !== 0
+          ? getConstraintOfTypeParameter(c, getNonDistributedTypeParameter(constraint))
+          : constraint;
       side.modifiersType =
         extended !== undefined && (extended.flags & TypeFlags.Index) !== 0
           ? instantiateType(c, (extended as IndexType).target, t.mapper)
@@ -1584,17 +1609,12 @@ export function getActualTypeVariable(c: Checker, t: Type): Type {
   if ((t.flags & TypeFlags.Substitution) !== 0) return getActualTypeVariable(c, (t as SubstitutionType).baseType);
   if ((t.flags & TypeFlags.IndexedAccess) !== 0) {
     const access = t as IndexedAccessType;
-    if (
-      (access.objectType.flags & TypeFlags.Substitution) !== 0 ||
-      (access.indexType.flags & TypeFlags.Substitution) !== 0
-    )
-      return getIndexedAccessType(
-        c,
-        getActualTypeVariable(c, access.objectType),
-        getActualTypeVariable(c, access.indexType),
-      );
+    const objectType = getActualTypeVariable(c, access.objectType);
+    const indexType = getActualTypeVariable(c, access.indexType);
+    if (objectType !== access.objectType || indexType !== access.indexType)
+      return getIndexedAccessType(c, objectType, indexType);
   }
-  return t;
+  return getNonDistributedTypeParameter(t);
 }
 
 export const enum MappedTypeNameTypeKind {
@@ -1907,7 +1927,7 @@ function instantiateMappedTypeTemplate(
   )
     return getOptionalType(c, propType, true);
   if (c.strictNullChecks && (modifiers & MappedTypeModifiers.ExcludeOptional) !== 0 && isOptional)
-    return filterType(c, propType, (u) => (u.flags & TypeFlags.Undefined) === 0);
+    return removeMissingOrUndefinedType(c, propType);
   return propType;
 }
 
@@ -1975,21 +1995,41 @@ export function getConditionalTypeInstantiation(
   if (result === undefined) {
     const newMapper = newTypeMapper(root.outerTypeParameters, typeArguments);
     const checkType = root.checkType;
-    const distributionType = root.isDistributive ? getReducedType(c, newMapper.map(checkType)) : undefined;
+    const distributionType = root.isDistributive ? getReducedType(c, getMappedType(checkType, newMapper)) : undefined;
     // Distributive conditional types distribute over unions.
     if (
       distributionType !== undefined &&
       checkType !== distributionType &&
       (distributionType.flags & (TypeFlags.Union | TypeFlags.Never)) !== 0
-    )
+    ) {
+      const distributed = c.distributedConditionals;
       result = mapTypeWithAlias(
         c,
         distributionType,
-        (u) => getConditionalType(c, root, prependTypeMapping(checkType, u, newMapper), forConstraint, undefined),
+        (u) => {
+          const member = getConditionalType(
+            c,
+            root,
+            prependTypeMapping(checkType, u, newMapper),
+            forConstraint,
+            undefined,
+          );
+          // Sharing results (shared-results.ts) names a distributed member by the instantiation it is part of.
+          if (distributed !== undefined && (member.flags & TypeFlags.Conditional) !== 0) {
+            if (!distributed.has(member))
+              distributed.set(member, new DistributedConditional(typeArguments.slice(), alias, tag, u));
+            c.distributedByKey!.set(distributedKey(root.node.id, typeArguments, alias, tag, u), member);
+          }
+          return member;
+        },
         alias,
       );
-    else result = getConditionalType(c, root, newMapper, forConstraint, alias);
+    } else result = getConditionalType(c, root, newMapper, forConstraint, alias);
     root.instantiations.set(hash, typeArguments, alias, tag, result);
+    // Sharing results names a conditional type made for another root (a tail or nested root) by this instantiation.
+    const results = c.conditionalResults;
+    if (results !== undefined && (result.flags & TypeFlags.Conditional) !== 0 && !results.has(result))
+      results.set(result, new ConditionalResultKey(root, typeArguments.slice(), alias, tag));
   }
   return result;
 }
@@ -2322,7 +2362,7 @@ function getTailRecursionRoot(c: Checker, newType: Type, newMapper: TypeMapper |
   const typeArguments: Type[] = [];
   for (const t of newRoot.outerTypeParameters) typeArguments.push(typeParamMapper.map(t));
   const newRootMapper = newTypeMapper(newRoot.outerTypeParameters, typeArguments);
-  const newCheckType = newRoot.isDistributive ? newRootMapper.map(newRoot.checkType) : undefined;
+  const newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : undefined;
   if (
     newCheckType === undefined ||
     newCheckType === newRoot.checkType ||
@@ -2435,7 +2475,7 @@ export function isTypeMatchedByTemplateLiteralType(
   target: TemplateLiteralType,
   compareTypes?: TemplateTypeComparer,
 ): boolean {
-  const inferences = inferTypesFromTemplateLiteralType(c, source, target);
+  const inferences = inferTypesFromTemplateLiteralType(c, source, target, compareTypes);
   if (inferences === undefined) return false;
   const compare = compareTypes ?? ((s: Type, t: Type) => isTypeAssignableTo(c, s, t));
   for (let i = 0; i < inferences.length; i++)
@@ -2508,3 +2548,20 @@ export function mappedTypeTarget(t: MappedType): MappedType {
   const target = t.target;
   return target !== undefined ? (target as MappedType) : t;
 }
+
+/** The key of the member of a conditional type instantiation's distribution for one constituent (shared-results.ts). */
+export function distributedKey(
+  root: number,
+  typeArguments: readonly Type[],
+  alias: TypeAlias | undefined,
+  tag: number,
+  constituent: Type,
+): string {
+  let key = root + ':' + tag + ':' + constituent.id + ':';
+  for (const t of typeArguments) key += t.id + ',';
+  if (alias !== undefined) {
+    key += '@' + getSymbolId(alias.symbol);
+    for (const t of alias.typeArguments) key += ',' + t.id;
+  }
+  return key;
+}

package/src/compiler/checker-types.ts

@@ -167,8 +167,7 @@ export const enum ObjectFlags {
   // Type references only.
   IdenticalBaseTypeCalculated = 1 << 27,
   IdenticalBaseTypeExists = 1 << 28,
-  UnresolvedMembers = 1 << 29,
-  FromTypeNode = 1 << 30,
+  FromTypeNode = 1 << 29,
   /**
    * The type keeps the state that is computed lazily in the checker's side tables instead of its
    * own fields, which stay unset (`sideOf`). Every type with `TSC_TS_SIDE_STATE=1`.
@@ -183,6 +182,9 @@ export const enum ObjectFlags {
   ContainsIntersections = 1 << 25,
   IsUnknownLikeUnionComputed = 1 << 26,
   IsUnknownLikeUnion = 1 << 27,
+  IsUniformEnumComputed = 1 << 28,
+  /** A primitive union in which no two literal constituents are comparable (`isUniformUnionType`). */
+  IsUniformEnum = 1 << 29,
   // Intersections only.
   IsNeverIntersectionComputed = 1 << 25,
   IsNeverIntersection = 1 << 26,
@@ -361,6 +363,8 @@ export const enum CachedTypeKind {
   PromisedTypeOfPromise,
   Optional,
   OptionalProperty,
+  SimplifiedConditionalForReading,
+  SimplifiedConditionalForWriting,
 }
 
 export function cachedTypeKey(kind: CachedTypeKind, id: number): number {
@@ -953,6 +957,62 @@ export class MemberNames {
   }
 }
 
+/**
+ * The properties of the instantiations of one source without base types, as `getNamedMembers` orders them
+ * for `container`: the source positions of the named members in that order, and their names
+ * (`PropertyMembers`). The other members are skipped, so the named members are all of an instantiation's table.
+ */
+export class NamedMemberOrder {
+  readonly container: Symbol | undefined;
+  readonly positions: number[];
+  readonly names: MemberNames;
+
+  constructor(container: Symbol | undefined, positions: number[], names: MemberNames) {
+    this.container = container;
+    this.positions = positions;
+    this.names = names;
+  }
+}
+
+/**
+ * What the pending instantiations of a declared members table share whatever their mapper: the members in
+ * table order, which of them are named (the others are skipped), and the members whose resolved type keeps
+ * them under any instantiation (`keepsSymbolTypeUnderInstantiation`), found so far.
+ */
+export class DeclaredMemberPlan {
+  readonly table: SymbolTable;
+  /**
+   * Whether instantiations build the table eagerly: tsgo's table wouldn't be keyed by symbol names, or an
+   * own member could be replaced by an inherited one. The other fields are then incomplete.
+   */
+  readonly eager: boolean;
+  readonly members: Symbol[];
+  /** 1 for a named member, 0 for a skipped one, by position. */
+  readonly named: number[];
+  /** Bits by position: the member's type keeps it under instantiation. Set when found, never cleared. */
+  readonly keptByType: number[];
+  readonly hasOwnMembers: boolean;
+  readonly hasRequiredOwnMembers: boolean;
+
+  constructor(
+    table: SymbolTable,
+    eager: boolean,
+    members: Symbol[],
+    named: number[],
+    hasOwnMembers: boolean,
+    hasRequiredOwnMembers: boolean,
+  ) {
+    this.table = table;
+    this.eager = eager;
+    this.members = members;
+    this.named = named;
+    this.keptByType = [];
+    for (let i = 0; i < members.length; i += 32) this.keptByType.push(0);
+    this.hasOwnMembers = hasOwnMembers;
+    this.hasRequiredOwnMembers = hasRequiredOwnMembers;
+  }
+}
+
 /** A type with members: object types, unions and intersections. */
 export class StructuredType extends Type {
   membersValue: SymbolTable | undefined;
@@ -1060,6 +1120,10 @@ export class InterfaceType extends TypeReference {
   declaredIndexInfos: IndexInfo[];
   /** Positions of the declared members by name, for lazily instantiated members of instantiations. */
   declaredMemberPositions: Map<string, number> | undefined;
+  /** The property order of instantiations (`NamedMemberOrder`); null where it can't be cached. */
+  namedMemberOrder: NamedMemberOrder | null | undefined;
+  /** What pending instantiations of the declared members share (`DeclaredMemberPlan`). */
+  declaredMemberPlan: DeclaredMemberPlan | undefined;
   /** The member states of the last pending instantiation of the type's members (`sharedStates`). */
   lastMemberStates: number[] | undefined;
   /** The property names of the last instantiation whose members table is built on demand. */
@@ -1074,6 +1138,8 @@ export class InterfaceType extends TypeReference {
     this.references = undefined;
     this.checking = undefined;
     this.declaredMemberPositions = undefined;
+    this.namedMemberOrder = undefined;
+    this.declaredMemberPlan = undefined;
     this.lastMemberStates = undefined;
     this.lastMemberNames = undefined;
     this.allTypeParameters = emptyTypes;
@@ -1345,7 +1411,14 @@ export class TypeParameter extends Type {
   target: Type | undefined;
   mapper: TypeMapper | undefined;
   isThisType: boolean;
+  /**
+   * A type parameter as referenced inside a distributive conditional type on it, which stands for each
+   * constituent in turn; its constraint is the type parameter it was made from (`getDistributedTypeParameter`).
+   */
+  isDistributed: boolean;
   resolvedDefaultType: Type | undefined;
+  /** The distributed form of this type parameter, made on first use. */
+  distributedType: TypeParameter | undefined;
 
   constructor(id: number, symbol: Symbol | undefined) {
     super(TypeFlags.TypeParameter, ObjectFlags.None, id, symbol);
@@ -1353,10 +1426,29 @@ export class TypeParameter extends Type {
     this.target = undefined;
     this.mapper = undefined;
     this.isThisType = false;
+    this.isDistributed = false;
     this.resolvedDefaultType = undefined;
+    this.distributedType = undefined;
   }
 }
 
+/** Whether `t` is the distributed form of a type parameter. */
+export function isDistributedTypeParameter(t: Type): boolean {
+  return (t.flags & TypeFlags.TypeParameter) !== 0 && (t as TypeParameter).isDistributed;
+}
+
+/** The type parameter a distributed type parameter was made from; other types as they are. */
+export function getNonDistributedTypeParameter(t: Type): Type {
+  return (t.flags & TypeFlags.TypeParameter) !== 0 && (t as TypeParameter).isDistributed
+    ? (t as TypeParameter).constraint!
+    : t;
+}
+
+/** What `mapper` maps `t` to, a distributed type parameter as the type parameter it was made from. */
+export function getMappedType(t: Type, mapper: TypeMapper): Type {
+  return mapper.map(getNonDistributedTypeParameter(t));
+}
+
 /** `keyof T`. */
 export class IndexType extends Type {
   readonly target: Type;
@@ -1759,8 +1851,17 @@ export const enum TypeMapperKind {
   Merged = 3,
 }
 
+/** The id of the next mapper this thread creates. */
+let nextTypeMapperId = 0;
+
 /** Maps type parameters to types. Subclasses replace tsgo's function mappers. */
 export abstract class TypeMapper {
+  /**
+   * A number for the mapper, unique among the mappers this thread creates (until it wraps at 2^31), so the
+   * stack of active mappers can be searched by id instead of by reference.
+   */
+  readonly id: number = (nextTypeMapperId = (nextTypeMapperId + 1) | 0);
+
   abstract map(type: Type): Type;
 
   kind(): TypeMapperKind {
@@ -1956,12 +2057,12 @@ export function mergeTypeMappers(m1: TypeMapper | undefined, m2: TypeMapper): Ty
 }
 
 export function prependTypeMapping(source: Type, target: Type, mapper: TypeMapper | undefined): TypeMapper {
-  const simple = new SimpleTypeMapper(source, target);
+  const simple = new SimpleTypeMapper(getNonDistributedTypeParameter(source), target);
   return mapper === undefined ? simple : new MergedTypeMapper(simple, mapper);
 }
 
 export function appendTypeMapping(mapper: TypeMapper | undefined, source: Type, target: Type): TypeMapper {
-  const simple = new SimpleTypeMapper(source, target);
+  const simple = new SimpleTypeMapper(getNonDistributedTypeParameter(source), target);
   return mapper === undefined ? simple : new MergedTypeMapper(mapper, simple);
 }
 
@@ -2129,6 +2230,16 @@ export class SymbolLinks implements ProgramLifetime {
     this.rare().enumChecked = value;
   }
 
+  get mergedExportsChecked(): boolean {
+    const rare = this.rareLinks;
+    return rare === undefined ? false : rare.mergedExportsChecked;
+  }
+
+  set mergedExportsChecked(value: boolean) {
+    if (value === false && this.rareLinks === undefined) return;
+    this.rare().mergedExportsChecked = value;
+  }
+
   get variances(): VarianceFlags[] | undefined {
     const rare = this.rareLinks;
     return rare === undefined ? undefined : rare.variances;
@@ -2238,6 +2349,7 @@ export class RareSymbolLinks implements ProgramLifetime {
   indexSignaturesChecked: boolean;
   typeParametersChecked: boolean;
   enumChecked: boolean;
+  mergedExportsChecked: boolean;
   variances: VarianceFlags[] | undefined;
   // Assignment tracking
   lastAssignmentPos: number;
@@ -2265,6 +2377,7 @@ export class RareSymbolLinks implements ProgramLifetime {
     this.indexSignaturesChecked = false;
     this.typeParametersChecked = false;
     this.enumChecked = false;
+    this.mergedExportsChecked = false;
     this.variances = undefined;
     this.lastAssignmentPos = 0;
     this.hasDefiniteAssignment = false;
@@ -2518,3 +2631,33 @@ export class RareNodeLinks implements ProgramLifetime {
     this.mentionsArguments = 0;
   }
 }
+
+/** A conditional type made as a member of a distribution: the instantiation's key, and the constituent it is for. */
+export class DistributedConditional {
+  readonly typeArguments: Type[];
+  readonly alias: TypeAlias | undefined;
+  readonly tag: number;
+  readonly constituent: Type;
+
+  constructor(typeArguments: Type[], alias: TypeAlias | undefined, tag: number, constituent: Type) {
+    this.typeArguments = typeArguments;
+    this.alias = alias;
+    this.tag = tag;
+    this.constituent = constituent;
+  }
+}
+
+/** The instantiation of a conditional type whose result is a conditional type: its root and key. */
+export class ConditionalResultKey {
+  readonly root: ConditionalRoot;
+  readonly typeArguments: Type[];
+  readonly alias: TypeAlias | undefined;
+  readonly tag: number;
+
+  constructor(root: ConditionalRoot, typeArguments: Type[], alias: TypeAlias | undefined, tag: number) {
+    this.root = root;
+    this.typeArguments = typeArguments;
+    this.alias = alias;
+    this.tag = tag;
+  }
+}

package/src/compiler/checker-unused.ts

@@ -53,7 +53,6 @@ import { SyntaxKind } from './syntax-kind.js';
 import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
 import { getResolvedSymbol } from './checker-expressions.js';
 import { skipTrivia } from './scanner.js';
-import { getContainingFunctionOrClassStaticBlock } from './checker-grammar.js';
 import { nodeCanBeDecorated } from './checker-decorators.js';
 import { symbolToString } from './type-printer.js';
 import type { Type } from './checker-types.js';
@@ -248,20 +247,14 @@ class PotentiallyUnusedCollector extends NodeVisitor {
   }
 
   /**
-   * Whether the checker skips the children of `node`: a `return` outside a function body, or in a class
-   * static block, and a decorator of a declaration that can't be decorated, are reported as errors and
-   * not checked further.
+   * Whether the checker skips the children of `node`: a decorator of a declaration that can't be decorated
+   * is reported as an error and not checked further. (The expression of a `return` outside a function
+   * body, or in a class static block, is still checked.)
    */
   private isUnchecked(node: Node): boolean {
-    if (node.kind === SyntaxKind.ReturnStatement) {
-      const container = getContainingFunctionOrClassStaticBlock(node);
-      return container === undefined || container.kind === SyntaxKind.ClassStaticBlockDeclaration;
-    }
-    if (node.kind === SyntaxKind.Decorator) {
-      const declaration = node.parent!;
-      return !nodeCanBeDecorated(this.legacyDecorators, declaration, declaration.parent, declaration.parent?.parent);
-    }
-    return false;
+    if (node.kind !== SyntaxKind.Decorator) return false;
+    const declaration = node.parent!;
+    return !nodeCanBeDecorated(this.legacyDecorators, declaration, declaration.parent, declaration.parent?.parent);
   }
 }
 
@@ -273,7 +266,8 @@ function isPotentiallyUnusedContainer(node: Node): boolean {
     case SyntaxKind.CaseBlock:
     case SyntaxKind.ForStatement:
     case SyntaxKind.ForInStatement:
-    case SyntaxKind.ForOfStatement: {
+    case SyntaxKind.ForOfStatement:
+    case SyntaxKind.ClassStaticBlockDeclaration: {
       const locals = getLocals(node);
       return locals !== undefined && locals.size !== 0;
     }
@@ -319,6 +313,7 @@ function checkUnusedIdentifiersOfNode(c: Checker, node: Node): void {
     case SyntaxKind.ForStatement:
     case SyntaxKind.ForInStatement:
     case SyntaxKind.ForOfStatement:
+    case SyntaxKind.ClassStaticBlockDeclaration:
       checkUnusedLocalsAndParameters(c, node);
       return;
     case SyntaxKind.Constructor: