tsc-ts 0.0.9 → 0.1.0

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

@@ -1,26 +1,27 @@
-import type { DeferredCollisionCheck } from './checker-generated-code.js';
+import type { ModuleSpecifierResult } from './node-builder-names.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
+import { CompactIntLinkTable, CompactLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics } from './diagnostics.js';
 import { type CompilerOptions, ModuleKind, ScriptTarget } from './options.js';
 import { CheckFlags, Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
-import { IndexInfo, IntrinsicType, LiteralType, MemberNames, NodeLinks, ObjectFlags, ObjectType, Signature, SignatureFlags, SymbolLinks, type Type, TypeFlags, TypeMapper, TypeParameter, TypePredicate, VarianceFlags, TypeListCache, TypeListTable, type ConditionalType, type InterfaceType, type TypeChecking } from './checker-types.js';
+import { IndexInfo, IntrinsicType, LiteralType, MemberNames, NamedMemberOrder, NodeLinks, ObjectFlags, ObjectType, Signature, SignatureFlags, SymbolLinks, type Type, TypeFlags, TypeMapper, TypeParameter, TypePredicate, VarianceFlags, TypeListCache, TypeListTable, type ConditionalType, type InterfaceType, type TypeChecking, type ConditionalResultKey, type DistributedConditional } from './checker-types.js';
 import type { ModuleResolution } from './checker-modules.js';
 import { CheckerNameResolver, type LibGlobals, type MergedGlobals, TableChanges, SuggestionNameResolver } from './checker-symbols.js';
-import { Relation, RelationKey, type InternedRelationKey, type Relater, TypeComparer } from './relations.js';
+import { Relation, RelationKey, type InternedRelationKey, type Relater, TypeComparer, type VarianceStackEntry } from './relations.js';
 import { TypeNodeVisitor } from './checker-source-file.js';
 import { InferenceCaches } from './checker-inference.js';
 import { AssignmentMarker, type FlowLoopInfo, type FlowState, type FlowWalk } from './checker-narrowing.js';
 import type { FlowNode, FlowReduceLabel } from './flow.js';
 import { JsxState } from './checker-jsx.js';
-import type { DeferredIterationError, IterationTypes } from './checker-iteration.js';
+import type { IterationTypes } from './checker-iteration.js';
 import type { SpreadIndices } from './checker-contextual.js';
 import { SourceFileMetadata } from './program-utilities.js';
 import type { GrammarChecker } from './checker-grammar.js';
 import type { ResolvedModule } from './module-resolution-types.js';
 import type { ModuleSpecifierHost } from './module-specifiers.js';
 import type { PropertyListIndex } from './checker-members.js';
+import { type ThreadSharing } from './shared-results.js';
 /** What the checker needs from a program. */
 export declare abstract class CheckerHost {
     abstract getCompilerOptions(): CompilerOptions;
@@ -57,20 +58,34 @@ export declare abstract class CheckerHost {
     /** What module specifier generation needs; without it, specifiers are relative paths. */
     getModuleSpecifierHost(): ModuleSpecifierHost | undefined;
 }
-/** Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection. */
+/**
+ * Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection, which keeps one of
+ * each set of equal diagnostics.
+ */
 declare class DiagnosticCollection {
     private readonly byFile;
     private readonly sortedFiles;
     private readonly global;
     private globalSorted;
-    /** The diagnostics added since `startLog`, while recording. */
+    /** The diagnostics at each file, position, end and code, to find an equal one when adding. */
+    private readonly byLocation;
+    /** The diagnostics reported since `startLog`, while recording, also those equal to one already added. */
     private log;
-    add(diagnostic: Diagnostic): void;
+    /** Adds `diagnostic` unless an equal one was added; returns the one the collection holds. */
+    add(diagnostic: Diagnostic): Diagnostic;
     forFile(fileName: string): Diagnostic[];
     count(): number;
     /** An already reported diagnostic equal to `diagnostic`, if any. */
     lookup(diagnostic: Diagnostic): Diagnostic | undefined;
     globals(): Diagnostic[];
+    /** The global diagnostics `withoutNewGlobals` removed. */
+    removedGlobals: number;
+    /** Where results are shared between checker threads (shared-results.ts): every diagnostic added, in order. */
+    added: Diagnostic[] | undefined;
+    /** Runs `run`, then removes the global diagnostics it added. */
+    withoutNewGlobals<T>(run: () => T): T;
+    /** Removes the global diagnostic `diagnostic` from the location index. */
+    private forget;
     /** Records the diagnostics added from now on. */
     startLog(): void;
     /** The diagnostics added since `startLog`, in order; stops recording. */
@@ -143,10 +158,20 @@ export declare class Checker implements TypeChecking {
     readonly memberPositionsInLists: Map<Symbol[], Map<string, number>>;
     /** The property names of the last instantiation of each such list whose table is built on demand. */
     readonly memberNamesOfLists: Map<Symbol[], MemberNames>;
+    /** The property order of the instantiations of each such list (`NamedMemberOrder`); null where it has none. */
+    readonly namedMemberOrdersOfLists: Map<Symbol[], NamedMemberOrder | null>;
     /** Long lists of inherited properties, by name. */
     readonly propertiesByName: Map<Symbol[], Map<string, Symbol>>;
     /** Number of `typeToString` calls in progress. */
     serializationLevel: number;
+    /**
+     * `typeToString` results by type, enclosing declaration, flags and the type parameter of the variance check in
+     * progress: the prints that created no types, which a later print with the same inputs repeats exactly
+     * (`typeToString`).
+     */
+    readonly typeStrings: Map<string, string>;
+    /** `symbolToString` results by symbol, then by enclosing declaration and flags, kept as `typeStrings` are. */
+    readonly symbolStrings: Map<Symbol, Map<string, string>>;
     /** Whether `globalObjectType` is set; global type lookups before it can't suggest `typeof`. */
     hasGlobalObjectType: boolean;
     /** The node being checked, for errors with no better location. */
@@ -163,7 +188,7 @@ export declare class Checker implements TypeChecking {
      */
     modulesMerged: boolean;
     /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
-    readonly moduleSpecifiers: Map<string, string>;
+    readonly moduleSpecifiers: Map<string, ModuleSpecifierResult>;
     /** Specifier generation for hosts without a program. */
     fallbackModuleSpecifierHost: ModuleSpecifierHost | undefined;
     readonly symbolLinkTable: SparseLinkTable<SymbolLinks>;
@@ -184,24 +209,24 @@ export declare class Checker implements TypeChecking {
     /** The mapper of an instantiated symbol or a mapped type property. */
     readonly symbolMappers: LinkTable<TypeMapper>;
     /** The literal type of a property name. */
-    readonly symbolNameTypes: LinkTable<Type>;
+    readonly symbolNameTypes: CompactLinkTable<Type>;
     /** The mapped type of a mapped type property, or the union/intersection of a synthetic property. */
-    readonly symbolContainingTypes: LinkTable<Type>;
+    readonly symbolContainingTypes: CompactLinkTable<Type>;
     /** The key type of a mapped type property. */
-    readonly symbolKeyTypes: LinkTable<Type>;
+    readonly symbolKeyTypes: CompactLinkTable<Type>;
     /** The property a mapped, spread or synthetic property comes from. */
-    readonly symbolSyntheticOrigins: LinkTable<Symbol>;
+    readonly symbolSyntheticOrigins: CompactLinkTable<Symbol>;
     /** The left and right properties a spread property combines. */
-    readonly symbolLeftSpreads: LinkTable<Symbol>;
-    readonly symbolRightSpreads: LinkTable<Symbol>;
+    readonly symbolLeftSpreads: CompactLinkTable<Symbol>;
+    readonly symbolRightSpreads: CompactLinkTable<Symbol>;
     /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
-    readonly symbolReferenceKinds: IntLinkTable;
+    readonly symbolReferenceKinds: CompactIntLinkTable;
     /** The resolved symbol of an identifier, entity name or call. */
-    readonly resolvedSymbols: CompactSymbolLinkTable;
+    readonly resolvedSymbols: CompactLinkTable<Symbol>;
     /** The resolved type of a type node or expression. */
-    readonly resolvedTypes: SparseLinkTable<Type>;
+    readonly resolvedTypes: CompactLinkTable<Type>;
     /** The resolved signature of a call-like node or a signature declaration. */
-    readonly resolvedSignatures: SparseLinkTable<Signature>;
+    readonly resolvedSignatures: CompactLinkTable<Signature>;
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     readonly mergedSymbols: Map<number, Symbol>;
     /**
@@ -364,13 +389,19 @@ export declare class Checker implements TypeChecking {
     readonly moduleTypeCache: Map<string, Type>;
     readonly globalSymbolCache: Map<string, Symbol | null>;
     resolutionStart: number;
-    inVarianceComputation: boolean;
+    /** The generic types whose variances are being computed, outermost first. */
+    varianceStack: VarianceStackEntry[];
     instantiationDepth: number;
+    /** The types being instantiated, outermost first: the first `instantiationDepth` entries are current. */
+    readonly instantiationStack: Type[];
+    /** The calls being resolved, outermost first: the first `callResolutionDepth` entries are current. */
+    readonly callResolutionStack: Node[];
+    callResolutionDepth: number;
     instantiationCount: number;
     /** Instantiations over the checker's lifetime (statistics). */
     totalInstantiations: number;
-    /** Mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
-    readonly activeMappers: TypeMapper[];
+    /** Ids of the mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
+    activeMapperIds: Int32Array<ArrayBuffer>;
     activeMapperDepth: number;
     /** Per active mapper: its instantiations by type id, created on the first nested write. */
     readonly activeMapperCaches: (Map<number, Type> | undefined)[];
@@ -385,20 +416,28 @@ export declare class Checker implements TypeChecking {
     /** Empty lists for type arguments that are compared with cached instantiations before any is kept. */
     readonly freeTypeLists: Type[][];
     /**
-     * 1 by type id for the anonymous and mapped types whose declaration has no outer type parameters
+     * The ids of the anonymous and mapped types whose declaration has no outer type parameters
      * to instantiate (`getObjectTypeInstantiation`).
      */
-    readonly withoutOuterTypeParameters: IntLinkTable;
+    readonly withoutOuterTypeParameters: PagedIdSet;
     conditionalConstraintDepth: number;
     readonly suggestionResolver: SuggestionNameResolver;
     readonly awaitedTypeStack: number[];
     /** Iteration types by type id and iteration use. */
     readonly iterationTypesCache: Map<number, IterationTypes>;
-    /** Whether diagnostics can be deferred to the end of the file being checked. */
-    saveDeferredDiagnostics: boolean;
-    deferredIterationErrors: DeferredIterationError[];
-    /** Collision checks waiting for the end of the file (checker-generated-code.ts). */
-    deferredCollisionChecks: DeferredCollisionCheck[];
+    /**
+     * Diagnostics reported after the checks of the file being checked, or before the next global
+     * diagnostics are read, in the order they were deferred. Reporting them earlier could resolve types
+     * that are being resolved.
+     */
+    deferredDiagnostics: (() => void)[];
+    /** Defers the diagnostic `report` reports at `node` (`deferredDiagnostics`). */
+    deferDiagnostic(node: Node, report: () => void): void;
+    /**
+     * The checked object literals of each file whose members may set deprecated properties of their contextual
+     * types, reported when the file's suggestion diagnostics are asked for (`checkObjectLiteralDeprecations`).
+     */
+    readonly objectLiteralsForDeprecations: Map<SourceFile, Node[]>;
     /** Binding patterns whose implied type is being computed as a contextual type. */
     readonly contextualBindingPatterns: Node[];
     /** The binding pattern or assignment pattern that implied each type. */
@@ -449,11 +488,13 @@ export declare class Checker implements TypeChecking {
     flowTypeCache: Map<Node, Type> | undefined;
     flowInvocationCount: number;
     /** The reduce labels being passed, innermost last; each limits its target label's antecedents. */
-    readonly flowReduceLabels: FlowReduceLabel[];
+    flowReduceLabels: FlowReduceLabel[];
     readonly flowNodeReachable: Map<FlowNode, boolean>;
     readonly flowNodePostSuper: Map<FlowNode, boolean>;
     lastFlowNode: FlowNode | undefined;
     lastFlowNodeReachable: boolean;
+    /** Symbols whose explicit type is being found, for flow analysis of self-referential `for...of`. */
+    readonly resolvingExplicitTypeOfSymbol: Set<Symbol>;
     readonly assignmentMarker: AssignmentMarker;
     readonly primitiveTypeAliasSuggestions: Map<string, Symbol>;
     /** Renamed binding elements in parameters of bodiless signatures, checked for use with their file. */
@@ -476,6 +517,9 @@ export declare class Checker implements TypeChecking {
     readonly ambientModuleSymbols: Symbol[];
     readonly patternAmbientModules: PatternAmbientModule[];
     readonly patternAmbientModuleAugmentations: Map<string, Symbol>;
+    /** The pattern module each entry of `patternAmbientModuleAugmentations` augments. */
+    readonly patternAmbientModuleAugmentationTargets: Map<string, Symbol>;
+    readonly moduleImportAttributesTypes: Map<Symbol, Type>;
     readonly inferenceCaches: InferenceCaches;
     /** The type resolution stack: the first `resolutionDepth` entries are live, later slots are reused. */
     readonly resolutionTargets: (Symbol | Type | Signature | Node)[];
@@ -484,6 +528,27 @@ export declare class Checker implements TypeChecking {
     resolutionDepth: number;
     /** The number of resolution cycles found (`pushTypeResolution`). */
     resolutionCycleCount: number;
+    /**
+     * While an `inferTypesFromUnstarted` walk runs: the unions and intersections whose properties
+     * `hasUnmatchedProperty` searched before they were resolved. Such a search creates fewer types
+     * than one of the resolved properties.
+     */
+    unresolvedPropertySearches: Type[] | undefined;
+    /** TSC_TS_SHARE: the checker thread's sharing with the other checker threads. */
+    threadSharing: ThreadSharing | undefined;
+    /**
+     * Where results are shared (shared-results.ts): for each conditional type made as a member of the distribution of a
+     * conditional type instantiation, that instantiation and the constituent it is for.
+     */
+    distributedConditionals: Map<Type, DistributedConditional> | undefined;
+    /** The same members by `distributedKey`. */
+    distributedByKey: Map<string, Type> | undefined;
+    /** The conditional types conditional type instantiations resolved to, with the instantiation's root and key. */
+    conditionalResults: Map<Type, ConditionalResultKey> | undefined;
+    /** The access flags of the key `getIndexedAccessTypeEx` keeps each indexed access type by. */
+    indexedAccessKeyFlags: Map<Type, number> | undefined;
+    /** Where results are shared between checker threads (shared-results.ts): the file of each diagnostic deferred. */
+    deferredDiagnosticFiles: string[] | undefined;
     constructor(host: CheckerHost);
     /** Checks `file` if needed and returns its semantic diagnostics, sorted. */
     getDiagnostics(file: SourceFile): Diagnostic[];
@@ -491,6 +556,13 @@ export declare class Checker implements TypeChecking {
     getSuggestionDiagnostics(file: SourceFile): Diagnostic[];
     /** Diagnostics without a file, such as missing global types. */
     getGlobalDiagnostics(): Diagnostic[];
+    /**
+     * Runs `run` (such as emitting declarations), then forgets the global diagnostics it reported:
+     * the program collects global diagnostics before it emits.
+     */
+    withoutGlobalDiagnostics<T>(run: () => T): T;
+    /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+    forgottenGlobalDiagnostics(): number;
     /** The rarely used links of `symbol`, created on first use. */
     symbolLinks(symbol: Symbol): SymbolLinks;
     /** The links of `symbol` if it has any, without creating them. */
@@ -511,7 +583,8 @@ export declare class Checker implements TypeChecking {
     newSignature(flags: SignatureFlags, declaration: Node | undefined, typeParameters: Type[], thisParameter: Symbol | undefined, parameters: Symbol[], resolvedReturnType: Type | undefined, minArgumentCount: number): Signature;
     /** Reports `message` at `node`, or as a global diagnostic without a node. */
     error(node: Node | undefined, message: DiagnosticMessage, ...args: string[]): Diagnostic;
-    addDiagnostic(diagnostic: Diagnostic): void;
+    /** Reports `diagnostic`; returns the equal diagnostic already reported, if any, else `diagnostic`. */
+    addDiagnostic(diagnostic: Diagnostic): Diagnostic;
     addSuggestion(diagnostic: Diagnostic): void;
     /** Reports an error, or a suggestion when `isError` is false. */
     addErrorOrSuggestion(isError: boolean, diagnostic: Diagnostic): void;