ttsc 0.26.1 → 0.27.0

package/driver/diagnostics_preamble.go

@@ -0,0 +1,284 @@
+package driver
+
+import (
+  "strings"
+
+  "github.com/microsoft/typescript-go/shim/ast"
+  "github.com/microsoft/typescript-go/shim/core"
+  shimparser "github.com/microsoft/typescript-go/shim/parser"
+)
+
+// Source-preamble correction for compiler diagnostics.
+//
+// ttsc injects a plugin's source preamble (e.g. @ttsc/banner's copyright block)
+// at the SOURCE level: sourcePreambleFS prepends it before TypeScript-Go parses,
+// so the preamble participates in comment emission, removeComments, JSDoc
+// association, and `.d.ts` emit naturally. The side effect is that every
+// position tsgo records — including every diagnostic's — is shifted down by the
+// preamble's line count, while the file the user reads has no preamble. The
+// emitted source map already undoes that shift (AdjustEmittedSourceMap); this is
+// the same invariant applied to the other coordinate the user is shown.
+//
+// The correction lives here, at the Program boundary where the preamble is
+// known, rather than in each renderer. `WritePrettyDiagnostics`, the structured
+// diagnostic list the JS launcher serializes, the graph snapshot, and any future
+// consumer all read a Diagnostic that is already authored-relative, so none of
+// them has to remember.
+
+// preambleView is the authored (preamble-free) view of one preamble-injected
+// source file, plus the byte region the preamble occupies in the buffer tsgo
+// parsed.
+//
+// file is a re-parse of the authored text. The diagnostic renderer reads a
+// source file's FileName, Text, and ECMA line map to place a location and quote
+// a code frame, and all three have to describe the text the user wrote — moving
+// the position alone would still quote the preamble-bearing buffer. Re-parsing
+// is what produces a line map tsgo itself computed rather than one this package
+// re-derived, and it costs one parse per file that actually carries a
+// diagnostic.
+type preambleView struct {
+  file *ast.SourceFile
+  // start is the byte offset where the preamble was inserted, and length its
+  // byte length. ApplySourcePreamble inserts after a BOM and after a hashbang
+  // line, so start is not always zero.
+  start  int
+  length int
+}
+
+// authoredPos maps a position in the preamble-bearing buffer to the authored
+// file. ok is false for a position inside the injected region, which has no
+// authored counterpart at all.
+func (v *preambleView) authoredPos(pos int) (int, bool) {
+  if pos < v.start {
+    return pos, true
+  }
+  if pos >= v.start+v.length {
+    return pos - v.length, true
+  }
+  return 0, false
+}
+
+// authoredEnd maps an exclusive end offset. An end inside the injected region is
+// truncated to the region's authored boundary, so a range that starts before the
+// preamble never stretches over text the user did not write.
+func (v *preambleView) authoredEnd(end int) int {
+  if end <= v.start {
+    return end
+  }
+  if end >= v.start+v.length {
+    return end - v.length
+  }
+  return v.start
+}
+
+// sourcePreambleBOM is the UTF-8 byte order mark ApplySourcePreamble keeps
+// ahead of an injected preamble.
+const sourcePreambleBOM = "\ufeff"
+
+// sourcePreambleRegion locates the injected preamble inside the text tsgo
+// parsed, mirroring ApplySourcePreamble's insertion point: after a BOM, and
+// after a hashbang line when one is present.
+//
+// The region is read back out of the parsed text rather than recomputed from the
+// on-disk file, so it stays correct whichever of the BOM or hashbang the host
+// stripped before parsing, and the leading-prefix check makes the result
+// self-verifying: a file the preamble was never injected into (a declaration
+// file, a `.json` input, a library file) simply does not match and is reported
+// as having no region.
+//
+// One degenerate shape is nominally off by one, matching the same allowance
+// AdjustSourceMapForPreamble states: a file whose entire content is a hashbang
+// with no trailing newline gets the preamble appended after an inserted newline,
+// which is indistinguishable from an authored trailing newline. Only a position
+// at that file's very end could differ, and such a file has no code to diagnose.
+func sourcePreambleRegion(filePath, text, preamble string) (start int, length int, ok bool) {
+  if preamble == "" || !isSourcePreambleTarget(filePath) {
+    return 0, 0, false
+  }
+  start = 0
+  if strings.HasPrefix(text, sourcePreambleBOM) {
+    start = len(sourcePreambleBOM)
+  }
+  if strings.HasPrefix(text[start:], "#!") {
+    newline := strings.IndexByte(text[start:], '\n')
+    if newline < 0 {
+      return 0, 0, false
+    }
+    start += newline + 1
+  }
+  if !strings.HasPrefix(text[start:], preamble) {
+    return 0, 0, false
+  }
+  return start, len(preamble), true
+}
+
+// preambleMapper rebuilds diagnostics against the authored source files of one
+// preamble-bearing Program. It caches one authored view per source file so every
+// diagnostic in a file shares a single re-parsed file object — the renderer's
+// "Found N errors in M files" summary groups by that object's identity.
+//
+// A mapper is built per diagnostics call and thrown away with it: it holds
+// re-parsed source files, which have no reason to outlive the report they were
+// built for.
+type preambleMapper struct {
+  preamble string
+  views    map[*ast.SourceFile]*preambleView
+}
+
+// newPreambleMapper returns nil when this Program has no source preamble, which
+// is the signal to leave every diagnostic exactly as tsgo produced it.
+func (p *Program) newPreambleMapper() *preambleMapper {
+  if p == nil || p.SourcePreamble == "" {
+    return nil
+  }
+  return &preambleMapper{
+    preamble: p.SourcePreamble,
+    views:    map[*ast.SourceFile]*preambleView{},
+  }
+}
+
+// viewOf returns the authored view of file, or nil when the preamble was never
+// injected into it.
+func (m *preambleMapper) viewOf(file *ast.SourceFile) *preambleView {
+  if m == nil || file == nil {
+    return nil
+  }
+  if view, cached := m.views[file]; cached {
+    return view
+  }
+  view := newPreambleView(file, m.preamble)
+  m.views[file] = view
+  return view
+}
+
+// newPreambleView re-parses file without its injected preamble. It returns nil
+// when the file carries no preamble, or when the re-parse yields nothing to
+// anchor against — an uncorrected position is still better than a nil file.
+func newPreambleView(file *ast.SourceFile, preamble string) *preambleView {
+  text := file.Text()
+  start, length, ok := sourcePreambleRegion(file.FileName(), text, preamble)
+  if !ok {
+    return nil
+  }
+  authored := shimparser.ParseSourceFile(file.ParseOptions(), text[:start]+text[start+length:], file.ScriptKind)
+  if authored == nil {
+    return nil
+  }
+  return &preambleView{file: authored, start: start, length: length}
+}
+
+// remapDiagnostic returns d anchored to its authored source file. ok is false
+// when d's own position falls inside the injected preamble, which is the one
+// case with no authored answer; see unanchoredPreambleDiagnostic for what the
+// caller does with it.
+//
+// The original diagnostic is never mutated: it belongs to the Program's own
+// diagnostic collection, which other callers read.
+func (m *preambleMapper) remapDiagnostic(d *ast.Diagnostic) (*ast.Diagnostic, bool) {
+  if m == nil || d == nil {
+    return d, d != nil
+  }
+  related, relatedChanged := m.remapRelated(d.RelatedInformation())
+  view := m.viewOf(d.File())
+  if view == nil {
+    if !relatedChanged {
+      return d, true
+    }
+    clone := d.Clone()
+    clone.SetRelatedInfo(related)
+    return clone, true
+  }
+  pos, ok := view.authoredPos(d.Pos())
+  if !ok {
+    return nil, false
+  }
+  clone := d.Clone()
+  clone.SetFile(view.file)
+  clone.SetLocation(core.NewTextRange(pos, view.authoredEnd(d.End())))
+  if relatedChanged {
+    clone.SetRelatedInfo(related)
+  }
+  return clone, true
+}
+
+// remapRelated remaps a diagnostic's related information, each entry against its
+// own file. An entry with no authored counterpart is dropped rather than
+// reported without a position: related information exists only to point at a
+// second location, and the primary diagnostic still carries the message.
+func (m *preambleMapper) remapRelated(in []*ast.Diagnostic) ([]*ast.Diagnostic, bool) {
+  if len(in) == 0 {
+    return nil, false
+  }
+  out := make([]*ast.Diagnostic, 0, len(in))
+  changed := false
+  for _, related := range in {
+    mapped, ok := m.remapDiagnostic(related)
+    if !ok {
+      changed = true
+      continue
+    }
+    if mapped != related {
+      changed = true
+    }
+    out = append(out, mapped)
+  }
+  return out, changed
+}
+
+// unanchoredPreambleDiagnostic reports a diagnostic whose position lies inside
+// an injected source preamble.
+//
+// The preamble is text the user never wrote, so there is no authored line to
+// name. The source-map lane drops such segments, but a diagnostic is not a
+// mapping: dropping it would leave a failing build with nothing on stderr to
+// explain the failure, and clamping it to the top of the file would print a
+// coordinate that is simply false — the exact defect this correction exists to
+// remove. So the report is kept and only the coordinate is dropped: the message,
+// the code, and the file the preamble was injected into survive, and the
+// diagnostic renders through the anchor-less `path: message` form ttsc already
+// uses for diagnostics that have no source range. It counts as an error exactly
+// as it did before, so the exit code is unchanged.
+//
+// One consequence to know: the JS launcher recovers structured diagnostics by
+// parsing rendered text, and the anchor-less form carries no `line:col` for that
+// parser to match — so a preamble-region diagnostic reaches stderr and the exit
+// code but not `IFailure.diagnostics`. That is the same deal every anchor-less
+// driver diagnostic has always had (`driver: linked plugins failed to apply`),
+// and it is preferable to publishing a structured position that is not real.
+func unanchoredPreambleDiagnostic(d *ast.Diagnostic) Diagnostic {
+  out := Diagnostic{
+    Code:     d.Code(),
+    Message:  d.String(),
+    Severity: SeverityError,
+  }
+  if file := d.File(); file != nil {
+    out.File = file.FileName()
+  }
+  return out
+}
+
+// convertProgramDiagnostics converts tsgo diagnostics produced by this Program,
+// undoing any source-preamble shift first. Every path that turns this Program's
+// raw diagnostics into driver Diagnostics goes through here, so the correction
+// cannot be forgotten by a new caller. Diagnostics that never pass through a
+// Program — a tsconfig parse failure, a bad CLI flag — keep using
+// convertDiagnostics directly, because no preamble is ever injected into them.
+func (p *Program) convertProgramDiagnostics(in []*ast.Diagnostic) []Diagnostic {
+  mapper := p.newPreambleMapper()
+  if mapper == nil {
+    return convertDiagnostics(in)
+  }
+  out := make([]Diagnostic, 0, len(in))
+  for _, d := range in {
+    if d == nil {
+      continue
+    }
+    mapped, ok := mapper.remapDiagnostic(d)
+    if !ok {
+      out = append(out, unanchoredPreambleDiagnostic(d))
+      continue
+    }
+    out = append(out, convertDiagnostic(mapped))
+  }
+  return out
+}

