ttsc 0.16.5 → 0.16.7

package/cmd/graphdump/main.go

@@ -1,7 +1,7 @@
 // Command graphdump builds the @ttsc/graph code graph for a project and prints
 // the entire graph (every node and every edge, with none of the MCP response
 // caps) as one JSON document. It is the repo-internal one-shot used by the
-// graph-bench viewer pipeline; the shipped equivalent is `ttscgraph dump`. Both
+// benchmark graph viewer pipeline; the shipped equivalent is `ttscgraph dump`. Both
 // serialize through graph.MarshalDump.
 package main
 

package/internal/graph/decorators.go

@@ -6,9 +6,8 @@ import (
 
 // DecoratorArgument is one argument written on a decorator. Literal holds the
 // statically-resolved value when the argument is a string or boolean literal
-// and is nil otherwise; Text is always the argument's printable source.
+// and is nil otherwise.
 type DecoratorArgument struct {
-  Text    string
   Literal any
 }
 
@@ -26,8 +25,8 @@ type Decorator struct {
 }
 
 // collectDecorators records the decorators on each class plus its methods and
-// properties, descending into namespace bodies. It is syntactic — a decorator's
-// name and literal arguments are read straight from the AST — because a consumer
+// properties, descending into namespace bodies. It is syntactic: a decorator's
+// name and literal arguments are read straight from the AST because a consumer
 // keys on the written convention name, not the resolved decorator symbol.
 func (g *Graph) collectDecorators(path string, statements []*shimast.Node) {
   for _, statement := range statements {
@@ -105,11 +104,10 @@ func decoratorFact(dec *shimast.Node) *Decorator {
   return fact
 }
 
-// decoratorArg captures one decorator argument. Only string and boolean literals
-// resolve to a Literal — the values a consumer can use directly — so a
-// non-literal argument keeps its source Text with a nil Literal.
+// decoratorArg captures one decorator argument. Only string and boolean
+// literals resolve to a Literal, the values a consumer can use directly.
 func decoratorArg(arg *shimast.Node) DecoratorArgument {
-  out := DecoratorArgument{Text: shimast.NodeText(arg)}
+  out := DecoratorArgument{}
   switch arg.Kind {
   case shimast.KindStringLiteral, shimast.KindNoSubstitutionTemplateLiteral:
     out.Literal = arg.Text()

package/internal/graph/dump.go

@@ -8,7 +8,7 @@ import (
 )
 
 // dump.go projects a built graph onto the JSON wire contract `ttscgraph dump`
-// prints — the IGraphDump shape the @ttsc/graph engine loads (and the 3D viewer
+// prints: the IGraphDump shape the @ttsc/graph engine loads (and the 3D viewer
 // reduces). The internal Node/Edge model stays narrow (so the resident MCP path
 // is untouched); the richer schema is produced here:
 //
@@ -16,7 +16,7 @@ import (
 //   - one EdgeValueCall splits by Origin into "calls" / "instantiates" /
 //     "renders", and EdgeHeritage into "extends" / "implements";
 //   - every edge is tagged checker-resolved / high (the graph's whole contract);
-//   - byte spans become 1-based line/col Evidence, with a short excerpt on edges;
+//   - byte spans become 1-based line/col Evidence ranges;
 //   - decorator facts ride on their target node;
 //   - file paths are project-relative and the output is sorted, so the dump is
 //     deterministic and diffable.
@@ -33,14 +33,12 @@ type DumpEvidence struct {
   StartCol  int    `json:"startCol,omitempty"`
   EndLine   int    `json:"endLine,omitempty"`
   EndCol    int    `json:"endCol,omitempty"`
-  Text      string `json:"text,omitempty"`
 }
 
 // DumpDecoratorArgument is one decorator argument; Literal is set only for a
 // statically-resolved string or boolean literal.
 type DumpDecoratorArgument struct {
-  Text    string `json:"text"`
-  Literal any    `json:"literal,omitempty"`
+  Literal any `json:"literal,omitempty"`
 }
 
 // DumpDecorator is a decorator as written on a declaration, carried on its
@@ -53,17 +51,18 @@ type DumpDecorator struct {
 // DumpNode is the wire shape of a graph node. Lowercase json keys are the
 // contract; the Go field names are not.
 type DumpNode struct {
-  ID            string          `json:"id"`
-  Kind          string          `json:"kind"`
-  Name          string          `json:"name"`
-  QualifiedName string          `json:"qualifiedName,omitempty"`
-  File          string          `json:"file"`
-  External      bool            `json:"external"`
-  Ignored       bool            `json:"ignored,omitempty"`
-  Exported      bool            `json:"exported,omitempty"`
-  Modifiers     []string        `json:"modifiers,omitempty"`
-  Evidence      *DumpEvidence   `json:"evidence,omitempty"`
-  Decorators    []DumpDecorator `json:"decorators,omitempty"`
+  ID             string          `json:"id"`
+  Kind           string          `json:"kind"`
+  Name           string          `json:"name"`
+  QualifiedName  string          `json:"qualifiedName,omitempty"`
+  File           string          `json:"file"`
+  External       bool            `json:"external"`
+  Ignored        bool            `json:"ignored,omitempty"`
+  Exported       bool            `json:"exported,omitempty"`
+  Modifiers      []string        `json:"modifiers,omitempty"`
+  Evidence       *DumpEvidence   `json:"evidence,omitempty"`
+  Implementation *DumpEvidence   `json:"implementation,omitempty"`
+  Decorators     []DumpDecorator `json:"decorators,omitempty"`
 }
 
 // DumpEdge is the wire shape of a graph edge. Lowercase json keys are the
@@ -98,7 +97,10 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
   for _, d := range g.Decorators {
     args := make([]DumpDecoratorArgument, 0, len(d.Arguments))
     for _, a := range d.Arguments {
-      args = append(args, DumpDecoratorArgument{Text: a.Text, Literal: a.Literal})
+      if a.Literal == nil {
+        continue
+      }
+      args = append(args, DumpDecoratorArgument{Literal: a.Literal})
     }
     decByNode[d.Target] = append(decByNode[d.Target], DumpDecorator{Name: d.Name, Arguments: args})
   }
@@ -107,17 +109,18 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
   for _, n := range g.Nodes {
     name, qualified := nodeNames(n)
     nodes = append(nodes, DumpNode{
-      ID:            ctx.relID(n.ID),
-      Kind:          string(n.Kind),
-      Name:          name,
-      QualifiedName: qualified,
-      File:          ctx.rel(n.File),
-      External:      n.External,
-      Ignored:       ignored[n.File],
-      Exported:      n.Exported,
-      Modifiers:     n.Modifiers,
-      Evidence:      ctx.evidence(n.File, n.Pos, n.End, false),
-      Decorators:    decByNode[n.ID],
+      ID:             ctx.relID(n.ID),
+      Kind:           string(n.Kind),
+      Name:           name,
+      QualifiedName:  qualified,
+      File:           ctx.rel(n.File),
+      External:       n.External,
+      Ignored:        ignored[n.File],
+      Exported:       n.Exported,
+      Modifiers:      n.Modifiers,
+      Evidence:       ctx.evidence(n.File, n.Pos, n.End),
+      Implementation: ctx.evidence(n.ImplementationFile, n.ImplementationPos, n.ImplementationEnd),
+      Decorators:     decByNode[n.ID],
     })
   }
   sort.Slice(nodes, func(i, j int) bool { return nodes[i].ID < nodes[j].ID })
@@ -199,7 +202,7 @@ func wireEdgeKind(kind EdgeKind, origin string) string {
 // nodeNames returns a node's simple name and, when it is owner-qualified, its
 // full qualified form for the wire. The simple name is the symbol's own name
 // recorded at build time, so a quoted member whose name contains a dot
-// (`"a.b"` → Name `C.a.b`) splits exactly; the qualified form is the full Name
+// (`"a.b"` becomes Name `C.a.b`) splits exactly; the qualified form is the full Name
 // when it differs from the simple name, and "" for a top-level declaration.
 // A node without a recorded simple name (a future virtual node) falls back to
 // the last dot-separated segment.
@@ -262,9 +265,8 @@ func (c *dumpContext) relID(id string) string {
 }
 
 // evidence builds the line/col span for a byte range in file, or nil when the
-// span is absent or no source is available. includeText attaches a one-line
-// excerpt (used for edge expressions, not declaration bodies).
-func (c *dumpContext) evidence(file string, pos, end int, includeText bool) *DumpEvidence {
+// span is absent or no source is available.
+func (c *dumpContext) evidence(file string, pos, end int) *DumpEvidence {
   if pos < 0 || c.sources == nil {
     return nil
   }
@@ -289,15 +291,12 @@ func (c *dumpContext) evidence(file string, pos, end int, includeText bool) *Dum
   ev := &DumpEvidence{File: c.rel(file), StartLine: sl, StartCol: sc}
   if end > pos && end <= len(text) {
     ev.EndLine, ev.EndCol = ls.at(end)
-    if includeText {
-      ev.Text = excerpt(text[pos:end])
-    }
   }
   return ev
 }
 
-// firstCodeOffset advances past leading trivia — whitespace, // line comments,
-// and /* */ block comments — from pos to the first code byte, or len(text) if
+// firstCodeOffset advances past leading trivia: whitespace, // line comments,
+// and /* */ block comments from pos to the first code byte, or len(text) if
 // the rest is all trivia. It mirrors how a token's real start is found, so an
 // evidence span lands on the declaration rather than the comment above it.
 func firstCodeOffset(text string, pos int) int {
@@ -328,15 +327,14 @@ func firstCodeOffset(text string, pos int) int {
   return i
 }
 
-// edgeEvidence is the evidence for an edge's source expression, with a short
-// excerpt of the expression text.
+// edgeEvidence is the evidence range for an edge's source expression.
 func (c *dumpContext) edgeEvidence(e *Edge) *DumpEvidence {
   // The edge's span lives in the From node's file.
   file := nodeFile(e.From)
   if file == "" {
     return nil
   }
-  return c.evidence(file, e.Pos, e.End, true)
+  return c.evidence(file, e.Pos, e.End)
 }
 
 // nodeFile recovers the source file path embedded in a node id
@@ -348,20 +346,6 @@ func nodeFile(id string) string {
   return ""
 }
 
-// excerpt is a single-line, length-capped slice of source text for inline
-// evidence.
-func excerpt(s string) string {
-  s = strings.TrimSpace(s)
-  if i := strings.IndexByte(s, '\n'); i >= 0 {
-    s = s[:i]
-  }
-  if len(s) > 160 {
-    // Drop a trailing partial UTF-8 rune so the excerpt cannot end mid-character.
-    s = strings.TrimSpace(strings.ToValidUTF8(s[:160], "")) + "…"
-  }
-  return s
-}
-
 // lineStarts holds the byte offset of each line's start, so an offset maps to a
 // 1-based line/column by binary search.
 type lineStarts []int

package/internal/graph/dump_serializes_the_full_graph_test.go

@@ -130,7 +130,7 @@ export function main(): void {
   }
   // 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":`} {
+  for _, gone := range []string{`"schemaVersion"`, `"provenance":`, `"confidence":`, `"text":`} {
     if strings.Contains(s, gone) {
       t.Fatalf("dump still emits removed key %s:\n%s", gone, s)
     }

package/internal/graph/edges.go

@@ -304,6 +304,11 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
       if !isInvokedAccess(child) {
         g.accessEdge(checker, from, child)
       }
+    case shimast.KindBinaryExpression:
+      if target := g.assignedFunctionTarget(checker, from, child); target != "" {
+        g.recordImplementation(target, child)
+        g.callsWithin(checker, target, child.AsBinaryExpression().Right)
+      }
     case shimast.KindJsxSelfClosingElement:
       // `<Component />` is a use of the component; an intrinsic tag (`<div />`)
       // resolves to nothing and is dropped by callEdge.
@@ -320,6 +325,40 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
   })
 }
 
+func (g *Graph) assignedFunctionTarget(checker *shimchecker.Checker, from string, node *shimast.Node) string {
+  binary := node.AsBinaryExpression()
+  if binary == nil ||
+    binary.OperatorToken == nil ||
+    binary.Right == nil ||
+    binary.OperatorToken.Kind != shimast.KindEqualsToken ||
+    !shimast.IsFunctionLike(binary.Right) {
+    return ""
+  }
+  target := Resolve(checker, binary.Left)
+  if target == nil || target.Symbol == nil {
+    return ""
+  }
+  to := g.ensureTargetNode(target)
+  if to == "" || to == from {
+    return ""
+  }
+  return to
+}
+
+func (g *Graph) recordImplementation(id string, assignment *shimast.Node) {
+  node := g.Nodes[id]
+  if node == nil || node.External || node.ImplementationFile != "" {
+    return
+  }
+  file := shimast.GetSourceFileOfNode(assignment)
+  if file == nil {
+    return
+  }
+  node.ImplementationFile = file.FileName()
+  node.ImplementationPos = assignment.Pos()
+  node.ImplementationEnd = assignment.End()
+}
+
 func isInvokedAccess(access *shimast.Node) bool {
   parent := access.Parent
   if parent == nil {
@@ -406,6 +445,10 @@ func (g *Graph) typeRefsWithin(checker *shimchecker.Checker, from string, node *
       if imp := child.AsImportTypeNode(); imp != nil && imp.Qualifier != nil {
         g.typeRefEdge(checker, from, imp.Qualifier)
       }
+    case shimast.KindBinaryExpression:
+      if target := g.assignedFunctionTarget(checker, from, child); target != "" {
+        g.typeRefsWithin(checker, target, child.AsBinaryExpression().Right)
+      }
     }
     g.typeRefsWithin(checker, from, child)
     return false

package/internal/graph/graph.go

@@ -47,8 +47,11 @@ type Node struct {
   // Pos and End bound the declaration in its source file (byte offsets). They
   // are for display, never identity, so an edit that shifts them does not re-key
   // the node.
-  Pos int
-  End int
+  Pos                int
+  End                int
+  ImplementationFile string
+  ImplementationPos  int
+  ImplementationEnd  int
 }
 
 // EdgeKind classifies a relationship between two nodes.

package/internal/graph/value_call_edges_attribute_function_assignments_to_members_test.go

@@ -0,0 +1,59 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesAttributeFunctionAssignmentsToMembers verifies function
+// assignments to resolved members are walked as that member's implementation.
+//
+// Libraries sometimes attach methods by assigning an arrow/function expression
+// to a typed property instead of declaring a class method body. The class-level
+// walk sees the assignment, but graph flow still needs the assigned member node
+// to own calls made inside the RHS function.
+//
+//  1. Compile a fixture where `inst.run = () => helper()` assigns a typed class
+//     method implementation.
+//  2. Build the graph.
+//  3. Assert the `Service.run` method has a value-call edge to `helper`.
+func TestValueCallEdgesAttributeFunctionAssignmentsToMembers(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 class Service {
+  run(): void {}
+}
+export function install(inst: Service): void {
+  inst.run = (): 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() }()
+
+  graph := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+
+  run := nodeID(path, "Service.run", NodeMethod)
+  helper := nodeID(path, "helper", NodeFunction)
+
+  if !hasEdge(graph, run, helper, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Service.run -> helper (assigned implementation); edges: %v", graph.Edges)
+  }
+  if graph.Nodes[run].ImplementationFile != path ||
+    graph.Nodes[run].ImplementationPos <= 0 ||
+    graph.Nodes[run].ImplementationEnd <= graph.Nodes[run].ImplementationPos {
+    t.Fatalf("Service.run missing assigned implementation span: %+v", graph.Nodes[run])
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttsc",
-  "version": "0.16.5",
+  "version": "0.16.7",
   "description": "General-purpose TypeScript-Go compiler, runtime, plugin host, and LSP host.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -32,13 +32,13 @@
     "typescript": "7.0.1-rc"
   },
   "optionalDependencies": {
-    "@ttsc/linux-x64": "0.16.5",
-    "@ttsc/linux-arm64": "0.16.5",
-    "@ttsc/darwin-x64": "0.16.5",
-    "@ttsc/darwin-arm64": "0.16.5",
-    "@ttsc/linux-arm": "0.16.5",
-    "@ttsc/win32-x64": "0.16.5",
-    "@ttsc/win32-arm64": "0.16.5"
+    "@ttsc/linux-arm": "0.16.7",
+    "@ttsc/linux-x64": "0.16.7",
+    "@ttsc/linux-arm64": "0.16.7",
+    "@ttsc/darwin-arm64": "0.16.7",
+    "@ttsc/win32-x64": "0.16.7",
+    "@ttsc/win32-arm64": "0.16.7",
+    "@ttsc/darwin-x64": "0.16.7"
   },
   "sideEffects": false,
   "files": [