tsc-ts 0.1.1 → 0.1.2

package/README.md

@@ -84,3 +84,9 @@ The program's diagnostics, with their text and positions, are those `tsc --api`
 An exception the compiler throws while answering a call reaches the caller as an `InternalCompilerError`, with the exception as its `cause`; the program's checker may be inconsistent after one, so dispose of the program. `program.dispose()` frees the program's checkers; calls on the program or its checker after it throw a `DisposedProgramError`.
 
 The package has a JavaScript build with declaration files for Node.js, and the TypeScript sources of the API and the compiler (the `source` export condition) for compilers that build it from source. The sources compile with scriptc: a test builds a program on `tsc-ts/api` natively and checks that it answers as the Node build.
+
+The API imports `@scriptc/threads`, an optional peer dependency that the command line doesn't use. Install it next to `tsc-ts` to use `tsc-ts/api`:
+
+```bash
+npm install -D tsc-ts @scriptc/threads
+```

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

@@ -2327,6 +2327,12 @@ export declare class SourceFile extends Node {
     patternAmbientModules: readonly PatternAmbientModule[];
     /** UMD exports from `export as namespace N`. */
     globalExports: SymbolTable | undefined;
+    /** The diagnostics the parse thread's grammar walk reported for this file. */
+    grammarDiagnostics: Diagnostic[] | undefined;
+    /** The nodes of this file whose grammar check needs the checker, in tree order. */
+    grammarResidualNodes: Node[] | undefined;
+    /** The blocks and statements that reported a statement in an ambient context. */
+    grammarAmbientReports: readonly number[];
     constructor(fileName: string, path: string, text: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions, statements: NodeList, endOfFileToken: Token);
     forEachChild(v: NodeVisitor): boolean;
     setParentOfChildren(): void;

package/dist/api/compiler/ast.js

@@ -52,9 +52,14 @@ export class NodeVisitor {
         return this.visitList(list);
     }
 }
