tsc-ts 0.0.5 → 0.0.7

package/src/compiler/node-builder-pseudo.ts

@@ -84,7 +84,6 @@ import {
 import { tryReuseExistingNode } from './node-builder-reuse.js';
 import { EmitFlags } from './printer/emit-flags.js';
 import { compareTypesIdentical } from './relations.js';
-import { CheckFlags, type Symbol, SymbolFlags } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { NodeBuilderFlags } from './transformers/declarations-resolver.js';
 import {
@@ -106,6 +105,7 @@ import {
 } from './transformers/declarations-pseudo.js';
 import { tryGetTextOfPropertyName } from './transformers/declarations-syntactic.js';
 import { TokenFlags } from './types.js';
+import { CheckFlags, declarationCount, type Symbol, SymbolFlags } from './symbol.js';
 
 /** Resolves no names: `undefined` in an expression is the undefined value, as tsgo's pseudochecker assumes. */
 class NoNames extends NameResolver {
@@ -562,7 +562,7 @@ export function pseudoTypeEquivalentToType(
       const targetProps = getPropertiesOfType(c, undefinedStripped);
       // Accessor pairs are two members but one property.
       let targetDeclCount = 0;
-      for (const prop of targetProps) targetDeclCount += prop.declarations.length;
+      for (const prop of targetProps) targetDeclCount += declarationCount(prop);
       if (pt.members.length !== targetDeclCount) return false;
       for (const e of pt.members) {
         let targetProp: Symbol | undefined = undefined;

package/src/compiler/node-builder.ts

@@ -214,7 +214,6 @@ import { TextWriter } from './printer/text-writer.js';
 import type { NodeFactory } from './printer/factory.js';
 import { isTypeIdenticalTo } from './relations.js';
 import { isIdentifierText } from './scanner.js';
-import { CheckFlags, type Symbol, SymbolFlags, type SymbolTable, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import {
   NodeBuilderFlags,
@@ -263,6 +262,15 @@ import {
   couldAlreadyReferToUndefined,
   undefinedType as pseudoUndefinedType,
 } from './transformers/declarations-pseudo.js';
+import {
+  CheckFlags,
+  declarationCount,
+  getDeclarations,
+  getSymbolId,
+  type Symbol,
+  SymbolFlags,
+  type SymbolTable,
+} from './symbol.js';
 
 const defaultMaximumTruncationLength = 160;
 const noTruncationMaximumTruncationLength = 1_000_000;
@@ -693,7 +701,7 @@ export class NodeBuilder {
 
   /** Adds the names bound by a destructured parameter; false if `param` isn't one. */
   private addBindingPatternParameters(param: Symbol, table: SymbolTable): boolean {
-    for (const d of param.declarations) {
+    for (const d of getDeclarations(param)) {
       if (d.kind !== SyntaxKind.Parameter) continue;
       const name = asBindingPattern(getName(d));
       if (name !== undefined) {
@@ -1431,14 +1439,14 @@ export class NodeBuilder {
     const c = this.c;
     let isStaticMethodSymbol = false;
     if ((symbol.flags & SymbolFlags.Method) !== 0)
-      for (const d of symbol.declarations)
+      for (const d of getDeclarations(symbol))
         if (isStatic(d) && !hasLateBindableIndexSignature(c, d)) isStaticMethodSymbol = true;
     let isNonLocalFunctionSymbol = false;
     let isFunctionExpressionSymbol = false;
     if ((symbol.flags & SymbolFlags.Function) !== 0) {
       if (symbol.parent !== undefined) isNonLocalFunctionSymbol = true;
       else
-        for (const d of symbol.declarations) {
+        for (const d of getDeclarations(symbol)) {
           const parent = d.parent!;
           if (parent.kind === SyntaxKind.SourceFile || parent.kind === SyntaxKind.ModuleBlock) {
             isNonLocalFunctionSymbol = true;
@@ -1740,8 +1748,8 @@ export class NodeBuilder {
     const saveEnclosingDeclaration = this.enclosingDeclaration;
     this.enclosingDeclaration = undefined;
     if (isLateBoundName(propertySymbol.name)) {
-      if (propertySymbol.declarations.length > 0) {
-        const decl = propertySymbol.declarations[0]!;
+      if (declarationCount(propertySymbol) > 0) {
+        const decl = propertySymbol.declaration!;
         if (hasLateBindableName(c, decl)) {
           if (decl instanceof BinaryExpression) {
             const name = getNameOfDeclaration(decl);
@@ -1756,7 +1764,7 @@ export class NodeBuilder {
     }
     this.enclosingDeclaration =
       propertySymbol.valueDeclaration ??
-      (propertySymbol.declarations.length > 0 ? propertySymbol.declarations[0]! : saveEnclosingDeclaration);
+      (declarationCount(propertySymbol) > 0 ? propertySymbol.declaration! : saveEnclosingDeclaration);
     const propertyName = getPropertyNameNodeForSymbol(this, propertySymbol);
     this.enclosingDeclaration = saveEnclosingDeclaration;
     this.approximateLength += symbolName(propertySymbol).length + 1;
@@ -1883,7 +1891,7 @@ export class NodeBuilder {
   }
 
   private isDeclaredInEnclosingFile(symbol: Symbol): boolean {
-    for (const d of symbol.declarations) if (getSourceFileOfNode(d) === this.enclosingFile) return true;
+    for (const d of getDeclarations(symbol)) if (getSourceFileOfNode(d) === this.enclosingFile) return true;
     return false;
   }
 
@@ -2119,8 +2127,8 @@ export class NodeBuilder {
     let result = symbolToName(this, typeParameter.symbol!, SymbolFlags.Type, true);
     if (!(result instanceof Identifier)) return this.identifier('(Missing type parameter)');
     const symbol = typeParameter.symbol;
-    if (symbol !== undefined && symbol.declarations.length > 0) {
-      const decl = symbol.declarations[0]!;
+    if (symbol !== undefined && declarationCount(symbol) > 0) {
+      const decl = symbol.declaration!;
       if (decl.kind === SyntaxKind.TypeParameter) result = this.setTextRange(result, getName(decl)) as Identifier;
     }
     if (generateNames) {
@@ -2484,7 +2492,7 @@ export class NodeBuilder {
   ): Node {
     const c = this.c;
     if (declaration === undefined && symbol !== undefined)
-      declaration = symbol.valueDeclaration ?? (symbol.declarations.length > 0 ? symbol.declarations[0]! : undefined);
+      declaration = symbol.valueDeclaration ?? (declarationCount(symbol) > 0 ? symbol.declaration! : undefined);
     if (symbol === undefined && declaration !== undefined) symbol = getSymbolOfDeclaration(c, declaration);
     let t = type;
     if (t === undefined && symbol !== undefined) {
@@ -2567,7 +2575,7 @@ export class NodeBuilder {
         : pseudo.getTypeOfDeclaration(declaration);
       if (pt.kind === PseudoTypeKind.NoResult && declaration.kind === SyntaxKind.BinaryExpression) {
         // The first annotated assignment declares the type for the rest.
-        for (const d of symbol.declarations)
+        for (const d of getDeclarations(symbol))
           if (getType(d) !== undefined) {
             pt = pseudo.getTypeOfDeclaration(d);
             break;
@@ -2814,9 +2822,9 @@ function isClassInstanceSide(c: Checker, t: Type): boolean {
 
 function getTypeAliasForTypeLiteral(c: Checker, t: Type): Symbol | undefined {
   const symbol = t.symbol;
-  if (symbol === undefined || (symbol.flags & SymbolFlags.TypeLiteral) === 0 || symbol.declarations.length === 0)
+  if (symbol === undefined || (symbol.flags & SymbolFlags.TypeLiteral) === 0 || declarationCount(symbol) === 0)
     return undefined;
-  let node = symbol.declarations[0]!.parent;
+  let node = symbol.declaration!.parent;
   while (node !== undefined && node.kind === SyntaxKind.ParenthesizedType) node = node.parent;
   if (node !== undefined && node.kind === SyntaxKind.TypeAliasDeclaration) return getSymbolOfDeclaration(c, node);
   return undefined;
@@ -2825,7 +2833,7 @@ function getTypeAliasForTypeLiteral(c: Checker, t: Type): Symbol | undefined {
 /** A copy of `t`, whose members are `resolved`, without its abstract construct signatures. */
 function getResolvedTypeWithoutAbstractConstructSignatures(c: Checker, t: Type, resolved: StructuredType): Type {
   if (resolved.constructSignatures.length === 0) return t;
-  const side = sideOf(c, t as StructuredType);
+  const side = membersHolder(c, t);
   if (side.objectTypeWithoutAbstractConstructSignatures !== undefined)
     return side.objectTypeWithoutAbstractConstructSignatures;
   const constructSignatures = resolved.constructSignatures.filter((s) => (s.flags & SignatureFlags.Abstract) === 0);
@@ -2865,7 +2873,7 @@ function getEffectiveConstraint(typeParameter: Node): Node | undefined {
 
 function getTypeParameterModifiers(tp: Type): ModifierFlags {
   let flags = ModifierFlags.None;
-  if (tp.symbol !== undefined) for (const d of tp.symbol.declarations) flags |= getCombinedModifierFlags(d);
+  if (tp.symbol !== undefined) for (const d of getDeclarations(tp.symbol)) flags |= getCombinedModifierFlags(d);
   return flags & (ModifierFlags.In | ModifierFlags.Out | ModifierFlags.Const);
 }
 

package/src/compiler/parallel-check.ts

@@ -440,7 +440,7 @@ function checksLittle(program: Program): boolean {
   let text = 0;
   for (const file of program.getSourceFiles()) {
     if (file.isDeclarationFile && options.skipLibCheck === true) continue;
-    text += file.text.length;
+    text += file.end;
     if (text >= littleText) return false;
   }
   return true;
@@ -454,10 +454,14 @@ export function autoCheckers(cpus: number, fit: number): number {
 /**
  * The number of threads that parse ahead of a program checked by `checkers` checkers: every CPU this
  * process may run on, as tsgo parses on every core whatever its checker count (parse threads hand
- * their files to the shared program; what else they allocate is reused by the checker threads).
+ * their files to the shared program; what else they allocate is reused by the checker threads), but
+ * one. The main thread hands out the chunks they load: with a thread on every CPU, it waits for a CPU
+ * each time a thread returns a chunk, and so does that thread for its next chunk (VS Code's parse took
+ * 18-57 ms longer with 16 threads on 16 CPUs than with 15).
  */
 export function parseThreads(checkers: number): number {
-  return Math.max(checkers, Math.min(availableParallelism(), maxAutoCheckers));
+  const cpus = availableParallelism();
+  return Math.max(1, Math.min(cpus - 1, Math.max(checkers, Math.min(cpus, maxAutoCheckers))));
 }
 
 /**
@@ -572,15 +576,14 @@ let lengthsProgram: Program | undefined = undefined;
 let lengthsOfProgram: number[] = [];
 
 /**
- * The text length of each of `program`'s files, by index, computed once per program. In scriptc
- * builds a thread caches the UTF-16 length of only the few non-ASCII strings it read last, so each
- * read of a non-ASCII file's `text.length` scans its text again, and planning reads a file's length
- * several times (its cost, the load of each group candidate importing it, its position).
+ * The text length of each of `program`'s files, by index, computed once per program: a file's `end`,
+ * the length the parser found. In scriptc builds a thread caches the UTF-16 length of only the few
+ * non-ASCII strings it read last, so reading a non-ASCII file's `text.length` scans its text.
  */
 export function textLengths(program: Program): number[] {
   if (lengthsProgram !== program) {
     const lengths: number[] = [];
-    for (const file of program.getSourceFiles()) lengths.push(file.text.length);
+    for (const file of program.getSourceFiles()) lengths.push(file.end);
     lengthsProgram = program;
     lengthsOfProgram = lengths;
   }

package/src/compiler/parallel-parse.ts

@@ -86,6 +86,11 @@ export function preparedVersion(file: SourceFile): string {
   return prepared !== undefined && prepared.file === file ? prepared.version : '';
 }
 
+/** Whether a parse thread prepared `fileName`. */
+export function isPrepared(fileName: string): boolean {
+  return parallelParse.files.has(fileName);
+}
+
 /** What a parse thread's FileLoader found loading `fileName`, if the thread prepared it. */
 export function preparedLoad(fileName: string): LoadedFile | undefined {
   if (parallelParse.files.size === 0) return undefined;
@@ -489,7 +494,9 @@ export class ParseSession {
   }
 
   private post(i: number, chunk: LoadMessage): void {
-    this.workers[i]!.postMessage(chunk);
+    // Published, the chunk reaches the thread by pointer: copying its names into the message took the
+    // main thread 25-45 us per chunk, which during config read delays the matching of root files.
+    this.workers[i]!.postMessage(publish(chunk));
     this.outstanding[i] = this.outstanding[i]! + 1;
     if (chunk.kinds[0] === LoadKind.Library && largeLibraries.has(chunk.names[0]!)) this.blocked[i] = true;
     this.busy++;

package/src/compiler/parse-thread.ts

@@ -6,7 +6,6 @@
 import { publish } from '@scriptc/threads';
 import { type ExternalModuleIndicatorOptions, ParseOptions, ScriptKind, type SourceFile } from './ast.js';
 import { bindSourceFile } from './binder.js';
-import { scanSiblingProperties } from './checker-symbol-types.js';
 import { useThreadTextCaches } from './diagnostics.js';
 import { CompilerHost, FileLoader } from './file-loader.js';
 import { computeHash } from './incremental.js';
@@ -50,9 +49,6 @@ class PreparingHost extends CompilerHost {
     );
     const t2 = timeline ? performance.now() : 0;
     bindSourceFile(file);
-    // Checkers look up the unions of the files tsgo checks with one checker (firstSiblingProperty):
-    // each file is scanned here once instead of by every checker.
-    file.siblingProperties = scanSiblingProperties(file, undefined);
     if (timeline) {
       const t3 = performance.now();
       this.readMs += t1 - t0;