ttsc 0.26.2 → 0.28.0

package/driver/resolution_candidates.go

@@ -23,9 +23,10 @@ type ModuleResolutionContext struct {
 
 // SupersedingModuleCandidates returns, per source-file envelope key, the
 // resolution candidates strictly ahead of each module target the loaded
-// program selected. A missing member can therefore become a freshness input
-// without making the whole resolution search (including lower-priority paths)
-// an invalidation input.
+// program selected. When the selected target is reported by physical path, it
+// also retains that candidate's lexical spelling. A missing member or a link
+// retarget can therefore become a freshness input without making the whole
+// resolution search (including lower-priority paths) an invalidation input.
 //
 // Candidate enumeration is host-owned. It mirrors the resident graph session's
 // speculation for relative modules, paths, rootDirs, package imports/exports,
@@ -75,7 +76,10 @@ func SupersedingModuleCandidates(prog *Program, cwd string) map[string][]string
 }
 
 // ModuleResolutionPredecessors returns the paths in the host-owned candidate
-// search that precede resolvedFileName. An unresolved specifier keeps the full
+// search that precede resolvedFileName. When the compiler reports the winner by
+// physical realpath, the result also retains that selected candidate's lexical
+// spelling: retargeting its symlink/junction can change resolution without
+// changing the old or new target bytes. An unresolved specifier keeps the full
 // candidate list through ModuleResolutionCandidates; a resolved specifier must
 // not track a lower-priority path because creating it cannot alter resolution.
 func ModuleResolutionPredecessors(
@@ -101,7 +105,11 @@ func ModuleResolutionPredecessors(
   // spellings already agree pays nothing for it.
   for index, candidate := range candidates {
     if sameExistingPath(candidate, resolvedFileName) {
-      return compactStringsInOrder(candidates[:index])
+      end := index
+      if !sameCandidatePath(candidate, resolvedFileName, caseSensitive) {
+        end++
+      }
+      return compactStringsInOrder(candidates[:end])
     }
   }
   // Never widen freshness to candidates whose precedence relative to the

package/driver/rewrite.go

@@ -129,7 +129,7 @@ func (p *Program) EmitAllRaw(writeFile shimcompiler.WriteFile) (*shimcompiler.Em
     }
     return DefaultWriteFile(fileName, text)
   }
-  result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+  result := p.emitProgram(shimcompiler.EmitOptions{
     WriteFile: wf,
   })
   return result, p.convertProgramDiagnostics(result.Diagnostics), nil
@@ -197,13 +197,56 @@ func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcom
     return DefaultWriteFile(fileName, patched)
   }
 
-  result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+  result := p.emitProgram(shimcompiler.EmitOptions{
     TargetSourceFile: target,
     WriteFile:        wf,
   })
   return result, p.convertProgramDiagnostics(result.Diagnostics), nil
 }
 
