ttsc 0.16.3 → 0.16.5

package/internal/graph/resolve.go

@@ -0,0 +1,102 @@
+// Package graph builds a checker-resolved code reference graph over a tsgo
+// Program: symbols as nodes, type-resolved relationships as edges. Because the
+// graph rides ttsc's in-process Checker, every edge is resolved by the real
+// type checker rather than a syntactic heuristic, so an edge can be tagged
+// "checker-resolved" instead of "guessed".
+//
+// resolve.go holds the load-bearing primitive the rest of the graph depends on:
+// following a reference to the true declaration the checker binds it to. The
+// hard case is the barrel re-export, where `pkg/index.ts` re-exports a sibling's
+// symbol; that shape carries almost every cross-package edge in a monorepo.
+// Stopping at GetSymbolAtLocation lands on the local import alias and severs the
+// edge at the index file, which collapses the output back to tree-sitter
+// quality. Unwrapping the alias chain (Checker_getAliasedSymbol) lands on the
+// sibling source that actually declares the symbol. Resolve does that unwrap,
+// then classifies where the declaration lives so a node_modules / `.d.ts`
+// boundary becomes an external leaf instead of pulling a dependency's internals
+// into the graph.
+package graph
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// Target is the resolved endpoint of a reference: the declaration symbol the
+// checker binds it to, the source file that declares it, and whether that file
+// sits outside the workspace (a node_modules or `.d.ts` boundary leaf).
+type Target struct {
+  Symbol   *shimast.Symbol
+  File     string
+  External bool
+  Pos      int
+  End      int
+}
+
+// Resolve follows ref to the real declaration the checker binds it to. It
+// unwraps import/export alias chains so a reference through a barrel re-export
+// lands on the sibling source that declares the symbol, not the re-exporting
+// index file. It returns nil when the checker cannot bind ref to a symbol (a
+// numeric literal, a punctuation token, an unresolved name).
+func Resolve(checker *shimchecker.Checker, ref *shimast.Node) *Target {
+  symbol := checker.GetSymbolAtLocation(ref)
+  if symbol == nil {
+    return nil
+  }
+  if symbol.Flags&shimast.SymbolFlagsAlias != 0 {
+    if aliased := shimchecker.Checker_getAliasedSymbol(checker, symbol); aliased != nil {
+      symbol = aliased
+    }
+  }
+  target := &Target{Symbol: symbol}
+  if declaration := declarationNode(symbol); declaration != nil {
+    target.Pos = declaration.Pos()
+    target.End = declaration.End()
+    if file := shimast.GetSourceFileOfNode(declaration); file != nil {
+      target.File = file.FileName()
+      target.External = file.IsDeclarationFile ||
+        strings.Contains(target.File, "/node_modules/")
+    }
+  }
+  return target
+}
+
+// declarationFile returns the source file of symbol's first declaration, or nil
+// when the symbol carries no declaration (an intrinsic or synthesized symbol).
+// The checker resolves symlinks to realpath because preserveSymlinks defaults to
+// false, so a pnpm `workspace:*` sibling resolves to its real source here and is
+// not misclassified as external by Resolve.
+func declarationFile(symbol *shimast.Symbol) *shimast.SourceFile {
+  if declaration := declarationNode(symbol); declaration != nil {
+    return shimast.GetSourceFileOfNode(declaration)
+  }
+  return nil
+}
+
+func declarationNode(symbol *shimast.Symbol) *shimast.Node {
+  if len(symbol.Declarations) == 0 {
+    return nil
+  }
+  // Prefer a non-declaration-file declaration. A declaration-merged symbol (a
+  // class paired with an interface, or a function with a namespace) can list a
+  // `.d.ts` declaration first; classifying by it would mark a real workspace
+  // symbol external and sever it from the graph.
+  for _, declaration := range symbol.Declarations {
+    if file := shimast.GetSourceFileOfNode(declaration); file != nil && !file.IsDeclarationFile && declaration.Body() != nil {
+      return declaration
+    }
+  }
+  for _, declaration := range symbol.Declarations {
+    if file := shimast.GetSourceFileOfNode(declaration); file != nil && !file.IsDeclarationFile {
+      return declaration
+    }
+  }
+  for _, declaration := range symbol.Declarations {
+    if declaration.Body() != nil {
+      return declaration
+    }
+  }
+  return symbol.Declarations[0]
+}

