tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/transformers/visitor-hooks.d.ts

@@ -0,0 +1,29 @@
+import { ModifierList, type Node, NodeList } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { NodeFactory } from '../printer/factory.js';
+export declare abstract class VisitorHooks {
+    readonly context: EmitContext;
+    readonly factory: NodeFactory;
+    constructor(context: EmitContext);
+    /** Visits one node: return it, a replacement, a `SyntaxList` of several nodes, or undefined to remove it. */
+    abstract visit(node: Node): Node | undefined;
+    abstract visitEachChild(node: Node): Node;
+    visitNode(node: Node | undefined): Node | undefined;
+    visitToken(node: Node | undefined): Node | undefined;
+    /** The visited nodes, or `nodes` itself if nothing changed. */
+    visitArray(nodes: Node[]): Node[];
+    visitNodes(list: NodeList | undefined): NodeList | undefined;
+    visitModifiers(list: ModifierList | undefined): ModifierList | undefined;
+    liftToBlock(node: Node | undefined): Node;
+    /** A visited statement, as a block if it became several, or undefined if removed. */
+    visitStatement(node: Node | undefined): Node | undefined;
+    /** The body of an `if`, `with` or labeled statement; an elided statement becomes `;`. */
+    visitEmbeddedStatement(node: Node | undefined): Node | undefined;
+    visitIterationBody(node: Node | undefined): Node | undefined;
+    visitParameters(list: NodeList | undefined): NodeList | undefined;
+    visitFunctionBody(node: Node | undefined): Node | undefined;
+    visitTopLevelStatements(list: NodeList | undefined): NodeList | undefined;
+    /** Moves initializers and binding patterns of parameters into the body when temporaries were hoisted. */
+    private addDefaultValueAssignments;
+    private addDefaultValueAssignment;
+}

package/dist/api/compiler/transformers/visitor-hooks.js