package/driver/emit_plugin.go

@@ -1,7 +1,6 @@
 package driver
 
 import (
-  "context"
   "errors"
   "strings"
   "sync"
@@ -133,13 +132,16 @@ func restoreOriginalDeclarationSymbols(ec *shimprinter.EmitContext, node *shimas
 // EmitTransformPlugins are chained after the caller's transforms in
 // registration order.
 //
-// Because the JavaScript side bypasses tsgo's own emitter, it reproduces the
-// emitter's source-map step via PrintFileWithSourceMap: a `sourceMap` /
-// `inlineSourceMap` build emits a `.js.map` (and `//# sourceMappingURL=`
-// trailer) just like a plain build, even when a transform expanded one source
-// line into many. All non-JavaScript outputs stay delegated to tsgo's normal
-// dts-only emitter so declaration files, declaration maps, and any future
-// declaration-lane outputs are not silently lost by the hand-assembled JS path.
+// Because the JavaScript side bypasses tsgo's own emitter, it reproduces that
+// emitter's whole printSourceFile step via PrintFileWithSourceMap: a
+// `sourceMap` / `inlineSourceMap` build emits a `.js.map` (and
+// `//# sourceMappingURL=` trailer) just like a plain build, even when a
+// transform expanded one source line into many; an `emitBOM` build still starts
+// with the byte order mark; and the caller's WriteFile still receives the
+// WriteFileData the emitter would hand it. All non-JavaScript outputs stay
+// delegated to tsgo's normal dts-only emitter so declaration files, declaration
+// maps, and any future declaration-lane outputs are not silently lost by the
+// hand-assembled JS path.
 func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, writeFile shimcompiler.WriteFile) ([]Diagnostic, error) {
   if p == nil || p.TSProgram == nil {
     return nil, errors.New("driver: nil program")
@@ -183,10 +185,10 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       }
       // Print through the source-map-aware helper so a `sourceMap` /
       // `inlineSourceMap` build still gets its `.js.map` and sourceMappingURL
-      // trailer: the hand-assembled emit pipeline does not run tsgo's emitter,
-      // so the source-map step printSourceFile would otherwise perform has to
-      // happen here. With maps off this is the same bare-printer output as
-      // before.
+      // trailer, and an `emitBOM` build its leading mark: the hand-assembled
+      // emit pipeline does not run tsgo's emitter, so everything printSourceFile
+      // would otherwise do around the printer has to happen here. With maps and
+      // emitBOM off this is the same bare-printer output as before.
       printed := shimcompiler.PrintFileWithSourceMap(ec, out.AsNode(), out, options, host, paths.JsFilePath(), paths.SourceMapFilePath())
       // A source-level preamble (e.g. @ttsc/banner linked into a typia host)
       // shifts the map's source coordinates; correct them here too, so the
@@ -204,20 +206,45 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
           }
         }
       }
