ttsc 0.18.3 → 0.19.0

package/cmd/ttscgraph/serve_session_revisits_source_edited_during_load_test.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestServeSessionRevisitsSourceEditedDuringLoad verifies a source edited
+// between compiler load and state capture is refreshed on the next snapshot.
+//
+// Hashing the raw disk bytes at capture time would bless content the resident
+// program never parsed: disk and graph would disagree until an unrelated
+// change. The capture must hash the resident text instead, so the next
+// snapshot sees the disk mismatch and applies the missed edit.
+//
+//  1. Load a session, then rewrite the source before capturing state.
+//  2. Take a snapshot and assert it refreshes to the on-disk declaration.
+//  3. Take another snapshot and assert the session has converged (unchanged).
+func TestServeSessionRevisitsSourceEditedDuringLoad(t *testing.T) {
+  root := graphSessionFixture(t)
+  compiler, diags, err := driver.NewSession(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if compiler == nil {
+    t.Fatalf("NewSession returned nil session (diagnostics: %v)", diags)
+  }
+  file := filepath.Join(root, "src", "index.ts")
+  if err := os.WriteFile(file, []byte("export class EditedDuringLoad {}\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  session := &graphSession{
+    cwd:         root,
+    tsconfig:    "tsconfig.json",
+    compiler:    compiler,
+    initialized: true,
+  }
+  defer session.Close()
+  if err := session.captureState(); err != nil {
+    t.Fatal(err)
+  }
+
+  dump, _, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || !changed || !hasDumpNode(*dump, "EditedDuringLoad") || hasDumpNode(*dump, "BeforeEdit") {
+    t.Fatalf("edited-during-load source was not refreshed: dump:%v changed:%v", dump != nil, changed)
+  }
+
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != "unchanged" || changed {
+    t.Fatalf("session did not converge after the missed edit: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_tolerates_os_invalid_resolution_candidate_test.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionToleratesOsInvalidResolutionCandidate verifies unresolved
+// module specifiers that name OS-unparseable paths never break the session.
+//
+// Bundler-style specifiers (`./style.css?inline`) and URL imports (`data:`)
+// stay unresolved in tsgo and become freshness candidates. On Windows those
+// candidate paths fail os.ReadFile with ERROR_INVALID_NAME, which is neither
+// ErrNotExist nor ErrInvalid; treating that as a snapshot error would make
+// every graph request fail forever on such a project.
+//
+//  1. Open a session whose only root imports a query-suffixed CSS path and a
+//     data: URL.
+//  2. Assert the session initializes and serves its initial dump.
+//  3. Assert an untouched second snapshot reports unchanged.
+func TestServeSessionToleratesOsInvalidResolutionCandidate(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs" },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), `
+// @ts-expect-error bundler-only specifier stays unresolved for tsgo
+import styles from "./style.css?inline";
+// @ts-expect-error data: URLs resolve at runtime, not through the compiler
+import remote from "data:text/plain,hello";
+export const value: unknown[] = [styles, remote];
+`)
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump == nil || mode != "initial" || !changed {
+    t.Fatalf("initial snapshot = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+
+  dump, mode, changed, err = session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != "unchanged" || changed {
+    t.Fatalf("untouched snapshot = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscgraph/serve_session_tracks_all_module_specifier_forms_test.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionTracksAllModuleSpecifierForms verifies that every TypeScript
+// syntax which can trigger module resolution contributes missing-file
+// candidates to the freshness snapshot.
+func TestServeSessionTracksAllModuleSpecifierForms(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), `
+import legacy = require("./legacy");
+export { exported } from "./exported";
+export type Deferred = import("./types").Deferred;
+export const lazy = import("./lazy");
+export const common = require("./common");
+export const result = legacy();
+`)
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+
+  for _, name := range []string{"legacy.ts", "exported.ts", "types.ts", "lazy.ts", "common.ts"} {
+    candidate := filepath.Join(root, "src", name)
+    state, ok := session.auxStates[candidate]
+    if !ok {
+      t.Errorf("module candidate %s was not tracked", name)
+    } else if state.Exists {
+      t.Errorf("missing module candidate %s unexpectedly exists", name)
+    }
+  }
+}

package/cmd/ttscgraph/serve_session_tracks_diamond_project_references_once_test.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeSessionTracksDiamondProjectReferencesOnce verifies the config
+// traversal terminates and deduplicates when two references share a child.
+//
+// A diamond (root -> left, root -> right, both -> shared) visits the shared
+// config twice; without the seen-set the traversal would duplicate tracked
+// state, and on a reference cycle it would never terminate. The shared leaf
+// must appear in the freshness state exactly once and the session must stay
+// stable across untouched snapshots.
+//
+//  1. Open a session over a diamond of project references.
+//  2. Assert the shared leaf config is hash-tracked.
+//  3. Assert an untouched snapshot reports unchanged.
+func TestServeSessionTracksDiamondProjectReferencesOnce(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "files": ["src/index.ts"],
+  "references": [{ "path": "./left" }, { "path": "./right" }]
+}`)
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"), "export const root = 1;\n")
+  for _, side := range []string{"left", "right"} {
+    writeGraphFile(t, filepath.Join(root, side, "tsconfig.json"), `{
+  "compilerOptions": { "composite": true },
+  "files": ["src/index.ts"],
+  "references": [{ "path": "../shared" }]
+}`)
+    writeGraphFile(t, filepath.Join(root, side, "src", "index.ts"), "export const side = 1;\n")
+  }
+  writeGraphFile(t, filepath.Join(root, "shared", "tsconfig.json"), `{
+  "compilerOptions": { "composite": true },
+  "files": ["src/index.ts"]
+}`)
+  writeGraphFile(t, filepath.Join(root, "shared", "src", "index.ts"), "export const shared = 1;\n")
+
+  session, err := newGraphSession(root, "tsconfig.json")
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer session.Close()
+  sharedConfig := filepath.ToSlash(filepath.Join(root, "shared", "tsconfig.json"))
+  if _, ok := session.configHashes[sharedConfig]; !ok {
+    t.Fatalf("shared diamond config was not tracked: %s; got %#v", sharedConfig, session.configHashes)
+  }
+  if _, _, _, err := session.Snapshot(); err != nil {
+    t.Fatal(err)
+  }
+
+  dump, mode, changed, err := session.Snapshot()
+  if err != nil {
+    t.Fatal(err)
+  }
+  if dump != nil || mode != "unchanged" || changed {
+    t.Fatalf("diamond references churned: dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+  }
+}

package/cmd/ttscserver/main.go

@@ -133,9 +133,11 @@ func runLSP(args []string) int {
   }
 
   // The SymbolProvider answers textDocument/documentSymbol and
-  // textDocument/references locally from ttsc's compiler-backed code graph;
-  // tsgo's native LSP does not implement them. It loads the program lazily on
-  // the first such request, so wiring it here adds no startup cost.
+  // textDocument/references from ttsc's compiler-backed code graph. tsgo
+  // implements both methods itself, so the proxy forwards to tsgo whenever it
+  // advertises the capability and consults this provider only as a fallback
+  // (tsgo did not advertise). It loads the program lazily on the first such
+  // request, so wiring it here adds no startup cost.
   symbolProvider := graphsymbols.NewProvider(cwd, strings.TrimSpace(*tsconfigFlag))
 
   err = runLSPServer(ctx, lspserver.LSPServerOptions{

package/driver/lsp.go

@@ -49,6 +49,12 @@ type LSPTextEdit = lspserver.LSPTextEdit
 // LSPDocumentVersion is the driver-level alias for lspserver.LSPDocumentVersion.
 type LSPDocumentVersion = lspserver.LSPDocumentVersion
 
+// LSPProjectDiagnostics is the driver-level alias for a project publication.
+type LSPProjectDiagnostics = lspserver.LSPProjectDiagnostics
+
+// LSPDiagnosticsResult separates document and project plugin diagnostics.
+type LSPDiagnosticsResult = lspserver.LSPDiagnosticsResult
+
 // LSPSymbolKind is the driver-level alias for lspserver.LSPSymbolKind.
 type LSPSymbolKind = lspserver.LSPSymbolKind
 
@@ -104,6 +110,12 @@ type LSPServerOptions = lspserver.LSPServerOptions
 // LSPUpstreamRunner is the driver-level alias for lspserver.LSPUpstreamRunner.
 type LSPUpstreamRunner = lspserver.LSPUpstreamRunner
 
+// LSPUpstreamValidator is the driver-level alias for lspserver.LSPUpstreamValidator.
+type LSPUpstreamValidator = lspserver.LSPUpstreamValidator
+
+// LSPUpstream is the driver-level alias for lspserver.LSPUpstream.
+type LSPUpstream = lspserver.LSPUpstream
+
 // MaxFrameBytes is the maximum byte length of a single JSON-RPC frame
 // the proxy will read without returning ErrFrameTooLarge.
 const MaxFrameBytes = lspserver.MaxFrameBytes
@@ -118,6 +130,7 @@ var ErrFrameClosed = lspserver.ErrFrameClosed
 var ErrFrameTooLarge = lspserver.ErrFrameTooLarge
 var ErrInvalidJSONRPC = lspserver.ErrInvalidJSONRPC
 var ErrLSPUpstreamPanic = lspserver.ErrLSPUpstreamPanic
+var ErrLSPUpstreamRunnerRequired = lspserver.ErrLSPUpstreamRunnerRequired
 var ErrLSPCwdRequired = lspserver.ErrLSPCwdRequired
 var ErrLSPTsgoBinaryRequired = lspserver.ErrLSPTsgoBinaryRequired
 
@@ -128,7 +141,6 @@ var NewFrameReader = lspserver.NewFrameReader
 var WriteFrame = lspserver.WriteFrame
 var ParseEnvelope = lspserver.ParseEnvelope
 var RecoverPanicAs = lspserver.RecoverPanicAs
-var WithUpstreamRunnerForTest = lspserver.WithUpstreamRunnerForTest
 var RunLSPServer = lspserver.RunLSPServer
 var DenyNpmInstall = lspserver.DenyNpmInstall
 

package/driver/plugins.go

@@ -4,6 +4,7 @@ import (
   "encoding/json"
   "fmt"
   "os"
+  "path/filepath"
   "strings"
 )
 
@@ -13,6 +14,40 @@ import (
 // linked plugins are active.
 const LinkedPluginsEnv = "TTSC_LINKED_PLUGINS_JSON"
 
+// PluginConfigDirEnv is the environment variable through which the ttsc
+// launcher passes the project root that plugin config-file discovery and
+// relative "configFile" resolution anchor at. The launcher sets it on every
+// native plugin spawn; it matters when the compiled tsconfig is a generated
+// wrapper outside the project — e.g. @ttsc/unplugin writes a compiler-options
+// overlay into the system temp directory that `extends` the real project
+// config — where the tsconfig directory no longer identifies the project and
+// an unanchored discovery walk would climb the temp tree instead. It rides
+// the environment rather than a CLI flag so third-party native hosts with
+// strict flag sets are unaffected and linked plugins running inside them
+// still receive it.
+const PluginConfigDirEnv = "TTSC_PLUGIN_CONFIG_DIR"
+
+// PluginConfigBaseDir returns the directory where a plugin anchors its
+// config-file discovery walk and resolves relative "configFile" paths.
+// The explicit PluginConfigDirEnv channel wins when set; otherwise the
+// tsconfig's directory is used, falling back to cwd when no tsconfig is set.
+func PluginConfigBaseDir(cwd, tsconfigPath string) string {
+  if dir := strings.TrimSpace(os.Getenv(PluginConfigDirEnv)); dir != "" {
+    if !filepath.IsAbs(dir) && cwd != "" {
+      dir = filepath.Join(cwd, dir)
+    }
+    return filepath.Clean(dir)
+  }
+  if tsconfigPath != "" {
+    resolved := tsconfigPath
+    if !filepath.IsAbs(resolved) {
+      resolved = filepath.Join(cwd, resolved)
+    }
+    return filepath.Dir(resolved)
+  }
+  return cwd
+}
+
 // PluginEntry is the manifest shape ttsc passes to driver-level plugins.
 type PluginEntry struct {
   Config map[string]any `json:"config"`
@@ -42,11 +77,14 @@ type ProgramPlugin interface {
 // EmitTransformPlugin contributes an emit-phase AST transformer. The returned
 // PluginTransform runs first in tsgo's per-file emit chain, sharing the emit
 // EmitContext with the builtin transformers, so a plugin returns AST instead of
-// spliced text: it injects its own imports with ec.Factory and references them
-// via NewGeneratedNameForNode, and tsgo's module-transform emits the require and
-// aliases the references itself. This is the AST-integration replacement for the
-// ProgramPlugin + RewriteSet text-splice model. A plugin whose returned
-// transform is nil contributes nothing.
+// spliced text. For an injected import, allocate its binding once with
+// ec.Factory.NewUniqueNameEx and the Optimistic | FileLevel flags, then reuse
+// that identifier for every reference. NewGeneratedNameForNode on a string
+// literal uses tsgo's temp-name channel and can be shadowed by downlevel temps.
+// Tsgo's module-transform emits the require and aliases the references itself.
+// This is the AST-integration replacement for the ProgramPlugin + RewriteSet
+// text-splice model. A plugin whose returned transform is nil contributes
+// nothing.
 type EmitTransformPlugin interface {
   EmitTransform(PluginContext) (PluginTransform, error)
 }
@@ -130,6 +168,19 @@ func (state linkedPluginState) apply(prog *Program) error {
   return nil
 }
 
+func (state linkedPluginState) hasProgramPlugins() bool {
+  for index := range state.entries {
+    plugin, ok := registeredPlugin(index)
+    if !ok {
+      continue
+    }
+    if _, ok := plugin.(ProgramPlugin); ok {
+      return true
+    }
+  }
+  return false
+}
+
 // emitTransforms collects an emit-phase PluginTransform from every registered
 // EmitTransformPlugin, in registration order. Entries that do not implement
 // EmitTransformPlugin, or whose transform is nil, are skipped.

package/driver/program.go

@@ -81,15 +81,14 @@ func NewLintDiagnostic(
     lint:     lint,
   }
   if file != nil {
+    pos = lint.Pos()
     d.File = file.FileName()
-    if pos >= 0 {
-      length := lint.Len()
-      d.Start = &pos
-      d.Length = &length
-      line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
-      d.Line = line + 1
-      d.Column = col + 1
-    }
+    length := lint.Len()
+    d.Start = &pos
+    d.Length = &length
+    line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
+    d.Line = line + 1
+    d.Column = col + 1
   }
   return d
 }
@@ -456,10 +455,10 @@ type sourcePreambleFS struct {
 
 func (fs sourcePreambleFS) ReadFile(filePath string) (string, bool) {
   contents, ok := fs.FS.ReadFile(filePath)
-  if !ok || !isSourcePreambleTarget(filePath) {
+  if !ok {
     return contents, ok
   }
-  return ApplySourcePreamble(contents, fs.preamble), true
+  return ApplySourcePreambleToFile(filePath, contents, fs.preamble), true
 }
 
 // isSourcePreambleTarget reports whether the preamble should be injected into
@@ -480,6 +479,15 @@ func isSourcePreambleTarget(filePath string) bool {
   return false
 }
 
+// ApplySourcePreambleToFile applies a generated preamble only when filePath is
+// a non-declaration TypeScript or JavaScript source, matching sourcePreambleFS.
+func ApplySourcePreambleToFile(filePath string, text string, preamble string) string {
+  if !isSourcePreambleTarget(filePath) {
+    return text
+  }
+  return ApplySourcePreamble(text, preamble)
+}
+
 // ApplySourcePreamble inserts a generated source preamble without moving the
 // file's BOM or hashbang away from the first bytes of the physical output.
 func ApplySourcePreamble(text string, preamble string) string {
@@ -542,6 +550,13 @@ func (p *Program) ApplyLinkedPlugins() error {
   return p.pluginsApplyErr
 }
 
+// HasLinkedProgramPlugins reports whether the loaded project has an active
+// ProgramPlugin. Those hooks mutate parsed ASTs in place and therefore require
+// a fresh Program rather than Session's incremental source replacement.
+func (p *Program) HasLinkedProgramPlugins() bool {
+  return p != nil && p.plugins.hasProgramPlugins()
+}
+
 // Diagnostics returns project diagnostics that must block compilation or
 // runtime execution before any JavaScript is emitted or evaluated.
 func (p *Program) Diagnostics() []Diagnostic {