@@ -0,0 +1,189 @@
+// Child traversal for transforms: visiting nodes and lists, with hoisted declarations tracked
+// in the emit context's variable environments as tsgo's emit-context visitors do.
+import { BindingPattern, Block, EmptyStatement, NodeList, NotEmittedStatement, ParameterDeclaration, SyntaxList, } from '../ast.js';
+export class VisitorHooks {
+    context;
+    factory;
+    constructor(context) {
+        this.context = context;
+        this.factory = context.factory;
+    }
+    visitNode(node) {
+        if (node === undefined)
+            return undefined;
+        const visited = this.visit(node);
+        if (visited instanceof SyntaxList) {
+            if (visited.children.length !== 1)
+                throw new Error('Expected only a single node to be written to output');
+            return visited.children[0];
+        }
+        return visited;
+    }
+    visitToken(node) {
+        return this.visitNode(node);
+    }
+    /** The visited nodes, or `nodes` itself if nothing changed. */
+    visitArray(nodes) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            let visited = this.visit(node);
+            if (visited === node)
+                continue;
+            const updated = nodes.slice(0, i);
+            for (;;) {
+                if (visited instanceof SyntaxList)
+                    for (let j = 0; j < visited.children.length; j++)
+                        updated.push(visited.children[j]);
+                else if (visited !== undefined)
+                    updated.push(visited);
+                if (++i >= nodes.length)
+                    break;
+                visited = this.visit(nodes[i]);
+            }
+            return updated;
+        }
+        return nodes;
+    }
+    visitNodes(list) {
+        if (list === undefined)
+            return undefined;
+        const nodes = this.visitArray(list.nodes);
+        return nodes === list.nodes ? list : new NodeList(list.pos, list.end, nodes);
+    }
+    visitModifiers(list) {
+        if (list === undefined)
+            return undefined;
+        const nodes = this.visitArray(list.nodes);
+        if (nodes === list.nodes)
+            return list;
+        const updated = this.factory.createModifierList(nodes);
+        updated.pos = list.pos;
+        updated.end = list.end;
+        return updated;
+    }
+    liftToBlock(node) {
+        if (node instanceof SyntaxList) {
+            if (node.children.length === 1)
+                return node.children[0];
+            return this.factory.createBlock(node.children, true);
+        }
+        if (node === undefined)
+            return this.factory.createBlock([], true);
+        return node;
+    }
+    /** A visited statement, as a block if it became several, or undefined if removed. */
+    visitStatement(node) {
+        if (node === undefined)
+            return undefined;
+        const visited = this.visit(node);
+        return visited === undefined ? undefined : this.liftToBlock(visited);
+    }
+    /** The body of an `if`, `with` or labeled statement; an elided statement becomes `;`. */
+    visitEmbeddedStatement(node) {
+        if (node === undefined)
+            return undefined;
+        const visited = this.visit(node);
+        const statement = visited === undefined ? undefined : this.liftToBlock(visited);
+        if (statement === undefined || statement instanceof NotEmittedStatement) {
+            const empty = this.factory.created(new EmptyStatement());
+            empty.pos = node.pos;
+            empty.end = node.end;
+            this.context.setOriginal(empty, node);
+            this.context.assignCommentRange(empty, node);
+            return empty;
+        }
+        return statement;
+    }
+    visitIterationBody(node) {
+        if (node === undefined)
+            return undefined;
+        const context = this.context;
+        context.startLexicalEnvironment();
+        const updated = this.visitEmbeddedStatement(node);
+        const declarations = context.endLexicalEnvironment();
+        if (declarations.length === 0)
+            return updated;
+        if (updated instanceof Block) {
+            const statements = declarations.concat(updated.statements.nodes);
+            return this.factory.updateBlock(updated, new NodeList(updated.statements.pos, updated.statements.end, statements), updated.multiLine);
+        }
+        declarations.push(updated);
+        return this.factory.createBlock(declarations, true);
+    }
+    visitParameters(list) {
+        const context = this.context;
+        context.startVariableEnvironment();
+        const flags = context.enterParameters();
+        let result = this.visitNodes(list);
+        if (context.exitParameters(flags) && result !== undefined)
+            result = this.addDefaultValueAssignments(result);
+        return result;
+    }
+    visitFunctionBody(node) {
+        const updated = this.visitNode(node);
+        const declarations = this.context.endVariableEnvironment();
+        if (declarations.length === 0)
+            return updated;
+        const factory = this.factory;
+        if (updated === undefined)
+            return factory.createBlock(declarations, true);
+        if (!(updated instanceof Block))
+            return factory.createBlock(this.context.mergeEnvironment([factory.createReturnStatement(updated)], declarations), false);
+        return factory.updateBlock(updated, this.context.mergeEnvironmentList(updated.statements, declarations), updated.multiLine);
+    }
+    visitTopLevelStatements(list) {
+        const context = this.context;
+        context.startVariableEnvironment();
+        const visited = this.visitNodes(list);
+        if (visited === undefined)
+            return undefined;
+        return context.mergeEnvironmentList(visited, context.endVariableEnvironment());
+    }
+    /** Moves initializers and binding patterns of parameters into the body when temporaries were hoisted. */
+    addDefaultValueAssignments(list) {
+        let result = undefined;
+        for (let i = 0; i < list.nodes.length; i++) {
+            const parameter = list.nodes[i];
+            if (!(parameter instanceof ParameterDeclaration))
+                continue;
+            const updated = this.addDefaultValueAssignment(parameter);
+            if (updated !== parameter) {
+                if (result === undefined)
+                    result = list.nodes.slice();
+                result[i] = updated;
+            }
+        }
+        return result === undefined ? list : new NodeList(list.pos, list.end, result);
+    }
+    addDefaultValueAssignment(parameter) {
+        if (parameter.dotDotDotToken !== undefined)
+            return parameter;
+        const factory = this.factory;
+        const context = this.context;
+        const name = parameter.name;
+        if (name instanceof BindingPattern) {
+            const temp = factory.createGeneratedNameForNode(parameter, 0, '', '');
+            const initializer = parameter.initializer === undefined
+                ? factory.createGeneratedNameForNode(parameter, 0, '', '')
+                : factory.createConditionalExpression(factory.createStrictEquality(factory.createGeneratedNameForNode(parameter, 0, '', ''), factory.createVoidZero()), parameter.initializer, factory.createGeneratedNameForNode(parameter, 0, '', ''));
+            context.addInitializationStatement(factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([factory.createVariableDeclaration(name, undefined, parameter.type, initializer)]), 0)));
+            return factory.updateParameterDeclaration(parameter, parameter.modifiers, parameter.dotDotDotToken, temp, parameter.questionToken, parameter.type, undefined);
+        }
+        const initializer = parameter.initializer;
+        if (initializer === undefined)
+            return parameter;
+        context.addEmitFlags(initializer, 12 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoComments */);
+        const nameClone = factory.cloneNode(name, name.deepClone());
+        context.addEmitFlags(nameClone, 12 /* EmitFlags.NoSourceMap */);
+        const assignment = factory.createAssignment(nameClone, initializer);
+        assignment.pos = parameter.pos;
+        assignment.end = parameter.end;
+        context.addEmitFlags(assignment, 384 /* EmitFlags.NoComments */);
+        const block = factory.createBlock([factory.createExpressionStatement(assignment)], false);
+        block.pos = parameter.pos;
+        block.end = parameter.end;
+        context.addEmitFlags(block, 1 /* EmitFlags.SingleLine */ | 8 /* EmitFlags.NoTrailingSourceMap */ | 96 /* EmitFlags.NoTokenSourceMaps */ | 384 /* EmitFlags.NoComments */);
+        context.addInitializationStatement(factory.createIfStatement(factory.createTypeCheck(factory.cloneNode(name, name.deepClone()), 'undefined'), block, undefined));
+        return factory.updateParameterDeclaration(parameter, parameter.modifiers, parameter.dotDotDotToken, name, parameter.questionToken, parameter.type, undefined);
+    }
+}

