tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,152 @@
+import type { ImportDeclaration, ModifierFlags, Node, SourceFile, FileReference } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { ModuleKind } from '../options.js';
+import type { Symbol, SymbolFlags } from '../symbol.js';
+import { EmitResolver } from './emit-resolver.js';
+export declare const enum SymbolAccessibility {
+    Accessible = 0,
+    NotAccessible = 1,
+    CannotBeNamed = 2,
+    NotResolved = 3
+}
+export declare class SymbolAccessibilityResult {
+    readonly accessibility: SymbolAccessibility;
+    /** Unexported declarations (usually imports) to keep because the name refers to them. */
+    readonly aliasesToMakeVisible: Node[];
+    readonly errorSymbolName: string;
+    readonly errorNode: Node | undefined;
+    /** The module of an inaccessible symbol, or `''`. */
+    readonly errorModuleName: string;
+    constructor(accessibility: SymbolAccessibility, aliasesToMakeVisible: Node[], errorSymbolName: string, errorNode: Node | undefined, errorModuleName: string);
+}
+export declare function accessible(aliasesToMakeVisible: Node[]): SymbolAccessibilityResult;
+/** Node builder options, as tsgo's `nodebuilder.Flags`; API clients send these values. */
+export declare const enum NodeBuilderFlags {
+    None = 0,
+    NoTruncation = 1,
+    WriteArrayAsGenericType = 2,
+    GenerateNamesForShadowedTypeParams = 4,
+    UseStructuralFallback = 8,
+    ForbidIndexedAccessSymbolReferences = 16,
+    WriteTypeArgumentsOfSignature = 32,
+    UseFullyQualifiedType = 64,
+    UseOnlyExternalAliasing = 128,
+    SuppressAnyReturnType = 256,
+    WriteTypeParametersInQualifiedName = 512,
+    MultilineObjectLiterals = 1024,
+    WriteClassExpressionAsTypeLiteral = 2048,
+    UseTypeOfFunction = 4096,
+    OmitParameterModifiers = 8192,
+    UseAliasDefinedOutsideCurrentScope = 16384,
+    UseSingleQuotesForStringLiteralType = 268435456,
+    NoTypeReduction = 536870912,
+    UseInstantiationExpressions = 1073741824,
+    OmitThisParameter = 33554432,
+    WriteCallStyleSignature = 134217728,
+    AllowThisInObjectLiteral = 32768,
+    AllowQualifiedNameInPlaceOfIdentifier = 65536,
+    AllowAnonymousIdentifier = 131072,
+    AllowEmptyUnionOrIntersection = 262144,
+    AllowEmptyTuple = 524288,
+    AllowUniqueESSymbolType = 1048576,
+    AllowEmptyIndexInfoType = 2097152,
+    AllowNodeModulesRelativePaths = 67108864,
+    IgnoreErrors = 70221824,
+    InObjectTypeLiteral = 4194304,
+    InTypeAlias = 8388608,
+    InInitialEntityName = 16777216,
+    DeclarationEmit = 531469
+}
+/** Node builder options callers inside the compiler use, as tsgo's `nodebuilder.InternalFlags`. */
+export declare const enum NodeBuilderInternalFlags {
+    None = 0,
+    WriteComputedProps = 1,
+    NoSyntacticPrinter = 2,
+    DoNotIncludeSymbolChain = 4,
+    AllowUnresolvedNames = 8
+}
+/**
+ * Receives what the node builder finds while writing a type: symbols it names (to check
+ * their visibility and keep their imports) and places it can't write without inference.
+ */
+export declare abstract class SymbolTracker {
+    /** Checks that `symbol` can be named from `enclosingDeclaration`; true if an error was reported. */
+    abstract trackSymbol(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): boolean;
+    /** Reports a type that `isolatedDeclarations` can't write without inference. */
+    abstract reportInferenceFallback(node: Node): boolean;
+    abstract reportCyclicStructureError(): boolean;
+    abstract reportInaccessibleThisError(): boolean;
+    abstract reportInaccessibleUniqueSymbolError(): boolean;
+    abstract reportLikelyUnsafeImportRequiredError(specifier: string, symbolName: string): boolean;
+    abstract reportNonSerializableProperty(propertyName: string): boolean;
+    abstract reportPrivateInBaseOfClassExpression(propertyName: string): boolean;
+    abstract reportTruncationError(): boolean;
+    /** Reports `augmentingSymbol`'s declarations outside `containingFile` that augment `parentSymbol`. */
+    abstract reportNonlocalAugmentation(containingFile: SourceFile, parentSymbol: Symbol, augmentingSymbol: Symbol): boolean;
+    /** The node errors are reported on while no declaration name applies. */
+    abstract pushErrorFallbackNode(node: Node): boolean;
+    abstract popErrorFallbackNode(): boolean;
+}
+/**
+ * Every query of declaration emit. The checker extends this class; the queries it answers with
+ * types (marked "Types:") are approximated by `SyntacticDeclarationEmitResolver`.
+ *
+ * Nodes passed in are parse tree nodes unless noted. `create*` methods return synthesized type
+ * nodes, or undefined for `any`, and report names they use to `tracker`.
+ */
+export declare abstract class DeclarationEmitResolver extends EmitResolver {
+    /** Marks the declarations named by `export =`, `export default` and `export {}` visible. Once per file. */
+    abstract precalculateDeclarationEmitVisibility(file: SourceFile): boolean;
+    /** Whether a declaration is visible outside its file (exported, global, or marked visible). */
+    abstract isDeclarationVisible(node: Node): boolean;
+    /** Whether the first identifier of an entity name can be named from `enclosingDeclaration`. */
+    abstract isEntityNameVisible(entityName: Node, enclosingDeclaration: Node): SymbolAccessibilityResult;
+    /** Whether `symbol` can be named from `enclosingDeclaration`; aliases to keep are marked visible. */
+    abstract isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasesToMakeVisible: boolean): SymbolAccessibilityResult;
+    /** Whether `name` resolves to anything at `location`. */
+    abstract isNameResolvable(location: Node, name: string): boolean;
+    /** Whether an import with no visible bindings must stay because a module augmentation needs it. */
+    abstract isImportRequiredByAugmentation(node: ImportDeclaration): boolean;
+    /** Modifier flags of `node` in `flags`, with the implicit `export` and `declare` of ambient contexts. */
+    abstract getEffectiveDeclarationFlags(node: Node, flags: ModifierFlags): ModifierFlags;
+    /** Whether a function-like with a body is the implementation of an overload set. */
+    abstract isImplementationOfOverload(node: Node): boolean;
+    /** Types: whether a declaration with a computed name has a late-bound (unique symbol or literal) name. */
+    abstract isLateBound(node: Node): boolean;
+    /** Whether `node` is `Symbol.x` or `globalThis.Symbol.x` for the global `Symbol`. */
+    abstract isDefinitelyReferenceToGlobalSymbolObject(node: Node): boolean;
+    /** Types: whether a `const` or `readonly` declaration has a fresh literal type, printed as its initializer. */
+    abstract isLiteralConstDeclaration(node: Node): boolean;
+    /** Types: whether a parameter is optional in its signature. */
+    abstract isOptionalParameter(node: Node): boolean;
+    /** Types: whether a parameter's type needs `| undefined` added (initialized before a required one). */
+    abstract requiresAddingImplicitUndefined(node: Node, enclosingDeclaration: Node | undefined): boolean;
+    /** Types: whether a function has properties assigned to it (`f.x = 1`). */
+    abstract isExpandoFunctionDeclaration(node: Node): boolean;
+    /** Types: the declarations of properties assigned to a function. */
+    abstract getExpandoPropertyDeclarations(node: Node): Node[];
+    /** The `resolution-mode` of import attributes, or undefined. */
+    abstract getResolutionModeOverride(node: Node): ModuleKind | undefined;
+    /** The program file a `/// <reference path>` names. */
+    abstract getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined;
+    /** The class member a JavaScript `this.x = …` assignment declares. */
+    abstract getReferencedMemberValueDeclaration(node: Node): Node | undefined;
+    /** Types: whether a `this.x = …` member is already provided by the base class. */
+    abstract isThisPropertyAssignmentDeclarationRedundant(node: Node): boolean;
+    /** The constant property name of an element access, or `''`. */
+    abstract getElementAccessExpressionName(node: Node): string;
+    /** Types: the type of a variable, parameter, property, accessor or export assignment. */
+    abstract createTypeOfDeclaration(context: EmitContext, declaration: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    /** Types: the return type of a signature. */
+    abstract createReturnTypeOfSignatureDeclaration(context: EmitContext, signature: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    /** Types: the type parameters of a signature declared by a JSDoc `@type`. */
+    abstract createTypeParametersOfSignatureDeclaration(context: EmitContext, signature: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node[] | undefined;
+    /** Types: the initializer of a literal const declaration (see `isLiteralConstDeclaration`). */
+    abstract createLiteralConstValue(context: EmitContext, node: Node, tracker: SymbolTracker): Node | undefined;
+    /** Types: the type of an expression, such as a class's `extends` expression. */
+    abstract createTypeOfExpression(context: EmitContext, expression: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    /** Types: index signatures of a class that come from late-bound computed names. */
+    abstract createLateBoundIndexSignatures(context: EmitContext, container: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node[];
+    /** Types: a JSDoc type rewritten as TypeScript, or undefined to fall back to `createTypeOfDeclaration`. */
+    abstract tryJSTypeNodeToTypeNode(context: EmitContext, typeNode: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+}

package/dist/api/compiler/transformers/declarations-resolver.js

@@ -0,0 +1,35 @@
+import { EmitResolver } from './emit-resolver.js';
+export class SymbolAccessibilityResult {
+    accessibility;
+    /** Unexported declarations (usually imports) to keep because the name refers to them. */
+    aliasesToMakeVisible;
+    errorSymbolName;
+    errorNode;
+    /** The module of an inaccessible symbol, or `''`. */
+    errorModuleName;
+    constructor(accessibility, aliasesToMakeVisible, errorSymbolName, errorNode, errorModuleName) {
+        this.accessibility = accessibility;
+        this.aliasesToMakeVisible = aliasesToMakeVisible;
+        this.errorSymbolName = errorSymbolName;
+        this.errorNode = errorNode;
+        this.errorModuleName = errorModuleName;
+    }
+}
+export function accessible(aliasesToMakeVisible) {
+    return new SymbolAccessibilityResult(0 /* SymbolAccessibility.Accessible */, aliasesToMakeVisible, '', undefined, '');
+}
+/**
+ * Receives what the node builder finds while writing a type: symbols it names (to check
+ * their visibility and keep their imports) and places it can't write without inference.
+ */
+export class SymbolTracker {
+}
+/**
+ * Every query of declaration emit. The checker extends this class; the queries it answers with
+ * types (marked "Types:") are approximated by `SyntacticDeclarationEmitResolver`.
+ *
+ * Nodes passed in are parse tree nodes unless noted. `create*` methods return synthesized type
+ * nodes, or undefined for `any`, and report names they use to `tracker`.
+ */
+export class DeclarationEmitResolver extends EmitResolver {
+}

package/dist/api/compiler/transformers/declarations-syntactic.d.ts

@@ -0,0 +1,119 @@
+import { FileReference, Identifier, type ImportDeclaration, ModifierFlags, type Node, SourceFile, type EntityName } from '../ast.js';
+import type { CompilerOptions, ModuleKind } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { Symbol, SymbolFlags } from '../symbol.js';
+import type { SyntacticEmitResolver } from './emit-resolver.js';
+import type { TypeReferenceSerializationKind } from './type-serialization.js';
+import type { Evaluation } from './reference-resolver.js';
+import { DeclarationEmitResolver, NodeBuilderFlags, SymbolAccessibilityResult, type SymbolTracker } from './declarations-resolver.js';
+/** How much of a file's declaration types needed inference. */
+export declare class InferenceCounts {
+    /** Types without annotations or literal initializers. */
+    fallbacks: number;
+    /** Of those, the ones written as `any` because only the checker knows them. */
+    unresolved: number;
+    constructor();
+}
+/**
+ * The files of a program by path and its globals merged across script files, as declaration emit
+ * without the checker resolves names. Read-only once built, so checker threads can share one.
+ */
+export declare class DeclarationGlobals {
+    readonly filesByPath: Map<string, SourceFile>;
+    readonly globals: Map<string, Symbol>;
+    /** Global symbols merged across files, by each file's symbol. */
+    readonly mergedSymbols: Map<Symbol, Symbol>;
+    constructor(files: readonly SourceFile[], currentDirectory: string);
+}
+export declare class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
+    readonly options: CompilerOptions;
+    readonly strictNullChecks: boolean;
+    private readonly emitResolver;
+    private readonly names;
+    private readonly pseudo;
+    private readonly filesByPath;
+    private readonly visibility;
+    private readonly aliasesMarked;
+    /** Inference counts by file. */
+    readonly inference: Map<SourceFile, InferenceCounts>;
+    /**
+     * `emitResolver` answers the queries of JavaScript emit and enum values. `indexed` is the program's
+     * `DeclarationGlobals` if they were built before; otherwise they are built from `files`.
+     */
+    constructor(options: CompilerOptions, files: readonly SourceFile[], currentDirectory: string, emitResolver: SyntacticEmitResolver, indexed?: DeclarationGlobals | undefined);
+    markLinkedReferences(file: SourceFile): boolean;
+    isReferencedAliasDeclaration(node: Node): boolean;
+    isValueAliasDeclaration(node: Node): boolean;
+    isTopLevelValueImportEqualsWithEntityName(node: Node): boolean;
+    precalculateDeclarationEmitVisibility(file: SourceFile): boolean;
+    /** Marks the declarations an export names visible, following `import x = a.b` chains. */
+    markLinkedAliases(node: Node): boolean;
+    isDeclarationVisible(node: Node): boolean;
+    private determineIfDeclarationIsVisible;
+    isEntityNameVisible(entityName: Node, enclosingDeclaration: Node): SymbolAccessibilityResult;
+    isSymbolAccessible(symbol: Symbol, _enclosingDeclaration: Node, _meaning: SymbolFlags, shouldComputeAliasesToMakeVisible: boolean): SymbolAccessibilityResult;
+    /** Accessible if every declaration is visible or can be made so by keeping an unexported statement. */
+    private hasVisibleDeclarations;
+    isNameResolvable(location: Node, name: string): boolean;
+    isImportRequiredByAugmentation(_node: ImportDeclaration): boolean;
+    getEffectiveDeclarationFlags(node: Node, flags: ModifierFlags): ModifierFlags;
+    isImplementationOfOverload(node: Node): boolean;
+    isLateBound(node: Node): boolean;
+    /** Whether a computed name's expression has a unique symbol or literal type, as far as declarations say. */
+    private isLateBindableExpression;
+    /** The declaration `a` or `a.b.c` names: a variable, a member of a namespace, class or enum, or of an object type or literal. */
+    private getEntityDeclaration;
+    isDefinitelyReferenceToGlobalSymbolObject(node: Node): boolean;
+    /** Whether `name` at `location` resolves to a declaration of a global file. */
+    private isGlobalValue;
+    isLiteralConstDeclaration(node: Node): boolean;
+    isOptionalParameter(node: Node): boolean;
+    requiresAddingImplicitUndefined(node: Node, enclosingDeclaration: Node | undefined): boolean;
+    private isRequiredInitializedParameter;
+    private isOptionalUninitializedParameterProperty;
+    /** Whether an annotation includes `undefined`, or names something unresolved (an error type). */
+    private declaredTypeContainsUndefined;
+    private typeContainsUndefined;
+    isExpandoFunctionDeclaration(node: Node): boolean;
+    getExpandoPropertyDeclarations(node: Node): Node[];
+    getReferencedExportContainer(node: Identifier, prefixLocals: boolean): Node | undefined;
+    getReferencedImportDeclaration(node: Identifier): Node | undefined;
+    getReferencedValueDeclaration(node: Identifier): Node | undefined;
+    getReferencedValueDeclarations(node: Identifier): Node[] | undefined;
+    getEnumMemberValue(member: Node): Evaluation;
+    getConstantValue(node: Node): Evaluation;
+    setReferencedImportDeclaration(name: Identifier, declaration: Node): void;
+    getJsxFactoryEntity(file: SourceFile): EntityName | undefined;
+    getJsxFragmentFactoryEntity(file: SourceFile): EntityName | undefined;
+    getTypeReferenceSerializationKind(typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;
+    getResolutionModeOverride(node: Node): ModuleKind | undefined;
+    getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined;
+    getReferencedMemberValueDeclaration(node: Node): Node | undefined;
+    isThisPropertyAssignmentDeclarationRedundant(_node: Node): boolean;
+    getElementAccessExpressionName(node: Node): string;
+    createTypeOfDeclaration(context: EmitContext, declaration: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    private hasMergedDeclarations;
+    /** Whether a parameter's pseudo-type already has `undefined`, so none is added. */
+    private pseudoContainsUndefined;
+    createReturnTypeOfSignatureDeclaration(context: EmitContext, signature: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    createTypeParametersOfSignatureDeclaration(_context: EmitContext, signature: Node, _enclosingDeclaration: Node, _flags: NodeBuilderFlags, _tracker: SymbolTracker): Node[] | undefined;
+    createLiteralConstValue(context: EmitContext, node: Node, _tracker: SymbolTracker): Node | undefined;
+    createTypeOfExpression(context: EmitContext, expression: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node | undefined;
+    createLateBoundIndexSignatures(context: EmitContext, container: Node, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): Node[];
+    tryJSTypeNodeToTypeNode(_context: EmitContext, typeNode: Node, _enclosingDeclaration: Node, _flags: NodeBuilderFlags, _tracker: SymbolTracker): Node | undefined;
+    /** The symbol of a declaration, merged with same-named globals of other files. */
+    getSymbolOfDeclaration(node: Node): Symbol | undefined;
+    resolveName(location: Node, name: string, meaning: SymbolFlags): Symbol | undefined;
+    /** The symbol of `a` or `a.b.c`, looking members up in namespace and enum exports. */
+    resolveEntityNameExpression(node: Node, meaning: SymbolFlags): Symbol | undefined;
+    /** Records a type that needed inference; `unresolved` if it's written as `any`. */
+    countFallback(node: Node, unresolved: boolean): boolean;
+}
+export declare function tryGetTextOfPropertyName(name: Node): string | undefined;
+/** What a reference to an entity name means: a value, a namespace or a type. */
+export declare function getMeaningOfEntityNameReference(entityName: Node): SymbolFlags;
+export declare function getAnyImportSyntax(node: Node): Node | undefined;
+export declare function isLateVisibilityPaintedStatement(node: Node): boolean;
+/** The node whose scope holds a declaration: a source file, module block or other container. */
+export declare function getDeclarationContainer(node: Node): Node;
+export declare function isExternalModuleAugmentation(node: Node): boolean;