-      if err := p.writePluginEmitOutput(paths.JsFilePath(), printed.JS, writeFile); err != nil {
+      // The emitter hands its writeFile callback a WriteFileData for the
+      // JavaScript and a nil one for the map (printSourceFile:
+      // `writeText(sourceMapFilePath, sourceMap, nil)`), so this lane does the
+      // same. See writePluginEmitOutput for what the struct carries here and
+      // why the remaining fields stay zero.
+      if err := p.writePluginEmitOutput(paths.JsFilePath(), printed.JS, &shimcompiler.WriteFileData{
+        SourceMapUrlPos: printed.SourceMapUrlPos,
+      }, writeFile); err != nil {
         return nil, err
       }
-      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, writeFile); err != nil {
+      if err := p.writePluginEmitOutput(printed.MapPath, printed.MapText, nil, writeFile); err != nil {
         return nil, err
       }
     }
   }
-  if !options.GetEmitDeclarations() {
+  // The declaration pass below doubles as this lane's build-information pass,
+  // so it also runs for a JavaScript-only `incremental` / `composite` project
+  // that has no declarations to write at all.
+  if !options.GetEmitDeclarations() && !p.emitsBuildInfo() {
     return nil, nil
   }
 
+  // What the build information this pass writes does and does not claim.
+  //
+  // The JavaScript above was hand-assembled and written outside tsgo's
+  // emitter, so tsgo's snapshot never saw it happen and records the JS emit of
+  // every file as still pending. That error is one-directional and safe: a
+  // consumer reading it can only decide to emit again, never to skip a file
+  // ttsc actually transformed. Making the record exact would mean running
+  // tsgo's own JavaScript emit a second time and discarding its output, paying
+  // a full emit to describe work already done. Everything else in the file —
+  // the compiler version, the resolved options, per-file versions and
+  // signatures, and the declaration state this pass does produce — is accurate.
+  //
+  // ttsc itself never reads build information back (see
+  // `shimcompiler.EmitFreshWithBuildInfo`), so this asymmetry costs a ttsc
+  // rebuild nothing.
   var wfMu sync.Mutex
-  result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+  result := p.emitProgram(shimcompiler.EmitOptions{
     EmitOnly: shimcompiler.EmitOnlyDts,
     WriteFile: func(fileName string, text string, data *shimcompiler.WriteFileData) error {
       wfMu.Lock()
@@ -235,17 +262,42 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
     },
   })
   if result != nil && len(result.Diagnostics) != 0 {
-    return convertDiagnostics(result.Diagnostics), nil
+    return p.convertProgramDiagnostics(result.Diagnostics), nil
   }
   return nil, nil
 }
 
