tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/transformers/reference-resolver.d.ts

@@ -0,0 +1,128 @@
+import { Identifier, type Node, SourceFile } from '../ast.js';
+import { type CompilerOptions } from '../options.js';
+import { Symbol, SymbolFlags, type SymbolTable } from '../symbol.js';
+export declare const enum ConstantKind {
+    None = 0,
+    Number = 1,
+    String = 2
+}
+/** The result of evaluating a constant expression, as the checker's evaluator returns it. */
+export declare class Evaluation {
+    readonly kind: ConstantKind;
+    readonly number: number;
+    readonly string: string;
+    readonly isSyntacticallyString: boolean;
+    readonly resolvedOtherFiles: boolean;
+    readonly hasExternalReferences: boolean;
+    constructor(kind: ConstantKind, numberValue: number, stringValue: string, isSyntacticallyString: boolean, resolvedOtherFiles: boolean, hasExternalReferences: boolean);
+    /** The value as a string, as `+` concatenates it. */
+    text(): string;
+    withFlags(isSyntacticallyString: boolean, resolvedOtherFiles: boolean, hasExternalReferences: boolean): Evaluation;
+}
+export declare function numberEvaluation(value: number): Evaluation;
+export declare function stringEvaluation(value: string, isSyntacticallyString: boolean): Evaluation;
+export declare const noEvaluation: Evaluation;
+/** Finds the program file a module specifier names. */
+export declare abstract class ModuleLookup {
+    /** The file `specifier`, the module name at `location` in `file`, resolves to. */
+    abstract resolveModule(location: Node, file: SourceFile, specifier: string): SourceFile | undefined;
+}
+/** The global symbol table, with declarations of script files merged as the checker merges them. */
+export declare class MergedGlobals {
+    readonly table: SymbolTable;
+    private readonly merged;
+    private aliases;
+    constructor();
+    /** Merges the globals of `files`, resolving aliases they merge with through `aliases`. */
+    merge(files: readonly SourceFile[], aliases: ReferenceResolver): boolean;
+    private mergeFiles;
+    getMergedSymbol(symbol: Symbol): Symbol;
+    private mergeTable;
+    private mergeSymbol;
+}
+export declare class ReferenceResolver {
+    readonly options: CompilerOptions;
+    readonly merged: MergedGlobals;
+    private readonly names;
+    private readonly modules;
+    private readonly enumValues;
+    private readonly computedEnums;
+    private readonly aliasTargets;
+    /** Value symbols of identifiers resolved as expressions, as the checker caches them. */
+    private readonly resolvedSymbols;
+    private readonly unresolvedReferences;
+    private readonly unresolvedAliases;
+    private readonly resolvingAliases;
+    /** The module each module specifier names (`null` for none), by specifier. */
+    private readonly specifierModules;
+    /** Results of `isTypeOnlyAliasChain`, for queries outside alias resolution. */
+    private readonly typeOnlyChains;
+    /** With `merged`, the globals of `files` as another resolver merged them (`EmitIndexes`), not merged again. */
+    constructor(options: CompilerOptions, files: readonly SourceFile[], modules: ModuleLookup | undefined, merged?: MergedGlobals | undefined);
+    getMergedSymbol(symbol: Symbol): Symbol;
+    getSymbolOfDeclaration(node: Node): Symbol | undefined;
+    resolveName(location: Node, name: string, meaning: SymbolFlags): Symbol | undefined;
+    /** The value an identifier in an expression refers to, cached for later queries of the identifier. */
+    getResolvedSymbol(node: Identifier): Symbol | undefined;
+    private getReferencedValueSymbol;
+    private getParentOfSymbol;
+    getExportSymbolOfValueSymbolIfExported(symbol: Symbol): Symbol;
+    /** The source file, namespace or enum whose export `node` refers to, if it refers to an export. */
+    getReferencedExportContainer(node: Identifier, prefixLocals: boolean): Node | undefined;
+    /** The import declaring the alias `node` refers to, unless a local value shadows it. */
+    getReferencedImportDeclaration(node: Identifier): Node | undefined;
+    /** Whether an alias reaches a type-only declaration before a symbol with `meaning`. */
+    private getTypeOnlyAliasDeclarationFor;
+    getReferencedValueDeclaration(node: Identifier): Node | undefined;
+    getReferencedValueDeclarations(node: Identifier): Node[] | undefined;
+    /** The export `name` of a namespace, enum or module. */
+    getExportOfSymbol(symbol: Symbol, name: string): Symbol | undefined;
+    isTypeOnlyAliasSymbol(symbol: Symbol): boolean;
+    /** Whether an alias is declared type-only; as in the checker, a default import counts only if its module resolves. */
+    private isTypeOnlyAlias;
+    /** Whether a module's export `name` comes from another module through an `export type *` on the way. */
+    private isExportedThroughTypeOnlyStar;
+    /** Whether a symbol is declared in the global scope. */
+    isGlobalSymbol(symbol: Symbol): boolean;
+    /** Whether a symbol is a value at runtime: const enums aren't unless preserved. */
+    isValueSymbol(symbol: Symbol): boolean;
+    /** Whether an alias refers to a value, counting unresolved aliases as values; `excludeTypeOnly` stops at type-only imports. */
+    isAliasResolvedToValue(symbol: Symbol, excludeTypeOnly: boolean): boolean;
+    /**
+     * Whether an alias is type-only, itself or through the aliases it directly names. Cached unless an
+     * alias is being resolved, when the answer can depend on which.
+     */
+    isTypeOnlyAliasChain(symbol: Symbol): boolean;
+    private computeTypeOnlyAliasChain;
+    /** The symbol an alias ultimately refers to, or undefined if it can't be resolved. */
+    resolveAlias(symbol: Symbol): Symbol | undefined;
+    /** The flags of a symbol and the aliases it resolves through; all flags for an unresolved alias. */
+    getSymbolFlags(start: Symbol, excludeTypeOnly: boolean, excludeLocal: boolean): SymbolFlags;
+    private getTargetOfAliasDeclaration;
+    /** The module an implicit import of `file`, such as the JSX runtime, refers to. */
+    resolveImplicitImport(file: SourceFile, name: string): Symbol | undefined;
+    /** The module `specifier` names; `location` is in the same file. */
+    private resolveModuleSpecifier;
+    private computeModuleOfSpecifier;
+    /** The `export =` target of a module, or the module itself. */
+    private resolveExternalModuleSymbol;
+    private getExportOfModule;
+    private getExportFromTable;
+    /** The symbol an identifier or dotted name refers to with `meaning`, through aliases unless `dontResolveAlias`. */
+    resolveEntityName(name: Node, meaning: SymbolFlags, dontResolveAlias: boolean): Symbol | undefined;
+    /** The value of an enum member, computing the values of its whole declaration. */
+    getEnumMemberValue(member: Node): Evaluation;
+    /** The inlined value of a const enum member access such as `E.A` or `E["A"]`. */
+    getConstantValue(node: Node): Evaluation;
+    private computeEnumMemberValues;
+    /** Evaluates a constant expression at `location`, as the checker's evaluator does. */
+    evaluate(node: Node, location: Node | undefined): Evaluation;
+    private evaluateBinary;
+    private evaluateTemplate;
+    private evaluateEntity;
+    private evaluateEnumMemberSymbol;
+}
+/** The text of a string literal or no-substitution template literal. */
+export declare function stringLiteralText(node: Node): string | undefined;
+export declare function isEntityNameExpressionNode(node: Node): boolean;
+export declare function getDeclarationOfAliasSymbol(symbol: Symbol): Node | undefined;