tsc-ts 0.1.1 → 0.1.2

package/dist/api/compiler/checker-heritage.js

@@ -668,17 +668,18 @@ function areTypeParametersIdentical(c, lists, targetParameters) {
  * (with `checkPrivateNames`) private names shared by static and instance members.
  */
 export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNames) {
-    const instanceNames = new Map();
-    const staticNames = new Map();
-    const privateNames = new Map();
+    // Only a symbol with several declarations can be a duplicate, so the maps are created for the first one.
+    let instanceNames;
+    let staticNames;
+    let privateNames;
     const nodeInAmbientContext = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
     for (const member of getMembers(node).nodes) {
         if (member.kind === 178 /* SyntaxKind.Constructor */) {
             for (const param of getParameters(member).nodes)
                 if (isParameterPropertyDeclaration(param, member) && !isBindingPattern(getName(param))) {
                     const symbol = getSymbolOfDeclaration(c, param);
-                    if (symbol !== undefined)
-                        checkPropertyOrAccessor(c, node, instanceNames, symbol, 1 /* MemberKind.Property */, false);
+                    if (symbol !== undefined && declarationCount(symbol) > 1)
+                        checkPropertyOrAccessor(c, node, (instanceNames ??= new Map()), symbol, 1 /* MemberKind.Property */, false);
                 }
             continue;
         }
@@ -688,17 +689,22 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
         const memberIsStatic = hasStaticModifier(member);
         if (!nodeInAmbientContext && memberIsStatic && symbol.name === 'prototype')
             c.error(getName(member), 838 /* Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1 */, symbol.name, symbolToString(c, getSymbolOfDeclaration(c, node)));
-        const names = memberIsStatic ? staticNames : instanceNames;
-        const hasAccessorModifier = hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */);
-        if ((member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
-            member.kind === 173 /* SyntaxKind.PropertySignature */)
-            checkPropertyOrAccessor(c, node, names, symbol, 1 /* MemberKind.Property */, memberIsStatic);
-        else if (member.kind === 179 /* SyntaxKind.GetAccessor */ ||
-            member.kind === 180 /* SyntaxKind.SetAccessor */ ||
-            (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
-            checkPropertyOrAccessor(c, node, names, symbol, 2 /* MemberKind.Accessor */, memberIsStatic);
+        if (declarationCount(symbol) > 1) {
+            const names = memberIsStatic
+                ? (staticNames ??= new Map())
+                : (instanceNames ??= new Map());
+            const hasAccessorModifier = hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */);
+            if ((member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
+                member.kind === 173 /* SyntaxKind.PropertySignature */)
+                checkPropertyOrAccessor(c, node, names, symbol, 1 /* MemberKind.Property */, memberIsStatic);
+            else if (member.kind === 179 /* SyntaxKind.GetAccessor */ ||
+                member.kind === 180 /* SyntaxKind.SetAccessor */ ||
+                (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
+                checkPropertyOrAccessor(c, node, names, symbol, 2 /* MemberKind.Accessor */, memberIsStatic);
+        }
         const name = getName(member);
         if (checkPrivateNames && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
+            privateNames ??= new Map();
             let flags = privateNames.get(symbol.name) ?? 0;
             if (flags === 3)
                 continue;

package/dist/api/compiler/checker-modules.js

@@ -1525,7 +1525,8 @@ function getSymbolFlagsExcludingTypeOnly(c, symbol) {
 }
 /** `getSymbolFlags`, optionally stopping at type-only aliases or leaving out the symbol's own flags. */
 function getSymbolFlagsEx(c, symbol, excludeTypeOnlyMeanings, excludeLocalMeanings) {
-    const seen = new Set();
+    // Only a chain of aliases needs the set, so most calls never create it.
+    let seen;
     let flags = excludeLocalMeanings ? 0 /* SymbolFlags.None */ : symbol.flags;
     while ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
         if (excludeTypeOnlyMeanings && getTypeOnlyAliasDeclaration(c, symbol) !== undefined)
@@ -1534,8 +1535,9 @@ function getSymbolFlagsEx(c, symbol, excludeTypeOnlyMeanings, excludeLocalMeanin
         if (target === c.unknownSymbol)
             return 1073741823 /* SymbolFlags.All */;
         if ((target.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
-            if (target === symbol || seen.has(target))
+            if (target === symbol || seen?.has(target))
                 break;
+            seen ??= new Set();
             seen.add(symbol);
             seen.add(target);
         }

package/dist/api/compiler/checker-source-file.js

@@ -520,7 +520,7 @@ function checkTypeMemberAccessor(c, node) {
 /** Variadic tuple elements must be array-like. */
 function checkTupleRestElements(c, node) {
     for (const e of node.elements.nodes) {
-        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) === 0)
+        if ((getTupleElementFlags(e) & 8 /* ElementFlags.Variadic */) === 0)
             continue;
         if (!isArrayLikeType(c, getTypeFromTypeNode(c, getType(e)))) {
             c.error(e, 732 /* Diagnostics.A_rest_element_type_must_be_an_array_type */);

package/dist/api/compiler/checker-type-factory.js

@@ -1749,18 +1749,27 @@ export function intersectTypes(c, type1, type2) {
 export function getIntersectionType(c, types) {
     return getIntersectionTypeEx(c, types, 0 /* IntersectionFlags.None */, undefined);
 }
+/**
+ * The distinct types of an intersection, in the order they were added. Most intersections have a few
+ * types, which a scan of `values` finds faster than a `Set` costs to build, so the set is created only
+ * once the list grows past `INDEX_AFTER`.
+ */
 class OrderedTypeSet {
+    static INDEX_AFTER = 8;
     values = [];
-    seen = new Set();
+    index;
     includes = 0;
     has(t) {
-        return this.seen.has(t);
+        return this.index !== undefined ? this.index.has(t) : this.values.includes(t);
     }
     add(t) {
-        if (!this.seen.has(t)) {
-            this.seen.add(t);
-            this.values.push(t);
-        }
+        if (this.has(t))
+            return;
+        this.values.push(t);
+        if (this.index !== undefined)
+            this.index.add(t);
+        else if (this.values.length > OrderedTypeSet.INDEX_AFTER)
+            this.index = new Set(this.values);
     }
 }
 function addTypesToIntersection(c, set, types) {
@@ -2126,7 +2135,8 @@ function getCrossProductIntersections(c, types, flags) {
  */
 function addCrossProductIntersections(c, types, flags, constituents, index, unit, intersections) {
     if (index === types.length) {
-        const t = getIntersectionTypeEx(c, constituents.slice(), flags, undefined);
+        // getIntersectionTypeEx copies the types it keeps, so the buffer is reused for the next combination.
+        const t = getIntersectionTypeEx(c, constituents, flags, undefined);
         if ((t.flags & 262144 /* TypeFlags.Never */) === 0)
             intersections.push(t);
         return;

package/dist/api/compiler/checker-type-nodes.d.ts

@@ -20,7 +20,7 @@ export declare function isTypeAlias(node: Node): boolean;
 export declare function getAliasForTypeNode(c: Checker, node: Node): TypeAlias | undefined;
 export declare function getAliasSymbolForTypeNode(c: Checker, node: Node): Symbol | undefined;
 export declare function getTypeAliasInstantiation(c: Checker, symbol: Symbol, typeArguments: Type[], alias: TypeAlias | undefined): Type;
-export declare function getTupleElementFlags(c: Checker, node: Node): ElementFlags;
+export declare function getTupleElementFlags(node: Node): ElementFlags;
 /** Type arguments of a deferred reference from its node. */
 export declare function getTypeArgumentsOfDeferredReference(c: Checker, node: Node, target: InterfaceType): Type[];
 /** The symbol an identifier resolves to, cached on the identifier. */

package/dist/api/compiler/checker-type-nodes.js

@@ -711,7 +711,7 @@ function getTypeFromTypeQueryNode(c, node) {
     }
     return type;
 }
-export function getTupleElementFlags(c, node) {
+export function getTupleElementFlags(node) {
     switch (node.kind) {
         case 192 /* SyntaxKind.OptionalType */:
             return 2 /* ElementFlags.Optional */;
@@ -730,8 +730,8 @@ export function getTupleElementFlags(c, node) {
     }
     return 1 /* ElementFlags.Required */;
 }
-function getTupleElementInfo(c, node) {
-    return new TupleElementInfo(getTupleElementFlags(c, node), node.kind === 204 /* SyntaxKind.NamedTupleMember */ || node.kind === 171 /* SyntaxKind.Parameter */ ? node : undefined);
+function getTupleElementInfo(node) {
+    return new TupleElementInfo(getTupleElementFlags(node), node.kind === 204 /* SyntaxKind.NamedTupleMember */ || node.kind === 171 /* SyntaxKind.Parameter */ ? node : undefined);
 }
 function getArrayElementTypeNode(node) {
     switch (node.kind) {
@@ -760,7 +760,7 @@ function getArrayOrTupleTargetType(c, node) {
         return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
     const elementInfos = [];
     for (const e of node.elements.nodes)
-        elementInfos.push(getTupleElementInfo(c, e));
+        elementInfos.push(getTupleElementInfo(e));
     return getTupleTargetType(c, elementInfos, readonly);
 }
 function getTypeFromArrayOrTupleTypeNode(c, node) {
@@ -787,7 +787,7 @@ function getTypeFromArrayOrTupleTypeNode(c, node) {
 }
 function hasVariadicTupleElement(c, node) {
     for (const e of node.elements.nodes)
-        if ((getTupleElementFlags(c, e) & 8 /* ElementFlags.Variadic */) !== 0)
+        if ((getTupleElementFlags(e) & 8 /* ElementFlags.Variadic */) !== 0)
             return true;
     return false;
 }

package/dist/api/compiler/checker-unused.js

@@ -326,8 +326,9 @@ function checkUnusedLocalsAndParameters(c, node) {
     const locals = getLocals(node);
     if (locals === undefined)
         return;
-    const variableParents = new Set();
-    const importClauses = new Map();
+    // Created on the first unused declaration: most scopes have none.
+    let variableParents;
+    let importClauses;
     for (const local of locals.values()) {
         const referenceKinds = c.symbolReferenceKinds.get(getSymbolId(local));
         if ((local.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
@@ -343,6 +344,7 @@ function checkUnusedLocalsAndParameters(c, node) {
                 case 262 /* SyntaxKind.VariableDeclaration */:
                 case 171 /* SyntaxKind.Parameter */:
                 case 210 /* SyntaxKind.BindingElement */:
+                    variableParents ??= new Set();
                     variableParents.add(getRootDeclaration(declaration).parent);
                     break;
                 case 275 /* SyntaxKind.ImportClause */:
@@ -350,6 +352,7 @@ function checkUnusedLocalsAndParameters(c, node) {
                 case 276 /* SyntaxKind.NamespaceImport */:
                     if (!isIdentifierThatStartsWithUnderscore(getName(declaration))) {
                         const importClause = importClauseFromImported(declaration);
+                        importClauses ??= new Map();
                         const unuseds = importClauses.get(importClause);
                         if (unuseds === undefined)
                             importClauses.set(importClause, [declaration]);
@@ -363,14 +366,16 @@ function checkUnusedLocalsAndParameters(c, node) {
             }
         }
     }
-    for (const declaration of variableParents) {
-        if (declaration.kind === 263 /* SyntaxKind.VariableDeclarationList */)
-            reportUnusedVariables(c, declaration, declaration.declarations.nodes);
-        else
-            reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
-    }
-    for (const [declaration, unuseds] of importClauses)
-        reportUnusedImports(c, declaration, unuseds);
+    if (variableParents !== undefined)
+        for (const declaration of variableParents) {
+            if (declaration.kind === 263 /* SyntaxKind.VariableDeclarationList */)
+                reportUnusedVariables(c, declaration, declaration.declarations.nodes);
+            else
+                reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
+        }
+    if (importClauses !== undefined)
+        for (const [declaration, unuseds] of importClauses)
+            reportUnusedImports(c, declaration, unuseds);
 }
 function reportUnusedLocal(c, node, name) {
     const message = isTypeDeclaration(node)

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

@@ -155,6 +155,8 @@ export declare class Checker implements TypeChecking {
     readonly noUncheckedIndexedAccess: boolean;
     typeCount: number;
     signatureCount: number;
+    /** Transient symbols the checker created (statistics), as tsgo's `Checker.SymbolCount`. */
+    symbolCount: number;
     /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
     readonly memberPositionsInLists: Map<Symbol[], Map<string, number>>;
     /** The property names of the last instantiation of each such list whose table is built on demand. */

package/dist/api/compiler/checker.js

@@ -282,6 +282,8 @@ export class Checker {
     // Counters for type and signature ids.
     typeCount = 0;
     signatureCount = 0;
+    /** Transient symbols the checker created (statistics), as tsgo's `Checker.SymbolCount`. */
+    symbolCount = 0;
     /** Positions of members by name in the tables and lists that lazily instantiated members come from. */
     memberPositionsInLists = new Map();
     /** The property names of the last instantiation of each such list whose table is built on demand. */
@@ -982,10 +984,12 @@ export class Checker {
         return new TypeParameter(this.nextTypeId(), symbol);
     }
     newSymbol(flags, name) {
+        this.symbolCount++;
         const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
         return symbol;
     }
     newSymbolWithCheckFlags(flags, name, checkFlags) {
+        this.symbolCount++;
         const symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name);
         symbol.checkFlags = checkFlags;
         return symbol;

package/dist/api/compiler/file-loader.d.ts

@@ -29,6 +29,11 @@ export declare class CompilerHost extends ModuleResolutionHost {
     readFile(path: string): string | undefined;
     realpath(path: string): string;
     getDirectories(path: string): readonly string[];
+    /**
+     * The metadata of the file `FileLoader` is parsing, which it computes from the file's package scope
+     * before it parses it; a host that walks the grammar of the parsed file reads it (parse-thread.ts).
+     */
+    loadingSourceFileMetadata: SourceFileMetadata | undefined;
     /** Parses a file, or returns `undefined` if it can't be read. */
     getSourceFile(fileName: string, path: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions): SourceFile | undefined;
     /** The config of a referenced project, or `undefined` if it can't be read. */

package/dist/api/compiler/file-loader.js

@@ -51,6 +51,11 @@ export class CompilerHost extends ModuleResolutionHost {
     getDirectories(path) {
         return this.fs.getAccessibleEntries(path).directories;
     }
+    /**
+     * The metadata of the file `FileLoader` is parsing, which it computes from the file's package scope
+     * before it parses it; a host that walks the grammar of the parsed file reads it (parse-thread.ts).
+     */
+    loadingSourceFileMetadata = undefined;
     /** Parses a file, or returns `undefined` if it can't be read. */
     getSourceFile(fileName, path, externalModuleIndicatorOptions) {
         // A file that parse threads prepared (parallel-parse.ts).
@@ -1054,6 +1059,8 @@ export class FileLoader {
                 ? libFileMetadata
                 : (loaded?.metadata ?? this.loadSourceFileMetadata(task.normalizedFilePath));
         const options = this.mapper.getCompilerOptionsForFile(task.path, task.normalizedFilePath);
+        // For the host that walks the grammar of the file as it parses it (parse-thread.ts).
+        this.host.loadingSourceFileMetadata = task.metadata;
         const file = this.host.getSourceFile(task.normalizedFilePath, task.path, getExternalModuleIndicatorOptions(task.normalizedFilePath, options, task.metadata));
         if (file === undefined)
             return;

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

@@ -88,6 +88,18 @@ export declare class CheckedProgram {
     createChecker(): Checker;
     /** Frees the checker that reports the program's diagnostics (`disposeChecker`). */
     disposeCheckers(): void;
+    /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+    addCheckerCounts(counts: readonly number[]): void;
+    /**
+     * The types, instantiations and transient symbols of every checker of the program: this thread's and
+     * the checker threads', as tsgo's `Program.TypeCount`, `InstantiationCount` and `SymbolCount` add them up.
+     * Reading them doesn't create this thread's checker.
+     */
+    checkerCounts(): {
+        types: number;
+        instantiations: number;
+        symbols: number;
+    };
     getBindDiagnostics(file: SourceFile | undefined): Diagnostic[];
     /**
      * Diagnostics of checker threads (parallel-check.ts): the semantic diagnostics of each file by file
@@ -109,6 +121,12 @@ export declare class CheckedProgram {
      */
     referenceThreads: number;
     readonly parallelGlobalDiagnostics: Diagnostic[];
+    /** The types checker threads created (`CheckerResult.counts`), which `--diagnostics` adds to `checker`'s. */
+    threadTypeCount: number;
+    /** The instantiations checker threads made. */
+    threadInstantiations: number;
+    /** The transient symbols checker threads created. */
+    threadSymbolCount: number;
     /**
      * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
      * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report

package/dist/api/compiler/program-checker.js

@@ -176,6 +176,27 @@ export class CheckedProgram {
             disposeChecker(this.reportingChecker);
         this.reportingChecker = undefined;
     }
+    /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+    addCheckerCounts(counts) {
+        if (counts.length < 3)
+            return;
+        this.threadTypeCount += counts[0];
+        this.threadInstantiations += counts[1];
+        this.threadSymbolCount += counts[2];
+    }
+    /**
+     * The types, instantiations and transient symbols of every checker of the program: this thread's and
+     * the checker threads', as tsgo's `Program.TypeCount`, `InstantiationCount` and `SymbolCount` add them up.
+     * Reading them doesn't create this thread's checker.
+     */
+    checkerCounts() {
+        const own = this.reportingChecker;
+        return {
+            types: (own === undefined ? 0 : own.typeCount) + this.threadTypeCount,
+            instantiations: (own === undefined ? 0 : own.totalInstantiations) + this.threadInstantiations,
+            symbols: (own === undefined ? 0 : own.symbolCount) + this.threadSymbolCount,
+        };
+    }
     getBindDiagnostics(file) {
         return this.collect(file, (f) => f.bindDiagnostics);
     }
@@ -199,6 +220,12 @@ export class CheckedProgram {
      */
     referenceThreads = 1;
     parallelGlobalDiagnostics = [];
+    /** The types checker threads created (`CheckerResult.counts`), which `--diagnostics` adds to `checker`'s. */
+    threadTypeCount = 0;
+    /** The instantiations checker threads made. */
+    threadInstantiations = 0;
+    /** The transient symbols checker threads created. */
+    threadSymbolCount = 0;
     /**
      * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
      * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsc-ts",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,19 +28,24 @@
     },
     "./package.json": "./package.json"
   },
-  "dependencies": {
+  "peerDependencies": {
     "@scriptc/threads": "0.4.8"
   },
+  "peerDependenciesMeta": {
+    "@scriptc/threads": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.1.1",
-    "@tsc-ts/darwin-x64": "0.1.1",
-    "@tsc-ts/linux-arm64-gnu": "0.1.1",
-    "@tsc-ts/linux-arm64-musl": "0.1.1",
-    "@tsc-ts/linux-x64-gnu": "0.1.1",
-    "@tsc-ts/linux-x64-musl": "0.1.1",
-    "@tsc-ts/win32-x64-msvc": "0.1.1"
+    "@tsc-ts/darwin-arm64": "0.1.2",
+    "@tsc-ts/darwin-x64": "0.1.2",
+    "@tsc-ts/linux-arm64-gnu": "0.1.2",
+    "@tsc-ts/linux-arm64-musl": "0.1.2",
+    "@tsc-ts/linux-x64-gnu": "0.1.2",
+    "@tsc-ts/linux-x64-musl": "0.1.2",
+    "@tsc-ts/win32-x64-msvc": "0.1.2"
   }
 }

package/src/compiler/ast.ts

@@ -209,9 +209,14 @@ export abstract class NodeVisitor {
   }
 }
 
-// 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 abstract class Node implements ProgramLifetime {
   readonly kind: SyntaxKind;
   flags: NodeFlags;
@@ -8244,6 +8249,7 @@ export const emptyCommentDirectives: readonly CommentDirective[] = [];
 export const emptyPragmas: readonly Pragma[] = [];
 export const emptyFileReferences: readonly FileReference[] = [];
 export const emptyPatternAmbientModules: readonly PatternAmbientModule[] = [];
+const emptyNumbers: readonly number[] = [];
 
 /** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
 export function appendToList<T>(list: readonly T[], item: T): readonly T[] {
@@ -8320,6 +8326,14 @@ export class SourceFile extends Node {
   /** UMD exports from `export as namespace N`. */
   globalExports: SymbolTable | undefined;
 
+  // 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: 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,
@@ -8373,6 +8387,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: NodeVisitor): boolean {