-func (p *Program) writePluginEmitOutput(fileName, text string, writeFile shimcompiler.WriteFile) error {
+// writePluginEmitOutput writes one artifact of the hand-assembled emit, passing
+// the caller's WriteFile the same WriteFileData tsgo's emitter would.
+//
+// What this lane can populate, and what it deliberately cannot:
+//
+//   - SourceMapUrlPos: the offset of the `//# sourceMappingURL=` trailer, or -1
+//     when none was written. PrintFileWithSourceMap records it exactly where
+//     printSourceFile does, so a consumer that relocates or rewrites the trailer
+//     works the same on both lanes. This is why a nil data was a real loss and
+//     not merely a cosmetic one.
+//   - Diagnostics: always empty. The emitter's field carries its accumulated
+//     emitterDiagnostics, which on the JavaScript lane are its own write
+//     failures; here a write failure is returned as an `error` from
+//     EmitWithPluginTransformers instead, and the declaration lane's diagnostics
+//     reach the caller through tsgo's own EmitOnlyDts pass and its own
+//     WriteFileData. Empty therefore means "nothing to report", not "never
+//     populated".
+//   - BuildInfo: always nil. It is the `.tsbuildinfo` payload, and this lane
+//     emits only JavaScript and its map.
+//   - SkippedDtsWrite: an out-parameter for the callee, left zero. Each write
+//     gets its own struct so one file's callback cannot observe another's.
+//
+// Nothing on this lane reads the struct back afterwards: unlike tsgo's emitter,
+// EmitWithPluginTransformers builds no EmitResult, so there is no EmittedFiles
+// list for a callee-set SkippedDtsWrite to keep a file out of.
+func (p *Program) writePluginEmitOutput(fileName, text string, data *shimcompiler.WriteFileData, writeFile shimcompiler.WriteFile) error {
   if fileName == "" || p.outputEscapesOutDir(fileName) {
     return nil
   }
   if writeFile != nil {
-    return writeFile(fileName, text, nil)
+    return writeFile(fileName, text, data)
   }
   return DefaultWriteFile(fileName, text)
 }

package/driver/graph.go

@@ -23,9 +23,10 @@ const bundledScheme = "bundled:///"
 //
 //   - Edges maps each file to its direct resolved references — imports,
 //     re-exports, `/// <reference>` targets, type reference directives, and
-//     ambient-module declaration files, type-only edges included. Direct
-//     edges are the minimal sufficient statistic; consumers that need a flat
-//     per-file list compute the reachability closure themselves.
+//     ambient-module declaration files, type-only edges included. A leaf file
+//     has an empty list so the node and its compiler-time input proof remain
+//     explicit. Direct edges are the minimal sufficient statistic; consumers
+//     that need a flat per-file list compute the reachability closure themselves.
 //   - Globals lists the files that contribute to the global scope (ambient
 //     declaration files, script files, global augmentations, `typeRoots`
 //     entries). A change to any of them can affect every file.
@@ -39,10 +40,12 @@ const bundledScheme = "bundled:///"
 // map: project-relative slash paths, falling back to slash-normalized
 // absolute paths outside the project root (see TransformOutputKey).
 type TransformGraph struct {
-  Edges      map[string][]string `json:"edges"`
-  Globals    []string            `json:"globals"`
-  Configs    []string            `json:"configs"`
-  Candidates map[string][]string `json:"candidates,omitempty"`
+  Edges          map[string][]string `json:"edges"`
+  Globals        []string            `json:"globals"`
+  Configs        []string            `json:"configs"`
+  Candidates     map[string][]string `json:"candidates,omitempty"`
+  InputHashes    map[string]*string  `json:"inputHashes,omitempty"`
+  InputRealpaths map[string]*string  `json:"inputRealpaths,omitempty"`
 }
 
 // NewTransformGraph computes the reference graph of a loaded program, keyed
@@ -69,16 +72,66 @@ func NewTransformGraph(prog *Program, cwd string) *TransformGraph {
     if shimcompiler.FileAffectsGlobalScope(file) {
       graph.Globals = append(graph.Globals, key)
     }
-    targets := referenceTargets(prog, cwd, file)
-    if len(targets) != 0 {
-      graph.Edges[key] = targets
-    }
+    // Keep leaf modules as empty adjacency-list entries. Besides making the
+    // graph's node universe explicit, this lets attachInputProof bind every
+    // source file to the bytes TypeScript-Go actually read. Omitting a leaf
+    // would let an A-B-A edit during compilation pair B's output with identical
+    // pre/post project snapshots for A.
+    graph.Edges[key] = referenceTargets(prog, cwd, file)
   }
   sort.Strings(graph.Globals)
   graph.Configs = configChain(prog, cwd)
+  graph.attachInputProof(prog, cwd)
   return graph
 }
 
