tsc-ts 0.0.9 → 0.1.0

package/src/compiler/diagnostics.ts

@@ -347,6 +347,11 @@ export class Diagnostic {
   readonly reportsDeprecated: boolean;
   skippedOnNoEmit = false;
   repopulateInfo: RepopulateInfo | undefined = undefined;
+  /**
+   * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+   * thread that found it formatted it (`packResult`); `''` otherwise.
+   */
+  formatted = '';
 
   constructor(
     file: DiagnosticFile | undefined,
@@ -388,6 +393,7 @@ export class Diagnostic {
     result.relatedInformation = this.relatedInformation;
     result.skippedOnNoEmit = this.skippedOnNoEmit;
     result.repopulateInfo = this.repopulateInfo;
+    result.formatted = this.formatted;
     return result;
   }
 }
@@ -510,9 +516,13 @@ function compareRelatedInfo(a: readonly Diagnostic[], b: readonly Diagnostic[]):
 /** The order tsc reports diagnostics in: by file, position, code, arguments, then elaboration. */
 export function compareDiagnostics(a: Diagnostic, b: Diagnostic): number {
   if (a === b) return 0;
-  let c = compareCodePoints(fileNameOf(a), fileNameOf(b));
-  if (c !== 0) return c;
-  c = a.pos - b.pos;
+  const c = compareCodePoints(fileNameOf(a), fileNameOf(b));
+  return c !== 0 ? c : compareDiagnosticsInFile(a, b);
+}
+
+/** `compareDiagnostics` of two diagnostics whose files have the same name. */
+function compareDiagnosticsInFile(a: Diagnostic, b: Diagnostic): number {
+  let c = a.pos - b.pos;
   if (c !== 0) return c;
   c = a.end - b.end;
   if (c !== 0) return c;
@@ -527,6 +537,61 @@ export function compareDiagnostics(a: Diagnostic, b: Diagnostic): number {
   return compareRelatedInfo(a.relatedInformation, b.relatedInformation);
 }
 
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export function sortDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[] {
+  const n = diagnostics.length;
+  if (n < 2) return diagnostics.slice();
+  const fileIndices = new Map<DiagnosticFile | undefined, number>();
+  const files: (DiagnosticFile | undefined)[] = [];
+  const fileOf: number[] = [];
+  let last: DiagnosticFile | undefined = undefined;
+  let lastIndex = -1;
+  for (let i = 0; i < n; i++) {
+    const file = diagnostics[i]!.file;
+    if (lastIndex < 0 || file !== last) {
+      let k = fileIndices.get(file);
+      if (k === undefined) {
+        k = files.length;
+        fileIndices.set(file, k);
+        files.push(file);
+      }
+      last = file;
+      lastIndex = k;
+    }
+    fileOf.push(lastIndex);
+  }
+  // Files with the same name share a rank, as they compare equal.
+  const nameOf = (k: number): string => {
+    const file = files[k];
+    return file === undefined ? '' : file.fileName;
+  };
+  const byName: number[] = [];
+  for (let k = 0; k < files.length; k++) byName.push(k);
+  byName.sort((x, y) => compareCodePoints(nameOf(x), nameOf(y)));
+  const rank: number[] = [];
+  for (let k = 0; k < files.length; k++) rank.push(0);
+  for (let k = 1; k < byName.length; k++)
+    rank[byName[k]!] = rank[byName[k - 1]!]! + (nameOf(byName[k]!) === nameOf(byName[k - 1]!) ? 0 : 1);
+  const order: number[] = [];
+  for (let i = 0; i < n; i++) order.push(i);
+  order.sort((x, y) => {
+    const c = rank[fileOf[x]!]! - rank[fileOf[y]!]!;
+    if (c !== 0) return c;
+    const a = diagnostics[x]!;
+    const b = diagnostics[y]!;
+    return a === b ? 0 : compareDiagnosticsInFile(a, b);
+  });
+  const sorted: Diagnostic[] = [];
+  for (const i of order) sorted.push(diagnostics[i]!);
+  return sorted;
+}
+
 function equalChain(a: readonly Diagnostic[], b: readonly Diagnostic[]): boolean {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
@@ -625,13 +690,29 @@ function formatDiagnosticIn(diagnostic: Diagnostic, fileName: string, options: D
   return result + flattenDiagnosticMessage(diagnostic, options.newLine, options.locale) + options.newLine;
 }
 
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export class FormattedReports {
+  format: DiagnosticFormatOptions | undefined = undefined;
+}
+
+export const formattedReports = new FormattedReports();
+
 /** `formatDiagnostic` of each diagnostic. */
 export function formatDiagnostics(diagnostics: readonly Diagnostic[], options: DiagnosticFormatOptions): string {
   let result = '';
+  const formatted = options === formattedReports.format;
   // Sorted diagnostics come a file at a time: the relative name of the last file is kept.
   let lastFile: DiagnosticFile | undefined = undefined;
   let lastName = '';
   for (const diagnostic of diagnostics) {
+    if (formatted && diagnostic.formatted !== '') {
+      result += diagnostic.formatted;
+      continue;
+    }
     const file = diagnostic.file;
     if (file !== undefined && file !== lastFile) {
       lastFile = file;

package/src/compiler/emitter.ts

@@ -1,7 +1,7 @@
 // Emits JavaScript and declarations for source files: runs the transforms, prints, and writes
 // the output, source map and `//# sourceMappingURL` comment.
 import { ScriptKind, type SourceFile } from './ast.js';
-import { compareDiagnostics, type Diagnostic } from './diagnostics.js';
+import { compareDiagnostics, equalDiagnostics, type Diagnostic } from './diagnostics.js';
 import { type CompilerOptions, JsxEmit, NewLineKind, getEmitScriptTarget, getIsolatedModules } from './options.js';
 import { LanguageVariant } from './types.js';
 import { type OutputPathsHost, getOutputPathsFor } from './output-paths.js';
@@ -33,7 +33,7 @@ import { RuntimeSyntax } from './transformers/runtime-syntax.js';
 import { ConstEnumInliner } from './transformers/const-enum-inliner.js';
 import { addDownlevelTransformers } from './transformers/downlevel.js';
 import { JsxTransformer } from './transformers/jsx.js';
-import { SyntaxFacts } from './transformers/syntax-facts.js';
+import { SubtreeFacts, SyntaxFacts } from './transformers/syntax-facts.js';
 import { LegacyDecorators } from './transformers/legacy-decorators.js';
 import { DecoratorMetadata } from './transformers/decorator-metadata.js';
 
@@ -143,6 +143,12 @@ export const enum EmitOnly {
    * signature of incremental builds; it is written with its errors and without a map.
    */
   ForcedDts,
+  /**
+   * The declaration file of a file whose JavaScript this build emits in a separate request, such as on another
+   * thread. tsgo emits both with one emit context, so the emit flags its JavaScript transforms set on the file's
+   * own nodes also apply to its declarations; this replays those transforms first.
+   */
+  DtsAfterJs,
 }
 
 export function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly: EmitOnly = EmitOnly.All): EmitResult {
@@ -157,21 +163,44 @@ export function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly
     const file = files[i];
     if (!sourceFileMayBeEmitted(file, options) || host.isSourceFileFromExternalLibrary(file)) continue;
     const paths = getOutputPathsFor(file.fileName, file.scriptKind === ScriptKind.JSON, options, host, forced);
+    // As in tsgo, a file's JavaScript and declarations share one emit context: emit flags that JavaScript
+    // transforms set on the file's own nodes, such as a decorated parameter's name, also apply to its declarations.
+    const context = new EmitContext();
     if (paths.jsFilePath !== '' && (emitOnly === EmitOnly.All || emitOnly === EmitOnly.Js)) {
       if (host.isEmitBlocked(paths.jsFilePath)) result.emitSkipped = true;
-      else emitJSFile(host, file, paths.jsFilePath, paths.sourceMapFilePath, result);
+      else emitJSFile(host, context, file, paths.jsFilePath, paths.sourceMapFilePath, result);
     }
     if (paths.declarationFilePath !== '' && emitOnly !== EmitOnly.Js) {
       if (!forced && host.isEmitBlocked(paths.declarationFilePath)) result.emitSkipped = true;
-      else emitDeclarationFile(host, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+      else {
+        if (emitOnly === EmitOnly.DtsAfterJs && paths.jsFilePath !== '') replayScriptTransforms(host, context, file);
+        emitDeclarationFile(host, context, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+      }
     }
   }
   return result;
 }
 
+/**
+ * Runs the JavaScript transforms of `file` in `context` without printing, for the emit flags they set on the
+ * file's own nodes. Only the decorator transforms set any that declaration emit prints (on decorated parameters'
+ * names), so files without decorators are skipped.
+ */
+function replayScriptTransforms(host: EmitHost, context: EmitContext, file: SourceFile): void {
+  if (!new SyntaxFacts().has(file, SubtreeFacts.ContainsDecorators)) return;
+  let transformed = file;
+  const transformers = getScriptTransformers(host, context, file);
+  for (let i = 0; i < transformers.length; i++) {
+    const transformer = transformers[i];
+    if (transformer.unsupported !== '') return;
+    transformed = transformer.transformSourceFile(transformed);
+  }
+}
+
 /** Emits a declaration file; the host's resolver must be a `DeclarationEmitResolver`. */
 function emitDeclarationFile(
   host: EmitHost,
+  context: EmitContext,
   file: SourceFile,
   declarationFilePath: string,
   declarationMapPath: string,
@@ -184,7 +213,6 @@ function emitDeclarationFile(
     return false;
   }
   const options = host.options;
-  const context = new EmitContext();
   const transformer = new DeclarationTransformer(context, host, options, resolver, declarationFilePath);
   const transformed = transformer.transformSourceFile(file);
   result.declarationTransformed = true;
@@ -214,11 +242,32 @@ function emitDeclarationFile(
     emitSourceMaps,
     false,
     result,
-    // Sorted, as tsgo's emitter diagnostics are; the order is part of the file's signature in build info.
-    diagnostics.length > 1 ? diagnostics.toSorted(compareDiagnostics) : diagnostics,
+    emitterDiagnostics(diagnostics),
   );
 }
 
+/**
+ * Declaration diagnostics as tsgo's emitter collects them: sorted, without repeats of an equal
+ * diagnostic. They are part of the file's signature in build info.
+ */
+function emitterDiagnostics(diagnostics: readonly Diagnostic[]): readonly Diagnostic[] {
+  if (diagnostics.length < 2) return diagnostics;
+  const sorted = diagnostics.toSorted(compareDiagnostics);
+  const result: Diagnostic[] = [];
+  for (const diagnostic of sorted) {
+    // Equal diagnostics compare as 0, so a repeat is among the last ones kept that compare as 0.
+    let repeated = false;
+    for (let i = result.length - 1; i >= 0 && compareDiagnostics(result[i], diagnostic) === 0; i--) {
+      if (equalDiagnostics(result[i], diagnostic)) {
+        repeated = true;
+        break;
+      }
+    }
+    if (!repeated) result.push(diagnostic);
+  }
+  return result;
+}
+
 function getScriptTransformers(host: EmitHost, context: EmitContext, file: SourceFile): Transformer[] {
   const options = host.options;
   const facts = new TypeScriptFacts();
@@ -248,13 +297,13 @@ function isJsxTransformEnabled(options: CompilerOptions): boolean {
 
 function emitJSFile(
   host: EmitHost,
+  context: EmitContext,
   file: SourceFile,
   jsFilePath: string,
   sourceMapFilePath: string,
   result: EmitResult,
 ): boolean {
   const options = host.options;
-  const context = new EmitContext();
   let transformed = file;
   const transformers = getScriptTransformers(host, context, file);
   for (let i = 0; i < transformers.length; i++) {

package/src/compiler/encoder.ts

@@ -1,7 +1,7 @@
-// Encodes a source file in TypeScript 7's binary AST format (protocol version 5), the
+// Encodes a source file in TypeScript 7.1's binary AST format (protocol version 9), the
 // `getSourceFile` payload of the API.
 //
-// Layout: a 44-byte header, string offsets (UTF-8 start/end pairs), string data (the
+// Layout: a 64-byte header, string offsets (UTF-8 start/end pairs), string data (the
 // UTF-8 file text, then strings that aren't slices of it), extended node data,
 // msgpack structured data, and 28-byte node records in visit order. Node positions are
 // UTF-16 offsets.
@@ -197,10 +197,10 @@ import { SyntaxKind } from './syntax-kind.js';
 import { hash128 } from './xxh3.js';
 import { utf8Offsets } from './character-codes.js';
 
-export const protocolVersion = 5;
+export const protocolVersion = 9;
 
 const nodeSize = 28;
-const headerSize = 44;
+const headerSize = 64;
 const nodeListKind = 0xffffffff;
 const noStructuredData = 0xffffffff;
 
@@ -210,6 +210,11 @@ const dataTypeExtended = 2 << 30;
 
 const utf8Encoder = new TextEncoder();
 
+/** A node list record's last word: 1 when the list ends with a comma. */
+function trailingComma(list: NodeList): number {
+  return list.hasTrailingComma() ? 1 : 0;
+}
+
 /** A growable little-endian byte buffer. */
 class ByteWriter {
   bytes: Uint8Array;
@@ -1261,7 +1266,8 @@ function childrenPropertyMask(node: Node): number {
       return node instanceof ModuleDeclaration
         ? (hasModifiers((node as ModuleDeclaration).modifiers) ? 1 : 0) |
             ((node as ModuleDeclaration).name !== undefined ? 2 : 0) |
-            ((node as ModuleDeclaration).body !== undefined ? 4 : 0)
+            ((node as ModuleDeclaration).attributes !== undefined ? 4 : 0) |
+            ((node as ModuleDeclaration).body !== undefined ? 8 : 0)
         : 0;
     case SyntaxKind.ImportEqualsDeclaration:
       return node instanceof ImportEqualsDeclaration
@@ -1381,6 +1387,7 @@ function commonData(node: Node): number {
       if (!(node instanceof ImportClause)) return 0;
       if ((node as ImportClause).phaseModifier === SyntaxKind.TypeKeyword) return 1 << 24;
       if ((node as ImportClause).phaseModifier === SyntaxKind.DeferKeyword) return 2 << 24;
+      if ((node as ImportClause).phaseModifier === SyntaxKind.SourceKeyword) return 3 << 24;
       return 0;
     case SyntaxKind.ImportSpecifier:
       return node instanceof ImportSpecifier ? bit((node as ImportSpecifier).isTypeOnly) << 24 : 0;
@@ -1577,7 +1584,7 @@ class Encoder extends NodeVisitor {
     this.linkSibling(index);
     const positions = this.positions;
     if (positions === undefined)
-      this.nodes.push(nodeListKind, list.pos, list.end, this.parentIndex, list.nodes.length, 0);
+      this.nodes.push(nodeListKind, list.pos, list.end, this.parentIndex, list.nodes.length, trailingComma(list));
     else
       this.nodes.push(
         nodeListKind,
@@ -1585,7 +1592,7 @@ class Encoder extends NodeVisitor {
         positions.of(list.end),
         this.parentIndex,
         list.nodes.length,
-        0,
+        trailingComma(list),
       );
     const saveParent = this.parentIndex;
     this.prevIndex = 0;
@@ -1659,6 +1666,8 @@ class Encoder extends NodeVisitor {
     out.u32(offsetExtended);
     out.u32(offsetStructured);
     out.u32(offsetNodes);
+    // Source file ID and lease ID (u64 each) and binder data offset: 0, none.
+    for (let i = 0; i < 5; i++) out.u32(0);
     out.append(strings.offsets.view());
     out.append(fileText);
     out.append(strings.others.view());
@@ -1787,7 +1796,8 @@ class Encoder extends NodeVisitor {
       );
       out.u32((node as TemplateTail).templateFlags);
     } else if (node instanceof SourceFile) {
-      out.u32(strings.addFileText((node as SourceFile).pos, (node as SourceFile).end));
+      const text = strings.addFileText((node as SourceFile).pos, (node as SourceFile).end);
+      out.u32(text);
       out.u32(strings.add((node as SourceFile).fileName, SyntaxKind.Unknown, 0, 0));
       out.u32(strings.add((node as SourceFile).path, SyntaxKind.Unknown, 0, 0));
       out.u32((node as SourceFile).languageVariant);
@@ -1801,6 +1811,11 @@ class Encoder extends NodeVisitor {
       out.u32(noStructuredData);
       out.u32(noStructuredData);
       out.u32(0);
+      // The original text is the text, and the content mapper fields (span map, supplemental
+      // file names, canonical file name, mapper, virtual file name, diagnostic directives) are
+      // empty: tsc-ts maps no file contents.
+      out.u32(text);
+      for (let i = 0; i < 6; i++) out.u32(noStructuredData);
     } else throw new Error(`no extended data for kind ${node.kind}`);
     return offset;
   }

package/src/compiler/file-include.ts

@@ -597,10 +597,16 @@ export class IncludeProcessor {
     return this.fileIncludeReasons.get(path) ?? [];
   }
 
-  addReason(path: string, reason: FileIncludeReason): void {
+  /** Adds an include reason of the file at `path`; returns the file's reasons. */
+  addReason(path: string, reason: FileIncludeReason): FileIncludeReason[] {
     const reasons = this.fileIncludeReasons.get(path);
-    if (reasons === undefined) this.fileIncludeReasons.set(path, [reason]);
-    else reasons.push(reason);
+    if (reasons === undefined) {
+      const added = [reason];
+      this.fileIncludeReasons.set(path, added);
+      return added;
+    }
+    reasons.push(reason);
+    return reasons;
   }
 
   addProcessingDiagnostic(diagnostic: ProcessingDiagnostic): void {