tsc-ts 0.0.5 → 0.0.7

package/src/compiler/printer/emit-context.ts

@@ -12,6 +12,7 @@ import {
   VariableDeclaration,
   VariableStatement,
 } from '../ast.js';
+import { ClusteredLinkTable } from '../link-tables.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { EmitFlags, GeneratedIdentifierFlags } from './emit-flags.js';
 import { AutoGenerateInfo } from './auto-generate.js';
@@ -135,8 +136,10 @@ export { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
 export class EmitContext extends NodeFactory {
   readonly autoGenerate: Map<Node, AutoGenerateInfo>;
   readonly textSource: Map<Node, Node>;
-  readonly original: Map<Node, Node>;
-  readonly emitNodes: Map<Node, EmitNode>;
+  /** The node each node was made from, by node id. */
+  readonly original: ClusteredLinkTable<Node>;
+  /** The emit data of nodes, by node id. */
+  readonly emitNodes: ClusteredLinkTable<EmitNode>;
   private lastLookup: Node | undefined;
   private lastEmitNode: EmitNode | undefined;
   readonly assignedNames: Map<Node, Node>;
@@ -150,8 +153,8 @@ export class EmitContext extends NodeFactory {
     super();
     this.autoGenerate = new Map<Node, AutoGenerateInfo>();
     this.textSource = new Map<Node, Node>();
-    this.original = new Map<Node, Node>();
-    this.emitNodes = new Map<Node, EmitNode>();
+    this.original = new ClusteredLinkTable<Node>();
+    this.emitNodes = new ClusteredLinkTable<EmitNode>();
     this.lastLookup = undefined;
     this.lastEmitNode = undefined;
     this.assignedNames = new Map<Node, Node>();
@@ -187,7 +190,7 @@ export class EmitContext extends NodeFactory {
     let emitNode = this.lookup(node);
     if (emitNode === undefined) {
       emitNode = new EmitNode();
-      this.emitNodes.set(node, emitNode);
+      this.emitNodes.set(node.id, emitNode);
       this.lastLookup = node;
       this.lastEmitNode = emitNode;
     }
@@ -197,7 +200,7 @@ export class EmitContext extends NodeFactory {
   /** The emit data of `node`. The printer asks for several of a node's in a row, so the last answer is kept. */
   private lookup(node: Node): EmitNode | undefined {
     if (node === this.lastLookup) return this.lastEmitNode;
-    const emitNode = this.emitNodes.get(node);
+    const emitNode = this.emitNodes.get(node.id);
     this.lastLookup = node;
     this.lastEmitNode = emitNode;
     return emitNode;
@@ -210,29 +213,31 @@ export class EmitContext extends NodeFactory {
   }
 
   setOriginalEx(node: Node, original: Node, allowOverwrite: boolean): void {
-    const existing = this.original.get(node);
+    const existing = this.original.get(node.id);
     if (existing === undefined) {
-      this.original.set(node, original);
+      this.original.set(node.id, original);
       const emitNode = this.lookup(original);
       if (emitNode !== undefined) this.emitNode(node).copyFrom(emitNode);
-    } else if (allowOverwrite) this.original.set(node, original);
+    } else if (allowOverwrite) this.original.set(node.id, original);
     else if (existing !== original) throw new Error('Original node already set.');
   }
 
   unsetOriginal(node: Node): boolean {
-    return this.original.delete(node);
+    if (this.original.get(node.id) === undefined) return false;
+    this.original.set(node.id, undefined);
+    return true;
   }
 
   getOriginal(node: Node): Node | undefined {
-    return this.original.get(node);
+    return this.original.get(node.id);
   }
 
   /** The node at the end of the chain of original nodes. */
   mostOriginal(node: Node): Node {
-    let original = this.original.get(node);
+    let original = this.original.get(node.id);
     while (original !== undefined) {
       node = original;
-      original = this.original.get(node);
+      original = this.original.get(node.id);
     }
     return node;
   }
@@ -260,7 +265,7 @@ export class EmitContext extends NodeFactory {
       return name;
     let node = info.node!;
     const id = info.id;
-    let original = this.original.get(node);
+    let original = this.original.get(node.id);
     while (original !== undefined) {
       node = original;
       if (node instanceof Identifier || node instanceof PrivateIdentifier) {
@@ -275,7 +280,7 @@ export class EmitContext extends NodeFactory {
           continue;
         }
       }
-      original = this.original.get(node);
+      original = this.original.get(node.id);
     }
     return node;
   }

package/src/compiler/printer/factory-base.ts

@@ -199,6 +199,13 @@ import {
   type Node,
   type NodeList,
   type Token,
+  propertyAssignmentPostfixToken,
+  propertyAssignmentType,
+  callQuestionDotToken,
+  propertyAssignmentModifiers,
+  callTypeArguments,
+  newCallExpression,
+  newPropertyAssignment,
 } from '../ast.js';
 import type { SyntaxKind } from '../syntax-kind.js';
 
@@ -359,12 +366,12 @@ export abstract class NodeFactoryBase {
   ): CallExpression {
     if (
       expression !== node.expression ||
-      questionDotToken !== node.questionDotToken ||
-      typeArguments !== node.typeArguments ||
+      questionDotToken !== callQuestionDotToken(node) ||
+      typeArguments !== callTypeArguments(node) ||
       args !== node.arguments ||
       flags !== node.flags
     ) {
-      const updated = new CallExpression(expression, questionDotToken, typeArguments, args, flags);
+      const updated = newCallExpression(expression, questionDotToken, typeArguments, args, flags, false);
       this.finishUpdate(updated, node);
       return updated;
     }
@@ -2057,13 +2064,13 @@ export abstract class NodeFactoryBase {
     initializer: Expression,
   ): PropertyAssignment {
     if (
-      modifiers !== node.modifiers ||
+      modifiers !== propertyAssignmentModifiers(node) ||
       name !== node.name ||
-      postfixToken !== node.postfixToken ||
-      typeNode !== node.type ||
+      postfixToken !== propertyAssignmentPostfixToken(node) ||
+      typeNode !== propertyAssignmentType(node) ||
       initializer !== node.initializer
     ) {
-      const updated = new PropertyAssignment(modifiers, name, postfixToken, typeNode, initializer);
+      const updated = newPropertyAssignment(modifiers, name, postfixToken, typeNode, initializer, false);
       this.finishUpdate(updated, node);
       return updated;
     }

package/src/compiler/printer/factory.ts

@@ -45,6 +45,8 @@ import {
   VariableDeclarationList,
   VariableStatement,
   VoidExpression,
+  newCallExpression,
+  newPropertyAssignment,
 } from '../ast.js';
 import { modifierToFlag } from '../ast-utilities.js';
 import { getNameOfDeclaration, getNonAssignedNameOfDeclaration, hasSyntacticModifier } from '../binder-utilities.js';
@@ -166,7 +168,7 @@ export abstract class NodeFactory extends NodeFactoryBase {
 
   createCallExpression(expression: Node, args: Node[]): CallExpression {
     return this.created(
-      new CallExpression(expression, undefined, undefined, this.createNodeList(args), NodeFlags.None),
+      newCallExpression(expression, undefined, undefined, this.createNodeList(args), NodeFlags.None, false),
     );
   }
 
@@ -265,7 +267,7 @@ export abstract class NodeFactory extends NodeFactoryBase {
   }
 
   createPropertyAssignment(name: Node, initializer: Node): PropertyAssignment {
-    return this.created(new PropertyAssignment(undefined, name, undefined, undefined, initializer));
+    return this.created(newPropertyAssignment(undefined, name, undefined, undefined, initializer, false));
   }
 
   createParameter(name: Node): ParameterDeclaration {
@@ -546,7 +548,7 @@ export abstract class NodeFactory extends NodeFactoryBase {
   createMethodCall(object: Node, method: string, args: Node[]): CallExpression {
     const callee = this.createPropertyAccessExpression(object, this.createIdentifier(method));
     const flags = object instanceof CallExpression ? object.flags & NodeFlags.OptionalChain : NodeFlags.None;
-    return this.created(new CallExpression(callee, undefined, undefined, this.createNodeList(args), flags));
+    return this.created(newCallExpression(callee, undefined, undefined, this.createNodeList(args), flags, false));
   }
 
   /** `Global.method(...args)`, such as `Math.pow(a, b)`. */

package/src/compiler/printer/printer.ts

@@ -157,6 +157,8 @@ import {
   getProperties,
   getStatements,
   getModifiers,
+  callQuestionDotToken,
+  callTypeArguments,
 } from '../ast.js';
 import { OperatorPrecedence } from '../ast-utilities.js';
 import {
@@ -2248,8 +2250,8 @@ export class Printer extends NameGeneratorHost {
   private emitCallExpression(node: CallExpression): boolean {
     const state = this.enterNode(node);
     this.emitCallee(node.expression, node);
-    this.emitOptionalToken(node.questionDotToken);
-    this.emitTypeArguments(node, node.typeArguments);
+    this.emitOptionalToken(callQuestionDotToken(node));
+    this.emitTypeArguments(node, callTypeArguments(node));
     this.emitList(ListItem.Argument, node, node.arguments, ListFormat.CallExpressionArguments);
     this.exitNode(node, state);
     return true;
@@ -2653,8 +2655,8 @@ export class Printer extends NameGeneratorHost {
       return factory.updateCallExpression(
         node,
         this.parenthesizeExpressionForNoAsi(node.expression),
-        node.questionDotToken,
-        node.typeArguments,
+        callQuestionDotToken(node),
+        callTypeArguments(node),
         node.arguments,
         node.flags,
       );
@@ -2921,8 +2923,8 @@ export class Printer extends NameGeneratorHost {
         this.write1('(');
         this.emitExpression(call.expression, OperatorPrecedence.Lowest);
         this.write1(')');
-        this.emitOptionalToken(call.questionDotToken);
-        this.emitTypeArguments(call, call.typeArguments);
+        this.emitOptionalToken(callQuestionDotToken(call));
+        this.emitTypeArguments(call, callTypeArguments(call));
         this.emitList(ListItem.Argument, call, call.arguments, ListFormat.CallExpressionArguments);
         this.exitNode(call, callState);
       }

package/src/compiler/program-checker.ts

@@ -32,6 +32,11 @@ import { CommentDirectiveKind } from './types.js';
 /** What the checker needs, answered by a program. */
 export class ProgramCheckerHost extends CheckerHost {
   private specifierHost: ProgramModuleSpecifierHost | undefined = undefined;
+  /**
+   * `getSourceFileForResolvedModule` by resolved file name (null when there is none): every import of
+   * a module asks again, and the program finds a file by its path, which it computes from the name.
+   */
+  private readonly resolvedSourceFiles = new Map<string, SourceFile | null>();
 
   constructor(readonly program: Program) {
     super();
@@ -54,7 +59,11 @@ export class ProgramCheckerHost extends CheckerHost {
   }
 
   getSourceFileForResolvedModule(fileName: string): SourceFile | undefined {
-    return this.program.getSourceFileForResolvedModule(fileName);
+    const known = this.resolvedSourceFiles.get(fileName);
+    if (known !== undefined) return known ?? undefined;
+    const file = this.program.getSourceFileForResolvedModule(fileName);
+    this.resolvedSourceFiles.set(fileName, file ?? null);
+    return file;
   }
 
   getModeForUsageLocation(file: SourceFile, location: Node): ModuleKind {
@@ -425,6 +434,8 @@ class Directives {
   private readonly byLine = new Map<number, { pos: number; end: number; kind: CommentDirectiveKind }>();
 
   constructor(readonly file: SourceFile) {
+    // Most files have no directives, and need no line starts.
+    if (file.commentDirectives.length === 0) return;
     const lineStarts = file.diagnosticFile().getLineStarts();
     for (const directive of file.commentDirectives) {
       const line = computeLineOfPosition(lineStarts, directive.pos);

package/src/compiler/program.ts

@@ -152,12 +152,19 @@ export class Program implements OutputPathsHost {
       this.includeProcessor = processed.includeProcessor;
       for (const diagnostic of previous.programDiagnosticsList) this.programDiagnosticsList.push(diagnostic);
       for (const path of previous.emitBlockingPaths) this.emitBlockingPaths.add(path);
-      this.symlinks = previous.symlinks;
+      // The files and include reasons it takes from a program shared with checker threads are immutable, and
+      // so is that program's symlink cache: this one computes its own then (`getSymlinkCache`).
+      this.shared = previous.shared;
+      if (!previous.shared) this.symlinks = previous.symlinks;
+      // The same files are emitted, so the common source directory is the same. Its diagnostics are those
+      // `previous` was created with (`IncludeProcessor.copy`).
+      this.commonSourceDirectoryValue = previous.commonSourceDirectoryValue;
     } else {
       this.processed = (loader ?? new FileLoader(host, commandLine)).load();
       this.includeProcessor = this.processed.includeProcessor;
       this.verifyCompilerOptions();
     }
+    this.includeProcessor.noteProgramCreated();
   }
 
   /**

package/src/compiler/relations.ts

@@ -13,7 +13,6 @@ import {
 import { getSymbolNameForPrivateIdentifier } from './binder.js';
 import { getCombinedModifierFlags } from './binder-utilities.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics, messageElidedInCompatibilityPyramid } from './diagnostics.js';
-import { CheckFlags, type Symbol, SymbolFlags, getSymbolId } from './symbol.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { isContextSensitive } from './checker-functions.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
@@ -130,6 +129,8 @@ import {
   getResolvedMember,
   hasResolvedProperties,
   resolvedPropertiesAreOptional,
+  positionsOfNamesFoundInSource,
+  firstUnmatchedProperty,
 } from './checker-members.js';
 import {
   getParentOfSymbol,
@@ -224,6 +225,7 @@ import {
   isNumericLiteralName,
   maybeTypeOfKind,
 } from './checker-utilities.js';
+import { CheckFlags, declarationCount, getDeclarations, getSymbolId, type Symbol, SymbolFlags } from './symbol.js';
 
 // ---- Results and caches
 
@@ -754,8 +756,8 @@ function isEnumTypeRelatedTo(c: Checker, source: Symbol, target: Symbol, reporte
       c.enumRelation.set(key, RelationComparisonResult.Failed);
       return false;
     }
-    const sourceDecl = sourceProperty.declarations.find((d) => d.kind === SyntaxKind.EnumMember);
-    const targetDecl = targetProperty.declarations.find((d) => d.kind === SyntaxKind.EnumMember);
+    const sourceDecl = getDeclarations(sourceProperty).find((d) => d.kind === SyntaxKind.EnumMember);
+    const targetDecl = getDeclarations(targetProperty).find((d) => d.kind === SyntaxKind.EnumMember);
     if (sourceDecl === undefined || targetDecl === undefined) continue;
     computeEnumMemberValues(c, sourceDecl.parent!);
     computeEnumMemberValues(c, targetDecl.parent!);
@@ -1375,8 +1377,8 @@ export class Relater extends TypeComparer {
             return true;
           }
           const objectLiteralDeclaration =
-            source.symbol !== undefined && source.symbol.declarations.length !== 0
-              ? source.symbol.declarations[0]!
+            source.symbol !== undefined && declarationCount(source.symbol) !== 0
+              ? source.symbol.declaration!
               : undefined;
           const valueDeclaration = prop.valueDeclaration;
           let suggestion: Symbol | undefined = undefined;
@@ -2822,7 +2824,13 @@ export class Relater extends TypeComparer {
       !isObjectLiteralType(source) &&
       !isEmptyArrayLiteralType(c, source) &&
       !isTupleType(source);
-    const unmatchedProperty = getUnmatchedProperty(c, source, target, requireOptionalProperties, false);
+    const targetProperties = getPropertiesOfType(c, target);
+    // Where it is known which target names the source has, nothing else is looked up by name.
+    const found = positionsOfNamesFoundInSource(c, source, target, targetProperties);
+    const unmatchedProperty =
+      found !== undefined
+        ? firstUnmatchedProperty(c, targetProperties, found, requireOptionalProperties)
+        : getUnmatchedProperty(c, source, target, requireOptionalProperties, false);
     if (unmatchedProperty !== undefined) {
       if (reportErrors && shouldReportUnmatchedPropertyError(c, source, target))
         this.reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
@@ -2842,7 +2850,7 @@ export class Relater extends TypeComparer {
       }
     }
     const numericNamesOnly = isTupleType(source) && isTupleType(target);
-    for (const targetProp of getPropertiesOfType(c, target)) {
+    for (const targetProp of found !== undefined ? found.map((i) => targetProperties[i]!) : targetProperties) {
       if (excludedProperties !== undefined && excludedProperties.has(targetProp.name)) continue;
       const name = targetProp.name;
       if (
@@ -3037,9 +3045,9 @@ export class Relater extends TypeComparer {
         names[0],
         names[1],
       ]);
-      if (unmatchedProperty.declarations.length !== 0)
+      if (declarationCount(unmatchedProperty) !== 0)
         this.relatedInfo.push(
-          createDiagnosticForNode(unmatchedProperty.declarations[0]!, Diagnostics.X_0_is_declared_here, [propName]),
+          createDiagnosticForNode(unmatchedProperty.declaration!, Diagnostics.X_0_is_declared_here, [propName]),
         );
     } else if (this.tryElaborateArrayLikeErrors(source, target, false)) {
       const names = getTypeNamesForErrorDisplay(c, source, target);
@@ -3486,7 +3494,7 @@ export class Relater extends TypeComparer {
     if (
       (source.flags & TypeFlags.TypeParameter) !== 0 &&
       source.symbol !== undefined &&
-      source.symbol.declarations.length !== 0 &&
+      declarationCount(source.symbol) !== 0 &&
       getConstraintOfType(c, source) === undefined
     ) {
       const syntheticParam = cloneTypeParameter(c, source);
@@ -3494,7 +3502,7 @@ export class Relater extends TypeComparer {
       if (hasNonCircularBaseConstraint(c, syntheticParam)) {
         this.relatedInfo.push(
           createDiagnosticForNode(
-            source.symbol.declarations[0]!,
+            source.symbol.declaration!,
             Diagnostics.This_type_parameter_might_need_an_extends_0_constraint,
             [typeToString(c, target)],
           ),
@@ -4504,7 +4512,7 @@ import { getTypeAliasInstantiation } from './checker-type-nodes.js';
 
 export function getTypeParameterModifiers(tp: Type): ModifierFlags {
   let flags = 0;
-  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/reparser.ts

@@ -84,6 +84,7 @@ import {
   getTypeExpression,
   getTypeParameters,
   type TypeNode,
+  FullPropertyAssignment,
 } from './ast.js';
 import {
   isAssignmentOperator,
@@ -855,10 +856,14 @@ export class Reparser {
     if (parent.kind !== SyntaxKind.ClassDeclaration && parent.kind !== SyntaxKind.ClassExpression) return false;
     const className = tag.className;
     const heritageClauses = getHeritageClauses(parent);
+    // Parsed lists may share their nodes array (empty ones do), so a longer list is a new list.
     if (heritageClauses !== undefined) {
       for (const clause of heritageClauses.nodes)
         if (clause instanceof HeritageClause && (clause as HeritageClause).token === SyntaxKind.ImplementsKeyword) {
-          (clause as HeritageClause).types.nodes.push(this.addDeepCloneReparse(className));
+          const types = (clause as HeritageClause).types;
+          const nodes = types.nodes.slice();
+          nodes.push(this.addDeepCloneReparse(className));
+          (clause as HeritageClause).types = this.p.newNodeList(types.pos, types.end, nodes);
           this.finishMutatedNode(clause);
           return true;
         }
@@ -868,7 +873,11 @@ export class Reparser {
     this.finishReparsedNode(heritageClause, className);
     if (heritageClauses === undefined)
       setHeritageClauses(parent, this.p.newNodeList(className.pos, className.end, [heritageClause]));
-    else heritageClauses.nodes.push(heritageClause);
+    else {
+      const nodes = heritageClauses.nodes.slice();
+      nodes.push(heritageClause);
+      setHeritageClauses(parent, this.p.newNodeList(heritageClauses.pos, heritageClauses.end, nodes));
+    }
     this.finishMutatedNode(parent);
     return true;
   }
@@ -1420,8 +1429,9 @@ function setType(node: Node, value: Node): boolean {
     (node as PropertyDeclaration).type = value;
     return true;
   }
-  if (node instanceof PropertyAssignment) {
-    (node as PropertyAssignment).type = value;
+  // Property assignments in JavaScript files, which are the ones reparsed, are full ones.
+  if (node instanceof FullPropertyAssignment) {
+    (node as FullPropertyAssignment).type = value;
     return true;
   }
   if (node instanceof ShorthandPropertyAssignment) {