-// Native builds store `pos`, `end` and `id` as 32-bit integers when every write provably stores an
-// int32, so writes of values the compiler can't bound (parameters, the id counter) are coerced
-// with `| 0`; the values are always int32.
+// Native builds store `pos`, `end` and `id` as 32-bit integers when every write provably stores
+// an int32, so writes of values the compiler can't bound (parameters, the id counter) are
+// coerced with `| 0`; the values are always int32.
+//
+// The fields of a node that the public API's node types declare are stored fields, not values
+// computed from or packed into another field: a native build copies the stored fields of a node
+// into a record when API code narrows one (`node as StringLiteralLike`), and a field behind an
+// accessor is not copied.
 export class Node {
     kind;
     flags;
@@ -6626,6 +6631,7 @@ export const emptyCommentDirectives = [];
 export const emptyPragmas = [];
 export const emptyFileReferences = [];
 export const emptyPatternAmbientModules = [];
+const emptyNumbers = [];
 /** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
 export function appendToList(list, item) {
     if (list.length === 0)
@@ -6698,6 +6704,13 @@ export class SourceFile extends Node {
     patternAmbientModules;
     /** UMD exports from `export as namespace N`. */
     globalExports;
+    // Set by the grammar checks of a parse thread (checker-grammar.ts).
+    /** The diagnostics the parse thread's grammar walk reported for this file. */
+    grammarDiagnostics;
+    /** The nodes of this file whose grammar check needs the checker, in tree order. */
+    grammarResidualNodes;
+    /** The blocks and statements that reported a statement in an ambient context. */
+    grammarAmbientReports;
     constructor(fileName, path, text, externalModuleIndicatorOptions, statements, endOfFileToken) {
         super(308 /* SyntaxKind.SourceFile */);
         this.fileName = fileName;
@@ -6744,6 +6757,9 @@ export class SourceFile extends Node {
         this.symbolCount = 0;
         this.patternAmbientModules = emptyPatternAmbientModules;
         this.globalExports = undefined;
+        this.grammarDiagnostics = undefined;
+        this.grammarResidualNodes = undefined;
+        this.grammarAmbientReports = emptyNumbers;
     }
     forEachChild(v) {
         return v.visitList(this.statements) || v.visitNode(this.endOfFileToken);

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

@@ -1,10 +1,17 @@
 import { type Node, type NodeList, NodeVisitor, type ObjectLiteralExpression, type SourceFile } from './ast.js';
 import { type Checker } from './checker.js';
-import { ModuleKind } from './options.js';
+import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { type CompilerOptions, ModuleKind } from './options.js';
 import { SourceFileMetadata } from './program-utilities.js';
 import { Scanner } from './scanner.js';
 /** Runs the grammar checks of every node of `file`. */
 export declare function checkGrammarSourceFile(c: Checker, file: SourceFile): void;
+/**
+ * Runs the grammar checks of `file` in a parse thread, before the file is published: the checks that
+ * don't need the checker report now, and the nodes of those that do are kept for the checker, which
+ * runs them in the same tree order (`checkGrammarSourceFile`).
+ */
+export declare function checkGrammarSourceFileInParseThread(file: SourceFile, options: CompilerOptions, metadata: SourceFileMetadata): void;
 /** Checks the grammar of an object literal each time it is checked, as tsgo does. */
 export declare function checkGrammarObjectLiteralOfExpression(c: Checker, node: ObjectLiteralExpression, inDestructuring: boolean): void;
 /** Reports a trailing comma after the rest element of a destructuring assignment. */
@@ -17,7 +24,10 @@ export declare function checkGrammarAwaitExpression(c: Checker, node: Node): voi
 export declare function checkGrammarYieldOfExpression(c: Checker, node: Node): void;
 /** Per-file state of the grammar walk. */
 export declare class GrammarChecker extends NodeVisitor {
-    readonly c: Checker;
+    /** The checker of a walk in the checker thread; undefined for a walk in a parse thread. */
+    readonly c: Checker | undefined;
+    readonly compilerOptions: CompilerOptions;
+    readonly languageVersion: number;
     readonly file: SourceFile;
     /** Grammar errors are only reported in files without parse errors. */
     readonly hasParseErrors: boolean;
@@ -25,10 +35,35 @@ export declare class GrammarChecker extends NodeVisitor {
     readonly metadata: SourceFileMetadata;
     readonly legacyDecorators: boolean;
     /** Blocks and statements that already reported a statement in an ambient context. */
-    readonly reportedAmbientStatements: Set<number>;
+    reportedAmbientStatements: Set<number>;
+    /**
+     * The IDs `reportedAmbientStatements` gained in a parse thread's walk, in the order it gained them, so
+     * that the reports of a node whose check the checker runs are undone without copying the set.
+     * Undefined in the checker thread, where no check is undone.
+     */
+    private readonly ambientReportLog;
+    /**
+     * The diagnostics of a walk in a parse thread, which has no checker, for the checker to add to its
+     * collection; undefined in the checker thread, where they are reported as they are found.
+     */
+    readonly diagnostics: Diagnostic[] | undefined;
+    /** The nodes of a parse thread's walk whose check needs the checker, in tree order. */
+    readonly residualNodes: Node[] | undefined;
+    /** Set when the check of a parse thread's walk needs the checker: the checker runs that node. */
+    needsChecker: boolean;
     private scanner;
-    constructor(c: Checker, file: SourceFile);
+    constructor(c: Checker | undefined, file: SourceFile, options?: CompilerOptions, metadata?: SourceFileMetadata, 
+    /** `file.grammarAmbientReports`: what a parse thread's walk already reported. */
+    ambientReports?: readonly number[]);
     visitNode(node: Node): boolean;
+    /** Records that `id` reported a statement in an ambient context. */
+    reportAmbientStatement(id: number): void;
+    /** Undoes the ambient-context reports added since the log had `mark` entries. */
+    private undoAmbientReports;
+    /** Reports an error at `node`, as `Checker.error`; returns the diagnostic. */
+    error(node: Node | undefined, message: DiagnosticMessage, ...args: string[]): Diagnostic;
+    /** Reports `diagnostic`, as `Checker.addDiagnostic`. */
+    report(diagnostic: Diagnostic): void;
     /** A scanner over the file's text, for rescanning tokens. */
     getScanner(): Scanner;
 }