ttsc 0.19.2 → 0.20.0

package/driver/graph.go

@@ -30,14 +30,19 @@ const bundledScheme = "bundled:///"
 //     declaration files, script files, global augmentations, `typeRoots`
 //     entries). A change to any of them can affect every file.
 //   - Configs lists the project tsconfig followed by its `extends` ancestry.
+//   - Candidates maps each importing file to the resolution probes that precede
+//     its selected module target. They are a separate class from resolved
+//     edges: a probe's file appearing or changing can change an unchanged
+//     import's meaning.
 //
 // Keys and values use the same convention as the envelope's `typescript`
 // 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"`
+  Edges      map[string][]string `json:"edges"`
+  Globals    []string            `json:"globals"`
+  Configs    []string            `json:"configs"`
+  Candidates map[string][]string `json:"candidates,omitempty"`
 }
 
 // NewTransformGraph computes the reference graph of a loaded program, keyed
@@ -50,9 +55,10 @@ func NewTransformGraph(prog *Program, cwd string) *TransformGraph {
     return nil
   }
   graph := &TransformGraph{
-    Edges:   map[string][]string{},
-    Globals: []string{},
-    Configs: []string{},
+    Edges:      map[string][]string{},
+    Globals:    []string{},
+    Configs:    []string{},
+    Candidates: SupersedingModuleCandidates(prog, cwd),
   }
   for _, file := range prog.TSProgram.SourceFiles() {
     fileName := file.FileName()

package/driver/lsp.go

@@ -55,6 +55,12 @@ type LSPProjectDiagnostics = lspserver.LSPProjectDiagnostics
 // LSPDiagnosticsResult separates document and project plugin diagnostics.
 type LSPDiagnosticsResult = lspserver.LSPDiagnosticsResult
 
+// LSPCompletionHint is the driver-level alias for lspserver.LSPCompletionHint.
+type LSPCompletionHint = lspserver.LSPCompletionHint
+
+// LSPCompletionItem is the driver-level alias for lspserver.LSPCompletionItem.
+type LSPCompletionItem = lspserver.LSPCompletionItem
+
 // LSPSymbolKind is the driver-level alias for lspserver.LSPSymbolKind.
 type LSPSymbolKind = lspserver.LSPSymbolKind
 
@@ -74,6 +80,30 @@ type SymbolProvider = lspserver.SymbolProvider
 // diagnostics, code actions, and workspace commands to the LSP proxy.
 type PluginSource = lspserver.PluginSource
 
+// CompletionHintSource is the optional extension a PluginSource implements to
+// contribute editor completion hints to the LSP proxy.
+type CompletionHintSource interface {
+  CompletionHints() []LSPCompletionHint
+}
+
+// CompletionHintRefresher is the optional extension a CompletionHintSource
+// implements when its corpus can change during a session. The proxy calls it
+// after a saved document, a configuration change, or a watched-file change, and
+// expects the call to return immediately: the source owns the scheduling and the
+// staleness rules, and completion keeps reading the previous corpus until the
+// new one is stored.
+type CompletionHintRefresher interface {
+  RefreshCompletionHints()
+}
+
+// CompletionHintObserverSource is the optional extension a CompletionHintSource
+// implements to tell the proxy that a refresh finished. The proxy uses it to
+// detect a completion trigger character that appeared after the initialize
+// response was already sent.
+type CompletionHintObserverSource interface {
+  SetCompletionHintsObserver(observer func())
+}
+
 // NullPluginSource is the driver-level alias for lspserver.NullPluginSource.
 type NullPluginSource = lspserver.NullPluginSource
 

package/driver/program.go

@@ -101,6 +101,9 @@ func (p *Program) SourceFile(filename string) *ast.SourceFile {
   if p == nil || p.TSProgram == nil {
     return nil
   }
+  // Discarded on purpose: an accessor returning a source file has no channel
+  // for an apply failure, and growing one would ripple through every caller.
+  // `Diagnostics` reports it, and the emit path checks the error directly.
   _ = p.ApplyLinkedPlugins()
   normalized := filepath.ToSlash(filename)
   for _, file := range p.TSProgram.SourceFiles() {
@@ -513,6 +516,7 @@ func ApplySourcePreamble(text string, preamble string) string {
 // SourceFiles exposes the program's user-authored source files (declaration
 // files filtered out).
 func (p *Program) SourceFiles() []*ast.SourceFile {
+  // Discarded on purpose; see SourceFile. `Diagnostics` carries the failure.
   _ = p.ApplyLinkedPlugins()
   return p.sourceFilesRaw()
 }
@@ -563,6 +567,38 @@ func (p *Program) Diagnostics() []Diagnostic {
   if p == nil || p.TSProgram == nil {
     return []Diagnostic{{Message: "driver: nil program"}}
   }
+  // A linked ProgramPlugin that failed to apply is reported here, ahead of the
+  // compiler's own findings, because every other consumer of this program is
+  // then looking at a tree the plugin did not transform.
+  //
+  // `SourceFile`, `SourceFiles`, and the graph builder all run the apply and
+  // discard its error — they have no channel of their own and are not the place
+  // to grow one. The emit path checks it directly and fails the build, so this
+  // is the read-only half of the same fact: `ttscgraph` used to describe the
+  // untransformed program with nothing to say about it, while `ttsc build` on
+  // the same project reported the failure.
+  //
+  // The cached outcome is read, never forced. Calling `ApplyLinkedPlugins`
+  // here would move WHEN the apply happens: diagnostics would then be computed
+  // against the mutated tree, whose nodes carry positions that need not map
+  // into the original source text, and the diagnostic writer walks that text to
+  // render context. It panics on the mismatch.
+  //
+  // Reading the cache costs nothing and is enough for the consumers this is
+  // for: `SourceTexts` and `SourceFiles` run the apply, and both graph entry
+  // points call them before asking for diagnostics. A caller that has not
+  // applied yet has nothing to report, which is correct — the plugins have not
+  // failed, they have not run.
+  //
+  // `driver: nil program` above is the precedent for a driver-level entry with
+  // no file or code.
+  var out []Diagnostic
+  if p.pluginsApplied && p.pluginsApplyErr != nil {
+    out = append(out, Diagnostic{
+      Severity: SeverityError,
+      Message:  "driver: linked plugins failed to apply: " + p.pluginsApplyErr.Error(),
+    })
+  }
   ctx := context.Background()
   raw := shimcompiler.GetDiagnosticsOfAnyProgram(
     ctx,
@@ -573,7 +609,7 @@ func (p *Program) Diagnostics() []Diagnostic {
     p.TSProgram.GetSemanticDiagnostics,
   )
   raw = filterDiagnostics(raw)
-  return convertDiagnostics(shimcompiler.SortAndDeduplicateDiagnostics(raw))
+  return append(out, convertDiagnostics(shimcompiler.SortAndDeduplicateDiagnostics(raw))...)
 }
 
 // filterDiagnostics removes diagnostics that are false positives in ttsc's