package/internal/graph/resolve_prefers_implementation_declaration_test.go

@@ -0,0 +1,50 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestResolvePrefersImplementationDeclarationSpan verifies overloaded callables
+// resolve to the executable implementation span, not the first signature.
+//
+// Without this, MCP answers can show only an overload header and omit the body
+// that explains downstream calls, pushing agents back to raw file reads.
+//
+//  1. Compile an overloaded function whose implementation contains a unique
+//     expression.
+//  2. Resolve the function symbol.
+//  3. Assert the selected target span includes the implementation body.
+func TestResolvePrefersImplementationDeclarationSpan(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function api(value: string): string
+export function api(value: string): string {
+  return value.toUpperCase()
+}
+
+api("x")
+`)
+
+  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() }()
+
+  file := sourceFile(t, prog, "main.ts")
+  target := Resolve(prog.Checker, identifier(t, file, "api"))
+  if target == nil {
+    t.Fatal("Resolve returned nil for api")
+  }
+  source := file.Text()[target.Pos:target.End]
+  if !strings.Contains(source, "toUpperCase") {
+    t.Fatalf("expected Resolve to report the implementation span, got:\n%s", source)
+  }
+}

package/internal/graph/resolve_unwraps_barrel_reexport_to_real_declaration_test.go

@@ -0,0 +1,230 @@
+package graph
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestResolveUnwrapsBarrelReexportToRealDeclaration is a traversal-completeness
+// probe, not a unit test of a single branch: it runs a real Checker over a
+// ttsc-owned fixture and asserts the load-bearing graph primitive
+// (GetSymbolAtLocation -> Checker_getAliasedSymbol -> declaration) reaches the
+// sibling source that actually declares a symbol, instead of dead-ending on the
+// barrel re-export. This is the differentiator the whole package rests on: a
+// path-heuristic tool stops at the index file and severs every cross-package
+// edge, so if this surface ever regresses the graph silently collapses back to
+// tree-sitter quality. Mirrors the naive-vs-bridged shape of the base-chain
+// probe in packages/lint/test/shim.
+//
+//  1. Compile a fixture where main.ts imports `target` through a barrel
+//     (`index.ts` re-exports it from `impl.ts`).
+//  2. Resolve the call-site reference two ways: the naive `GetSymbolAtLocation`
+//     stop (the local import alias) and the bridged `Resolve` (alias unwrapped).
+//  3. Assert the naive stop lands on the import in main.ts (the edge is severed
+//     there) while `Resolve` lands on the real declaration in impl.ts, and that
+//     a workspace declaration is not classified as an external boundary leaf.
+func TestResolveUnwrapsBarrelReexportToRealDeclaration(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/main.ts"]
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "impl.ts"), `export function target(): number {
+  return 1;
+}
+`)
+  // The barrel: re-exports the sibling's symbol without redeclaring it. This is
+  // the alias hop that severs the edge for a path-string resolver.
+  writeFile(t, filepath.Join(root, "src", "index.ts"), `export { target } from "./impl";
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `import { target } from "./index";
+const value = 1;
+const echoed = value;
+target();
+void echoed;
+`)
+
+  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() }()
+
+  checker := prog.Checker
+  if checker == nil {
+    t.Fatal("LoadProgram did not acquire a checker")
+  }
+  main := sourceFile(t, prog, "main.ts")
+
+  // The naive stop: GetSymbolAtLocation alone binds the call-site reference to
+  // the LOCAL import alias, whose declaration is the import specifier in main.ts.
+  // A resolver that stops here severs the edge at the import and never reaches
+  // the package that declares target.
+  callee := calleeIdentifier(t, main)
+  raw := checker.GetSymbolAtLocation(callee)
+  if raw == nil {
+    t.Fatal("GetSymbolAtLocation returned nil for the call-site reference")
+  }
+  if raw.Flags&shimast.SymbolFlagsAlias == 0 {
+    t.Fatal("premise broken: the call-site reference is not an alias, so there is no barrel hop to unwrap")
+  }
+  if rawFile := declarationFile(raw); rawFile == nil || !strings.HasSuffix(rawFile.FileName(), "main.ts") {
+    t.Fatalf("naive stop did not land on the import in main.ts: %v", raw.Declarations)
+  }
+
+  // The bridged walk: Resolve unwraps the alias chain to the real declaration.
+  resolved := Resolve(checker, callee)
+  if resolved == nil {
+    t.Fatal("Resolve returned nil for the call-site reference")
+  }
+  if resolved.Symbol == nil || resolved.Symbol.Name != "target" {
+    t.Fatalf("Resolve did not land on the target symbol: %+v", resolved.Symbol)
+  }
+  if !strings.HasSuffix(resolved.File, "impl.ts") {
+    t.Fatalf("Resolve dead-ended before impl.ts: got %q (a barrel-severed resolver would report index.ts)", resolved.File)
+  }
+  if strings.HasSuffix(resolved.File, "index.ts") {
+    t.Fatalf("Resolve stopped at the re-exporting barrel index.ts instead of the declaration")
+  }
+  if resolved.External {
+    t.Fatalf("a workspace declaration (%q) was misclassified as an external boundary leaf", resolved.File)
+  }
+
+  // A directly-declared local reference skips the alias unwrap and is a
+  // workspace node, not an external leaf.
+  local := Resolve(checker, identifier(t, main, "value"))
+  if local == nil || local.Symbol == nil || local.Symbol.Name != "value" {
+    t.Fatalf("Resolve did not bind the local const reference: %+v", local)
+  }
+  if !strings.HasSuffix(local.File, "main.ts") || local.External {
+    t.Fatalf("local const resolved to the wrong place: %+v", local)
+  }
+
+  // A node the checker cannot bind to a symbol resolves to nil rather than
+  // panicking, so the extraction walk can skip it.
+  if got := Resolve(checker, numericLiteral(t, main)); got != nil {
+    t.Fatalf("Resolve bound a numeric literal to a symbol: %+v", got)
+  }
+}
+
+// sourceFile returns the resident program's source file whose path ends with
+// suffix, failing the test when no such file is loaded.
+func sourceFile(t *testing.T, prog *driver.Program, suffix string) *shimast.SourceFile {
+  t.Helper()
+  for _, file := range prog.SourceFiles() {
+    if strings.HasSuffix(file.FileName(), suffix) {
+      return file
+    }
+  }
+  t.Fatalf("source file %q not found in program", suffix)
+  return nil
+}
+
+// calleeIdentifier returns the expression identifier of the first call
+// expression in file (the `target` in `target()`), failing when absent.
+func calleeIdentifier(t *testing.T, file *shimast.SourceFile) *shimast.Node {
+  t.Helper()
+  var found *shimast.Node
+  walkNodes(file, func(node *shimast.Node) bool {
+    if node.Kind == shimast.KindCallExpression {
+      if call := node.AsCallExpression(); call != nil {
+        found = call.Expression
+        return true
+      }
+    }
+    return false
+  })
+  if found == nil {
+    t.Fatal("could not locate a call-site identifier in the fixture")
+  }
+  return found
+}
+
+// identifier returns the first identifier node in file whose text is name,
+// failing when absent.
+func identifier(t *testing.T, file *shimast.SourceFile, name string) *shimast.Node {
+  t.Helper()
+  var found *shimast.Node
+  walkNodes(file, func(node *shimast.Node) bool {
+    if node.Kind == shimast.KindIdentifier && shimast.NodeText(node) == name {
+      found = node
+      return true
+    }
+    return false
+  })
+  if found == nil {
+    t.Fatalf("identifier %q not found in the fixture", name)
+  }
+  return found
+}
+
+// numericLiteral returns the first numeric literal node in file, failing when
+// absent.
+func numericLiteral(t *testing.T, file *shimast.SourceFile) *shimast.Node {
+  t.Helper()
+  var found *shimast.Node
+  walkNodes(file, func(node *shimast.Node) bool {
+    if node.Kind == shimast.KindNumericLiteral {
+      found = node
+      return true
+    }
+    return false
+  })
+  if found == nil {
+    t.Fatal("numeric literal not found in the fixture")
+  }
+  return found
+}
+
+// walkNodes performs a pre-order walk of file's statement subtrees, calling
+// visit on each node and stopping the whole walk as soon as visit returns true.
+func walkNodes(file *shimast.SourceFile, visit func(*shimast.Node) bool) {
+  if file.Statements == nil {
+    return
+  }
+  var recur func(node *shimast.Node) bool
+  recur = func(node *shimast.Node) bool {
+    if node == nil {
+      return false
+    }
+    if visit(node) {
+      return true
+    }
+    return node.ForEachChild(func(child *shimast.Node) bool {
+      return recur(child)
+    })
+  }
+  for _, stmt := range file.Statements.Nodes {
+    if recur(stmt) {
+      return
+    }
+  }
+}
+
+// writeFile writes content to path, creating parent directories, failing the
+// test on any error.
+func writeFile(t *testing.T, path, content string) {
+  t.Helper()
+  if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+    t.Fatal(err)
+  }
+}