+// attachInputProof pairs every graph path with the state the compiler
+// filesystem actually returned while constructing the resident Program. A
+// missing entry means proof was incomplete or contradictory; persistent hosts
+// then keep the fresh result but decline cross-build reuse.
+func (graph *TransformGraph) attachInputProof(prog *Program, cwd string) {
+  if prog == nil || prog.inputObserver == nil {
+    return
+  }
+  inputs := map[string]struct{}{}
+  for source, targets := range graph.Edges {
+    inputs[source] = struct{}{}
+    for _, target := range targets {
+      inputs[target] = struct{}{}
+    }
+  }
+  for _, input := range graph.Globals {
+    inputs[input] = struct{}{}
+  }
+  for _, input := range graph.Configs {
+    inputs[input] = struct{}{}
+  }
+  for source, candidates := range graph.Candidates {
+    inputs[source] = struct{}{}
+    for _, candidate := range candidates {
+      inputs[candidate] = struct{}{}
+    }
+  }
+  hashes := map[string]*string{}
+  realpaths := map[string]*string{}
+  for input := range inputs {
+    file := filepath.FromSlash(input)
+    if !filepath.IsAbs(file) {
+      file = filepath.Join(cwd, file)
+    }
+    hash, realpath, ok := prog.inputObserver.proof(file)
+    if !ok {
+      continue
+    }
+    hashes[input] = hash
+    realpaths[input] = realpath
+  }
+  if len(hashes) != 0 {
+    graph.InputHashes = hashes
+    graph.InputRealpaths = realpaths
+  }
+}
+
 // referenceTargets resolves one file's direct reference set to sorted envelope
 // keys, dropping bundled library files and the file itself.
 func referenceTargets(prog *Program, cwd string, file *ast.SourceFile) []string {