tsc-ts 0.1.0 → 0.1.1

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/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/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,