tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker.js

@@ -0,0 +1,932 @@
+import { sideOf } from './side-state.js';
+import { CompactSymbolLinkTable, IntLinkTable, LinkTable, SparseLinkTable } from './link-tables.js';
+import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
+import { Diagnostic, compareDiagnostics } from './diagnostics.js';
+import { ModuleKind, ScriptTarget, getEmitScriptTarget, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from './options.js';
+import { Symbol, getSymbolId } from './symbol.js';
+import { IndexInfo, IntrinsicType, LiteralType, NodeLinks, Signature, SymbolLinks, TypeParameter, TypePredicate, emptyTypes, TypeListCache, TypeListTable, } from './checker-types.js';
+import { getBaseTypes } from './checker-declared-types.js';
+import { getFalseTypeFromConditionalType, getTrueTypeFromConditionalType } from './checker-type-operators.js';
+import { createArrayType, createTypeFromGenericGlobalType, getBigIntLiteralType, getNumberLiteralType, getStringLiteralType, getTemplateLiteralType, getUnionType, newAnonymousType, newObjectType, } from './checker-type-factory.js';
+import { CheckerNameResolver, borrowLibGlobals, findLibGlobals, returnLibGlobals, setGlobal, SuggestionNameResolver, getGlobalStrictFunctionType, getGlobalType, initializeGlobals, mergeAmbientModulesAndAugmentations, } from './checker-symbols.js';
+import { PermissiveMapper, ReportingMapper, RestrictiveMapper, UniqueLiteralMapper } from './instantiation.js';
+import { Relation, RelationKey } from './relations.js';
+import { TypeNodeVisitor, checkSourceFile } from './checker-source-file.js';
+import { InferenceCaches } from './checker-inference.js';
+import { AssignmentMarker } from './checker-narrowing.js';
+import { JsxState } from './checker-jsx.js';
+import { SourceFileMetadata, getEmitModuleFormatOfFile } from './program-utilities.js';
+/** What the checker needs from a program. */
+export class CheckerHost {
+    /** How a module name in `file` resolved in `mode`, if the program resolved it. */
+    getResolvedModule(_file, _moduleName, _mode) {
+        return undefined;
+    }
+    /** The program file for a resolved file name, following project reference redirects. */
+    getSourceFileForResolvedModule(_fileName) {
+        return undefined;
+    }
+    /** The resolution mode of the module specifier `location` in `file`. */
+    getModeForUsageLocation(_file, _location) {
+        return ModuleKind.None;
+    }
+    /** The resolution mode of module names in `file` without a specifier of their own. */
+    getDefaultResolutionModeForFile(_file) {
+        return ModuleKind.None;
+    }
+    /** Packages that modules resolved into, by name: whether any of their resolutions was a declaration file. */
+    getPackagesMap() {
+        return new Map();
+    }
+    /** The declaration output of a referenced project's source file, or `''`. */
+    getProjectReferenceOutputDts(_fileName) {
+        return '';
+    }
+    fileExists(_path) {
+        return false;
+    }
+    /** 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) {
+        return undefined;
+    }
+    getJSXRuntimeImportSpecifier(_file) {
+        return undefined;
+    }
+    /** The globals and module augmentations of the program, if a checker merged them for the others. */
+    getMergedGlobals() {
+        return undefined;
+    }
+    /** The format `file` is emitted in when it differs from `module`, else `None`. */
+    getImpliedNodeFormatForEmit(_file) {
+        return ModuleKind.None;
+    }
+    /** The module syntax (`ESNext` or `CommonJS`) of the import or export with module specifier `usage`. */
+    getEmitSyntaxForUsageLocation(_file, _usage) {
+        return ModuleKind.None;
+    }
+    /** The `package.json` scope and implied module format of a file, if known. */
+    getSourceFileMetadata(_file) {
+        return undefined;
+    }
+    /** The module format `file` is emitted in. */
+    getEmitModuleFormatOfFile(file) {
+        return getEmitModuleFormatOfFile(file.fileName, this.getCompilerOptions(), this.getSourceFileMetadata(file) ?? new SourceFileMetadata('', '', ModuleKind.None));
+    }
+    /** What module specifier generation needs; without it, specifiers are relative paths. */
+    getModuleSpecifierHost() {
+        return undefined;
+    }
+}
+/** Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection. */
+class DiagnosticCollection {
+    byFile = new Map();
+    sortedFiles = new Set();
+    global = [];
+    globalSorted = true;
+    /** The diagnostics added since `startLog`, while recording. */
+    log = undefined;
+    add(diagnostic) {
+        if (this.log !== undefined)
+            this.log.push(diagnostic);
+        const file = diagnostic.file;
+        if (file === undefined) {
+            this.global.push(diagnostic);
+            this.globalSorted = false;
+            return;
+        }
+        let list = this.byFile.get(file.fileName);
+        if (list === undefined) {
+            list = [];
+            this.byFile.set(file.fileName, list);
+        }
+        list.push(diagnostic);
+        this.sortedFiles.delete(file.fileName);
+    }
+    forFile(fileName) {
+        const list = this.byFile.get(fileName);
+        if (list === undefined)
+            return [];
+        if (!this.sortedFiles.has(fileName)) {
+            stableSort(list);
+            this.sortedFiles.add(fileName);
+        }
+        return list.slice();
+    }
+    count() {
+        let count = this.global.length;
+        for (const list of this.byFile.values())
+            count += list.length;
+        return count;
+    }
+    /** An already reported diagnostic equal to `diagnostic`, if any. */
+    lookup(diagnostic) {
+        const file = diagnostic.file;
+        const list = file === undefined ? this.global : this.byFile.get(file.fileName);
+        if (list === undefined)
+            return undefined;
+        for (const d of list)
+            if (compareDiagnostics(d, diagnostic) === 0)
+                return d;
+        return undefined;
+    }
+    globals() {
+        if (!this.globalSorted) {
+            stableSort(this.global);
+            this.globalSorted = true;
+        }
+        return this.global.slice();
+    }
+    /** Records the diagnostics added from now on. */
+    startLog() {
+        this.log = [];
+    }
+    /** The diagnostics added since `startLog`, in order; stops recording. */
+    takeLog() {
+        const log = this.log;
+        this.log = undefined;
+        return log;
+    }
+}
+function stableSort(list) {
+    // Array.prototype.sort is stable.
+    list.sort(compareDiagnostics);
+}
+/** Maximum depth of nested `typeToString` calls before diagnostics are discarded. */
+export const maxSerializationLevel = 2;
+/**
+ * File positions per symbol id in `ExternalModuleContainerIndex.keys`. Symbol ids are int32, so the
+ * keys stay exact.
+ */
+export const fileIndexScale = 2 ** 21;
+/** The modules that export each symbol, built once from every module's exports. */
+export class ExternalModuleContainerIndex {
+    complete = false;
+    /**
+     * One key per symbol and module that exports it, ascending: the id of the symbol the export
+     * resolves to times `fileIndexScale`, plus the module's file position in `Checker.files`. The
+     * keys of one symbol are contiguous and in program order.
+     */
+    keys = [];
+}
+/** The checker's caches for symbol accessibility. */
+export class SymbolAccessibilityCaches {
+    /** Accessible chains by symbol id, then by `chainCacheKey`. */
+    accessibleChains = new Map();
+    /** Alias symbols of large tables (globals and exports), by table id. */
+    tableAliases = new Map();
+    /** Modules imported by a file that export a symbol, by symbol id then file node id. */
+    containersByFile = new Map();
+    /** All modules that export a symbol, by symbol id. */
+    containers = new Map();
+    /** The modules each symbol is exported from, built on the first search of all modules. */
+    externalModuleContainers = undefined;
+    /** The name tables of named class expressions, by node id. */
+    classExpressionNames = new Map();
+    /** Computed declaration visibility by node id (see isDeclarationVisible), 0 if not computed. */
+    declarationVisibility = new IntLinkTable();
+    /** The checker slots (bit `slot + 1`) whose declaration emit marked a node visible, by node id. */
+    markedSlots = new IntLinkTable();
+    /** The checker slot of the file in declaration emit, -1 before declaration emit. */
+    markedSlot = -1;
+    /** Counts the times declaration emit left a checker slot. */
+    visibilityEpoch = 0;
+    /** The epoch at which each slot (index `slot + 1`) was last left. */
+    slotsLeftAt = [0, 0, 0, 0, 0];
+}
+export class Checker {
+    host;
+    compilerOptions;
+    files;
+    fileIndex;
+    languageVersion;
+    strictNullChecks;
+    strictFunctionTypes;
+    strictBindCallApply;
+    strictPropertyInitialization;
+    strictBuiltinIteratorReturn;
+    noImplicitAny;
+    noImplicitThis;
+    legacyDecorators;
+    useUnknownInCatchVariables;
+    exactOptionalPropertyTypes;
+    isolatedModules;
+    preserveConstEnums;
+    noUncheckedIndexedAccess;
+    // Counters for type and signature ids.
+    typeCount = 0;
+    signatureCount = 0;
+    /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
+    memberPositionsInLists = new Map();
+    /** The property names of the last instantiation of each such list whose table is built on demand. */
+    memberNamesOfLists = new Map();
+    /** Long lists of inherited properties, by name. */
+    propertiesByName = new Map();
+    /** Number of `typeToString` calls in progress. */
+    serializationLevel = 0;
+    /** Whether `globalObjectType` is set; global type lookups before it can't suggest `typeof`. */
+    hasGlobalObjectType = false;
+    /** The node being checked, for errors with no better location. */
+    currentNode = undefined;
+    diagnostics = new DiagnosticCollection();
+    suggestionDiagnostics = new DiagnosticCollection();
+    /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
+    moduleSpecifiers = new Map();
+    /** Specifier generation for hosts without a program. */
+    fallbackModuleSpecifierHost = undefined;
+    // Links of symbols and nodes by symbol and node id (see link-tables.ts). Values that many symbols
+    // or nodes have are columns of their own; the rest share one links object per symbol or node,
+    // created on first use.
+    symbolLinkTable = new SparseLinkTable();
+    nodeLinkTable = new SparseLinkTable();
+    /** The holders of the lazily computed state of types with side state (`sideOf`), by type id. */
+    sideHolders = new LinkTable();
+    /** The same for signatures with side state (`signatureSideOf`), by signature id. */
+    signatureSideHolders = new LinkTable();
+    /** The type of a value symbol. */
+    symbolTypes = new LinkTable();
+    /** For instantiated and synthetic symbols, the symbol they come from. */
+    symbolTargets = new LinkTable();
+    /** The mapper of an instantiated symbol or a mapped type property. */
+    symbolMappers = new LinkTable();
+    /** The literal type of a property name. */
+    symbolNameTypes = new LinkTable();
+    /** The mapped type of a mapped type property, or the union/intersection of a synthetic property. */
+    symbolContainingTypes = new LinkTable();
+    /** The key type of a mapped type property. */
+    symbolKeyTypes = new LinkTable();
+    /** The property a mapped, spread or synthetic property comes from. */
+    symbolSyntheticOrigins = new LinkTable();
+    /** The left and right properties a spread property combines. */
+    symbolLeftSpreads = new LinkTable();
+    symbolRightSpreads = new LinkTable();
+    /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
+    symbolReferenceKinds = new IntLinkTable();
+    /** The resolved symbol of an identifier, entity name or call. */
+    resolvedSymbols = new CompactSymbolLinkTable();
+    /** The resolved type of a type node or expression. */
+    resolvedTypes = new SparseLinkTable();
+    /** The resolved signature of a call-like node or a signature declaration. */
+    resolvedSignatures = new SparseLinkTable();
+    /** Merged symbols, indexed by the id of the symbol merged into them. */
+    mergedSymbols;
+    /** Globals merged from the default libraries, shared with other checkers. */
+    libGlobals;
+    /** The program's globals and module augmentations as another checker merged them, shared with it. */
+    mergedGlobals;
+    /**
+     * The diagnostics and suggestions the merges reported: those of the globals, then those of the
+     * ambient modules and module augmentations.
+     */
+    mergeDiagnostics = [];
+    /**
+     * 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 = undefined;
+    mergedSymbolChanges = undefined;
+    /** This checker's copies of shared symbols, and the symbols they stand for. */
+    sharedSymbolCopies = new Map();
+    /** Accessible symbol chains and declaration visibility, created on first use. */
+    symbolAccessibilityCaches = undefined;
+    // Symbols
+    globals;
+    resolver;
+    undefinedSymbol;
+    argumentsSymbol;
+    requireSymbol;
+    unknownSymbol;
+    globalThisSymbol;
+    unresolvedSymbols = new Map();
+    /** Widening's optional `undefined` properties by the id of the property each is created from. */
+    undefinedProperties = new Map();
+    // Interning tables.
+    stringLiteralTypes = new Map();
+    numberLiteralTypes = new Map();
+    bigintLiteralTypes = new Map();
+    enumLiteralTypes = new Map();
+    uniqueESSymbolTypes = new Map();
+    /** Unions by a hash of their key; `unionTypes` holds the unions whose key hash was taken. */
+    unionTypesByHash = new Map();
+    unionTypes = new Map();
+    unionOfUnionTypes = new Map();
+    /** `unionOfUnionTypes` without an alias, by both ids and the reduction packed into one number. */
+    unionOfUnionTypesById = new Map();
+    intersectionTypes = new TypeListCache();
+    tupleTypes = new Map();
+    indexedAccessTypes = new Map();
+    templateLiteralTypes = new Map();
+    /** Instantiations of template literal types: the instantiated types, tagged with the template's id. */
+    templateLiteralInstantiations = new TypeListCache();
+    /** The type argument lists that references and instantiations keep, one of each (`TypeListTable`). */
+    typeLists = new TypeListTable();
+    stringMappingTypes = new Map();
+    substitutionTypes = new Map();
+    subtypeReductionCache = new TypeListCache();
+    cachedTypes = new Map();
+    /** Cached types by `cachedTypeKey` and by `cachedTypePairKey`, without spelled keys. */
+    cachedTypesById = new Map();
+    cachedTypesByPair = new Map();
+    errorTypes = new Map();
+    // Intrinsic types, created in tsgo's order so ids (the last-resort union order) match.
+    anyType;
+    autoType;
+    wildcardType;
+    blockedStringType;
+    errorType;
+    unresolvedType;
+    nonInferrableAnyType;
+    intrinsicMarkerType;
+    unknownType;
+    undefinedType;
+    undefinedWideningType;
+    missingType;
+    undefinedOrMissingType;
+    optionalType;
+    nullType;
+    nullWideningType;
+    stringType;
+    numberType;
+    bigintType;
+    regularFalseType;
+    falseType;
+    regularTrueType;
+    trueType;
+    booleanType;
+    esSymbolType;
+    voidType;
+    neverType;
+    silentNeverType;
+    implicitNeverType;
+    unreachableNeverType;
+    nonPrimitiveType;
+    stringOrNumberType;
+    stringNumberSymbolType;
+    numberOrBigIntType;
+    numericStringType;
+    templateConstraintType;
+    uniqueLiteralType;
+    emptyObjectType;
+    emptyJsxObjectType;
+    emptyFreshJsxObjectType;
+    emptyTypeLiteralType;
+    unknownEmptyObjectType;
+    unknownUnionType;
+    emptyGenericType;
+    anyFunctionType;
+    noConstraintType;
+    circularConstraintType;
+    resolvingDefaultType;
+    markerSuperType;
+    markerSubType;
+    markerOtherType;
+    markerSuperTypeForCheck;
+    markerSubTypeForCheck;
+    noTypePredicate;
+    anySignature;
+    unknownSignature;
+    resolvingSignature;
+    silentNeverSignature;
+    enumNumberIndexInfo;
+    anyBaseTypeIndexInfo;
+    emptyStringType;
+    zeroType;
+    zeroBigIntType;
+    typeofType;
+    // Mappers that observe the types they map.
+    reportUnreliableMapper;
+    reportUnmeasurableMapper;
+    restrictiveMapper;
+    permissiveMapper;
+    uniqueLiteralMapper;
+    /** Set by the reporting mappers during variance measurement. */
+    reliabilityFlags = 0;
+    // Relations
+    subtypeRelation = new Relation();
+    strictSubtypeRelation = new Relation();
+    assignableRelation = new Relation();
+    comparableRelation = new Relation();
+    identityRelation = new Relation();
+    enumRelation = new Map();
+    /** A relater that is not in use, kept so that relation checks don't allocate one each. */
+    spareRelater = undefined;
+    // Global types, set by `initializeChecker`.
+    globalArrayType;
+    globalObjectType;
+    globalFunctionType;
+    globalCallableFunctionType;
+    globalNewableFunctionType;
+    globalStringType;
+    globalNumberType;
+    globalBooleanType;
+    globalRegExpType;
+    anyArrayType;
+    autoArrayType;
+    globalReadonlyArrayType;
+    anyReadonlyArrayType;
+    globalThisType;
+    /** Lazily resolved global types and symbols, by name. */
+    globalTypeCache = new Map();
+    /** Module namespace types with synthetic defaults, by kind and type id. */
+    moduleTypeCache = new Map();
+    globalSymbolCache = new Map();
+    // Resolution stacks for cycle detection (see pushTypeResolution).
+    resolutionStart = 0;
+    inVarianceComputation = false;
+    // Instantiation
+    instantiationDepth = 0;
+    instantiationCount = 0;
+    /** Instantiations over the checker's lifetime (statistics). */
+    totalInstantiations = 0;
+    /** Mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
+    activeMappers = [];
+    activeMapperDepth = 0;
+    /** Per active mapper: its instantiations by type id, created on the first nested write. */
+    activeMapperCaches = [];
+    /** Per active mapper: its instantiations with an alias, by type id and alias key. */
+    activeMapperAliasCaches = [];
+    /**
+     * Cleared caches of popped mappers, reused as tsgo's pushActiveMapper reuses the maps
+     * popActiveMapper clears: the first `freeMapperCacheCount` are free.
+     */
+    freeMapperCaches = [];
+    freeMapperCacheCount = 0;
+    /** Empty lists for type arguments that are compared with cached instantiations before any is kept. */
+    freeTypeLists = [];
+    /**
+     * 1 by type id for the anonymous and mapped types whose declaration has no outer type parameters
+     * to instantiate (`getObjectTypeInstantiation`).
+     */
+    withoutOuterTypeParameters = new IntLinkTable();
+    conditionalConstraintDepth = 0;
+    suggestionResolver;
+    awaitedTypeStack = [];
+    /** Iteration types by type id and iteration use. */
+    iterationTypesCache = new Map();
+    /** Whether diagnostics can be deferred to the end of the file being checked. */
+    saveDeferredDiagnostics = false;
+    deferredIterationErrors = [];
+    /** Collision checks waiting for the end of the file (checker-generated-code.ts). */
+    deferredCollisionChecks = [];
+    /** Binding patterns whose implied type is being computed as a contextual type. */
+    contextualBindingPatterns = [];
+    /** The binding pattern or assignment pattern that implied each type. */
+    patternForType = new Map();
+    /** Spread element indices of array literals with contextually typed elements. */
+    spreadIndices = new Map();
+    /** Instantiation expression types by node and expression type id. */
+    instantiationExpressionTypes = new Map();
+    relationComparers = [];
+    relationScratchKey = new RelationKey();
+    /** Numbers for relation keys that are spelled as strings (see getRelationKey). */
+    relationKeyIds = new Map();
+    /** Numbers for generic relation keys spelled as tokens, by a hash of the tokens. */
+    relationKeyTokens = new Map();
+    /** The number of interned relation keys of both kinds. */
+    relationKeyCount = 0;
+    markerTypes = new Set();
+    arrayVariances = [1 /* VarianceFlags.Covariant */];
+    nanLiteralType = undefined;
+    /** `{ meta: ImportMeta }`, the type of `import.meta` for symbol queries. */
+    importMetaExpressionType = undefined;
+    // Control flow analysis
+    flowAnalysisDisabled = false;
+    inlineLevel = 0;
+    /**
+     * Shared flow nodes cached by the walks in progress, with their types: the first
+     * `sharedFlowCount` entries are live, later slots are reused.
+     */
+    sharedFlowNodes = [];
+    sharedFlowTypes = [];
+    sharedFlowIncomplete = [];
+    sharedFlowCount = 0;
+    /**
+     * 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.
+     */
+    sharedFlowIndexes = [];
+    /**
+     * Flow states, reused as in tsgo's getFlowState/putFlowState: the first `flowStateDepth` belong
+     * to walks in progress, the rest are free.
+     */
+    flowStates = [];
+    flowStateDepth = 0;
+    flowLoopCaches = new Map();
+    /** The last long walk of each reference key outside loops: see `FlowWalk`. */
+    flowWalks = new Map();
+    flowLoopStack = [];
+    /** Types of expressions whose computation needed flow analysis, outside loop back edges. */
+    flowTypeCache = undefined;
+    flowInvocationCount = 0;
+    /** The reduce labels being passed, innermost last; each limits its target label's antecedents. */
+    flowReduceLabels = [];
+    flowNodeReachable = new Map();
+    flowNodePostSuper = new Map();
+    lastFlowNode = undefined;
+    lastFlowNodeReachable = false;
+    assignmentMarker;
+    primitiveTypeAliasSuggestions = new Map();
+    /** Renamed binding elements in parameters of bodiless signatures, checked for use with their file. */
+    renamedBindingElementsInTypes = [];
+    /** The type parameter whose variance annotation is being checked, to name its marker types. */
+    varianceTypeParameter = undefined;
+    /** Whether the statement being checked is unreachable, to report unreachable code once. */
+    withinUnreachableCode = false;
+    reportedUnreachableNodes = new Set();
+    /** The grammar checker of the file whose expressions are being checked. */
+    grammarChecker = undefined;
+    /** Nodes queued for a deferred check (checkNodeDeferred), each checked once. */
+    deferredNodeIds = new Set();
+    typeNodeVisitor;
+    jsx = new JsxState();
+    /** Per file: its tslib module and the emit helpers checked against it (checkExternalEmitHelpers). */
+    emitHelperFileLinks = new Map();
+    /** The file checkSourceFile is checking. */
+    fileBeingChecked = undefined;
+    // Ambient modules
+    ambientModuleSymbols = [];
+    patternAmbientModules = [];
+    patternAmbientModuleAugmentations = new Map();
+    inferenceCaches = new InferenceCaches();
+    /** The type resolution stack: the first `resolutionDepth` entries are live, later slots are reused. */
+    resolutionTargets = [];
+    resolutionResults = [];
+    resolutionPropertyNames = [];
+    resolutionDepth = 0;
+    /** The number of resolution cycles found (`pushTypeResolution`). */
+    resolutionCycleCount = 0;
+    constructor(host) {
+        this.host = host;
+        const options = host.getCompilerOptions();
+        this.compilerOptions = options;
+        this.files = host.getSourceFiles();
+        this.fileIndex = new Map();
+        for (let i = 0; i < this.files.length; i++)
+            this.fileIndex.set(this.files[i], i);
+        this.languageVersion = getEmitScriptTarget(options);
+        this.strictNullChecks = getStrictOptionValue(options, options.strictNullChecks);
+        this.strictFunctionTypes = getStrictOptionValue(options, options.strictFunctionTypes);
+        this.strictBindCallApply = getStrictOptionValue(options, options.strictBindCallApply);
+        this.strictPropertyInitialization = getStrictOptionValue(options, options.strictPropertyInitialization);
+        this.strictBuiltinIteratorReturn = getStrictOptionValue(options, options.strictBuiltinIteratorReturn);
+        this.noImplicitAny = getStrictOptionValue(options, options.noImplicitAny);
+        this.noImplicitThis = getStrictOptionValue(options, options.noImplicitThis);
+        this.legacyDecorators = options.experimentalDecorators === true;
+        this.useUnknownInCatchVariables = getStrictOptionValue(options, options.useUnknownInCatchVariables);
+        this.exactOptionalPropertyTypes = options.exactOptionalPropertyTypes === true;
+        this.isolatedModules = getIsolatedModules(options);
+        this.preserveConstEnums = shouldPreserveConstEnums(options);
+        this.noUncheckedIndexedAccess = options.noUncheckedIndexedAccess === true;
+        this.undefinedSymbol = this.newSymbol(4 /* SymbolFlags.Property */, 'undefined');
+        this.argumentsSymbol = this.newSymbol(4 /* SymbolFlags.Property */, 'arguments');
+        this.requireSymbol = this.newSymbol(4 /* SymbolFlags.Property */, 'require');
+        this.unknownSymbol = this.newSymbol(4 /* SymbolFlags.Property */, 'unknown');
+        const merged = host.getMergedGlobals();
+        this.mergedGlobals = merged;
+        const libs = merged === undefined ? findLibGlobals(this) : undefined;
+        this.libGlobals = libs;
+        if (merged !== undefined) {
+            this.globals = new Map(merged.globals);
+            this.mergedSymbols = new Map(merged.mergedSymbols);
+        }
+        else if (libs === undefined) {
+            this.globals = new Map();
+            this.mergedSymbols = new Map();
+        }
+        else if (libs.borrower === undefined) {
+            borrowLibGlobals(this, libs);
+            this.globals = libs.globals;
+            this.mergedSymbols = libs.mergedSymbols;
+        }
+        else {
+            this.globals = libs.copyGlobals();
+            this.mergedSymbols = libs.copyMergedSymbols();
+        }
+        this.globalThisSymbol = this.newSymbol(1536 /* SymbolFlags.Module */, 'globalThis');
+        this.globalThisSymbol.checkFlags = 8 /* CheckFlags.Readonly */;
+        this.globalThisSymbol.exports = this.globals;
+        setGlobal(this, this.globalThisSymbol.name, this.globalThisSymbol);
+        this.resolver = new CheckerNameResolver(this);
+        this.suggestionResolver = new SuggestionNameResolver(this);
+        this.typeNodeVisitor = new TypeNodeVisitor(this);
+        this.assignmentMarker = new AssignmentMarker(this);
+        this.anyType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'any', 0 /* ObjectFlags.None */);
+        this.autoType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'any', 262144 /* ObjectFlags.NonInferrableType */);
+        this.wildcardType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'any', 0 /* ObjectFlags.None */);
+        this.blockedStringType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'any', 0 /* ObjectFlags.None */);
+        this.errorType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'error', 0 /* ObjectFlags.None */);
+        this.unresolvedType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'unresolved', 0 /* ObjectFlags.None */);
+        this.nonInferrableAnyType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'any', 65536 /* ObjectFlags.ContainsWideningType */);
+        this.intrinsicMarkerType = this.newIntrinsicType(1 /* TypeFlags.Any */, 'intrinsic', 0 /* ObjectFlags.None */);
+        this.unknownType = this.newIntrinsicType(2 /* TypeFlags.Unknown */, 'unknown', 0 /* ObjectFlags.None */);
+        this.undefinedType = this.newIntrinsicType(4 /* TypeFlags.Undefined */, 'undefined', 0 /* ObjectFlags.None */);
+        this.undefinedWideningType = this.strictNullChecks
+            ? this.undefinedType
+            : this.newIntrinsicType(4 /* TypeFlags.Undefined */, 'undefined', 65536 /* ObjectFlags.ContainsWideningType */);
+        this.missingType = this.newIntrinsicType(4 /* TypeFlags.Undefined */, 'undefined', 0 /* ObjectFlags.None */);
+        this.undefinedOrMissingType = this.exactOptionalPropertyTypes ? this.missingType : this.undefinedType;
+        this.optionalType = this.newIntrinsicType(4 /* TypeFlags.Undefined */, 'undefined', 0 /* ObjectFlags.None */);
+        this.nullType = this.newIntrinsicType(8 /* TypeFlags.Null */, 'null', 0 /* ObjectFlags.None */);
+        this.nullWideningType = this.strictNullChecks
+            ? this.nullType
+            : this.newIntrinsicType(8 /* TypeFlags.Null */, 'null', 65536 /* ObjectFlags.ContainsWideningType */);
+        this.stringType = this.newIntrinsicType(32 /* TypeFlags.String */, 'string', 0 /* ObjectFlags.None */);
+        this.numberType = this.newIntrinsicType(64 /* TypeFlags.Number */, 'number', 0 /* ObjectFlags.None */);
+        this.bigintType = this.newIntrinsicType(128 /* TypeFlags.BigInt */, 'bigint', 0 /* ObjectFlags.None */);
+        this.regularFalseType = this.newLiteralType(8192 /* TypeFlags.BooleanLiteral */, 'false', 0, undefined);
+        this.falseType = this.newLiteralType(8192 /* TypeFlags.BooleanLiteral */, 'false', 0, undefined);
+        this.falseType.regularType = this.regularFalseType;
+        this.regularFalseType.freshType = this.falseType;
+        this.falseType.freshType = this.falseType;
+        this.regularTrueType = this.newLiteralType(8192 /* TypeFlags.BooleanLiteral */, 'true', 0, undefined);
+        this.trueType = this.newLiteralType(8192 /* TypeFlags.BooleanLiteral */, 'true', 0, undefined);
+        this.trueType.regularType = this.regularTrueType;
+        this.regularTrueType.freshType = this.trueType;
+        this.trueType.freshType = this.trueType;
+        this.booleanType = getUnionType(this, [this.regularFalseType, this.regularTrueType]);
+        this.esSymbolType = this.newIntrinsicType(512 /* TypeFlags.ESSymbol */, 'symbol', 0 /* ObjectFlags.None */);
+        this.voidType = this.newIntrinsicType(16 /* TypeFlags.Void */, 'void', 0 /* ObjectFlags.None */);
+        this.neverType = this.newIntrinsicType(262144 /* TypeFlags.Never */, 'never', 0 /* ObjectFlags.None */);
+        this.silentNeverType = this.newIntrinsicType(262144 /* TypeFlags.Never */, 'never', 262144 /* ObjectFlags.NonInferrableType */);
+        this.implicitNeverType = this.newIntrinsicType(262144 /* TypeFlags.Never */, 'never', 0 /* ObjectFlags.None */);
+        this.unreachableNeverType = this.newIntrinsicType(262144 /* TypeFlags.Never */, 'never', 0 /* ObjectFlags.None */);
+        this.nonPrimitiveType = this.newIntrinsicType(131072 /* TypeFlags.NonPrimitive */, 'object', 0 /* ObjectFlags.None */);
+        this.stringOrNumberType = getUnionType(this, [this.stringType, this.numberType]);
+        this.stringNumberSymbolType = getUnionType(this, [this.stringType, this.numberType, this.esSymbolType]);
+        this.numberOrBigIntType = getUnionType(this, [this.numberType, this.bigintType]);
+        this.numericStringType = getTemplateLiteralType(this, ['', ''], [this.numberType]);
+        this.templateConstraintType = getUnionType(this, [
+            this.stringType,
+            this.numberType,
+            this.booleanType,
+            this.bigintType,
+            this.nullType,
+            this.undefinedType,
+        ]);
+        this.uniqueLiteralType = this.newIntrinsicType(262144 /* TypeFlags.Never */, 'never', 0 /* ObjectFlags.None */);
+        this.reportUnreliableMapper = new ReportingMapper(this, 16 /* VarianceReporting.Unreliable */);
+        this.reportUnmeasurableMapper = new ReportingMapper(this, 8 /* VarianceReporting.Unmeasurable */);
+        this.restrictiveMapper = new RestrictiveMapper(this);
+        this.permissiveMapper = new PermissiveMapper(this);
+        this.uniqueLiteralMapper = new UniqueLiteralMapper(this);
+        this.emptyObjectType = newAnonymousType(this, undefined);
+        this.emptyJsxObjectType = newAnonymousType(this, undefined);
+        this.emptyFreshJsxObjectType = newAnonymousType(this, undefined);
+        this.emptyTypeLiteralType = newAnonymousType(this, this.newSymbol(2048 /* SymbolFlags.TypeLiteral */, '￾type'));
+        this.unknownEmptyObjectType = newAnonymousType(this, undefined);
+        this.unknownUnionType = this.strictNullChecks
+            ? getUnionType(this, [this.undefinedType, this.nullType, this.unknownEmptyObjectType])
+            : this.unknownType;
+        this.emptyGenericType = newAnonymousType(this, undefined);
+        sideOf(this, this.emptyGenericType).instantiations = new TypeListCache();
+        this.anyFunctionType = newAnonymousType(this, undefined);
+        this.anyFunctionType.objectFlags |= 262144 /* ObjectFlags.NonInferrableType */;
+        this.noConstraintType = newAnonymousType(this, undefined);
+        this.circularConstraintType = newAnonymousType(this, undefined);
+        this.resolvingDefaultType = newAnonymousType(this, undefined);
+        this.markerSuperType = this.newTypeParameter(undefined);
+        this.markerSubType = this.newTypeParameter(undefined);
+        this.markerSubType.constraint = this.markerSuperType;
+        this.markerOtherType = this.newTypeParameter(undefined);
+        this.markerSuperTypeForCheck = this.newTypeParameter(undefined);
+        this.markerSubTypeForCheck = this.newTypeParameter(undefined);
+        this.markerSubTypeForCheck.constraint = this.markerSuperTypeForCheck;
+        this.noTypePredicate = new TypePredicate(1 /* TypePredicateKind.Identifier */, '<<unresolved>>', 0, this.anyType);
+        this.anySignature = this.newSignature(0 /* SignatureFlags.None */, undefined, emptyTypes, undefined, [], this.anyType, 0);
+        this.unknownSignature = this.newSignature(0 /* SignatureFlags.None */, undefined, emptyTypes, undefined, [], this.errorType, 0);
+        this.resolvingSignature = this.newSignature(0 /* SignatureFlags.None */, undefined, emptyTypes, undefined, [], this.anyType, 0);
+        this.silentNeverSignature = this.newSignature(0 /* SignatureFlags.None */, undefined, emptyTypes, undefined, [], this.silentNeverType, 0);
+        this.enumNumberIndexInfo = new IndexInfo(this.numberType, this.stringType, true, undefined, []);
+        this.anyBaseTypeIndexInfo = new IndexInfo(this.stringType, this.anyType, false, undefined, []);
+        this.emptyStringType = getStringLiteralType(this, '');
+        this.zeroType = getNumberLiteralType(this, 0);
+        this.zeroBigIntType = getBigIntLiteralType(this, '0');
+        const typeofNames = ['bigint', 'boolean', 'function', 'number', 'object', 'string', 'symbol', 'undefined'];
+        const typeofTypes = [];
+        for (const name of typeofNames)
+            typeofTypes.push(getStringLiteralType(this, name));
+        this.typeofType = getUnionType(this, typeofTypes);
+        // initializeChecker
+        this.diagnostics.startLog();
+        this.suggestionDiagnostics.startLog();
+        initializeGlobals(this);
+        this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
+        this.symbolTypes.set(getSymbolId(this.undefinedSymbol), this.undefinedWideningType);
+        this.symbolTypes.set(getSymbolId(this.argumentsSymbol), getGlobalType(this, 'IArguments', 0, true));
+        this.symbolTypes.set(getSymbolId(this.unknownSymbol), this.errorType);
+        this.symbolTypes.set(getSymbolId(this.globalThisSymbol), newObjectType(this, 16 /* ObjectFlags.Anonymous */, this.globalThisSymbol));
+        this.globalArrayType = getGlobalType(this, 'Array', 1, true);
+        this.globalObjectType = getGlobalType(this, 'Object', 0, true);
+        this.hasGlobalObjectType = true;
+        this.globalFunctionType = getGlobalType(this, 'Function', 0, true);
+        this.globalCallableFunctionType = getGlobalStrictFunctionType(this, 'CallableFunction');
+        this.globalNewableFunctionType = getGlobalStrictFunctionType(this, 'NewableFunction');
+        this.globalStringType = getGlobalType(this, 'String', 0, true);
+        this.globalNumberType = getGlobalType(this, 'Number', 0, true);
+        this.globalBooleanType = getGlobalType(this, 'Boolean', 0, true);
+        this.globalRegExpType = getGlobalType(this, 'RegExp', 0, true);
+        this.anyArrayType = createArrayType(this, this.anyType);
+        let autoArrayType = createArrayType(this, this.autoType);
+        // autoArrayType is a marker, so it must be unique even without a global Array type.
+        if (autoArrayType === this.emptyObjectType)
+            autoArrayType = newAnonymousType(this, undefined);
+        this.autoArrayType = autoArrayType;
+        let readonlyArrayType = getGlobalType(this, 'ReadonlyArray', 1, false);
+        if (readonlyArrayType === this.emptyGenericType)
+            readonlyArrayType = this.globalArrayType;
+        this.globalReadonlyArrayType = readonlyArrayType;
+        this.anyReadonlyArrayType = createTypeFromGenericGlobalType(this, readonlyArrayType, [this.anyType]);
+        this.globalThisType = getGlobalType(this, 'ThisType', 1, false);
+        this.diagnostics.startLog();
+        this.suggestionDiagnostics.startLog();
+        mergeAmbientModulesAndAugmentations(this);
+        this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
+    }
+    // ---- Public API
+    /** Checks `file` if needed and returns its semantic diagnostics, sorted. */
+    getDiagnostics(file) {
+        const options = this.compilerOptions;
+        checkSourceFile(this, file, options.noUnusedLocals === true || options.noUnusedParameters === true);
+        return this.diagnostics.forFile(file.fileName);
+    }
+    /** Checks `file`, including unused identifiers, and returns its suggestion diagnostics. */
+    getSuggestionDiagnostics(file) {
+        checkSourceFile(this, file, true);
+        return this.suggestionDiagnostics.forFile(file.fileName);
+    }
+    /** Diagnostics without a file, such as missing global types. */
+    getGlobalDiagnostics() {
+        return this.diagnostics.globals();
+    }
+    // ---- Links
+    /** The rarely used links of `symbol`, created on first use. */
+    symbolLinks(symbol) {
+        const id = getSymbolId(symbol);
+        let links = this.symbolLinkTable.get(id);
+        if (links === undefined) {
+            links = new SymbolLinks();
+            this.symbolLinkTable.set(id, links);
+        }
+        return links;
+    }
+    /** The links of `symbol` if it has any, without creating them. */
+    existingSymbolLinks(symbol) {
+        return this.symbolLinkTable.get(symbol.id);
+    }
+    /** The rarely used links of `node`, created on first use. */
+    nodeLinks(node) {
+        const id = node.id;
+        let links = this.nodeLinkTable.get(id);
+        if (links === undefined) {
+            links = new NodeLinks();
+            this.nodeLinkTable.set(id, links);
+        }
+        return links;
+    }
+    /** The links of `node` if it has any, without creating them. */
+    existingNodeLinks(node) {
+        return this.nodeLinkTable.get(node.id);
+    }
+    // ---- Constructors for types, symbols and signatures
+    nextTypeId() {
+        return ++this.typeCount;
+    }
+    // TypeChecking: for the methods of types tsc-ts's public API calls.
+    baseTypesOf(t) {
+        return getBaseTypes(this, t);
+    }
+    trueTypeOf(t) {
+        return getTrueTypeFromConditionalType(this, t);
+    }
+    falseTypeOf(t) {
+        return getFalseTypeFromConditionalType(this, t);
+    }
+    newIntrinsicType(flags, name, objectFlags) {
+        return new IntrinsicType(flags, objectFlags, this.nextTypeId(), name);
+    }
+    newLiteralType(flags, stringValue, numberValue, symbol) {
+        return new LiteralType(flags, this.nextTypeId(), symbol, stringValue, numberValue);
+    }
+    newTypeParameter(symbol) {
+        return new TypeParameter(this.nextTypeId(), symbol);
+    }
+    newSymbol(flags, name) {
+        const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
+        return symbol;
+    }
+    newSymbolWithCheckFlags(flags, name, checkFlags) {
+        const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
+        symbol.checkFlags = checkFlags;
+        return symbol;
+    }
+    newSignature(flags, declaration, typeParameters, thisParameter, parameters, resolvedReturnType, minArgumentCount) {
+        return new Signature(++this.signatureCount, flags, declaration, typeParameters, thisParameter, parameters, resolvedReturnType, undefined, minArgumentCount);
+    }
+    // ---- Diagnostics
+    /** Reports `message` at `node`, or as a global diagnostic without a node. */
+    error(node, message, ...args) {
+        const diagnostic = createDiagnosticForNode(node, message, args);
+        this.addDiagnostic(diagnostic);
+        return diagnostic;
+    }
+    addDiagnostic(diagnostic) {
+        // Discard diagnostics created while at the maximum number of nested typeToString calls.
+        if (this.serializationLevel < maxSerializationLevel)
+            this.diagnostics.add(diagnostic);
+    }
+    addSuggestion(diagnostic) {
+        this.suggestionDiagnostics.add(diagnostic);
+    }
+    /** Reports an error, or a suggestion when `isError` is false. */
+    addErrorOrSuggestion(isError, diagnostic) {
+        if (isError)
+            this.addDiagnostic(diagnostic);
+        else
+            this.addSuggestion(diagnostic);
+    }
+}
+/**
+ * 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 function disposeChecker(c) {
+    c.symbolLinkTable.clear();
+    c.nodeLinkTable.clear();
+    c.symbolTypes.clear();
+    c.symbolTargets.clear();
+    c.symbolMappers.clear();
+    c.symbolNameTypes.clear();
+    c.symbolContainingTypes.clear();
+    c.symbolKeyTypes.clear();
+    c.symbolSyntheticOrigins.clear();
+    c.symbolLeftSpreads.clear();
+    c.symbolRightSpreads.clear();
+    c.symbolReferenceKinds.clear();
+    c.resolvedSymbols.clear();
+    c.resolvedTypes.clear();
+    c.resolvedSignatures.clear();
+    c.spareRelater = undefined;
+    if (c.globalChanges !== undefined)
+        returnLibGlobals(c);
+    else {
+        c.mergedSymbols.clear();
+        c.globals.clear();
+    }
+    c.sharedSymbolCopies.clear();
+    c.memberPositionsInLists.clear();
+    c.memberNamesOfLists.clear();
+    c.propertiesByName.clear();
+    c.symbolAccessibilityCaches = undefined;
+    c.unresolvedSymbols.clear();
+    c.undefinedProperties.clear();
+    c.stringLiteralTypes.clear();
+    c.numberLiteralTypes.clear();
+    c.bigintLiteralTypes.clear();
+    c.enumLiteralTypes.clear();
+    c.uniqueESSymbolTypes.clear();
+    c.unionTypesByHash.clear();
+    c.unionTypes.clear();
+    c.unionOfUnionTypes.clear();
+    c.unionOfUnionTypesById.clear();
+    c.intersectionTypes.clear();
+    c.tupleTypes.clear();
+    c.indexedAccessTypes.clear();
+    c.templateLiteralTypes.clear();
+    c.templateLiteralInstantiations.clear();
+    c.stringMappingTypes.clear();
+    c.substitutionTypes.clear();
+    c.subtypeReductionCache.clear();
+    c.cachedTypes.clear();
+    c.cachedTypesById.clear();
+    c.cachedTypesByPair.clear();
+    c.iterationTypesCache.clear();
+    c.deferredIterationErrors = [];
+    c.deferredCollisionChecks = [];
+    c.errorTypes.clear();
+    c.globalTypeCache.clear();
+    c.globalSymbolCache.clear();
+    c.markerTypes.clear();
+    c.flowLoopCaches.clear();
+    c.flowWalks.clear();
+    c.flowNodeReachable.clear();
+    c.flowNodePostSuper.clear();
+    c.primitiveTypeAliasSuggestions.clear();
+    c.patternAmbientModuleAugmentations.clear();
+    c.sharedFlowTypes.length = 0;
+    c.relationComparers = [];
+}
+/** A diagnostic at `node`'s error range, or a global one without a node. */
+export function createDiagnosticForNode(node, message, args) {
+    // Without a node, the diagnostic has no file and an empty range at 0, as in tsgo.
+    if (node === undefined)
+        return new Diagnostic(undefined, 0, 0, message, args);
+    const file = getSourceFileOfNode(node);
+    const range = getErrorRangeForNode(file, node);
+    return new Diagnostic(file.diagnosticFile(), range.pos, range.end, message, args);
+}
+/** A message for `chainDiagnostic`-style elaboration; the location is taken from the head. */
+export function messageDiagnostic(message, args) {
+    return new Diagnostic(undefined, 0, 0, message, args);
+}
+export { ScriptTarget };