tsc-ts 0.1.1 → 0.1.2

package/src/compiler/checker-heritage.ts

@@ -965,16 +965,25 @@ const enum MemberKind {
  * (with `checkPrivateNames`) private names shared by static and instance members.
  */
 export function checkObjectTypeForDuplicateDeclarations(c: Checker, node: Node, checkPrivateNames: boolean): void {
-  const instanceNames = new Map<string, MemberKind>();
-  const staticNames = new Map<string, MemberKind>();
-  const privateNames = new Map<string, number>();
+  // Only a symbol with several declarations can be a duplicate, so the maps are created for the first one.
+  let instanceNames: Map<string, MemberKind> | undefined;
+  let staticNames: Map<string, MemberKind> | undefined;
+  let privateNames: Map<string, number> | undefined;
   const nodeInAmbientContext = (node.flags & NodeFlags.Ambient) !== 0;
   for (const member of getMembers(node)!.nodes) {
     if (member.kind === 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, MemberKind.Property, false);
+          if (symbol !== undefined && declarationCount(symbol) > 1)
+            checkPropertyOrAccessor(
+              c,
+              node,
+              (instanceNames ??= new Map<string, MemberKind>()),
+              symbol,
+              MemberKind.Property,
+              false,
+            );
         }
       continue;
     }
@@ -988,21 +997,26 @@ export function checkObjectTypeForDuplicateDeclarations(c: Checker, node: Node,
         symbol.name,
         symbolToString(c, getSymbolOfDeclaration(c, node)!),
       );
-    const names = memberIsStatic ? staticNames : instanceNames;
-    const hasAccessorModifier = hasSyntacticModifier(member, ModifierFlags.Accessor);
-    if (
-      (member.kind === SyntaxKind.PropertyDeclaration && !hasAccessorModifier) ||
-      member.kind === SyntaxKind.PropertySignature
-    )
-      checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Property, memberIsStatic);
-    else if (
-      member.kind === SyntaxKind.GetAccessor ||
-      member.kind === SyntaxKind.SetAccessor ||
-      (member.kind === SyntaxKind.PropertyDeclaration && hasAccessorModifier)
-    )
-      checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Accessor, memberIsStatic);
+    if (declarationCount(symbol) > 1) {
+      const names = memberIsStatic
+        ? (staticNames ??= new Map<string, MemberKind>())
+        : (instanceNames ??= new Map<string, MemberKind>());
+      const hasAccessorModifier = hasSyntacticModifier(member, ModifierFlags.Accessor);
+      if (
+        (member.kind === SyntaxKind.PropertyDeclaration && !hasAccessorModifier) ||
+        member.kind === SyntaxKind.PropertySignature
+      )
+        checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Property, memberIsStatic);
+      else if (
+        member.kind === SyntaxKind.GetAccessor ||
+        member.kind === SyntaxKind.SetAccessor ||
+        (member.kind === SyntaxKind.PropertyDeclaration && hasAccessorModifier)
+      )
+        checkPropertyOrAccessor(c, node, names, symbol, MemberKind.Accessor, memberIsStatic);
+    }
     const name = getName(member);
     if (checkPrivateNames && name !== undefined && name.kind === SyntaxKind.PrivateIdentifier) {
+      privateNames ??= new Map<string, number>();
       let flags = privateNames.get(symbol.name) ?? 0;
       if (flags === 3) continue;
       flags |= isStatic(member) ? 2 : 1;

package/src/compiler/checker-modules.ts

@@ -2167,14 +2167,16 @@ function getSymbolFlagsEx(
   excludeTypeOnlyMeanings: boolean,
   excludeLocalMeanings: boolean,
 ): SymbolFlags {
-  const seen = new Set<Symbol>();
+  // Only a chain of aliases needs the set, so most calls never create it.
+  let seen: Set<Symbol> | undefined;
   let flags = excludeLocalMeanings ? SymbolFlags.None : symbol.flags;
   while ((symbol.flags & SymbolFlags.Alias) !== 0) {
     if (excludeTypeOnlyMeanings && getTypeOnlyAliasDeclaration(c, symbol) !== undefined) break;
     const target = getExportSymbolOfValueSymbolIfExported(c, resolveAlias(c, symbol));
     if (target === c.unknownSymbol) return SymbolFlags.All;
     if ((target.flags & SymbolFlags.Alias) !== 0) {
-      if (target === symbol || seen.has(target)) break;
+      if (target === symbol || seen?.has(target)) break;
+      seen ??= new Set<Symbol>();
       seen.add(symbol);
       seen.add(target);
     }

package/src/compiler/checker-source-file.ts

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

package/src/compiler/checker-type-factory.ts

@@ -1765,20 +1765,26 @@ export function getIntersectionType(c: Checker, types: Type[]): Type {
   return getIntersectionTypeEx(c, types, 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 {
+  private static readonly INDEX_AFTER = 8;
   readonly values: Type[] = [];
-  private readonly seen = new Set<Type>();
+  private index: Set<Type> | undefined;
   includes = 0;
 
   has(t: Type): boolean {
-    return this.seen.has(t);
+    return this.index !== undefined ? this.index.has(t) : this.values.includes(t);
   }
 
   add(t: Type): void {
-    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);
   }
 }
 
@@ -2153,7 +2159,8 @@ function addCrossProductIntersections(
   intersections: Type[],
 ): void {
   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 & TypeFlags.Never) === 0) intersections.push(t);
     return;
   }

package/src/compiler/checker-type-nodes.ts

@@ -882,7 +882,7 @@ function getTypeFromTypeQueryNode(c: Checker, node: Node): Type {
   return type;
 }
 
-export function getTupleElementFlags(c: Checker, node: Node): ElementFlags {
+export function getTupleElementFlags(node: Node): ElementFlags {
   switch (node.kind) {
     case SyntaxKind.OptionalType:
       return ElementFlags.Optional;
@@ -901,9 +901,9 @@ export function getTupleElementFlags(c: Checker, node: Node): ElementFlags {
   return ElementFlags.Required;
 }
 
-function getTupleElementInfo(c: Checker, node: Node): TupleElementInfo {
+function getTupleElementInfo(node: Node): TupleElementInfo {
   return new TupleElementInfo(
-    getTupleElementFlags(c, node),
+    getTupleElementFlags(node),
     node.kind === SyntaxKind.NamedTupleMember || node.kind === SyntaxKind.Parameter ? node : undefined,
   );
 }
@@ -934,7 +934,7 @@ function getArrayOrTupleTargetType(c: Checker, node: Node): Type {
     parent.kind === SyntaxKind.TypeOperator && (parent as TypeOperatorNode).operator === SyntaxKind.ReadonlyKeyword;
   if (getArrayElementTypeNode(node) !== undefined) return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
   const elementInfos: TupleElementInfo[] = [];
-  for (const e of (node as TupleTypeNode).elements.nodes) elementInfos.push(getTupleElementInfo(c, e));
+  for (const e of (node as TupleTypeNode).elements.nodes) elementInfos.push(getTupleElementInfo(e));
   return getTupleTargetType(c, elementInfos, readonly);
 }
 
@@ -969,7 +969,7 @@ function getTypeFromArrayOrTupleTypeNode(c: Checker, node: Node): Type {
 }
 
 function hasVariadicTupleElement(c: Checker, node: TupleTypeNode): boolean {
-  for (const e of node.elements.nodes) if ((getTupleElementFlags(c, e) & ElementFlags.Variadic) !== 0) return true;
+  for (const e of node.elements.nodes) if ((getTupleElementFlags(e) & ElementFlags.Variadic) !== 0) return true;
   return false;
 }
 

package/src/compiler/checker-unused.ts

@@ -421,8 +421,9 @@ function checkUnusedClassMembers(c: Checker, node: Node): void {
 function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
   const locals = getLocals(node);
   if (locals === undefined) return;
-  const variableParents = new Set<Node>();
-  const importClauses = new Map<Node, Node[]>();
+  // Created on the first unused declaration: most scopes have none.
+  let variableParents: Set<Node> | undefined;
+  let importClauses: Map<Node, Node[]> | undefined;
   for (const local of locals.values()) {
     const referenceKinds = c.symbolReferenceKinds.get(getSymbolId(local));
     if ((local.flags & SymbolFlags.TypeParameter) !== 0) {
@@ -438,6 +439,7 @@ function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
         case SyntaxKind.VariableDeclaration:
         case SyntaxKind.Parameter:
         case SyntaxKind.BindingElement:
+          variableParents ??= new Set<Node>();
           variableParents.add(getRootDeclaration(declaration).parent!);
           break;
         case SyntaxKind.ImportClause:
@@ -445,6 +447,7 @@ function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
         case SyntaxKind.NamespaceImport:
           if (!isIdentifierThatStartsWithUnderscore(getName(declaration))) {
             const importClause = importClauseFromImported(declaration);
+            importClauses ??= new Map<Node, Node[]>();
             const unuseds = importClauses.get(importClause);
             if (unuseds === undefined) importClauses.set(importClause, [declaration]);
             else unuseds.push(declaration);
@@ -456,12 +459,14 @@ function checkUnusedLocalsAndParameters(c: Checker, node: Node): void {
       }
     }
   }
-  for (const declaration of variableParents) {
-    if (declaration.kind === SyntaxKind.VariableDeclarationList)
-      reportUnusedVariables(c, declaration, (declaration as VariableDeclarationList).declarations.nodes);
-    else reportUnusedVariableDeclarations(c, getParameters(declaration)!.nodes);
-  }
-  for (const [declaration, unuseds] of importClauses) reportUnusedImports(c, declaration as ImportClause, unuseds);
+  if (variableParents !== undefined)
+    for (const declaration of variableParents) {
+      if (declaration.kind === SyntaxKind.VariableDeclarationList)
+        reportUnusedVariables(c, declaration, (declaration as VariableDeclarationList).declarations.nodes);
+      else reportUnusedVariableDeclarations(c, getParameters(declaration)!.nodes);
+    }
+  if (importClauses !== undefined)
+    for (const [declaration, unuseds] of importClauses) reportUnusedImports(c, declaration as ImportClause, unuseds);
 }
 
 function reportUnusedLocal(c: Checker, node: Node, name: string): void {

package/src/compiler/checker.ts

@@ -411,6 +411,8 @@ export class Checker implements TypeChecking {
   // 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. */
   readonly memberPositionsInLists = new Map<Symbol[], Map<string, number>>();
   /** The property names of the last instantiation of each such list whose table is built on demand. */
@@ -1173,11 +1175,13 @@ export class Checker implements TypeChecking {
   }
 
   newSymbol(flags: SymbolFlags, name: string): Symbol {
+    this.symbolCount++;
     const symbol = new Symbol(flags | SymbolFlags.Transient, name);
     return symbol;
   }
 
   newSymbolWithCheckFlags(flags: SymbolFlags, name: string, checkFlags: CheckFlags): Symbol {
+    this.symbolCount++;
     const symbol = new Symbol(flags | SymbolFlags.Transient, name);
     symbol.checkFlags = checkFlags;
     return symbol;

package/src/compiler/file-loader.ts

@@ -131,6 +131,12 @@ export class CompilerHost extends ModuleResolutionHost {
     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: SourceFileMetadata | undefined = undefined;
+
   /** Parses a file, or returns `undefined` if it can't be read. */
   getSourceFile(
     fileName: string,
@@ -1222,6 +1228,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,

package/src/compiler/parallel-check.ts

@@ -199,6 +199,11 @@ export class CheckerResult {
     readonly units: number[] = [],
     /** Those of `units` after which its checker had diagnostics in their file (`checkSourceFileRange`). */
     readonly reportingUnits: number[] = [],
+    /**
+     * The types, instantiations and transient symbols its checker created, which `--diagnostics` adds to
+     * the main thread's (`CheckedProgram.addCheckerCounts`); empty for a result without a checker of its own.
+     */
+    readonly counts: number[] = [],
   ) {}
 }
 
@@ -243,6 +248,7 @@ export type PackedResult = {
   readonly reserved: number[];
   readonly units: Int32Array;
   readonly reportingUnits: Int32Array;
+  readonly counts: number[];
 };
 
 class ResultPacker {
@@ -346,6 +352,7 @@ export function packResult(result: CheckerResult, program: Program): PackedResul
     reserved: result.reserved,
     units: Int32Array.from(result.units),
     reportingUnits: Int32Array.from(result.reportingUnits),
+    counts: result.counts,
   };
 }
 
@@ -475,6 +482,7 @@ export function unpackResult(
     emits,
     Array.from(packed.units),
     Array.from(packed.reportingUnits),
+    packed.counts,
   );
 }
 
@@ -1928,6 +1936,7 @@ export function checkFromQueue(
     emits,
     unitsDone,
     reportingUnits,
+    onMainThread ? [] : [checked.checker.typeCount, checked.checker.totalInstantiations, checked.checker.symbolCount],
   );
 }
 
@@ -2326,6 +2335,7 @@ export function startParallelCheck(
     done(performance.now() - start);
   };
   const record = (result: CheckerResult): void => {
+    checked.addCheckerCounts(result.counts);
     if (declarationsTo !== undefined) {
       for (let k = 0; k < result.declarations.length; k++) declarationsTo[result.files[k]!] = result.declarations[k]!;
       if (trace)
@@ -2569,6 +2579,7 @@ class Revival {
       copy.emits.map((emit) => this.emit(emit)),
       copy.units,
       copy.reportingUnits,
+      copy.counts,
     );
   }
 

package/src/compiler/parse-thread.ts

@@ -6,10 +6,11 @@
 import { publish } from '@scriptc/threads';
 import { type ExternalModuleIndicatorOptions, ParseOptions, ScriptKind, type SourceFile } from './ast.js';
 import { bindSourceFile } from './binder.js';
+import { checkGrammarSourceFileInParseThread } from './checker-grammar.js';
 import { useThreadTextCaches } from './diagnostics.js';
 import { CompilerHost, FileLoader } from './file-loader.js';
 import { computeHash } from './incremental.js';
-import { isIncremental } from './options.js';
+import { type CompilerOptions, isIncremental } from './options.js';
 import type { FileSystem } from './file-system.js';
 import {
   fileSize,
@@ -29,6 +30,18 @@ class PreparingHost extends CompilerHost {
   prepared: PreparedFile[] = [];
   /** Whether the files' build info versions are computed (an incremental program). */
   computesVersions = false;
+  /**
+   * Whether the files the loader parses here run their grammar checks before they are published. The
+   * walk is the checker's, run off the checking threads (checker-grammar.ts).
+   */
+  grammarChecks = true;
+  /** The program's options, which the grammar checks of a file are given. */
+  readonly options: CompilerOptions;
+
+  constructor(fs: FileSystem, currentDirectory: string, defaultLibraryPath: string, options: CompilerOptions) {
+    super(fs, currentDirectory, defaultLibraryPath);
+    this.options = options;
+  }
   readMs = 0;
   parseMs = 0;
   bindMs = 0;
@@ -49,6 +62,12 @@ class PreparingHost extends CompilerHost {
     );
     const t2 = timeline ? performance.now() : 0;
     bindSourceFile(file);
+    // The checker does not check the declaration files `skipLibCheck` names, so it does not walk their
+    // grammar either. The walk reads the metadata the loader computed for the file, which is the one the
+    // checking thread reads it with, so it looks up no package.json the load has not looked up.
+    const metadata = this.loadingSourceFileMetadata;
+    if (this.grammarChecks && metadata !== undefined && !(this.options.skipLibCheck === true && file.isDeclarationFile))
+      checkGrammarSourceFileInParseThread(file, this.options, metadata);
     // Published now, while its nodes are in cache: the chunk's publish (`ParseThread.load`) then skips
     // them, where walking the whole chunk's files at once reads each node from memory again.
     publish(file);
@@ -85,11 +104,14 @@ export class ParseThread {
   private sentPackageJsons = 0;
 
   constructor(config: ParsedCommandLine, fs: FileSystem, currentDirectory: string, defaultLibraryPath: string) {
-    this.host = new PreparingHost(fs, currentDirectory, defaultLibraryPath);
+    this.host = new PreparingHost(fs, currentDirectory, defaultLibraryPath, config.options);
     // The versions of an incremental program's files are computed here rather than one after another
     // on the main thread (programToSnapshot, incremental.ts).
     this.host.computesVersions = isIncremental(config.options);
     this.loader = new FileLoader(this.host, config);
+    // A program that does not check has no grammar diagnostics to report. An incremental program checks
+    // the files a change affects and parses all of them, so the walk stays with the checker there.
+    this.host.grammarChecks = config.options.noCheck !== true && !isIncremental(config.options);
     // The files this thread loads are published with their chunk: text caches it computes later (of
     // declaration files, which the parser leaves out) go to copies.
     useThreadTextCaches();

package/src/compiler/program-checker.ts

@@ -248,6 +248,28 @@ export class CheckedProgram {
     this.reportingChecker = undefined;
   }
 
+  /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+  addCheckerCounts(counts: readonly number[]): void {
+    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(): { types: number; instantiations: number; symbols: number } {
+    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: SourceFile | undefined): Diagnostic[] {
     return this.collect(file, (f) => f.bindDiagnostics);
   }
@@ -272,6 +294,12 @@ export class CheckedProgram {
    */
   referenceThreads = 1;
   readonly parallelGlobalDiagnostics: Diagnostic[] = [];
+  /** 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/src/compiler/tsc-compile.ts

@@ -878,6 +878,8 @@ export class Statistics {
     rows.push([prefix + 'Types', String(this.types)]);
     rows.push([prefix + 'Instantiations', String(this.instantiations)]);
     rows.push([prefix + 'Memory used', `${Math.floor(this.memoryUsed / 1024)}K`]);
+    // The table has tsgo's rows. No runtime counter matches its allocation count (runtime.MemStats.Mallocs),
+    // so this one stays 0.
     rows.push([prefix + 'Memory allocs', String(this.memoryAllocs)]);
     const t = this.times;
     if (t.configTime !== 0) rows.push([prefix + 'Config time', formatDuration(t.configTime)]);
@@ -916,7 +918,14 @@ export function statisticsOf(compilerProgram: CompilerProgram): Statistics {
     statistics.identifiers += file.identifierCount;
     statistics.symbols += file.symbolCount;
   }
-  statistics.types = compilerProgram.checked.checker.typeCount;
+  // Every checker's counts, the checker threads' included, as tsgo's statisticsFromProgram reports them.
+  const counts = compilerProgram.checked.checkerCounts();
+  statistics.symbols += counts.symbols;
+  statistics.types = counts.types;
+  statistics.instantiations = counts.instantiations;
+  // tsgo reports the Go heap in use (runtime.MemStats.Alloc); the closest this runtime has is the
+  // process's resident set, which includes the checker threads' heaps.
+  statistics.memoryUsed = process.memoryUsage.rss();
   const t = statistics.times;
   const source = compilerProgram.times;
   t.configTime = source.configTime;