tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/node-builder.d.ts

@@ -0,0 +1,270 @@
+import { Identifier, type ModifierList, type Node, NodeList, type SourceFile, StringLiteral, Token, TypeParameterDeclaration } from './ast.js';
+import { type Checker } from './checker.js';
+import { ElementFlags, type IndexInfo, Signature, type Type, type TypeMapper, type TypePredicate } from './checker-types.js';
+import { EmitContext } from './printer/emit-context.js';
+import type { NodeFactory } from './printer/factory.js';
+import { type Symbol, SymbolFlags } from './symbol.js';
+import { SyntaxKind } from './syntax-kind.js';
+import { NodeBuilderFlags, NodeBuilderInternalFlags, SymbolAccessibilityResult, SymbolTracker } from './transformers/declarations-resolver.js';
+import { type PseudoChecker } from './transformers/declarations-pseudo.js';
+/** A symbol the builder named, kept with a cached result so it can be tracked again. */
+export declare class TrackedSymbol {
+    readonly symbol: Symbol;
+    readonly enclosingDeclaration: Node | undefined;
+    readonly meaning: SymbolFlags;
+    constructor(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags);
+}
+declare class SerializedTypeEntry {
+    readonly node: Node;
+    readonly truncating: boolean;
+    readonly addedLength: number;
+    readonly trackedSymbols: TrackedSymbol[];
+    constructor(node: Node, truncating: boolean, addedLength: number, trackedSymbols: TrackedSymbol[]);
+}
+/**
+ * What a builder's tracker records for it. The builder and its tracker share it, so the tracker doesn't refer to
+ * the builder: a builder and a tracker that pointed at each other made every builder a reference cycle.
+ */
+export declare class BuilderReports {
+    reportedDiagnostic: boolean;
+    trackedSymbols: TrackedSymbol[];
+}
+/**
+ * The tracker a builder reports to: records the symbols it names and that a diagnostic was
+ * reported (`BuilderReports`), and forwards to the caller's tracker, if any.
+ */
+export declare class BuilderTracker extends SymbolTracker {
+    readonly reports: BuilderReports;
+    readonly inner: SymbolTracker | undefined;
+    constructor(reports: BuilderReports, inner: SymbolTracker | undefined);
+    trackSymbol(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): boolean;
+    reportInferenceFallback(node: Node): boolean;
+    reportCyclicStructureError(): boolean;
+    reportInaccessibleThisError(): boolean;
+    reportInaccessibleUniqueSymbolError(): boolean;
+    reportLikelyUnsafeImportRequiredError(specifier: string, symbolName: string): boolean;
+    reportNonSerializableProperty(propertyName: string): boolean;
+    reportPrivateInBaseOfClassExpression(propertyName: string): boolean;
+    reportTruncationError(): boolean;
+    reportNonlocalAugmentation(containingFile: SourceFile, parentSymbol: Symbol, augmentingSymbol: Symbol): boolean;
+    pushErrorFallbackNode(node: Node): boolean;
+    popErrorFallbackNode(): boolean;
+}
+/** What `signatureToSignatureDeclaration` may add to the declaration. */
+declare class SignatureDeclarationOptions {
+    readonly modifiers: Node[];
+    readonly name: Node | undefined;
+    readonly questionToken: Token | undefined;
+    constructor(modifiers: Node[], name: Node | undefined, questionToken: Token | undefined);
+}
+export declare const enum PropertyNameKind {
+    Identifier = 0,
+    NumericLiteral = 1,
+    StringLiteral = 2
+}
+export declare function classifyPropertyName(name: string, stringNamed: boolean, isMethod: boolean): PropertyNameKind;
+export declare function isNumericLiteralName(name: string): boolean;
+/** One serialization of types to nodes. */
+export declare class NodeBuilder {
+    readonly c: Checker;
+    readonly context: EmitContext;
+    readonly factory: NodeFactory;
+    tracker: SymbolTracker;
+    flags: NodeBuilderFlags;
+    internalFlags: NodeBuilderInternalFlags;
+    approximateLength: number;
+    encounteredError: boolean;
+    truncating: boolean;
+    enclosingDeclaration: Node | undefined;
+    readonly enclosingFile: SourceFile | undefined;
+    inferTypeParameters: Type[];
+    private visitedTypesStore;
+    private symbolDepthStore;
+    /** What its tracker records (`reportedDiagnostic`, `trackedSymbols`). */
+    readonly reports: BuilderReports;
+    mapper: TypeMapper | undefined;
+    private reverseMappedStackStore;
+    private enclosingSymbolTypesStore;
+    suppressReportInferenceFallback: boolean;
+    private remappedSymbolReferencesStore;
+    typeParameterNames: Map<number, Identifier> | undefined;
+    typeParameterNamesByText: Set<string> | undefined;
+    typeParameterNamesByTextNextNameCount: Map<string, number> | undefined;
+    typeParameterSymbolList: Set<number> | undefined;
+    private serializedTypesStore;
+    private fakeScopesStore;
+    /**
+     * Declaration emit's pseudochecker: with it, types of declarations are written from what the
+     * source wrote where that denotes the checker's type.
+     */
+    pseudo: PseudoChecker | undefined;
+    /** Set for declaration emit, which writes unions in an order that doesn't depend on the checker's history. */
+    declarationOrder: boolean;
+    constructor(c: Checker, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags, internalFlags: NodeBuilderInternalFlags, tracker: SymbolTracker | undefined, context?: EmitContext | undefined);
+    get reportedDiagnostic(): boolean;
+    set reportedDiagnostic(value: boolean);
+    get trackedSymbols(): TrackedSymbol[];
+    set trackedSymbols(value: TrackedSymbol[]);
+    get visitedTypes(): Set<number>;
+    /** Nesting depth of each symbol, node or constructor being written. */
+    get symbolDepth(): Map<string, number>;
+    get reverseMappedStack(): Symbol[];
+    /** Types of symbols being written, which may differ from their declared types. */
+    get enclosingSymbolTypes(): Map<number, Type>;
+    get remappedSymbolReferences(): Map<number, Symbol>;
+    /** Serialized types by enclosing declaration id, then type, flags and internal flags. */
+    get serializedTypes(): Map<number, Map<string, SerializedTypeEntry>>;
+    /** The kind of fake scope a block stands for: `params` or `typeParams`. */
+    get fakeScopes(): Map<Node, string>;
+    /** `result`, or undefined if serialization failed. */
+    finish<T>(result: T | undefined): T | undefined;
+    /** Reports a symbol the builder names; without a location it's only recorded. */
+    trackSymbol(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags): void;
+    checkTruncationLength(): boolean;
+    created<T extends Node>(node: T): T;
+    list(nodes: Node[]): NodeList;
+    modifierList(nodes: Node[]): ModifierList | undefined;
+    keyword(kind: SyntaxKind): Node;
+    token(kind: SyntaxKind): Token;
+    identifier(text: string): Identifier;
+    stringLiteral(text: string, isSingleQuote: boolean): StringLiteral;
+    typeReference(name: Node, typeArguments: NodeList | undefined): Node;
+    /** `...`, or `any /*elided*\/` without truncation. */
+    createElidedInformationPlaceholder(): Node;
+    /** Sets the type `symbol` is written with until the returned function restores it. */
+    addSymbolTypeToContext(symbol: Symbol, t: Type): () => void;
+    /** Enters the scope of a signature, returning its exit; `expandedParameters` holds its parameters. */
+    enterSignatureScope(signature: Signature): () => void;
+    /** The parameters of the signature scope entered last. */
+    expandedParameters: Symbol[];
+    /**
+     * Enters a scope introducing parameters and type parameters. Names generated within it don't
+     * consume names outside it. The enclosing declaration gets a fake scope making the parameters
+     * visible, so names they shadow are qualified; it's shared along a chain of scopes.
+     */
+    enterNewScope(declaration: Node | undefined, expandedParams: Symbol[] | undefined, typeParameters: Type[] | undefined, originalParameters: Symbol[] | undefined, mapper: TypeMapper | undefined): () => void;
+    /** Adds the names bound by a destructured parameter; false if `param` isn't one. */
+    private addBindingPatternParameters;
+    private addBindingPattern;
+    /** Adds `names` to the fake scope of `kind` at the enclosing declaration, creating it if needed. */
+    private pushFakeScope;
+    /** The enclosing declaration without fake scopes. */
+    getEnclosingDeclarationIgnoringFakeScope(): Node | undefined;
+    private elidedCount;
+    /** Type nodes of `list`; a bare list (union or intersection members) truncates in the middle. */
+    mapToTypeNodes(list: readonly Type[], isBareList: boolean): NodeList | undefined;
+    typeToTypeNode(type: Type | undefined): Node | undefined;
+    /** Writes `t` with `transform`, eliding its circular references; cached per enclosing declaration. */
+    visitAndTransformType(t: Type, transform: TransformKind): Node | undefined;
+    private typeToTypeNodeOrCircularityElision;
+    private conditionalTypeToTypeNode;
+    private getParentSymbolOfTypeParameter;
+    private typeReferenceToTypeNode;
+    private shouldWriteTypeOfFunctionSymbol;
+    /** The symbol to write `typeof` of for an anonymous type, if any. */
+    private shouldEmitTypeOfSymbol;
+    createAnonymousTypeNode(t: Type, forceClassExpansion: boolean, forceExpansion: boolean): Node | undefined;
+    createTypeNodeFromObjectType(t: Type): Node | undefined;
+    /** The type elements of `t`, whose members are `resolved`. */
+    private createTypeNodesFromResolvedType;
+    private shouldUsePlaceholderForProperty;
+    trackComputedName(accessExpression: Node, enclosingDeclaration: Node | undefined): void;
+    private addPropertyToElementList;
+    setCommentRange(node: Node, range: Node | undefined): void;
+    private isDeclaredInEnclosingFile;
+    private areTriviallySerializableComputedNames;
+    private isTriviallySerializableComputedName;
+    private indexInfoToObjectComputedNamesOrSignatureDeclaration;
+    indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, typeNode: Node | undefined): Node;
+    private isMappedTypeHomomorphic;
+    private isHomomorphicMappedTypeWithNonHomomorphicInstantiation;
+    private createMappedTypeNodeFromType;
+    typeParameterToName(typeParameter: Type): Identifier;
+    private typeParameterShadowsOtherTypeParameterInScope;
+    typeParameterToDeclarationWithConstraint(typeParameter: Type, constraintNode: Node | undefined): TypeParameterDeclaration;
+    typeParameterToDeclaration(parameter: Type): TypeParameterDeclaration;
+    /** The type node for `t`, reusing `typeNode` if it denotes `t`. */
+    private typeToTypeNodeWithPossibleReusableTypeNode;
+    typeParametersToTypeParameterDeclarations(symbol: Symbol): Node[];
+    getTypeParametersOfClassOrInterface(symbol: Symbol): Type[];
+    signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, options: SignatureDeclarationOptions | undefined): Node;
+    private tryGetThisParameterDeclaration;
+    symbolToParameterDeclaration(parameterSymbol: Symbol, preserveModifierFlags: boolean): Node;
+    parameterToParameterDeclarationName(parameterSymbol: Symbol, parameterDeclaration: Node | undefined): Node;
+    /**
+     * A copy of `node`'s subtree without positions, as tsgo's `DeepCloneNode`: each copy has its
+     * node as original, and so its emit flags.
+     */
+    deepCloneNode(node: Node): Node;
+    /** A copy of `node` without positions. */
+    cloneSynthesized(node: Node): Node;
+    /**
+     * The type node for `t` declared by `declaration` (or `symbol`'s declaration). A symbol's own
+     * `unique symbol` type is written as such rather than `typeof symbol`.
+     */
+    serializeTypeForDeclaration(declaration: Node | undefined, type: Type | undefined, symbol: Symbol | undefined, tryReuse: boolean): Node;
+    /** `serializeTypeForDeclaration` with declaration emit's reuse of what the source wrote. */
+    private serializeTypeForDeclarationReusing;
+    /** The return type node of `signature`; `any` is omitted with `SuppressAnyReturnType`. */
+    serializeReturnTypeForSignature(signature: Signature): Node | undefined;
+    /** `serializeReturnTypeForSignature`; with `tryReuse` and a pseudochecker, the source's return type where it matches. */
+    serializeReturnTypeForSignatureEx(signature: Signature, tryReuse: boolean): Node | undefined;
+    private serializeReturnTypeReusing;
+    private serializeInferredReturnTypeForSignature;
+    typePredicateToTypePredicateNode(predicate: TypePredicate): Node;
+    /** The type of a type node, instantiated with the scope's mapper; with `noMappedTypes`, undefined if that changes it. */
+    getTypeFromTypeNode(node: Node, noMappedTypes: boolean): Type | undefined;
+    private typeNodeIsEquivalentToType;
+    tryReuseExistingNonParameterTypeNode(existing: Node, t: Type, host: Node | undefined, annotationType: Type | undefined): Node | undefined;
+    /**
+     * A copy of `range` positioned like `location`: without positions unless both are in the file
+     * being written, with `location` as its original.
+     */
+    setTextRange(range: Node, location: Node | undefined): Node;
+}
+declare const enum TransformKind {
+    Type = 0,
+    TypeReference = 1,
+    Conditional = 2,
+    ObjectType = 3
+}
+/** Whether an existing type reference node can stand for `t`: JS `Foo` meaning `Foo<any>` can't. */
+export declare function canReuseExistingJSTypeNode(b: NodeBuilder, existing: Node, t: Type): boolean;
+/** Drops the positions of a copied subtree; its flags stay those of the original, as in tsgo. */
+export declare function clearPositions(node: Node): void;
+/** Whether a parameter is optional in its signature, as tsgo's `isOptionalParameter`. */
+export declare function isOptionalParameter(c: Checker, node: Node): boolean;
+/** Whether a parameter's written type needs `| undefined`: initialized before a required parameter. */
+export declare function requiresAddingImplicitUndefined(c: Checker, parameter: Node, enclosingDeclaration: Node | undefined): boolean;
+/** Whether the first identifier of an entity name can be named from `enclosingDeclaration`. */
+export declare function isEntityNameVisible(c: Checker, entityName: Node, enclosingDeclaration: Node, shouldComputeAliasesToMakeVisible?: boolean): SymbolAccessibilityResult;
+/**
+ * The parameter lists of a signature with a tuple rest parameter spread into parameters; one
+ * list per member of a union of tuples unless `skipUnionExpanding`.
+ */
+export declare function getExpandedParameters(c: Checker, signature: Signature, skipUnionExpanding: boolean): Symbol[][];
+/** The name a tuple element gets as a parameter. */
+export declare function getTupleElementLabel(c: Checker, flags: ElementFlags, labeledDeclaration: Node | undefined, restSymbol: Symbol | undefined, index: number): string;
+/**
+ * The type node TypeScript would write for `type`. As in tsgo, the builder has a pseudochecker, so types
+ * of declarations are written from what the source wrote where that denotes the type.
+ */
+export declare function typeToTypeNode(c: Checker, type: Type, enclosingDeclaration: Node | undefined, flags: number, internalFlags?: NodeBuilderInternalFlags, tracker?: SymbolTracker | undefined): Node | undefined;
+/** The declaration of kind `kind` TypeScript would write for `signature`, with a pseudochecker as `typeToTypeNode`. */
+export declare function signatureToSignatureDeclaration(c: Checker, signature: Signature, kind: SyntaxKind, enclosingDeclaration: Node | undefined, flags: number, internalFlags?: NodeBuilderInternalFlags, tracker?: SymbolTracker | undefined): Node | undefined;
+/**
+ * `type` as text, printed from its type node as tsgo's `TypeToStringEx` does; `typeFormatFlags`
+ * are `TypeFormatFlags`. Undefined if the builder fails.
+ */
+export declare function typeToStringFromTypeNode(c: Checker, type: Type, enclosingDeclaration: Node | undefined, typeFormatFlags: number): string | undefined;
+/** The index signature TypeScript would write for `info`. */
+export declare function indexInfoToIndexSignatureDeclaration(c: Checker, info: IndexInfo, enclosingDeclaration: Node | undefined, flags: number, tracker: SymbolTracker | undefined): Node | undefined;
+/** The type parameter declaration TypeScript would write for `parameter`. */
+export declare function typeParameterToDeclaration(c: Checker, parameter: Type, enclosingDeclaration: Node | undefined, flags: number, tracker: SymbolTracker | undefined): Node | undefined;
+/** The type predicate node TypeScript would write for `predicate`. */
+export declare function typePredicateToTypePredicateNode(c: Checker, predicate: TypePredicate, enclosingDeclaration: Node | undefined, flags: number, tracker: SymbolTracker | undefined): Node | undefined;
+/** The entity name TypeScript would write for `symbol` with `meaning`. */
+export declare function symbolToEntityName(c: Checker, symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: number, tracker: SymbolTracker | undefined): Node | undefined;
+/** The expression TypeScript would write for `symbol` with `meaning`. */
+export declare function symbolToExpressionNode(c: Checker, symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: number, tracker: SymbolTracker | undefined): Node | undefined;
+export {};