tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,141 @@
+// Small helpers shared across checker modules.
+import { BinaryExpression, getAsteriskToken, getBody, getExpression, getName, } from './ast.js';
+import { hasSyntacticModifier } from './binder-utilities.js';
+import { isGenericType } from './checker-type-operators.js';
+import { isPatternLiteralType, typesOf } from './checker-type-factory.js';
+import { checkComputedPropertyName, checkExpressionCached } from './checker-expressions.js';
+import { isTypeAssignableTo } from './relations.js';
+export function isTypeUsableAsPropertyName(t) {
+    return (t.flags & 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */) !== 0;
+}
+/** The member name a literal or unique symbol type denotes. */
+export function getPropertyNameFromType(t) {
+    if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+        return t.stringValue;
+    if ((t.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+        return String(t.numberValue);
+    return t.name;
+}
+/** Whether `ToString(ToNumber(name))` is `name`; true for Infinity, -Infinity and NaN. */
+export function isNumericLiteralName(name) {
+    return String(Number(name)) === name;
+}
+/** Names of members keyed by unique symbols. */
+export function isLateBoundName(name) {
+    return name.length >= 2 && name.charCodeAt(0) === 0xfffe && name.charCodeAt(1) === 0x40;
+}
+export function maybeTypeOfKind(t, kind) {
+    if ((t.flags & kind) !== 0)
+        return true;
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0)
+        for (const u of typesOf(t))
+            if (maybeTypeOfKind(u, kind))
+                return true;
+    return false;
+}
+export function isValidIndexKeyType(c, t) {
+    if ((t.flags & (32 /* TypeFlags.String */ | 64 /* TypeFlags.Number */ | 512 /* TypeFlags.ESSymbol */)) !== 0 || isPatternLiteralType(c, t))
+        return true;
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && !isGenericType(c, t))
+        for (const u of typesOf(t))
+            if (isValidIndexKeyType(c, u))
+                return true;
+    return false;
+}
+function isEntityNameExpression(node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return true;
+    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const name = getName(node);
+        return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpression(getExpression(node));
+    }
+    return false;
+}
+function isLateBindableAST(node) {
+    let expr;
+    if (node.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        expr = getExpression(node);
+    else if (node.kind === 213 /* SyntaxKind.ElementAccessExpression */)
+        expr = node.argumentExpression;
+    return expr !== undefined && isEntityNameExpression(expr);
+}
+/** A computed name of entity-name form whose type is a literal or unique symbol. */
+export function hasLateBindableName(c, node) {
+    const name = getLateBindableNameOfDeclaration(node);
+    return name !== undefined && isLateBindableName(c, name);
+}
+/** Whether a computed name or `F[name]` target has a unique symbol or literal type. */
+export function isLateBindableName(c, name) {
+    if (!isLateBindableAST(name))
+        return false;
+    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        return isTypeUsableAsPropertyName(checkComputedPropertyName(c, name));
+    return isTypeUsableAsPropertyName(checkExpressionCached(c, name.argumentExpression));
+}
+/** The name of a member, or the `F[name]` target of a JavaScript element access assignment. */
+export function getLateBindableNameOfDeclaration(node) {
+    return node instanceof BinaryExpression ? node.left : getName(node);
+}
+export function hasLateBindableIndexSignature(c, node) {
+    const name = getName(node);
+    if (name === undefined || !isLateBindableAST(name) || name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+        return false;
+    return isTypeAssignableTo(c, checkComputedPropertyName(c, name), c.stringNumberSymbolType);
+}
+/** Whether a declaration's name is a computed name that isn't a literal. */
+export function hasDynamicName(node) {
+    const name = getName(node);
+    if (name === undefined || name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+        return false;
+    const e = getExpression(name);
+    return !(e.kind === 10 /* SyntaxKind.StringLiteral */ ||
+        e.kind === 8 /* SyntaxKind.NumericLiteral */ ||
+        e.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */);
+}
+/** Whether a function-like declaration is async and/or a generator. */
+export function getFunctionFlags(node) {
+    if (node === undefined)
+        return 4 /* FunctionFlags.Invalid */;
+    let flags = 0 /* FunctionFlags.Normal */;
+    switch (node.kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            if (getAsteriskToken(node) !== undefined)
+                flags |= 1 /* FunctionFlags.Generator */;
+            if (hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */))
+                flags |= 2 /* FunctionFlags.Async */;
+            break;
+        case 220 /* SyntaxKind.ArrowFunction */:
+            if (hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */))
+                flags |= 2 /* FunctionFlags.Async */;
+            break;
+    }
+    if (getBody(node) === undefined)
+        flags |= 4 /* FunctionFlags.Invalid */;
+    return flags;
+}
+export function isBindingPattern(node) {
+    return (node !== undefined &&
+        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+}
+/** The index of the node with `node`'s range among `nodes`, which are in source order; -1 if none. */
+export function indexOfNode(nodes, node) {
+    let low = 0;
+    let high = nodes.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        const n = nodes[middle];
+        const order = n.pos !== node.pos ? n.pos - node.pos : n.end - node.end;
+        if (order < 0)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    if (low < nodes.length) {
+        const n = nodes[low];
+        if (n.pos === node.pos && n.end === node.end)
+            return low;
+    }
+    return -1;
+}

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

@@ -0,0 +1,491 @@
+import type { DeferredCollisionCheck } from './checker-generated-code.js';
+import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
+import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
+import { IntLinkTable, LinkTable, 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, type ConditionalType, type InterfaceType, type TypeChecking } from './checker-types.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 { 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 { SpreadIndices } from './checker-contextual.js';
+import type { SlotSiblingProperties } from './checker-symbol-types.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';
+/** What the checker needs from a program. */
+export declare abstract class CheckerHost {
+    abstract getCompilerOptions(): CompilerOptions;
+    /** Every file of the program, libraries first, in program order. */
+    abstract getSourceFiles(): readonly SourceFile[];
+    abstract isSourceFileDefaultLibrary(file: SourceFile): boolean;
+    /** How a module name in `file` resolved in `mode`, if the program resolved it. */
+    getResolvedModule(_file: SourceFile, _moduleName: string, _mode: ModuleKind): ResolvedModule | undefined;
+    /** The program file for a resolved file name, following project reference redirects. */
+    getSourceFileForResolvedModule(_fileName: string): SourceFile | undefined;
+    /** The resolution mode of the module specifier `location` in `file`. */
+    getModeForUsageLocation(_file: SourceFile, _location: Node): ModuleKind;
+    /** The resolution mode of module names in `file` without a specifier of their own. */
+    getDefaultResolutionModeForFile(_file: SourceFile): ModuleKind;
+    /** Packages that modules resolved into, by name: whether any of their resolutions was a declaration file. */
+    getPackagesMap(): ReadonlyMap<string, boolean>;
+    /** The declaration output of a referenced project's source file, or `''`. */
+    getProjectReferenceOutputDts(_fileName: string): string;
+    fileExists(_path: string): boolean;
+    /** The synthetic specifier of a file's implicit JSX runtime import, such as `react/jsx-runtime`, if any. */
+    /** The `tslib` import the program adds to `file` under --importHelpers. */
+    getImportHelpersImportSpecifier(_file: SourceFile): Node | undefined;
+    getJSXRuntimeImportSpecifier(_file: SourceFile): Node | undefined;
+    /** The globals and module augmentations of the program, if a checker merged them for the others. */
+    getMergedGlobals(): MergedGlobals | undefined;
+    /** The format `file` is emitted in when it differs from `module`, else `None`. */
+    getImpliedNodeFormatForEmit(_file: SourceFile): ModuleKind;
+    /** The module syntax (`ESNext` or `CommonJS`) of the import or export with module specifier `usage`. */
+    getEmitSyntaxForUsageLocation(_file: SourceFile, _usage: Node): ModuleKind;
+    /** The `package.json` scope and implied module format of a file, if known. */
+    getSourceFileMetadata(_file: SourceFile): SourceFileMetadata | undefined;
+    /** The module format `file` is emitted in. */
+    getEmitModuleFormatOfFile(file: SourceFile): ModuleKind;
+    /** 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. */
+declare class DiagnosticCollection {
+    private readonly byFile;
+    private readonly sortedFiles;
+    private readonly global;
+    private globalSorted;
+    /** The diagnostics added since `startLog`, while recording. */
+    private log;
+    add(diagnostic: Diagnostic): void;
+    forFile(fileName: string): Diagnostic[];
+    count(): number;
+    /** An already reported diagnostic equal to `diagnostic`, if any. */
+    lookup(diagnostic: Diagnostic): Diagnostic | undefined;
+    globals(): Diagnostic[];
+    /** Records the diagnostics added from now on. */
+    startLog(): void;
+    /** The diagnostics added since `startLog`, in order; stops recording. */
+    takeLog(): Diagnostic[];
+}
+/** Maximum depth of nested `typeToString` calls before diagnostics are discarded. */
+export declare const maxSerializationLevel = 2;
+/** The checker's caches for symbol accessibility. */
+export declare class SymbolAccessibilityCaches {
+    /** Accessible chains by symbol id, then by `chainCacheKey`. */
+    readonly accessibleChains: Map<number, Map<string, Symbol[]>>;
+    /** Alias symbols of large tables (globals and exports), by table id. */
+    readonly tableAliases: Map<number, Symbol[]>;
+    /** Modules imported by a file that export a symbol, by symbol id then file node id. */
+    readonly containersByFile: Map<number, Map<number, Symbol[]>>;
+    /** All modules that export a symbol, by symbol id. */
+    readonly containers: Map<number, Symbol[]>;
+    /** The name tables of named class expressions, by node id. */
+    readonly classExpressionNames: Map<number, SymbolTable>;
+    /** Computed declaration visibility by node id (see isDeclarationVisible), 0 if not computed. */
+    readonly declarationVisibility: IntLinkTable;
+    /** The checker slots (bit `slot + 1`) whose declaration emit marked a node visible, by node id. */
+    readonly markedSlots: IntLinkTable;
+    /** The checker slot of the file in declaration emit, -1 before declaration emit. */
+    markedSlot: number;
+    /** Counts the times declaration emit left a checker slot. */
+    visibilityEpoch: number;
+    /** The epoch at which each slot (index `slot + 1`) was last left. */
+    readonly slotsLeftAt: number[];
+}
+export declare class Checker implements TypeChecking {
+    readonly host: CheckerHost;
+    readonly compilerOptions: CompilerOptions;
+    readonly files: readonly SourceFile[];
+    readonly fileIndex: Map<SourceFile, number>;
+    readonly languageVersion: ScriptTarget;
+    readonly strictNullChecks: boolean;
+    readonly strictFunctionTypes: boolean;
+    readonly strictBindCallApply: boolean;
+    readonly strictPropertyInitialization: boolean;
+    readonly strictBuiltinIteratorReturn: boolean;
+    readonly noImplicitAny: boolean;
+    readonly noImplicitThis: boolean;
+    readonly legacyDecorators: boolean;
+    readonly useUnknownInCatchVariables: boolean;
+    readonly exactOptionalPropertyTypes: boolean;
+    readonly isolatedModules: boolean;
+    readonly preserveConstEnums: boolean;
+    readonly noUncheckedIndexedAccess: boolean;
+    typeCount: number;
+    signatureCount: number;
+    /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
+    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>;
+    /** Long lists of inherited properties, by name. */
+    readonly propertiesByName: Map<Symbol[], Map<string, Symbol>>;
+    /** Number of `typeToString` calls in progress. */
+    serializationLevel: number;
+    /** 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. */
+    currentNode: Node | undefined;
+    readonly diagnostics: DiagnosticCollection;
+    readonly suggestionDiagnostics: DiagnosticCollection;
+    /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
+    readonly moduleSpecifiers: Map<string, string>;
+    /** Specifier generation for hosts without a program. */
+    fallbackModuleSpecifierHost: ModuleSpecifierHost | undefined;
+    readonly symbolLinkTable: SparseLinkTable<SymbolLinks>;
+    readonly nodeLinkTable: SparseLinkTable<NodeLinks>;
+    /** The holders of the lazily computed state of types with side state (`sideOf`), by type id. */
+    readonly sideHolders: LinkTable<Type>;
+    /** The same for signatures with side state (`signatureSideOf`), by signature id. */
+    readonly signatureSideHolders: LinkTable<Signature>;
+    /** The type of a value symbol. */
+    readonly symbolTypes: LinkTable<Type>;
+    /** For instantiated and synthetic symbols, the symbol they come from. */
+    readonly symbolTargets: LinkTable<Symbol>;
+    /** 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>;
+    /** The mapped type of a mapped type property, or the union/intersection of a synthetic property. */
+    readonly symbolContainingTypes: LinkTable<Type>;
+    /** The key type of a mapped type property. */
+    readonly symbolKeyTypes: LinkTable<Type>;
+    /** The property a mapped, spread or synthetic property comes from. */
+    readonly symbolSyntheticOrigins: LinkTable<Symbol>;
+    /** The left and right properties a spread property combines. */
+    readonly symbolLeftSpreads: LinkTable<Symbol>;
+    readonly symbolRightSpreads: LinkTable<Symbol>;
+    /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
+    readonly symbolReferenceKinds: IntLinkTable;
+    /** The resolved symbol of an identifier, entity name or call. */
+    readonly resolvedSymbols: SparseLinkTable<Symbol>;
+    /** The resolved type of a type node or expression. */
+    readonly resolvedTypes: SparseLinkTable<Type>;
+    /** The resolved signature of a call-like node or a signature declaration. */
+    readonly resolvedSignatures: SparseLinkTable<Signature>;
+    /** Merged symbols, indexed by the id of the symbol merged into them. */
+    readonly mergedSymbols: Map<number, Symbol>;
+    /** Globals merged from the default libraries, shared with other checkers. */
+    libGlobals: LibGlobals | undefined;
+    /** The program's globals and module augmentations as another checker merged them, shared with it. */
+    mergedGlobals: MergedGlobals | undefined;
+    /**
+     * The diagnostics and suggestions the merges reported: those of the globals, then those of the
+     * ambient modules and module augmentations.
+     */
+    readonly mergeDiagnostics: Diagnostic[][];
+    /**
+     * This checker's changes to `globals` and `mergedSymbols` when it uses the tables of
+     * `libGlobals` in place rather than copies; they are undone when it is disposed.
+     */
+    globalChanges: TableChanges<string, Symbol> | undefined;
+    mergedSymbolChanges: TableChanges<number, Symbol> | undefined;
+    /** This checker's copies of shared symbols, and the symbols they stand for. */
+    readonly sharedSymbolCopies: Map<Symbol, Symbol>;
+    /** Accessible symbol chains and declaration visibility, created on first use. */
+    symbolAccessibilityCaches: SymbolAccessibilityCaches | undefined;
+    readonly globals: SymbolTable;
+    readonly resolver: CheckerNameResolver;
+    readonly undefinedSymbol: Symbol;
+    readonly argumentsSymbol: Symbol;
+    readonly requireSymbol: Symbol;
+    readonly unknownSymbol: Symbol;
+    readonly globalThisSymbol: Symbol;
+    readonly unresolvedSymbols: Map<string, Symbol>;
+    /** Widening's optional `undefined` properties by the id of the property each is created from. */
+    readonly undefinedProperties: Map<number, Symbol>;
+    /** By file and name, the property that widening's optional `undefined` properties are created from. */
+    readonly firstSiblingProperties: Map<SourceFile, Map<string, Node>>;
+    /** By tsgo checker, the first sibling properties of its files (firstSiblingProperty). */
+    readonly slotSiblingProperties: Map<number, SlotSiblingProperties>;
+    readonly stringLiteralTypes: Map<string, LiteralType>;
+    readonly numberLiteralTypes: Map<number, LiteralType>;
+    readonly bigintLiteralTypes: Map<string, LiteralType>;
+    readonly enumLiteralTypes: Map<string, LiteralType>;
+    readonly uniqueESSymbolTypes: Map<Symbol, Type>;
+    /** Unions by a hash of their key; `unionTypes` holds the unions whose key hash was taken. */
+    readonly unionTypesByHash: Map<number, Type>;
+    readonly unionTypes: Map<string, Type>;
+    readonly unionOfUnionTypes: Map<string, Type>;
+    /** `unionOfUnionTypes` without an alias, by both ids and the reduction packed into one number. */
+    readonly unionOfUnionTypesById: Map<number, Type>;
+    readonly intersectionTypes: TypeListCache<Type>;
+    readonly tupleTypes: Map<string, Type>;
+    readonly indexedAccessTypes: Map<string, Type>;
+    readonly templateLiteralTypes: Map<string, Type>;
+    /** Instantiations of template literal types: the instantiated types, tagged with the template's id. */
+    readonly templateLiteralInstantiations: TypeListCache<Type>;
+    readonly stringMappingTypes: Map<string, Type>;
+    readonly substitutionTypes: Map<string, Type>;
+    readonly subtypeReductionCache: TypeListCache<Type[]>;
+    readonly cachedTypes: Map<string, Type>;
+    /** Cached types by `cachedTypeKey` and by `cachedTypePairKey`, without spelled keys. */
+    readonly cachedTypesById: Map<number, Type>;
+    readonly cachedTypesByPair: Map<number, Type>;
+    readonly errorTypes: Map<string, Type>;
+    readonly anyType: IntrinsicType;
+    readonly autoType: IntrinsicType;
+    readonly wildcardType: IntrinsicType;
+    readonly blockedStringType: IntrinsicType;
+    readonly errorType: IntrinsicType;
+    readonly unresolvedType: IntrinsicType;
+    readonly nonInferrableAnyType: IntrinsicType;
+    readonly intrinsicMarkerType: IntrinsicType;
+    readonly unknownType: IntrinsicType;
+    readonly undefinedType: IntrinsicType;
+    readonly undefinedWideningType: IntrinsicType;
+    readonly missingType: IntrinsicType;
+    readonly undefinedOrMissingType: IntrinsicType;
+    readonly optionalType: IntrinsicType;
+    readonly nullType: IntrinsicType;
+    readonly nullWideningType: IntrinsicType;
+    readonly stringType: IntrinsicType;
+    readonly numberType: IntrinsicType;
+    readonly bigintType: IntrinsicType;
+    readonly regularFalseType: LiteralType;
+    readonly falseType: LiteralType;
+    readonly regularTrueType: LiteralType;
+    readonly trueType: LiteralType;
+    readonly booleanType: Type;
+    readonly esSymbolType: IntrinsicType;
+    readonly voidType: IntrinsicType;
+    readonly neverType: IntrinsicType;
+    readonly silentNeverType: IntrinsicType;
+    readonly implicitNeverType: IntrinsicType;
+    readonly unreachableNeverType: IntrinsicType;
+    readonly nonPrimitiveType: IntrinsicType;
+    readonly stringOrNumberType: Type;
+    readonly stringNumberSymbolType: Type;
+    readonly numberOrBigIntType: Type;
+    readonly numericStringType: Type;
+    readonly templateConstraintType: Type;
+    readonly uniqueLiteralType: IntrinsicType;
+    readonly emptyObjectType: ObjectType;
+    readonly emptyJsxObjectType: ObjectType;
+    readonly emptyFreshJsxObjectType: ObjectType;
+    readonly emptyTypeLiteralType: ObjectType;
+    readonly unknownEmptyObjectType: ObjectType;
+    readonly unknownUnionType: Type;
+    readonly emptyGenericType: ObjectType;
+    readonly anyFunctionType: ObjectType;
+    readonly noConstraintType: ObjectType;
+    readonly circularConstraintType: ObjectType;
+    readonly resolvingDefaultType: ObjectType;
+    readonly markerSuperType: TypeParameter;
+    readonly markerSubType: TypeParameter;
+    readonly markerOtherType: TypeParameter;
+    readonly markerSuperTypeForCheck: TypeParameter;
+    readonly markerSubTypeForCheck: TypeParameter;
+    readonly noTypePredicate: TypePredicate;
+    readonly anySignature: Signature;
+    readonly unknownSignature: Signature;
+    readonly resolvingSignature: Signature;
+    readonly silentNeverSignature: Signature;
+    readonly enumNumberIndexInfo: IndexInfo;
+    readonly anyBaseTypeIndexInfo: IndexInfo;
+    readonly emptyStringType: Type;
+    readonly zeroType: Type;
+    readonly zeroBigIntType: Type;
+    readonly typeofType: Type;
+    readonly reportUnreliableMapper: TypeMapper;
+    readonly reportUnmeasurableMapper: TypeMapper;
+    readonly restrictiveMapper: TypeMapper;
+    readonly permissiveMapper: TypeMapper;
+    readonly uniqueLiteralMapper: TypeMapper;
+    /** Set by the reporting mappers during variance measurement. */
+    reliabilityFlags: number;
+    readonly subtypeRelation: Relation;
+    readonly strictSubtypeRelation: Relation;
+    readonly assignableRelation: Relation;
+    readonly comparableRelation: Relation;
+    readonly identityRelation: Relation;
+    readonly enumRelation: Map<string, number>;
+    /** A relater that is not in use, kept so that relation checks don't allocate one each. */
+    spareRelater: Relater | undefined;
+    globalArrayType: Type;
+    globalObjectType: Type;
+    globalFunctionType: Type;
+    globalCallableFunctionType: Type;
+    globalNewableFunctionType: Type;
+    globalStringType: Type;
+    globalNumberType: Type;
+    globalBooleanType: Type;
+    globalRegExpType: Type;
+    anyArrayType: Type;
+    autoArrayType: Type;
+    globalReadonlyArrayType: Type;
+    anyReadonlyArrayType: Type;
+    globalThisType: Type;
+    /** Lazily resolved global types and symbols, by name. */
+    readonly globalTypeCache: Map<string, Map<number, Type>>;
+    /** Module namespace types with synthetic defaults, by kind and type id. */
+    readonly moduleTypeCache: Map<string, Type>;
+    readonly globalSymbolCache: Map<string, Symbol | null>;
+    resolutionStart: number;
+    inVarianceComputation: boolean;
+    instantiationDepth: 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[];
+    activeMapperDepth: number;
+    /** Per active mapper: its instantiations by type id, created on the first nested write. */
+    readonly activeMapperCaches: (Map<number, Type> | undefined)[];
+    /** Per active mapper: its instantiations with an alias, by type id and alias key. */
+    readonly activeMapperAliasCaches: (Map<string, Type> | undefined)[];
+    /**
+     * Cleared caches of popped mappers, reused as tsgo's pushActiveMapper reuses the maps
+     * popActiveMapper clears: the first `freeMapperCacheCount` are free.
+     */
+    readonly freeMapperCaches: Map<number, Type>[];
+    freeMapperCacheCount: number;
+    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[];
+    /** 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. */
+    readonly patternForType: Map<Type, Node>;
+    /** Spread element indices of array literals with contextually typed elements. */
+    readonly spreadIndices: Map<Node, SpreadIndices>;
+    /** Instantiation expression types by node and expression type id. */
+    readonly instantiationExpressionTypes: Map<string, Type>;
+    relationComparers: TypeComparer[];
+    readonly relationScratchKey: RelationKey;
+    /** Numbers for relation keys that are spelled as strings (see getRelationKey). */
+    readonly relationKeyIds: Map<string, number>;
+    /** Numbers for generic relation keys spelled as tokens, by a hash of the tokens. */
+    readonly relationKeyTokens: Map<number, InternedRelationKey>;
+    /** The number of interned relation keys of both kinds. */
+    relationKeyCount: number;
+    readonly markerTypes: Set<Type>;
+    readonly arrayVariances: VarianceFlags[];
+    nanLiteralType: LiteralType | undefined;
+    /** `{ meta: ImportMeta }`, the type of `import.meta` for symbol queries. */
+    importMetaExpressionType: Type | undefined;
+    flowAnalysisDisabled: boolean;
+    inlineLevel: number;
+    /**
+     * Shared flow nodes cached by the walks in progress, with their types: the first
+     * `sharedFlowCount` entries are live, later slots are reused.
+     */
+    readonly sharedFlowNodes: FlowNode[];
+    readonly sharedFlowTypes: Type[];
+    readonly sharedFlowIncomplete: boolean[];
+    sharedFlowCount: number;
+    /**
+     * For each walk in progress, by its depth (`flowStateDepth`), once it has cached
+     * `sharedFlowIndexThreshold` shared nodes: the index of each node's first entry in the cache above.
+     */
+    readonly sharedFlowIndexes: Map<FlowNode, number>[];
+    /**
+     * Flow states, reused as in tsgo's getFlowState/putFlowState: the first `flowStateDepth` belong
+     * to walks in progress, the rest are free.
+     */
+    readonly flowStates: FlowState[];
+    flowStateDepth: number;
+    readonly flowLoopCaches: Map<FlowNode, Map<string, Type>>;
+    /** The last long walk of each reference key outside loops: see `FlowWalk`. */
+    readonly flowWalks: Map<string, FlowWalk>;
+    flowLoopStack: FlowLoopInfo[];
+    /** Types of expressions whose computation needed flow analysis, outside loop back edges. */
+    flowTypeCache: Map<Node, Type> | undefined;
+    flowInvocationCount: number;
+    /** The reduce labels being passed, innermost last; each limits its target label's antecedents. */
+    readonly flowReduceLabels: FlowReduceLabel[];
+    readonly flowNodeReachable: Map<FlowNode, boolean>;
+    readonly flowNodePostSuper: Map<FlowNode, boolean>;
+    lastFlowNode: FlowNode | undefined;
+    lastFlowNodeReachable: boolean;
+    readonly assignmentMarker: AssignmentMarker;
+    readonly primitiveTypeAliasSuggestions: Map<string, Symbol>;
+    /** Renamed binding elements in parameters of bodiless signatures, checked for use with their file. */
+    readonly renamedBindingElementsInTypes: Node[];
+    /** The type parameter whose variance annotation is being checked, to name its marker types. */
+    varianceTypeParameter: Type | undefined;
+    /** Whether the statement being checked is unreachable, to report unreachable code once. */
+    withinUnreachableCode: boolean;
+    readonly reportedUnreachableNodes: Set<Node>;
+    /** The grammar checker of the file whose expressions are being checked. */
+    grammarChecker: GrammarChecker | undefined;
+    /** Nodes queued for a deferred check (checkNodeDeferred), each checked once. */
+    readonly deferredNodeIds: Set<number>;
+    readonly typeNodeVisitor: TypeNodeVisitor;
+    readonly jsx: JsxState;
+    /** Per file: its tslib module and the emit helpers checked against it (checkExternalEmitHelpers). */
+    readonly emitHelperFileLinks: Map<SourceFile, EmitHelperFileLinks>;
+    /** The file checkSourceFile is checking. */
+    fileBeingChecked: SourceFile | undefined;
+    readonly ambientModuleSymbols: Symbol[];
+    readonly patternAmbientModules: PatternAmbientModule[];
+    readonly patternAmbientModuleAugmentations: Map<string, Symbol>;
+    readonly inferenceCaches: InferenceCaches;
+    /** The type resolution stack: the first `resolutionDepth` entries are live, later slots are reused. */
+    readonly resolutionTargets: (Symbol | Type | Signature | Node)[];
+    readonly resolutionResults: boolean[];
+    readonly resolutionPropertyNames: number[];
+    resolutionDepth: number;
+    /** The number of resolution cycles found (`pushTypeResolution`). */
+    resolutionCycleCount: number;
+    constructor(host: CheckerHost);
+    /** Checks `file` if needed and returns its semantic diagnostics, sorted. */
+    getDiagnostics(file: SourceFile): Diagnostic[];
+    /** Checks `file`, including unused identifiers, and returns its suggestion diagnostics. */
+    getSuggestionDiagnostics(file: SourceFile): Diagnostic[];
+    /** Diagnostics without a file, such as missing global types. */
+    getGlobalDiagnostics(): Diagnostic[];
+    /** 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. */
+    existingSymbolLinks(symbol: Symbol): SymbolLinks | undefined;
+    /** The rarely used links of `node`, created on first use. */
+    nodeLinks(node: Node): NodeLinks;
+    /** The links of `node` if it has any, without creating them. */
+    existingNodeLinks(node: Node): NodeLinks | undefined;
+    nextTypeId(): number;
+    baseTypesOf(t: InterfaceType): readonly Type[];
+    trueTypeOf(t: ConditionalType): Type;
+    falseTypeOf(t: ConditionalType): Type;
+    newIntrinsicType(flags: TypeFlags, name: string, objectFlags: ObjectFlags): IntrinsicType;
+    newLiteralType(flags: TypeFlags, stringValue: string, numberValue: number, symbol: Symbol | undefined): LiteralType;
+    newTypeParameter(symbol: Symbol | undefined): TypeParameter;
+    newSymbol(flags: SymbolFlags, name: string): Symbol;
+    newSymbolWithCheckFlags(flags: SymbolFlags, name: string, checkFlags: CheckFlags): Symbol;
+    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;
+    addSuggestion(diagnostic: Diagnostic): void;
+    /** Reports an error, or a suggestion when `isError` is false. */
+    addErrorOrSuggestion(isError: boolean, diagnostic: Diagnostic): void;
+}
+/**
+ * Drops a checker's links and type caches. Native builds free memory by reference counting, and
+ * the checker's caches, types and mappers reference each other; releasing them early lets most of
+ * them go without a cycle collection.
+ */
+export declare function disposeChecker(c: Checker): void;
+export declare const enum VarianceReporting {
+    Unreliable = 16,
+    Unmeasurable = 8
+}
+/** A diagnostic at `node`'s error range, or a global one without a node. */
+export declare function createDiagnosticForNode(node: Node | undefined, message: DiagnosticMessage, args: string[]): Diagnostic;
+/** A message for `chainDiagnostic`-style elaboration; the location is taken from the head. */
+export declare function messageDiagnostic(message: DiagnosticMessage, args: string[]): Diagnostic;
+export { Diagnostics, ScriptTarget };