ttsc 0.16.3 → 0.16.5

package/internal/graph/dump_evidence_skips_leading_trivia_test.go

@@ -0,0 +1,92 @@
+package graph
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestDumpEvidenceSkipsLeadingTrivia verifies that a node's and an edge's
+// evidence line/column point at the code, not the leading trivia, because
+// tsgo's Pos() is the full-start (it includes the doc comment and indentation
+// before a token).
+//
+// A declaration preceded by a doc comment and a call indented under its function
+// are the two shapes that break a naive Pos->line/col: the node would land on the
+// comment line and the edge column on the indentation. The dump skips leading
+// whitespace and `//` / `/* */` comments first, so this pins both to the real
+// token start.
+//
+//  1. Compile a fixture where `main` carries a block doc comment and calls
+//     `helper()` indented two spaces.
+//  2. Build and marshal the dump.
+//  3. Assert the `main` node's evidence starts on the `export function main`
+//     line, and the calls edge's evidence is the indented call's line and column.
+func TestDumpEvidenceSkipsLeadingTrivia(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+/**
+ * doc for main
+ */
+export function main(): void {
+  helper();
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  g := Build(prog)
+  data, err := MarshalDump(g, root, "tsconfig.json", nil, SourceTexts(prog), false)
+  if err != nil {
+    t.Fatalf("MarshalDump: %v", err)
+  }
+  var dump Dump
+  if err := json.Unmarshal(data, &dump); err != nil {
+    t.Fatalf("dump is not valid JSON: %v", err)
+  }
+
+  // The `main` declaration starts on line 5 — past its three-line doc comment —
+  // not on line 2 where the comment (its leading trivia) begins.
+  var main *DumpNode
+  for i := range dump.Nodes {
+    if dump.Nodes[i].Kind == "function" && dump.Nodes[i].Name == "main" {
+      main = &dump.Nodes[i]
+    }
+  }
+  if main == nil || main.Evidence == nil {
+    t.Fatalf("missing main node with evidence: %+v", dump.Nodes)
+  }
+  if main.Evidence.StartLine != 5 {
+    t.Fatalf("main evidence startLine = %d, want 5 (past the doc comment)", main.Evidence.StartLine)
+  }
+
+  // The `helper()` call sits on line 6, indented two spaces, so the edge
+  // evidence is line 6 column 3 — not line 5 (where the trivia begins) or
+  // column 1 (the indentation).
+  var call *DumpEdge
+  for i := range dump.Edges {
+    e := &dump.Edges[i]
+    if e.Kind == "calls" && e.From == "src/main.ts#main:function" {
+      call = e
+    }
+  }
+  if call == nil || call.Evidence == nil {
+    t.Fatalf("missing calls edge with evidence: %+v", dump.Edges)
+  }
+  if call.Evidence.StartLine != 6 || call.Evidence.StartCol != 3 {
+    t.Fatalf(
+      "call evidence = line %d col %d, want line 6 col 3 (the indented call)",
+      call.Evidence.StartLine, call.Evidence.StartCol,
+    )
+  }
+}

package/internal/graph/dump_serializes_the_full_graph_test.go

@@ -0,0 +1,146 @@
+package graph
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestMarshalDumpSerializesTheFullGraph verifies that MarshalDump projects a
+// built graph onto the IGraphDump wire contract the `ttscgraph dump` command
+// prints and the @ttsc/graph engine loads: the project envelope, every node and
+// edge, project-relative paths, line/col evidence, and the lowercase wire keys.
+//
+// The Node/Edge structs carry no json tags, so dump.go's projection is the only
+// thing standing between the Go fields and the wire. A regression there would
+// ship keys or kinds the engine does not read, so the key and kind assertions
+// are load-bearing, not cosmetic.
+//
+//  1. Build a two-function fixture with one call, so the dump has a node set and
+//     a value-call edge.
+//  2. Marshal it with source texts and assert the envelope, counts, and that the
+//     call edge maps to kind "calls" with a line/col evidence span.
+//  3. Assert paths are project-relative, the wire keys are the lowercase json
+//     tags, every edge endpoint resolves to a dumped node, and --pretty indents.
+func TestMarshalDumpSerializesTheFullGraph(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function helper(): void {}
+export function main(): void {
+  helper();
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  g := Build(prog)
+  sources := SourceTexts(prog)
+
+  data, err := MarshalDump(g, root, "tsconfig.json", nil, sources, false)
+  if err != nil {
+    t.Fatalf("MarshalDump: %v", err)
+  }
+
+  var dump Dump
+  if err := json.Unmarshal(data, &dump); err != nil {
+    t.Fatalf("dump is not valid JSON: %v\n%s", err, data)
+  }
+  if dump.Project != root || dump.Tsconfig != "tsconfig.json" {
+    t.Fatalf("project/tsconfig not echoed: %q / %q", dump.Project, dump.Tsconfig)
+  }
+  if len(dump.Nodes) != len(g.Nodes) {
+    t.Fatalf("dumped %d nodes, graph has %d", len(dump.Nodes), len(g.Nodes))
+  }
+  if len(dump.Edges) != len(g.Edges) {
+    t.Fatalf("dumped %d edges, graph has %d", len(dump.Edges), len(g.Edges))
+  }
+
+  // Locate the two function nodes by their wire shape, and confirm paths and ids
+  // are project-relative (no temp-dir prefix leaked).
+  byID := make(map[string]DumpNode, len(dump.Nodes))
+  var mainID, helperID string
+  for _, n := range dump.Nodes {
+    byID[n.ID] = n
+    if n.Kind == "function" && n.Name == "main" {
+      mainID = n.ID
+    }
+    if n.Kind == "function" && n.Name == "helper" {
+      helperID = n.ID
+    }
+  }
+  if mainID == "" || helperID == "" {
+    t.Fatalf("missing main/helper function nodes: %v", dump.Nodes)
+  }
+  if mainID != "src/main.ts#main:function" {
+    t.Fatalf("node id not project-relative: %q", mainID)
+  }
+  if byID[mainID].File != "src/main.ts" {
+    t.Fatalf("node file not project-relative: %q", byID[mainID].File)
+  }
+  if byID[mainID].Evidence == nil || byID[mainID].Evidence.StartLine == 0 {
+    t.Fatalf("main node missing line/col evidence: %+v", byID[mainID].Evidence)
+  }
+
+  // The main -> helper call maps to kind "calls" with a located evidence span.
+  var call *DumpEdge
+  for i := range dump.Edges {
+    e := &dump.Edges[i]
+    if e.From == mainID && e.To == helperID && e.Kind == "calls" {
+      call = e
+    }
+  }
+  if call == nil {
+    t.Fatalf("no calls edge main -> helper in dump:\n%s", data)
+  }
+  if call.Evidence == nil || call.Evidence.StartLine == 0 || call.Evidence.File != "src/main.ts" {
+    t.Fatalf("call edge missing project-relative line/col evidence: %+v", call.Evidence)
+  }
+
+  // Every edge endpoint resolves to a dumped node.
+  for _, e := range dump.Edges {
+    if _, ok := byID[e.From]; !ok {
+      t.Fatalf("edge from %q has no dumped node", e.From)
+    }
+    if _, ok := byID[e.To]; !ok {
+      t.Fatalf("edge to %q has no dumped node", e.To)
+    }
+  }
+
+  // The wire keys are the lowercase json tags, not the Go field names.
+  s := string(data)
+  for _, key := range []string{`"id":`, `"kind":`, `"name":`, `"file":`, `"external":`, `"from":`, `"to":`} {
+    if !strings.Contains(s, key) {
+      t.Fatalf("dump missing wire key %s:\n%s", key, s)
+    }
+  }
+  for _, leaked := range []string{`"ID":`, `"Kind":`, `"From":`, `"External":`} {
+    if strings.Contains(s, leaked) {
+      t.Fatalf("dump leaked Go field name %s:\n%s", leaked, s)
+    }
+  }
+  // The dump carries no ceremony keys: it is wholly checker-resolved, so it has
+  // no per-edge trust flags and no schema version to negotiate.
+  for _, gone := range []string{`"schemaVersion"`, `"provenance":`, `"confidence":`} {
+    if strings.Contains(s, gone) {
+      t.Fatalf("dump still emits removed key %s:\n%s", gone, s)
+    }
+  }
+
+  pretty, err := MarshalDump(g, root, "tsconfig.json", nil, sources, true)
+  if err != nil {
+    t.Fatalf("MarshalDump pretty: %v", err)
+  }
+  if !strings.Contains(string(pretty), "\n  ") {
+    t.Fatalf("--pretty output is not indented:\n%s", pretty)
+  }
+}

package/internal/graph/edge_spans_point_to_resolved_usage_test.go

@@ -0,0 +1,90 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestEdgeSpansPointToResolvedUsage verifies each checker-resolved edge keeps
+// the source expression that produced it. The edge is still deduped by
+// from/to/kind, but MCP needs the first concrete use span so a truncated
+// declaration can reopen the right line without string-searching for a target
+// name that may appear elsewhere.
+func TestEdgeSpansPointToResolvedUsage(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  path := filepath.Join(root, "src", "main.ts")
+  writeFile(t, path, `export function helper(): number {
+  return 1;
+}
+
+export function caller(): number {
+  const helperShadow = 0;
+  return helper() + helperShadow;
+}
+
+export class Box {
+  value = 1;
+
+  read(): number {
+    return this.value;
+  }
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  caller := nodeByName(graph, "caller", NodeFunction)
+  helper := nodeByName(graph, "helper", NodeFunction)
+  read := nodeByName(graph, "Box.read", NodeMethod)
+  value := nodeByName(graph, "Box.value", NodeVariable)
+  if caller == nil || helper == nil || read == nil || value == nil {
+    t.Fatalf("missing fixture nodes: caller=%v helper=%v read=%v value=%v", caller, helper, read, value)
+  }
+  source := prog.SourceFile(caller.File).Text()
+
+  call := findEdge(graph, caller.ID, helper.ID, EdgeValueCall)
+  if call == nil {
+    t.Fatalf("missing caller -> helper value-call edge; edges: %v", graph.Edges)
+  }
+  if got := strings.TrimSpace(source[call.Pos:call.End]); got != "helper" {
+    t.Fatalf("value-call span = %q, want helper", got)
+  }
+
+  access := findEdge(graph, read.ID, value.ID, EdgeValueAccess)
+  if access == nil {
+    t.Fatalf("missing Box.read -> Box.value value-access edge; edges: %v", graph.Edges)
+  }
+  if got := source[access.Pos:access.End]; !strings.Contains(got, "this.value") {
+    t.Fatalf("value-access span = %q, want this.value expression", got)
+  }
+}
+
+func nodeByName(graph *Graph, name string, kind NodeKind) *Node {
+  for _, node := range graph.Nodes {
+    if node.Name == name && node.Kind == kind {
+      return node
+    }
+  }
+  return nil
+}
+
+func findEdge(graph *Graph, from, to string, kind EdgeKind) *Edge {
+  for _, edge := range graph.Edges {
+    if edge.From == from && edge.To == to && edge.Kind == kind {
+      return edge
+    }
+  }
+  return nil
+}