package/internal/graph/type_ref_edges_cover_typeof_as_satisfies_test.go

@@ -0,0 +1,79 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestTypeRefEdgesCoverTypeofAsSatisfies verifies that the type-position shapes
+// beyond a plain `Foo` annotation are all resolved to type-ref edges:
+//
+//   - `typeof value`      -> the value it queries (an EntityName, not a TypeReference)
+//   - `x as Target`       -> Target (the assertion's type)
+//   - `expr satisfies T`  -> T (the satisfies type)
+//
+// `as` and `satisfies` carry an ordinary TypeReference the recursion already
+// reaches; `typeof` names its value through an EntityName, which a
+// TypeReference-only walk would miss. All three must produce an edge so an
+// impact query sees the dependency.
+func TestTypeRefEdgesCoverTypeofAsSatisfies(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/main.ts"]
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export interface Config {}
+export interface Target {}
+
+export const settings = { mode: "fast" };
+
+export type SettingsShape = typeof settings;
+
+export function coerce(x: unknown): Target {
+  return x as Target;
+}
+
+export const config = { a: 1 } satisfies Config;
+`)
+
+  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()
+
+  settingsShape := nodeID(path, "SettingsShape", NodeTypeAlias)
+  settings := nodeID(path, "settings", NodeVariable)
+  coerce := nodeID(path, "coerce", NodeFunction)
+  target := nodeID(path, "Target", NodeInterface)
+  config := nodeID(path, "config", NodeVariable)
+  configType := nodeID(path, "Config", NodeInterface)
+
+  if !hasEdge(graph, settingsShape, settings, EdgeTypeRef) {
+    t.Errorf("missing type-ref edge SettingsShape -> settings (typeof query)")
+  }
+  if !hasEdge(graph, coerce, target, EdgeTypeRef) {
+    t.Errorf("missing type-ref edge coerce -> Target (as assertion)")
+  }
+  if !hasEdge(graph, config, configType, EdgeTypeRef) {
+    t.Errorf("missing type-ref edge config -> Config (satisfies)")
+  }
+  if t.Failed() {
+    t.Logf("edges: %v", graph.Edges)
+  }
+}

package/internal/graph/type_ref_edges_resolve_named_types_across_files_test.go

@@ -0,0 +1,52 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestTypeRefEdgesResolveNamedTypesAcrossFiles verifies that a type-position
+// reference to a named type in another file is recorded as a type-ref edge to
+// that type's real declaration, and is kept distinct from a value-call. Treating
+// type references as first-class edges lets an impact query separate "uses this
+// at runtime" from "depends on this type", which fits the ttsc thesis.
+//
+//  1. Compile a fixture where use(c: Config) annotates a parameter with an
+//     interface declared in another file.
+//  2. Build the graph.
+//  3. Assert a use -> Config type-ref edge exists and is not a value-call.
+func TestTypeRefEdgesResolveNamedTypesAcrossFiles(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "types.ts"), `export interface Config {
+  name: string;
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `import { Config } from "./types";
+export function use(c: Config): string {
+  return c.name;
+}
+`)
+
+  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)
+  use := nodeID(sourceFile(t, prog, "main.ts").FileName(), "use", NodeFunction)
+  config := nodeID(sourceFile(t, prog, "types.ts").FileName(), "Config", NodeInterface)
+
+  if !hasEdge(graph, use, config, EdgeTypeRef) {
+    t.Fatalf("missing type-ref edge use -> Config; edges: %v", graph.Edges)
+  }
+  if hasEdge(graph, use, config, EdgeValueCall) {
+    t.Fatalf("a type reference was misclassified as a value-call edge")
+  }
+}