package/dist/api/compiler/tsconfig.d.ts

@@ -0,0 +1,177 @@
+/**
+ * tsconfig.json: options, `extends`, `files`/`include`/`exclude` and project references, with tsgo's diagnostics.
+ *
+ * ```ts
+ * const errors: Diagnostic[] = [];
+ * const config = new ConfigParser(fs, '/app').parseConfigFile('/app/tsconfig.json', {}, undefined, errors);
+ * ```
+ */
+import { ObjectLiteralExpression, PropertyAssignment, StringLiteral, type Node, type SourceFile } from './ast.js';
+import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import type { FileSystem } from './file-system.js';
+import { type OptionDeclaration } from './option-declarations.js';
+import { type CompilerOptions, type OptionValue, type TypeAcquisition } from './options.js';
+import { type OutputPathsHost } from './output-paths.js';
+/** A value of a config file as JSON: `null`, a primitive, an array or an object. */
+export type JsonValue = null | boolean | number | string | JsonArray | JsonObject;
+export declare class JsonArray {
+    readonly items: JsonValue[];
+    /** A non-empty array whose items were all `null` or invalid, which tsgo treats like a missing array. */
+    readonly dropped: boolean;
+    constructor(items: JsonValue[], 
+    /** A non-empty array whose items were all `null` or invalid, which tsgo treats like a missing array. */
+    dropped?: boolean);
+}
+/** Entries in source order; a repeated key keeps its first position and its last value. */
+export declare class JsonObject {
+    readonly entries: Map<string, JsonValue>;
+}
+/** Extensions of root files, in priority groups. */
+export declare function getSupportedExtensions(options: CompilerOptions): readonly (readonly string[])[];
+export declare function getSupportedExtensionsWithJsonIfResolveJsonModule(options: CompilerOptions): readonly (readonly string[])[];
+export declare function flattenExtensions(groups: readonly (readonly string[])[]): string[];
+export declare class ProjectReference {
+    /** Absolute path of the referenced config file or directory. */
+    readonly path: string;
+    readonly originalPath: string;
+    readonly circular: boolean;
+    constructor(
+    /** Absolute path of the referenced config file or directory. */
+    path: string, originalPath: string, circular: boolean);
+}
+/** The config file `path` of a reference names: itself if a `.json` file, else its `tsconfig.json`. */
+export declare function resolveProjectReferencePath(reference: ProjectReference): string;
+/** `files`, `include` and `exclude` after validation. */
+export declare class ConfigFileSpecs {
+    readonly validatedFilesSpec: readonly string[];
+    readonly validatedIncludeSpecs: readonly string[];
+    readonly validatedExcludeSpecs: readonly string[];
+    readonly validatedFilesSpecBeforeSubstitution: readonly string[];
+    readonly validatedIncludeSpecsBeforeSubstitution: readonly string[];
+    readonly isDefaultIncludeSpec: boolean;
+    constructor(validatedFilesSpec: readonly string[], validatedIncludeSpecs: readonly string[], validatedExcludeSpecs: readonly string[], validatedFilesSpecBeforeSubstitution: readonly string[], validatedIncludeSpecsBeforeSubstitution: readonly string[], isDefaultIncludeSpec: boolean);
+    matchesExclude(fileName: string, currentDirectory: string, useCaseSensitiveFileNames: boolean): boolean;
+    /** The `include` spec (as written) matching `fileName`, or `''`. */
+    getMatchedIncludeSpec(fileName: string, currentDirectory: string, useCaseSensitiveFileNames: boolean): string;
+    /** The `files` entry (as written) naming `fileName`, or `''`. */
+    getMatchedFileSpec(fileName: string, currentDirectory: string, useCaseSensitiveFileNames: boolean): string;
+}
+/** A parsed config file: its syntax tree and the config files it extends. */
+export declare class TsConfigSourceFile {
+    readonly sourceFile: SourceFile;
+    /** Every config file this one extends, directly or not, sorted. */
+    extendedSourceFiles: string[];
+    configFileSpecs: ConfigFileSpecs | undefined;
+    constructor(sourceFile: SourceFile);
+}
+/** Options, root files and references of a project, from a config file or the command line. */
+export declare class ParsedCommandLine implements OutputPathsHost {
+    readonly options: CompilerOptions;
+    readonly typeAcquisition: TypeAcquisition | undefined;
+    readonly fileNames: readonly string[];
+    readonly projectReferences: readonly ProjectReference[];
+    readonly configFile: TsConfigSourceFile | undefined;
+    readonly errors: Diagnostic[];
+    /** The config's directory, or the current directory without a config. */
+    readonly currentDirectory: string;
+    readonly useCaseSensitiveFileNames: boolean;
+    /** How many of `fileNames` come from `files`. */
+    readonly literalFileNamesLength: number;
+    /** The config file name, or `''`. */
+    readonly configName: string;
+    /** Where `getOutputDeclarationFileName` maps sources of this project, once computed. */
+    private sourceToReference;
+    private outputDtsToReference;
+    private commonSourceDirectoryValue;
+    private referencePaths;
+    constructor(options: CompilerOptions, typeAcquisition: TypeAcquisition | undefined, fileNames: readonly string[], projectReferences: readonly ProjectReference[], configFile: TsConfigSourceFile | undefined, errors: Diagnostic[], 
+    /** The config's directory, or the current directory without a config. */
+    currentDirectory: string, useCaseSensitiveFileNames: boolean, 
+    /** How many of `fileNames` come from `files`. */
+    literalFileNamesLength: number);
+    /** Config file paths of the references. */
+    resolvedProjectReferencePaths(): readonly string[];
+    /** Diagnostics of reading the config: syntax errors, then option errors. */
+    configFileParsingDiagnostics(): readonly Diagnostic[];
+    getMatchedFileSpec(fileName: string): string;
+    /** The `include` spec matching `fileName`, or `''`; the default spec `**\/*` matches everything. */
+    getMatchedIncludeSpec(fileName: string): string;
+    isDefaultIncludeSpec(): boolean;
+    /** The directory outputs are laid out relative to (with a trailing `/`), or `''`. */
+    commonSourceDirectory(): string;
+    private emittedRootFiles;
+    private checkSourceFilesBelongToPath;
+    /** Maps each source of this project to its declaration output and back. */
+    sourceToProjectReference(): ReadonlyMap<string, SourceOutputAndProjectReference>;
+    outputDtsToProjectReference(): ReadonlyMap<string, SourceOutputAndProjectReference>;
+    private parseInputOutputNames;
+    /** The `.tsbuildinfo` file of an incremental build, or `''`. */
+    buildInfoFileName(): string;
+}
+/** A source file of a referenced project and its declaration output. */
+export declare class SourceOutputAndProjectReference {
+    readonly source: string;
+    /** `''` for declaration and JSON sources. */
+    readonly outputDts: string;
+    readonly resolved: ParsedCommandLine;
+    constructor(source: string, 
+    /** `''` for declaration and JSON sources. */
+    outputDts: string, resolved: ParsedCommandLine);
+}
+/** A diagnostic at `node` without its leading trivia, or a compiler diagnostic without a node. */
+export declare function diagnosticAtNode(file: SourceFile | undefined, node: Node | undefined, message: DiagnosticMessage, ...args: string[]): Diagnostic;
+/** The root object of a config file. */
+export declare function getTsConfigObjectLiteral(file: SourceFile | undefined): ObjectLiteralExpression | undefined;
+/** The first property assignment of `object` named `key` (or `key2`). */
+export declare function findPropertyAssignment(object: ObjectLiteralExpression | undefined, key: string, key2?: string): PropertyAssignment | undefined;
+/** The string literal `value` in the array of the root property `key`. */
+export declare function findTsConfigArrayElement(file: SourceFile | undefined, key: string, value: string): StringLiteral | undefined;
+/** The string literal `value` in the array initializing `property`. */
+export declare function findArrayElement(property: PropertyAssignment | undefined, value: string): StringLiteral | undefined;
+/** The text of a property name, or `undefined` for computed names that aren't literals. */
+export declare function propertyNameText(name: Node): string | undefined;
+/** Rejects specs ending in `**` (for `include`) and `..` after a `**`. */
+export declare function specToDiagnostic(spec: string, disallowTrailingRecursion: boolean): DiagnosticMessage | undefined;
+/** Names of options given as `null` on the command line. */
+export declare function nullKeysOfCommandLine(raw: ReadonlyMap<string, OptionValue> | undefined): Set<string> | undefined;
+/** Reads config files with a file system, sharing parsed `extends` targets. */
+export declare class ConfigParser {
+    readonly fs: FileSystem;
+    readonly currentDirectory: string;
+    private readonly extendedConfigs;
+    private readonly resolutionHost;
+    /**
+     * Whether parsed configs list their root files. Parse threads (parallel-parse.ts), which get the
+     * files to load from the main thread, read the config without matching `include` patterns.
+     */
+    expandFileNames: boolean;
+    /**
+     * Called once, with the options of the config, before its `include` patterns are matched; what it
+     * returns is called with each root file name as it is found: literal `files` first, then the matched
+     * files a directory at a time, without those that a file of the same name with a higher priority
+     * extension leaves out.
+     */
+    beforeRootFiles: ((options: CompilerOptions) => ((fileName: string) => void) | undefined) | undefined;
+    constructor(fs: FileSystem, currentDirectory: string);
+    /**
+     * Reads `configFileName` and applies command-line `options` (`raw` as given, for `null` resets) over it.
+     * Returns `undefined`, with `errors`, if the file can't be read.
+     */
+    parseConfigFile(configFileName: string, options: CompilerOptions | undefined, raw: ReadonlyMap<string, OptionValue> | undefined, errors: Diagnostic[]): ParsedCommandLine | undefined;
+    /** Converts a parsed config file into options and root files. */
+    parseConfigFileContent(file: TsConfigSourceFile, basePath: string, existingOptions: CompilerOptions | undefined, existingRaw: ReadonlyMap<string, OptionValue> | undefined, configFileName: string): ParsedCommandLine;
+    /** A config file's options with what it extends applied. */
+    private parseConfig;
+    private applyExtendedConfig;
+    /** A parsed extended config; cached unless it is part of an `extends` cycle. */
+    private getExtendedConfig;
+    private parseExtendedConfig;
+    /** Converts a value of `option`, reporting invalid values at `valueExpression`. */
+    convertOption(option: OptionDeclaration, value: JsonValue, basePath: string, property: PropertyAssignment | undefined, valueExpression: Node | undefined, file: SourceFile | undefined, errors: Diagnostic[]): JsonValue;
+    private convertListOption;
+    /** Resolves `extends`: a path, a package, or an array of those. */
+    getExtendsConfigPaths(value: JsonValue, basePath: string, configFileName: string, property: PropertyAssignment, valueExpression: Node, file: SourceFile, errors: Diagnostic[]): string[];
+    private getExtendsConfigPath;
+    /** Root files: `files` as given, then `include` matches not excluded, then JSON files matched explicitly. */
+    private getFileNamesFromConfigSpecs;
+}