+// emitProgram runs one whole-program or single-file emit, taking tsgo's
+// incremental lane when the resolved compiler options ask for build
+// information.
+//
+// tsgo's own CLI branches the same way — `performIncrementalCompilation` vs
+// `performCompilation`, on `CompilerOptions.IsIncremental()` — but it branches
+// in `internal/execute`, which a host constructing its Program in-process never
+// enters. ttsc always took the plain branch, so `incremental`, `composite`, and
+// `tsBuildInfoFile` parsed, resolved, and then vanished: a plugin-carrying
+// project emitted its JavaScript and no `.tsbuildinfo` at all (issue #1188).
+// `driver/emit_containment.go` had already exempted `.tsbuildinfo` from the
+// outDir guard for a write that could not happen.
+//
+// A single-file emit stays on the plain lane. Build information describes a
+// whole program, and tsgo's incremental program returns early on a
+// `TargetSourceFile` request without writing any, so routing it there would
+// only add a snapshot computation nothing reads.
+func (p *Program) emitProgram(options shimcompiler.EmitOptions) *shimcompiler.EmitResult {
+  ctx := context.Background()
+  if options.TargetSourceFile == nil && p.emitsBuildInfo() {
+    return shimcompiler.EmitFreshWithBuildInfo(ctx, p.TSProgram, options)
+  }
+  return p.TSProgram.Emit(ctx, options)
+}
+
+// emitsBuildInfo reports whether this program's resolved options ask tsgo to
+// write build information.
+//
+// The question is delegated to `CompilerOptions.IsIncremental`, the same
+// predicate tsgo's own CLI branches on, rather than restated as
+// `Incremental || Composite` here: a second copy of the rule is a second thing
+// to keep in step with upstream.
+func (p *Program) emitsBuildInfo() bool {
+  if p == nil || p.TSProgram == nil {
+    return false
+  }
+  options := p.TSProgram.Options()
+  if options == nil {
+    return false
+  }
+  return options.IsIncremental()
+}
+
 // DefaultWriteFile is the default disk writer used when EmitAll's caller does not
 // supply a custom WriteFile callback.
 func DefaultWriteFile(fileName, text string) error {

package/driver/transform_dependencies.go

@@ -0,0 +1,283 @@
+package driver
+
+import (
+  "sort"
+  "sync"
+)
+
+// TransformDependencies is the transform envelope's dependency side channel:
+// the per-file input lists a producer reports and the subset of files whose
+// list is complete.
+//
+// A producer that declares nothing leaves both fields empty, so its envelope is
+// byte-identical to what it was before this existed. The lane with no linked
+// plugin at all is the deliberate exception: nothing there can contribute to a
+// file, so every file is listed.
+type TransformDependencies struct {
+  // Complete lists the files whose Dependencies entry is the whole input set
+  // beyond the file itself and the universal compiler-option chain.
+  Complete []string
+  // Dependencies maps a transformed file to the files whose content influenced
+  // its output, keyed and valued like every other envelope section.
+  Dependencies map[string][]string
+}
+
+// TransformDependenciesFor computes the dependency side channel for the files
+// this program transforms, keyed against cwd.
+//
+// **The rule that makes any of this declarable.** ttsc's own source-to-source
+// transform is syntactic: the built-in native host answers with each file's
+// parsed text, and the linked-plugin generic host prints the parsed AST through
+// a printer that is handed neither a checker nor an emit resolver. Neither lane
+// runs the emit transformer chain, so none of the type-driven lowerings happen
+// there — no type-driven import elision, no `design:type` metadata, no `enum`,
+// `namespace`, or JSX lowering, and no declaration emit. The output of a file
+// the host alone produced is therefore a function of that file's own text and
+// the compiler options, and nothing the type system knows about any other file
+// can change it.
+//
+// What that leaves is the plugins. A source preamble is prepended to every
+// file's text before parsing, and a program plugin mutates the parsed AST, so
+// either can make an output depend on anything it consulted — including, for a
+// checker-driven plugin, the whole type graph. Such a plugin is the only party
+// that knows what it read, which is why the declaration is per (plugin, file)
+// and why a file is complete only when every plugin that can contribute to it
+// declared it. An emit-only plugin is not a contributor here: its transform runs
+// in `build`, which produces no envelope.
+//
+// With no linked plugin at all the contributor set is empty and every file is
+// complete with an empty list, which is the rule above stated for the lane that
+// has nothing but the host in it. A contributor that declares nothing leaves
+// every file unlisted, which is exactly the behaviour of every producer written
+// before this existed.
+//
+// An embedder that supplies LoadProgramOptions.SourcePreamble itself, rather
+// than obtaining it from a linked plugin, makes the same claim about that text
+// by calling this: the preamble must be a function of inputs its envelope
+// reports elsewhere, the way a plugin's preamble is a function of the config
+// files it reports as host inputs.
+func (p *Program) TransformDependenciesFor(cwd string) TransformDependencies {
+  if p == nil {
+    return TransformDependencies{}
+  }
+  // Declarations are made from inside the plugin hooks, so they exist only
+  // after those hooks ran. The apply is latched, so this cannot re-run them.
+  _ = p.ApplyLinkedPlugins()
+  files := p.sourceFilesRaw()
+  keys := make([]string, 0, len(files))
+  for _, file := range files {
+    keys = append(keys, TransformOutputKey(cwd, file.FileName()))
+  }
+  return p.plugins.transformDependencies(keys)
+}
+
+// transformDependencies aggregates every contributing plugin's declarations
+// over the envelope keys of the transformed files.
+func (state linkedPluginState) transformDependencies(keys []string) TransformDependencies {
+  return aggregateTransformDependencies(keys, state.transformContributors(), state.declarations)
+}
+
+// aggregateTransformDependencies folds the declarations of the given
+// contributors into one envelope side channel.
+//
+// Separated from the entry classification above so the aggregation rule can be
+// exercised without the process-wide plugin registry that classification reads.
+func aggregateTransformDependencies(keys []string, contributors []int, declarations *pluginFileDeclarations) TransformDependencies {
+  out := TransformDependencies{}
+  for _, key := range keys {
+    declared := 0
+    inputs := map[string]struct{}{}
+    for _, index := range contributors {
+      declaration := declarations.lookup(index)
+      if declaration == nil {
+        continue
+      }
+      for _, input := range declaration.dependenciesOf(key) {
+        // A file never depends on itself: the file's own text is outside the
+        // completeness contract by construction, and a self-edge would only
+        // make consumers register the module they are already transforming.
+        if input != key {
+          inputs[input] = struct{}{}
+        }
+      }
+      if declaration.declaresComplete(key) {
+        declared++
+      }
+    }
+    if len(inputs) != 0 {
+      out.Dependencies = appendDependencyEntry(out.Dependencies, key, inputs)
+    }
+    if declared == len(contributors) {
+      out.Complete = append(out.Complete, key)
+    }
+  }
+  sort.Strings(out.Complete)
+  return out
+}
+
+// appendDependencyEntry records one file's sorted dependency list, allocating
+// the map only for a producer that reported something.
+func appendDependencyEntry(into map[string][]string, key string, inputs map[string]struct{}) map[string][]string {
+  if into == nil {
+    into = map[string][]string{}
+  }
+  entry := make([]string, 0, len(inputs))
+  for input := range inputs {
+    entry = append(entry, input)
+  }
+  sort.Strings(entry)
+  into[key] = entry
+  return into
+}
+
+// transformContributors returns the indexes of the linked plugin entries that
+// can influence source-to-source transform output.
+//
+// An entry with no registered plugin cannot be inspected, so it counts as a
+// contributor that declared nothing; the host fails that entry elsewhere, and
+// until it does, silence is the conservative answer.
+func (state linkedPluginState) transformContributors() []int {
+  contributors := make([]int, 0, len(state.entries))
+  for index := range state.entries {
+    plugin, ok := registeredPlugin(index)
+    if !ok {
+      contributors = append(contributors, index)
+      continue
+    }
+    _, preamble := plugin.(SourcePreamblePlugin)
+    _, program := plugin.(ProgramPlugin)
+    if preamble || program {
+      contributors = append(contributors, index)
+    }
+  }
+  return contributors
+}
+
+// pluginFileDeclarations holds one declaration record per linked plugin entry.
+type pluginFileDeclarations struct {
+  mu      sync.Mutex
+  plugins map[int]*pluginFileDeclaration
+}
+
+// pluginFileDeclaration is one plugin's reported dependencies and completeness
+// claims, keyed by envelope key.
+type pluginFileDeclaration struct {
+  complete     map[string]struct{}
+  completeAll  bool
+  dependencies map[string]map[string]struct{}
+  mu           sync.Mutex
+  // rejected holds the files whose reported list this plugin could not state
+  // in full, because one of its members was unusable as a key.
+  rejected map[string]struct{}
+}
+
+func newPluginFileDeclarations() *pluginFileDeclarations {
+  return &pluginFileDeclarations{plugins: map[int]*pluginFileDeclaration{}}
+}
+
+// forPlugin returns the declaration record of one plugin entry, creating it on
+// first use. A nil ledger still answers a usable record so a hand-built state
+// (unit tests, embedders) never panics through a plugin's reporting call.
+func (declarations *pluginFileDeclarations) forPlugin(index int) *pluginFileDeclaration {
+  record := &pluginFileDeclaration{
+    complete:     map[string]struct{}{},
+    dependencies: map[string]map[string]struct{}{},
+    rejected:     map[string]struct{}{},
+  }
+  if declarations == nil {
+    return record
+  }
+  declarations.mu.Lock()
+  defer declarations.mu.Unlock()
+  if existing, ok := declarations.plugins[index]; ok {
+    return existing
+  }
+  declarations.plugins[index] = record
+  return record
+}
+
+// lookup returns the declaration record of one plugin entry, or nil when that
+// entry never reported anything.
+func (declarations *pluginFileDeclarations) lookup(index int) *pluginFileDeclaration {
+  if declarations == nil {
+    return nil
+  }
+  declarations.mu.Lock()
+  defer declarations.mu.Unlock()
+  return declarations.plugins[index]
+}
+
+func (declaration *pluginFileDeclaration) addDependency(file string, dependency string) {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  entry, ok := declaration.dependencies[file]
+  if !ok {
+    entry = map[string]struct{}{}
+    declaration.dependencies[file] = entry
+  }
+  entry[dependency] = struct{}{}
+}
+
+// rejectDependency withdraws this plugin's completeness claim for one file.
+func (declaration *pluginFileDeclaration) rejectDependency(file string) {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  declaration.rejected[file] = struct{}{}
+}
+
+func (declaration *pluginFileDeclaration) addComplete(file string) {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  declaration.complete[file] = struct{}{}
+}
+
+func (declaration *pluginFileDeclaration) completeEveryFile() {
+  if declaration == nil {
+    return
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  declaration.completeAll = true
+}
+
+func (declaration *pluginFileDeclaration) dependenciesOf(file string) []string {
+  if declaration == nil {
+    return nil
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  entry, ok := declaration.dependencies[file]
+  if !ok {
+    return nil
+  }
+  out := make([]string, 0, len(entry))
+  for input := range entry {
+    out = append(out, input)
+  }
+  return out
+}
+
+func (declaration *pluginFileDeclaration) declaresComplete(file string) bool {
+  if declaration == nil {
+    return false
+  }
+  declaration.mu.Lock()
+  defer declaration.mu.Unlock()
+  if _, rejected := declaration.rejected[file]; rejected {
+    return false
+  }
+  if declaration.completeAll {
+    return true
+  }
+  _, ok := declaration.complete[file]
+  return ok
+}

package/driver/transform_dependencies_declares_every_file_without_a_contributor_test.go

@@ -0,0 +1,28 @@
+package driver
+
+import (
+  "reflect"
+  "testing"
+)
+
+// TestTransformDependenciesDeclaresEveryFileWithoutAContributor verifies the
+// rule the host declares under when nothing else can contribute: a
+// source-to-source transform is syntactic, so a file the host alone produced
+// depends on its own text and the compiler options, and on nothing else.
+//
+// With an empty contributor set the aggregation is vacuously satisfied for
+// every file, which is what lets a plugin-free project's consumer stop
+// revalidating each delivered module's whole reference closure
+// (samchon/ttsc#1259).
+func TestTransformDependenciesDeclaresEveryFileWithoutAContributor(t *testing.T) {
+  keys := []string{"src/main.ts", "src/types.ts"}
+
+  out := aggregateTransformDependencies(keys, nil, newPluginFileDeclarations())
+
+  if !reflect.DeepEqual(out.Complete, []string{"src/main.ts", "src/types.ts"}) {
+    t.Fatalf("expected every file declared complete, got %v", out.Complete)
+  }
+  if out.Dependencies != nil {
+    t.Fatalf("expected no dependency entries, got %v", out.Dependencies)
+  }
+}

package/driver/transform_dependencies_drops_a_self_reported_dependency_test.go

@@ -0,0 +1,21 @@
+package driver
+
+import "testing"
+
+// TestTransformDependenciesDropsASelfReportedDependency verifies a file never
+// enters its own dependency list.
+//
+// The file's own text sits outside the completeness contract by construction —
+// every consumer compares it before anything else — so a self-edge would only
+// make a bundler register the module it is already transforming as one of that
+// module's watch inputs.
+func TestTransformDependenciesDropsASelfReportedDependency(t *testing.T) {
+  declarations := newPluginFileDeclarations()
+  declarations.forPlugin(0).addDependency("src/main.ts", "src/main.ts")
+
+  out := aggregateTransformDependencies([]string{"src/main.ts"}, []int{0}, declarations)
+
+  if len(out.Dependencies) != 0 {
+    t.Fatalf("expected the self-reported dependency to be dropped, got %v", out.Dependencies)
+  }
+}

package/driver/transform_dependencies_keys_a_reported_path_like_the_envelope_test.go

@@ -0,0 +1,46 @@
+package driver
+
+import (
+  "path/filepath"
+  "reflect"
+  "testing"
+)
+
+// TestTransformDependenciesKeysAReportedPathLikeTheEnvelope verifies a plugin's
+// reported paths reach the envelope under the same key convention as every other
+// section.
+//
+// A plugin reports the spellings its host handed it — absolute program file
+// names, which the compiler normalizes to forward slashes on every platform, or
+// paths relative to the plugin's cwd. Keying either differently from
+// `typescript` would leave a consumer unable to join the sections at all, and on
+// Windows the two spellings differ by separator alone, which is exactly the kind
+// of mismatch that passes on POSIX CI and fails on a developer's machine.
+func TestTransformDependenciesKeysAReportedPathLikeTheEnvelope(t *testing.T) {
+  // A real directory, so the absolute spellings below are absolute under the
+  // running platform's own rule rather than under POSIX's alone.
+  cwd := t.TempDir()
+  declarations := newPluginFileDeclarations()
+  ctx := PluginContext{
+    Cwd:                  cwd,
+    reportFileDependency: declarations.forPlugin(0).addDependency,
+    reportFileComplete:   declarations.forPlugin(0).addComplete,
+  }
+
+  // The compiler's own spelling of a source file, and a cwd-relative one.
+  ctx.ReportFileDependency(
+    filepath.ToSlash(filepath.Join(cwd, "src", "main.ts")),
+    filepath.Join("src", "consulted.d.ts"),
+  )
+  ctx.ReportFileDependenciesComplete(filepath.Join(cwd, "src", "main.ts"))
+  ctx.ReportFileDependency("   ", "src/ignored.d.ts")
+
+  out := aggregateTransformDependencies([]string{"src/main.ts"}, []int{0}, declarations)
+
+  if !reflect.DeepEqual(out.Complete, []string{"src/main.ts"}) {
+    t.Fatalf("expected the reported file to key like the envelope, got %v", out.Complete)
+  }
+  if !reflect.DeepEqual(out.Dependencies["src/main.ts"], []string{"src/consulted.d.ts"}) {
+    t.Fatalf("expected the reported dependency to key like the envelope, got %v", out.Dependencies)
+  }
+}

package/driver/transform_dependencies_requires_every_contributor_to_declare_test.go

@@ -0,0 +1,38 @@
+package driver
+
+import (
+  "reflect"
+  "testing"
+)
+
+// TestTransformDependenciesRequiresEveryContributorToDeclare verifies the
+// aggregation rule over a composed plugin set: a file is complete only when
+// every contributing plugin declared it, because a consumer cannot attribute
+// one plugin's reported inputs back to it.
+//
+// It also pins that reporting and declaring are separate acts: a plugin's
+// dependency list widens what consumers invalidate on even while the file
+// itself stays unlisted (samchon/ttsc#1263).
+func TestTransformDependenciesRequiresEveryContributorToDeclare(t *testing.T) {
+  declarations := newPluginFileDeclarations()
+  first := declarations.forPlugin(0)
+  first.addDependency("src/main.ts", "src/consulted.d.ts")
+  first.addComplete("src/main.ts")
+  keys := []string{"src/main.ts"}
+
+  partial := aggregateTransformDependencies(keys, []int{0, 1}, declarations)
+
+  if len(partial.Complete) != 0 {
+    t.Fatalf("expected the silent contributor to block the claim, got %v", partial.Complete)
+  }
+  if !reflect.DeepEqual(partial.Dependencies["src/main.ts"], []string{"src/consulted.d.ts"}) {
+    t.Fatalf("expected the reported dependency to survive, got %v", partial.Dependencies)
+  }
+
+  declarations.forPlugin(1).completeEveryFile()
+  full := aggregateTransformDependencies(keys, []int{0, 1}, declarations)
+
+  if !reflect.DeepEqual(full.Complete, []string{"src/main.ts"}) {
+    t.Fatalf("expected both contributors to complete the claim, got %v", full.Complete)
+  }
+}

package/driver/transform_dependencies_stays_silent_for_an_undeclared_contributor_test.go

@@ -0,0 +1,23 @@
+package driver
+
+import "testing"
+
+// TestTransformDependenciesStaysSilentForAnUndeclaredContributor verifies that
+// a plugin able to change transform output blocks every completeness claim
+// until it makes one itself.
+//
+// This is the compatibility half of the contract: every producer written before
+// the declaration existed keeps the host-owned bound exactly, and a plugin whose
+// output depends on the type graph cannot have that bound narrowed on its
+// behalf (samchon/ttsc#1263).
+func TestTransformDependenciesStaysSilentForAnUndeclaredContributor(t *testing.T) {
+  out := aggregateTransformDependencies(
+    []string{"src/main.ts"},
+    []int{0},
+    newPluginFileDeclarations(),
+  )
+
+  if len(out.Complete) != 0 {
+    t.Fatalf("expected no completeness declaration, got %v", out.Complete)
+  }
+}

package/driver/transform_dependencies_withdraws_completeness_after_an_unusable_dependency_test.go

@@ -0,0 +1,37 @@
+package driver
+
+import "testing"
+
+// TestTransformDependenciesWithdrawsCompletenessAfterAnUnusableDependency
+// verifies a dependency the host could not key withdraws the claim it belonged
+// to, instead of leaving a complete list with a member missing from it.
+//
+// A plugin whose own lookup answered nothing for one input is the case: it
+// reports what it has and declares the file complete, and a host that dropped
+// the unusable member would publish exactly the under-declaration the protocol
+// blames on the plugin — manufactured by the host. Only the affected file loses
+// the claim; the plugin's other files keep theirs.
+func TestTransformDependenciesWithdrawsCompletenessAfterAnUnusableDependency(t *testing.T) {
+  cwd := t.TempDir()
+  declarations := newPluginFileDeclarations()
+  record := declarations.forPlugin(0)
+  ctx := PluginContext{
+    Cwd:                          cwd,
+    reportFileDependency:         record.addDependency,
+    reportFileDependencyRejected: record.rejectDependency,
+    reportEveryFileComplete:      record.completeEveryFile,
+  }
+
+  ctx.ReportDependenciesComplete()
+  ctx.ReportFileDependency("src/main.ts", "")
+
+  out := aggregateTransformDependencies(
+    []string{"src/main.ts", "src/other.ts"},
+    []int{0},
+    declarations,
+  )
+
+  if len(out.Complete) != 1 || out.Complete[0] != "src/other.ts" {
+    t.Fatalf("expected only the unaffected file to stay complete, got %v", out.Complete)
+  }
+}