package/internal/graph/value_access_edges_cover_properties_test.go

@@ -0,0 +1,96 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueAccessEdgesCoverPropertiesAndAccessors verifies property and
+// accessor reads/writes become value-access edges, not value-call edges.
+//
+// Lazy getters and state properties are part of the runtime flow an agent
+// needs, but they are not invocations. The graph must expose them without
+// corrupting call-flow semantics.
+//
+//  1. Compile a class with a property initializer, getter, setter, dotted access,
+//     and string-literal bracket access.
+//  2. Build the graph.
+//  3. Assert property/getter/setter uses are value-access edges while the
+//     property initializer's real function call stays a value-call edge.
+func TestValueAccessEdgesCoverPropertiesAndAccessors(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export function seed(): string[] {
+  return []
+}
+
+export class Store {
+  protected items: string[] = seed()
+
+  get count(): number {
+    return this.items.length
+  }
+
+  set count(value: number) {
+    this.items = Array(value).fill("")
+  }
+
+  read(): number {
+    return this.count + this.items.length + this["count"] + this["items"].length
+  }
+
+  write(): void {
+    this.count = 1
+    this["count"] = 2
+    this.items = []
+  }
+}
+`)
+
+  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()
+  read := nodeID(path, "Store.read", NodeMethod)
+  write := nodeID(path, "Store.write", NodeMethod)
+  count := nodeID(path, "Store.count", NodeMethod)
+  items := nodeID(path, "Store.items", NodeVariable)
+  seed := nodeID(path, "seed", NodeFunction)
+
+  if _, ok := graph.Nodes[items]; !ok {
+    t.Fatalf("Build did not record Store.items; have %v", nodeIDSet(graph))
+  }
+  if !hasEdge(graph, read, count, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.read -> Store.count; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, read, items, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.read -> Store.items; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, count, items, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.count -> Store.items; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, write, count, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.write -> Store.count; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, write, items, EdgeValueAccess) {
+    t.Fatalf("missing value-access edge Store.write -> Store.items; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, items, seed, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Store.items -> seed; edges: %v", graph.Edges)
+  }
+  if hasEdge(graph, read, count, EdgeValueCall) {
+    t.Fatalf("getter read was also recorded as value-call Store.read -> Store.count; edges: %v", graph.Edges)
+  }
+  if hasEdge(graph, write, count, EdgeValueCall) {
+    t.Fatalf("setter write was also recorded as value-call Store.write -> Store.count; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/value_call_edges_cover_jsx_components_test.go

@@ -0,0 +1,82 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestValueCallEdgesCoverJsxComponents verifies that a JSX component use
+// (`<Child />`) is a value-call edge to the component — the relationship a React
+// codebase is built from, which a call-expression-only walk silently dropped. An
+// intrinsic tag (`<div />`) resolves to nothing and adds no edge, so the walk
+// distinguishes a component use from a host element.
+//
+//  1. Compile a .tsx fixture where Parent renders <Child /> inside a <div>.
+//  2. Build the graph.
+//  3. Assert a Parent -> Child value-call edge exists.
+func TestValueCallEdgesCoverJsxComponents(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "jsx": "preserve",
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/main.tsx"]
+}
+`)
+  writeFile(t, filepath.Join(root, "src", "main.tsx"), `declare namespace JSX {
+  interface Element {}
+  interface IntrinsicElements {
+    div: {};
+  }
+}
+export function Child(): JSX.Element {
+  return null as unknown as JSX.Element;
+}
+export function Parent(): JSX.Element {
+  return (
+    <div>
+      <Child />
+    </div>
+  );
+}
+`)
+
+  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.tsx").FileName()
+
+  parent := nodeID(path, "Parent", NodeFunction)
+  child := nodeID(path, "Child", NodeFunction)
+
+  if !hasEdge(graph, parent, child, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Parent -> Child (JSX component use); edges: %v", graph.Edges)
+  }
+
+  // The intrinsic `<div>` host element resolves to nothing and must add no edge.
+  // Without this negative twin, a regression that started resolving intrinsic
+  // tags would fill every React codebase's call graph with host-element noise
+  // while the positive assertion above still passed.
+  for _, edge := range graph.Edges {
+    if edge.From != parent {
+      continue
+    }
+    if to := graph.Nodes[edge.To]; to != nil && to.Name == "div" {
+      t.Fatalf("intrinsic <div> produced a spurious value-call edge from Parent: %v", edge)
+    }
+  }
+}