tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,181 @@
+import { type Identifier, type Node, type PatternAmbientModule, type SourceFile, Tristate } from './ast.js';
+import { getSourceFileOfNode } from './binder-utilities.js';
+import { type Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { NameResolver } from './name-resolver.js';
+import { Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
+import { type Checker } from './checker.js';
+import { type Type, type Signature } from './checker-types.js';
+import { getTypeOfSymbol } from './checker-symbol-types.js';
+/** The binder's name resolver with the checker's merging, alias handling and errors. */
+export declare class CheckerNameResolver extends NameResolver {
+    readonly checker: Checker;
+    constructor(checker: Checker);
+    lookup(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol | undefined;
+    getSymbolOfDeclaration(node: Node): Symbol | undefined;
+    error(location: Node, message: DiagnosticMessage, args: readonly string[]): void;
+    symbolReferenced(symbol: Symbol, meaning: SymbolFlags): void;
+    getRequiresScopeChangeCache(node: Node): Tristate;
+    setRequiresScopeChangeCache(node: Node, value: Tristate): void;
+    /**
+     * A property initializer that references a local of the constructor, where the initializer is emitted
+     * when class fields aren't standard: reports a missing `this.` when the name resolves to nothing, else
+     * that the initializer (or the property's type) can't reference it.
+     */
+    onPropertyWithInvalidInitializer(location: Node, name: string, declaration: Node, result: Symbol | undefined): boolean;
+    onFailedToResolveSymbol(location: Node | undefined, name: string, meaning: SymbolFlags, message: DiagnosticMessage): void;
+    onSuccessfullyResolvedSymbol(location: Node | undefined, result: Symbol, meaning: SymbolFlags, lastLocation: Node | undefined, associatedDeclarationForContainingInitializerOrBindingName: Node | undefined, withinDeferredContext: boolean): void;
+}
+export declare function resolveName(c: Checker, location: Node | undefined, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage | undefined, isUse: boolean, excludeGlobals: boolean): Symbol | undefined;
+/** `symbols[name]` (merged) if it has `meaning`, directly or through an alias. */
+export declare function getSymbolOfMeaning(c: Checker, symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol | undefined;
+/** Resolves names to their closest misspelling in scope, for "Did you mean" suggestions. */
+export declare class SuggestionNameResolver extends CheckerNameResolver {
+    lookup(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol | undefined;
+    error(_location: Node, _message: DiagnosticMessage, _args: readonly string[]): void;
+    symbolReferenced(_symbol: Symbol, _meaning: SymbolFlags): void;
+    onFailedToResolveSymbol(_location: Node | undefined, _name: string, _meaning: SymbolFlags, _message: DiagnosticMessage): void;
+}
+/** The symbol whose name is closest to `name` and that has `meaning`, if close enough. */
+export declare function getSpellingSuggestionForName(c: Checker, name: string, symbols: readonly Symbol[], meaning: SymbolFlags): Symbol | undefined;
+/** Changes to a map, recorded so that they can be undone. */
+export declare class TableChanges<K, V> {
+    private readonly added;
+    private readonly replaced;
+    set(table: Map<K, V>, key: K, value: V): void;
+    /** Restores `table`, or a copy of it, to its state before the changes. */
+    undo(table: Map<K, V>): void;
+}
+/**
+ * Globals merged from the locals of a program's leading default libraries. Checkers of programs
+ * with the same libraries start from them; a later merge into a shared symbol merges into a copy.
+ * One checker at a time borrows the tables and changes them in place; the others copy them.
+ */
+export declare class LibGlobals {
+    readonly files: SourceFile[];
+    readonly globals: SymbolTable;
+    readonly mergedSymbols: Map<number, Symbol>;
+    readonly ambientModuleSymbols: Symbol[];
+    readonly patternAmbientModules: PatternAmbientModule[];
+    /** Ids of the symbols merged into each shared symbol. */
+    readonly sources: Map<Symbol, number[]>;
+    /** The checker using `globals` and `mergedSymbols` in place. */
+    borrower: Checker | undefined;
+    constructor(c: Checker, files: SourceFile[]);
+    copyGlobals(): SymbolTable;
+    copyMergedSymbols(): Map<number, Symbol>;
+    /** Whether `files` starts with exactly these `count` libraries. */
+    matches(files: readonly SourceFile[], count: number): boolean;
+}
+/**
+ * The globals, merged symbols and module augmentations of a whole program, as one checker merged
+ * them before checker threads share the program (parallel-check.ts). Other checkers of the program
+ * start from copies of the tables and add the diagnostics the merges reported; the merged symbols
+ * are shared, and a later merge into one merges into a copy.
+ */
+export declare class MergedGlobals {
+    readonly globals: SymbolTable;
+    readonly mergedSymbols: Map<number, Symbol>;
+    readonly ambientModuleSymbols: Symbol[];
+    readonly patternAmbientModules: PatternAmbientModule[];
+    readonly patternAmbientModuleAugmentations: Map<string, Symbol>;
+    /** Whether the global `undefined` is the checker's own (no declaration of `undefined` merged). */
+    readonly ownUndefined: boolean;
+    /** Ids of the symbols merged into each shared symbol. */
+    readonly sources: Map<Symbol, number[]>;
+    /** Copies of the checker's `mergeDiagnostics`. */
+    readonly diagnostics: Diagnostic[][];
+    constructor(c: Checker);
+}
+/**
+ * Shares the globals and module augmentations `c` merged with the other checkers of its program;
+ * `c` treats its merged symbols as shared from now on.
+ */
+export declare function shareMergedGlobals(c: Checker): MergedGlobals;
+/** Drops the shared library globals (a rebuild reparses the library files). */
+export declare function clearLibGlobalsCache(): void;
+/** Drops the shared library globals merged from any of `files`, for a program that is no longer used. */
+export declare function dropLibGlobals(files: readonly SourceFile[]): void;
+/** The shared globals of the checker's default libraries, if another checker merged them. */
+export declare function findLibGlobals(c: Checker): LibGlobals | undefined;
+export declare function borrowLibGlobals(c: Checker, libs: LibGlobals): void;
+/** Undoes a disposed checker's changes to the tables it borrowed. */
+export declare function returnLibGlobals(c: Checker): void;
+export declare function setGlobal(c: Checker, name: string, symbol: Symbol): void;
+/** Merges script locals into globals; ambient modules and augmentations wait for global types. */
+export declare function initializeGlobals(c: Checker): void;
+export declare function mergeAmbientModulesAndAugmentations(c: Checker): void;
+export declare function isAmbientModuleSymbolName(name: string): boolean;
+export declare function mergeSymbolTable(c: Checker, target: SymbolTable, source: SymbolTable, unidirectional: boolean, mergedParent: Symbol | undefined): void;
+/** Merges `source` into `target`, cloning a non-transient target first. */
+export declare function mergeSymbol(c: Checker, target: Symbol, source: Symbol, unidirectional: boolean): Symbol;
+export declare function addDuplicateDeclarationError(c: Checker, node: Node, message: DiagnosticMessage, name: string, relatedNodes: Node[]): void;
+export declare function getExcludedSymbolFlags(flags: SymbolFlags): SymbolFlags;
+export declare function cloneSymbol(c: Checker, symbol: Symbol): Symbol;
+export declare function getMergedSymbol(c: Checker, symbol: Symbol): Symbol;
+export declare function getParentOfSymbol(c: Checker, symbol: Symbol): Symbol | undefined;
+export declare function getExportSymbolOfValueSymbolIfExported(c: Checker, symbol: Symbol): Symbol;
+export declare function getSymbolOfDeclaration(c: Checker, node: Node): Symbol | undefined;
+export declare function getLateBoundSymbol(c: Checker, symbol: Symbol): Symbol;
+export declare function getGlobalSymbol(c: Checker, name: string, meaning: SymbolFlags, diagnostic: DiagnosticMessage | undefined): Symbol | undefined;
+/** The global class or interface `name` with `arity` type parameters, or the empty (generic) object type. */
+export declare function getGlobalType(c: Checker, name: string, arity: number, reportErrors: boolean): Type;
+/** Memoized `getGlobalType`, keyed by name, arity and whether errors were reported. */
+export declare function getCachedGlobalType(c: Checker, name: string, arity: number, reportErrors: boolean): Type;
+export declare function getGlobalTypeAliasSymbol(c: Checker, name: string, arity: number, reportErrors: boolean): Symbol | undefined;
+export declare function getGlobalValueSymbol(c: Checker, name: string, reportErrors: boolean): Symbol | undefined;
+export declare function getGlobalStrictFunctionType(c: Checker, name: string): Type;
+export declare function isNonLocalAlias(symbol: Symbol | undefined, excludes: SymbolFlags): boolean;
+export declare function resolveSymbol(c: Checker, symbol: Symbol | undefined): Symbol | undefined;
+export declare function resolveSymbolEx(c: Checker, symbol: Symbol, dontResolveAlias: boolean): Symbol;
+export declare function getDeclarationOfAliasSymbol(symbol: Symbol): Node | undefined;
+export declare function isAliasSymbolDeclaration(node: Node): boolean;
+/** The alias target, unless resolving it now would be circular. */
+export declare function tryResolveAlias(c: Checker, symbol: Symbol): Symbol | undefined;
+export declare function resolveAlias(c: Checker, symbol: Symbol): Symbol;
+/**
+ * The combined flags of `symbol` and every alias target; All when an alias resolves to unknown. With
+ * `excludeTypeOnlyMeanings`, the chain stops at the first alias with a type-only declaration.
+ */
+export declare function getSymbolFlags(c: Checker, symbol: Symbol, excludeTypeOnlyMeanings?: boolean): SymbolFlags;
+export declare function getExportsOfSymbol(c: Checker, symbol: Symbol): SymbolTable;
+export declare const emptySymbolTable: SymbolTable;
+export declare function getExportsOfModule(c: Checker, moduleSymbol: Symbol): SymbolTable;
+export declare function getMembersOfSymbol(c: Checker, symbol: Symbol): SymbolTable;
+export declare function combineSymbolTables(c: Checker, first: SymbolTable, second: SymbolTable): SymbolTable;
+export declare function isReservedMemberName(name: string): boolean;
+/** Whether `symbol` has a value meaning; one reached through a type-only alias doesn't count. */
+export declare function symbolIsValue(c: Checker, symbol: Symbol): boolean;
+/** Value members other than signatures and index signatures, declared ones first, each part ordered by declaration. */
+export declare function getNamedMembers(c: Checker, members: SymbolTable | undefined, container: Symbol | undefined): Symbol[];
+export declare function getFirstIdentifier(node: Node): Identifier;
+export declare function resolveEntityName(c: Checker, name: Node, meaning: SymbolFlags, ignoreErrors: boolean, dontResolveAlias: boolean, location: Node | undefined): Symbol | undefined;
+/**
+ * `symbol` qualified by its parents. The outermost one is written as seen from `containingLocation`
+ * if given, so that a module is named by a specifier the containing file could import it with.
+ */
+export declare function getFullyQualifiedName(c: Checker, symbol: Symbol, containingLocation?: Node): string;
+export declare function getCannotFindNameDiagnosticForName(c: Checker, node: Node): DiagnosticMessage;
+export declare const enum TypeSystemPropertyName {
+    Type = 0,
+    ResolvedBaseConstructorType = 1,
+    DeclaredType = 2,
+    ResolvedReturnType = 3,
+    ResolvedBaseConstraint = 4,
+    ResolvedTypeArguments = 5,
+    ResolvedBaseTypes = 6,
+    WriteType = 7,
+    InitializerIsUndefined = 8,
+    AliasTarget = 9
+}
+type ResolutionTarget = Symbol | Type | Signature | Node;
+/**
+ * Pushes a resolution of `propertyName` on `target`. When the same resolution is already on the
+ * stack with no resolved entries above it, marks the cycle and returns false.
+ */
+export declare function pushTypeResolution(c: Checker, target: ResolutionTarget, propertyName: TypeSystemPropertyName): boolean;
+/** Pops the last resolution; false if it was part of a cycle. */
+export declare function popTypeResolution(c: Checker): boolean;
+export declare function findResolutionCycleStartIndex(c: Checker, target: ResolutionTarget, propertyName: TypeSystemPropertyName): number;
+export declare function reportCircularityError(c: Checker, symbol: Symbol): Type;
+export { getTypeOfSymbol, getSourceFileOfNode };
+export type { SourceFile };