tsc-ts 0.1.0 → 0.1.2

package/src/compiler/parallel-emit.ts

@@ -15,12 +15,12 @@
  * thread's checker finds every diagnostic but those of declaration emit.
  */
 import type { Worker } from 'node:worker_threads';
-import { availableParallelism } from 'node:os';
 import { publish } from '@scriptc/threads';
 import { lastNodeIdValue, type SourceFile } from './ast.js';
 import { JavaScriptEmitter, type OutputWriter } from './compile-program.js';
 import type { Diagnostic, DiagnosticFile } from './diagnostics.js';
 import { EmitOnly, EmitResult, sourceFileMayBeEmitted } from './emitter.js';
+import { availableCpus } from './cgroup.js';
 import {
   CheckerResult,
   packResult,
@@ -78,7 +78,7 @@ export function emitThreads(
   emitKinds: readonly number[] | undefined = undefined,
 ): number {
   if (parallelEmit.spawn === undefined || singleThreaded === true) return 0;
-  const cpus = availableParallelism();
+  const cpus = availableCpus();
   if (cpus < 2) return 0;
   const files = program.getSourceFiles();
   let text = 0;
@@ -220,7 +220,7 @@ const maxDeclarationThreadCheckers = 8;
  * from 1 to 8 checkers, about even at 12, and 32-38% slower at 16. It also needs a CPU of its own.
  */
 export function declarationThreadPays(checkers: number): boolean {
-  return checkers <= maxDeclarationThreadCheckers && checkers < availableParallelism();
+  return checkers <= maxDeclarationThreadCheckers && checkers < availableCpus();
 }
 
 /**

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/parser.ts

@@ -202,6 +202,7 @@ import {
   newCallExpression,
   newPropertyAssignment,
 } from './ast.js';
+import { IdentifierName } from './identifier-name.js';
 import {
   OperatorPrecedence,
   canHaveDecorators,
@@ -3038,7 +3039,7 @@ export class Parser extends ScannerErrorReporter {
       identifierName = name;
     } else {
       this.parseErrorAt(skipTrivia(this.sourceText, name.pos), name.end, Diagnostics.Identifier_expected);
-      identifierName = this.newIdentifier('');
+      identifierName = this.newIdentifier(new IdentifierName(''));
       this.finishNode(identifierName, name.pos);
     }
     return this.checkJSSyntax(this.finishNode(new ImportSpecifier(isTypeOnly, propertyName, identifierName), pos));
@@ -3559,12 +3560,12 @@ export class Parser extends ScannerErrorReporter {
    * A new identifier of the class `use` calls for. Callers create it after the identifier's token, so
    * for an element name the current token tells a shorthand property from an assignment or a method.
    */
-  newIdentifier(text: string, use: IdentifierUse = IdentifierUse.Reference): Identifier {
+  newIdentifier(name: IdentifierName, use: IdentifierUse = IdentifierUse.Reference): Identifier {
     this.identifierCount++;
-    if (text === 'await') this.statementHasAwaitIdentifier = true;
+    if (name.text === 'await') this.statementHasAwaitIdentifier = true;
     if (use === IdentifierUse.Name || (use === IdentifierUse.ElementName && this.isElementNameEnd()))
-      return new Identifier(text);
-    return new ReferenceIdentifier(text);
+      return new Identifier(name);
+    return new ReferenceIdentifier(name);
   }
 
   /** Whether the current token ends an object literal element name that is not a shorthand property. */
@@ -3574,7 +3575,7 @@ export class Parser extends ScannerErrorReporter {
   }
 
   createMissingIdentifier(use: IdentifierUse = IdentifierUse.Reference): Identifier {
-    const result = this.newIdentifier('', use);
+    const result = this.newIdentifier(new IdentifierName(''), use);
     this.finishNode(result, this.nodePos());
     return result;
   }
@@ -4971,7 +4972,7 @@ export class Parser extends ScannerErrorReporter {
         // An unclosed opening element took its parent's closing element: restructure
         // (<div>(...<span>...</div>)) into (<div>(...<span>...</>)</div>). The parent reports it.
         const end = (lastChild as JsxElement).children.end;
-        const missingIdentifier = this.finishNodeWithEnd(this.newIdentifier(''), end, end);
+        const missingIdentifier = this.finishNodeWithEnd(this.newIdentifier(new IdentifierName('')), end, end);
         const newClosingElement = new JsxClosingElement(missingIdentifier);
         this.finishNodeWithEnd(newClosingElement, end, end);
         const newLast = new JsxElement(
@@ -6091,10 +6092,11 @@ export class Parser extends ScannerErrorReporter {
     if (isIdentifier) {
       const pos = this.scanner.hasPrecedingJSDocLeadingAsterisks() ? this.scanner.getTokenStart() : this.nodePos();
       const text = this.scanner.getIdentifierValue();
+      const name = this.scanner.getIdentifierName();
       const record = this.scanner.recordIdentifierValue(text);
       this.nextTokenWithoutCheck();
       if (record) this.identifierTexts.push(text);
-      const result = this.newIdentifier(text, use);
+      const result = this.newIdentifier(name, use);
       this.finishNode(result, pos);
       return result;
     }

package/src/compiler/printer/factory.ts

@@ -70,6 +70,7 @@ import {
 } from './helpers.js';
 import { formatGeneratedName, isMemberName, nodeIsSynthesized } from './utilities.js';
 import { OuterExpressionKinds, isOuterExpression, outerExpressionOperand } from '../transformers/utilities.js';
+import { IdentifierName } from '../identifier-name.js';
 
 /**
  * The node factory of an emit context. The context is the factory (`EmitContext` extends it), so the two are one
@@ -108,7 +109,7 @@ export abstract class NodeFactory extends NodeFactoryBase {
   }
 
   cloneIdentifier(node: Identifier): Identifier {
-    return this.cloneNode(node, new Identifier(node.text));
+    return this.cloneNode(node, new Identifier(node.identifierName));
   }
 
   createNodeList(nodes: Node[]): NodeList {
@@ -132,7 +133,7 @@ export abstract class NodeFactory extends NodeFactoryBase {
   }
 
   createIdentifier(text: string): Identifier {
-    return this.created(new Identifier(text));
+    return this.created(new Identifier(new IdentifierName(text)));
   }
 
   createKeywordExpression(kind: SyntaxKind): KeywordExpression {

package/src/compiler/printer/printer.ts

@@ -660,7 +660,8 @@ export class Printer extends NameGeneratorHost {
       case SyntaxKind.PrivateIdentifier:
       case SyntaxKind.JsxNamespacedName:
         // Its text either way: the source text, or the text of a node from elsewhere.
-        if (this.textIsSourceText(node)) return (node as Identifier | PrivateIdentifier).text;
+        if (this.textIsSourceText(node))
+          return node instanceof Identifier ? node.text : (node as PrivateIdentifier).text;
         if (!canUseSourceFile || !this.isInCurrentSourceFile(node)) {
           if (node instanceof Identifier) return node.text;
           if (node instanceof PrivateIdentifier) return node.text;
@@ -691,7 +692,8 @@ export class Printer extends NameGeneratorHost {
     if (!(node instanceof Identifier) && !(node instanceof PrivateIdentifier)) return false;
     if ((node.flags & (NodeFlags.Reparsed | NodeFlags.JSDoc | NodeFlags.ReparserTransformedLiteral)) !== 0)
       return false;
-    const text = node.text;
+    // Natively an identifier's text is read through its name, and a private identifier's from its field.
+    const text = node instanceof Identifier ? node.text : (node as PrivateIdentifier).text;
     const source = this.sourceText;
     const end = node.end;
     const start = end - text.length;

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/reparser.ts

@@ -98,6 +98,7 @@ import { Diagnostics } from './diagnostic-messages.js';
 import type { Parser } from './parser.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { TokenFlags } from './types.js';
+import { IdentifierName } from './identifier-name.js';
 
 /** Sets the parent of every node in a subtree. */
 class ParentInChildrenSetter extends NodeVisitor {
@@ -360,7 +361,7 @@ export class Reparser {
         const param = params[pi]!;
         let parameter: ParameterDeclaration;
         if (param instanceof JSDocThisTag) {
-          const thisIdent = new Identifier('this');
+          const thisIdent = new Identifier(new IdentifierName('this'));
           thisIdent.pos = (param as JSDocThisTag).pos;
           thisIdent.end = (param as JSDocThisTag).end;
           thisIdent.flags = p.contextFlags | NodeFlags.Reparsed;
@@ -387,7 +388,10 @@ export class Reparser {
           let name: Node = (param as JSDocParameterOrPropertyTag).name;
           if (name instanceof Identifier && !isValidIdentifier((name as Identifier).text)) {
             // Replace invalid characters with `_`, or use `_N` for an empty name, for a valid parameter name.
-            name = this.addTransformedReparse(new Identifier(sanitizeIdentifier((name as Identifier).text, pi)), name);
+            name = this.addTransformedReparse(
+              new Identifier(new IdentifierName(sanitizeIdentifier((name as Identifier).text, pi))),
+              name,
+            );
           } else {
             name = this.addDeepCloneReparse(name);
           }
@@ -611,7 +615,7 @@ export class Reparser {
             const thisParam = new ParameterDeclaration(
               undefined,
               undefined,
-              new Identifier('this'),
+              new Identifier(new IdentifierName('this')),
               undefined,
               undefined,
               undefined,