ttsc 0.16.3 → 0.16.5

package/internal/graph/exports.go

@@ -0,0 +1,60 @@
+package graph
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// markExports flags every node reachable through a source file's export table as
+// Exported. It runs on the checker, so it sees the real public surface: an
+// inline `export class`, a separate `export { Foo }`, a re-export
+// `export { Foo } from "./foo"`, and a barrel `export *` all land here, where a
+// purely syntactic `export`-modifier scan would miss the re-export forms that
+// carry most of a monorepo's public API.
+func (g *Graph) markExports(checker *shimchecker.Checker, file *shimast.SourceFile) {
+  moduleSymbol := checker.GetSymbolAtLocation(file.AsNode())
+  if moduleSymbol == nil {
+    return
+  }
+  for _, export := range shimchecker.Checker_getExportsOfModule(checker, moduleSymbol) {
+    symbol := export
+    // A re-export is an alias; unwrap it to the declaration it points at so the
+    // exported flag lands on the real node, not a re-exporting index file's
+    // local alias symbol (which has no node of its own).
+    if symbol.Flags&shimast.SymbolFlagsAlias != 0 {
+      if aliased := shimchecker.Checker_getAliasedSymbol(checker, symbol); aliased != nil {
+        symbol = aliased
+      }
+    }
+    g.markExportedSymbol(symbol)
+  }
+}
+
+// markExportedSymbol sets Exported on the node a resolved export symbol declares,
+// when the graph recorded one. A symbol whose declaration the graph does not
+// model as a node (a re-exported value from a dependency, a kind it does not
+// track) is skipped rather than fabricated.
+func (g *Graph) markExportedSymbol(symbol *shimast.Symbol) {
+  declaration := declarationNode(symbol)
+  if declaration == nil {
+    return
+  }
+  file := shimast.GetSourceFileOfNode(declaration)
+  if file == nil {
+    return
+  }
+  kind := symbolNodeKind(symbol)
+  if kind == "" {
+    return
+  }
+  name := qualifiedName(symbol)
+  if kind == NodeMethod {
+    name = methodName(symbol)
+  }
+  if name == "" {
+    return
+  }
+  if node, ok := g.Nodes[nodeID(file.FileName(), name, kind)]; ok {
+    node.Exported = true
+  }
+}

package/internal/graph/file_diagnostics_match_tsgo_code_and_location_test.go

@@ -0,0 +1,59 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestFileDiagnosticsMatchTsgoCodeAndLocation verifies that FileDiagnostics
+// surfaces the same semantic error code and line tsgo emits, scoped to one file.
+// This is validation gate 4 from issue #259: a deliberate type error must yield
+// the exact tsc code/location from the graph's shared Program, proving the
+// diagnostics path is the real checker and not a re-implementation.
+//
+//  1. Compile a fixture whose only file assigns a string to a number binding.
+//  2. Ask FileDiagnostics for that file.
+//  3. Assert a TS2322 (not assignable) diagnostic on line 1, and that an
+//     unrelated path yields none.
+func TestFileDiagnosticsMatchTsgoCodeAndLocation(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export const broken: number = "not a number";
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  // LoadProgram reports only config/parse diagnostics; the type error is
+  // syntactically valid, so it surfaces through Program.Diagnostics() instead.
+  if len(diags) != 0 {
+    t.Fatalf("unexpected parse diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  main := sourceFile(t, prog, "main.ts").FileName()
+  got := FileDiagnostics(prog, main)
+
+  var match *driver.Diagnostic
+  for i := range got {
+    if got[i].Code == 2322 {
+      match = &got[i]
+      break
+    }
+  }
+  if match == nil {
+    t.Fatalf("expected a TS2322 diagnostic for the bad assignment, got %v", got)
+  }
+  if match.Line != 1 {
+    t.Fatalf("TS2322 reported on line %d, expected line 1", match.Line)
+  }
+  if match.File != main {
+    t.Fatalf("diagnostic file %q is not the queried file %q", match.File, main)
+  }
+  if other := FileDiagnostics(prog, filepath.Join(root, "src", "absent.ts")); len(other) != 0 {
+    t.Fatalf("a file with no diagnostics returned %d", len(other))
+  }
+}

package/internal/graph/file_diagnostics_report_code_column_and_message_test.go

@@ -0,0 +1,69 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestFileDiagnosticsReportCodeColumnAndMessage verifies that FileDiagnostics
+// surfaces the full tsgo-reported location and text of a type error, not just
+// its code and line: the column points at the offending initializer and the
+// message carries the human-readable reason.
+//
+// The existing match-code-and-location probe pins Line and Code; this one
+// strengthens the contract to Column and Message so a regression that kept the
+// right code but lost the precise span (or the text) is caught. The oracle is
+// the real checker: tsgo attributes the assignability error to the declared
+// binding, so on `export const broken: number = "nope";` the diagnostic sits at
+// `broken` — 1-based column 14 (`export const ` is 13 characters).
+//
+//  1. Compile a fixture whose only file assigns a string to a number binding.
+//  2. Ask FileDiagnostics for that file.
+//  3. Assert the TS2322 diagnostic sits at line 1 / column 14 and its message
+//     contains "not assignable".
+func TestFileDiagnosticsReportCodeColumnAndMessage(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export const broken: number = "nope";
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  // The bad assignment is syntactically valid, so it surfaces through
+  // Program.Diagnostics() rather than the config/parse diagnostics LoadProgram
+  // returns.
+  if len(diags) != 0 {
+    t.Fatalf("unexpected parse diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  main := sourceFile(t, prog, "main.ts").FileName()
+  got := FileDiagnostics(prog, main)
+
+  var match *driver.Diagnostic
+  for i := range got {
+    if got[i].Code == 2322 {
+      match = &got[i]
+      break
+    }
+  }
+  if match == nil {
+    t.Fatalf("expected a TS2322 diagnostic for the bad assignment, got %v", got)
+  }
+  if match.Line != 1 {
+    t.Fatalf("TS2322 reported on line %d, expected line 1", match.Line)
+  }
+  // Oracle column: tsgo attributes the assignability error to the declared
+  // binding `broken`, which begins at the 14th character of the line.
+  if match.Column != 14 {
+    t.Fatalf("TS2322 reported at column %d, expected column 14 (the binding)", match.Column)
+  }
+  if !strings.Contains(match.Message, "not assignable") {
+    t.Fatalf("TS2322 message %q does not mention 'not assignable'", match.Message)
+  }
+}

package/internal/graph/function_locals_do_not_collide_test.go

@@ -0,0 +1,66 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestFunctionLocalsDoNotCollide verifies that a function-local declaration is
+// not minted as a graph node. Build records top-level declarations, namespace
+// members, and class/interface members only; a body-scoped local resolved as an
+// edge target has an unqualified, position-free id, so two same-named locals in
+// different scopes would key the same node and merge — fabricating a false edge
+// from each unrelated caller to one phantom callable.
+func TestFunctionLocalsDoNotCollide(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 function outerA(): number {
+  function inner(): number {
+    return 1;
+  }
+  return inner();
+}
+
+export function outerB(): number {
+  function inner(): number {
+    return 2;
+  }
+  return inner();
+}
+`)
+
+  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()
+
+  // No function-local node is minted...
+  if _, ok := graph.Nodes[nodeID(path, "inner", NodeFunction)]; ok {
+    t.Fatalf("a function-local 'inner' was minted as a node (would collide across scopes)")
+  }
+  // ...so no edge points at a phantom shared 'inner'.
+  for _, edge := range graph.Edges {
+    if to := graph.Nodes[edge.To]; to != nil && to.Name == "inner" {
+      t.Fatalf("edge to a function-local 'inner' (false cross-scope merge): %v", edge)
+    }
+  }
+}

package/internal/graph/gitignore.go

@@ -0,0 +1,51 @@
+package graph
+
+import (
+  "os/exec"
+  "strings"
+)
+
+// GitIgnoredFiles returns the graph's source files that git ignores: generated
+// output an author does not navigate, such as a Prisma client or other codegen
+// emitted as real .ts into the source tree (the .d.ts emit is already dropped by
+// driver.SourceFiles, but a generated .ts becomes a node and, being large and
+// highly connected, otherwise dominates ranking and floods responses). Callers
+// de-surface them: the MCP matcher keeps them reachable as edge targets and by
+// exact name; the full-graph dump drops them from the viewer payload entirely.
+//
+// Empty when cwd is unset, the tree is not a git work tree, or git is
+// unavailable, so a non-git project is unaffected.
+func GitIgnoredFiles(cwd string, g *Graph) map[string]bool {
+  if cwd == "" || g == nil {
+    return nil
+  }
+  seen := make(map[string]bool)
+  var paths []string
+  for _, node := range g.Nodes {
+    f := node.File
+    if f == "" || strings.HasPrefix(f, "bundled:///") || seen[f] {
+      continue
+    }
+    seen[f] = true
+    paths = append(paths, f)
+  }
+  if len(paths) == 0 {
+    return nil
+  }
+  cmd := exec.Command("git", "-C", cwd, "check-ignore", "--stdin")
+  cmd.Stdin = strings.NewReader(strings.Join(paths, "\n") + "\n")
+  // check-ignore exits 0 with the ignored paths on stdout, 1 (an error to
+  // Output) with no output when none match, and 128 when git cannot run. Only
+  // stdout matters: parse it whenever it is non-empty, ignore the exit code.
+  out, _ := cmd.Output()
+  ignored := make(map[string]bool)
+  for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
+    if line != "" {
+      ignored[line] = true
+    }
+  }
+  if len(ignored) == 0 {
+    return nil
+  }
+  return ignored
+}

package/internal/graph/graph.go

@@ -0,0 +1,119 @@
+package graph
+
+// NodeKind classifies a graph node by what its symbol declares.
+type NodeKind string
+
+const (
+  NodeFunction  NodeKind = "function"
+  NodeClass     NodeKind = "class"
+  NodeInterface NodeKind = "interface"
+  NodeTypeAlias NodeKind = "type"
+  NodeEnum      NodeKind = "enum"
+  NodeVariable  NodeKind = "variable"
+  // NodeMethod is a class or interface member (a method, constructor, or
+  // accessor). Its id is class-qualified ("path#Class.method:method") so a
+  // resolved method call lands on the same node the build pass recorded.
+  NodeMethod NodeKind = "method"
+)
+
+// Node is one declared symbol. Its ID is position-invariant, built from the file
+// realpath, the declared name, and the kind, so inserting a line above a
+// declaration does not re-key it. That keeps a future incremental layer from
+// churning the whole graph on every edit, which a byte-offset key would force.
+type Node struct {
+  ID   string
+  Name string
+  // Simple is the unqualified declared name (`create`, `OrderService`), taken
+  // straight from the declaration's symbol. Name may join an owner chain to a
+  // member with a single dot, and a quoted member name can itself contain a dot
+  // (`"a.b"` → Name `C.a.b`), so the simple/qualified boundary cannot be
+  // recovered from Name by splitting on a dot. Recording it here keeps the dump
+  // split exact instead of guessing.
+  Simple   string
+  Kind     NodeKind
+  File     string
+  External bool
+  // Exported marks a node that is part of its module's export surface, resolved
+  // through the checker's export table so a re-export (`export { Foo } from`) or
+  // a barrel (`export *`) counts, not only an inline `export` modifier. It is
+  // the signal a public-API projection filters on.
+  Exported bool
+  // Modifiers holds the declaration's syntactic modifiers as wire strings (a
+  // subset of the TtscGraphNodeModifier union: export/default/declare/abstract/
+  // static/readonly/async/const/public/private/protected). It is recorded from
+  // the declaration's combined modifier flags during the build pass and emitted
+  // for projections that filter on visibility and shape.
+  Modifiers []string
+  // 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
+}
+
+// EdgeKind classifies a relationship between two nodes.
+type EdgeKind string
+
+const (
+  // EdgeHeritage is an `extends` / `implements` relationship from a class or
+  // interface to a base it derives from.
+  EdgeHeritage EdgeKind = "heritage"
+  // EdgeValueCall is a runtime use from one declaration of the function, method,
+  // or constructor it invokes: a call, a `new T()`, a `<Component/>` JSX use, or
+  // a tagged-template tag. Uses of a dependency's method are not modeled (the
+  // boundary stops at the external type).
+  EdgeValueCall EdgeKind = "value-call"
+  // EdgeValueAccess is a runtime property/accessor read or write. It is kept
+  // separate from calls so architecture flows can follow lazy getter/property
+  // behavior without pretending those reads invoke a function.
+  EdgeValueAccess EdgeKind = "value-access"
+  // EdgeTypeRef is a type-position reference from one declaration to a named
+  // type it mentions (a parameter, return, property, or alias type). It is not a
+  // runtime call, so an impact query can filter value edges from type edges.
+  EdgeTypeRef EdgeKind = "type-ref"
+)
+
+// Edge is a directed, checker-resolved relationship from one node to another,
+// both referenced by Node.ID. Pos and End bound the source expression in the
+// From node's file that produced the edge. They are evidence, not identity; a
+// duplicate relationship keeps the first source-order span.
+type Edge struct {
+  From string
+  To   string
+  Kind EdgeKind
+  // Origin records the syntactic form a value-call or heritage edge came from,
+  // so the JSON dump can split one internal kind into the finer schema kinds
+  // (calls / instantiates / renders, extends / implements) without the
+  // MCP-facing model losing the distinction. It is "" for kinds that need no
+  // split (type-ref, value-access). For EdgeValueCall it is "call", "new",
+  // "jsx", or "tagged"; for EdgeHeritage it is "extends" or "implements".
+  Origin string
+  Pos    int
+  End    int
+}
+
+// Graph is the in-memory adjacency the MCP tools query. Edges are added by the
+// resolution pass on top of the declaration nodes Build records.
+type Graph struct {
+  Nodes map[string]*Node
+  Edges []*Edge
+  // Decorators holds the decorators written on the workspace's declarations,
+  // captured syntactically so the JSON dump can emit `decorates` edges and a
+  // consumer can interpret `@Controller`/`@Get` conventions without re-parsing
+  // source. It is dump-only metadata, separate from Edges so the existing
+  // checker-resolved relationships are untouched.
+  Decorators []*Decorator
+  // bodyNodes tracks whether a callable node's display span is the overload
+  // implementation rather than an overload signature. It is build-only metadata
+  // and intentionally stays out of JSON dumps.
+  bodyNodes map[string]bool
+  // seen deduplicates edges in O(1) during construction, so building a graph
+  // with N edges is O(N), not O(N²). Keyed by from\x00to\x00kind.
+  seen map[string]struct{}
+}
+
+// nodeID builds the position-invariant identity for a symbol named name,
+// declared as kind in the source file at path.
+func nodeID(path string, name string, kind NodeKind) string {
+  return path + "#" + name + ":" + string(kind)
+}

package/internal/graph/heritage_edges_cover_implements_and_interface_extends_test.go

@@ -0,0 +1,76 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestHeritageEdgesCoverImplementsAndInterfaceExtends verifies that
+// collectHeritage spans both heritage-bearing declaration kinds and both clause
+// keywords: an interface `extends` and a class `implements` each yield a
+// heritage edge to the same base, while a class that only mentions the base in a
+// parameter type position yields a type-ref edge, never a heritage edge.
+//
+// The negative twin pins the boundary collectHeritage must hold: heritage is an
+// `extends`/`implements` relationship, so a base reached only through a method
+// parameter type (`greet(b: Base)`) must not leak into the heritage set; a path
+// heuristic that treated any mention of Base as inheritance would over-match
+// here.
+//
+//  1. Compile a fixture with `interface Derived extends Base`,
+//     `class Impl implements Base`, and `class Unrelated` whose only Base
+//     reference is the parameter type of a method.
+//  2. Build the graph.
+//  3. Assert heritage edges Derived->Base and Impl->Base exist, and that
+//     Unrelated->Base is a type-ref edge but not a heritage edge.
+func TestHeritageEdgesCoverImplementsAndInterfaceExtends(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export interface Base {}
+export interface Derived extends Base {}
+export class Impl implements Base {}
+export class Unrelated {
+  greet(b: Base): void {
+    void b;
+  }
+}
+`)
+
+  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()
+
+  base := nodeID(path, "Base", NodeInterface)
+  derived := nodeID(path, "Derived", NodeInterface)
+  impl := nodeID(path, "Impl", NodeClass)
+  unrelated := nodeID(path, "Unrelated", NodeClass)
+  greet := nodeID(path, "Unrelated.greet", NodeMethod)
+
+  // Interface `extends`: Derived inherits Base.
+  if !hasEdge(graph, derived, base, EdgeHeritage) {
+    t.Fatalf("missing heritage edge Derived -> Base (interface extends); edges: %v", graph.Edges)
+  }
+  // Class `implements`: Impl declares Base as a heritage base.
+  if !hasEdge(graph, impl, base, EdgeHeritage) {
+    t.Fatalf("missing heritage edge Impl -> Base (class implements); edges: %v", graph.Edges)
+  }
+  // Negative twin: the base named only in a method parameter type is a type-ref
+  // dependency of that method (Unrelated.greet -> Base), never a heritage edge —
+  // not from the class and not from the method.
+  if hasEdge(graph, unrelated, base, EdgeHeritage) || hasEdge(graph, greet, base, EdgeHeritage) {
+    t.Fatalf("a parameter-type reference to Base was misclassified as a heritage edge; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, greet, base, EdgeTypeRef) {
+    t.Fatalf("missing type-ref edge Unrelated.greet -> Base (parameter type); edges: %v", graph.Edges)
+  }
+}

package/internal/graph/heritage_edges_keep_extends_and_implements_to_same_base_test.go

@@ -0,0 +1,61 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestHeritageEdgesKeepExtendsAndImplementsToSameBase verifies that a class which
+// both extends and implements the same base records two distinct heritage edges
+// — `extends` and `implements` — rather than collapsing to one. The edge dedup
+// keys on the emitted wire kind, so two relationships to one target that mean
+// different things both survive; a dedup on the internal edge kind alone would
+// drop the second clause and the dump would claim only inheritance or only
+// conformance, never both.
+//
+//  1. Compile a fixture with `class Derived extends Base implements Base`.
+//  2. Build the graph.
+//  3. Assert both an `extends` and an `implements` heritage edge Derived -> Base,
+//     and that they map to the distinct wire kinds the dump emits.
+func TestHeritageEdgesKeepExtendsAndImplementsToSameBase(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export class Base {
+  value(): number {
+    return 1;
+  }
+}
+export class Derived extends Base implements Base {}
+`)
+
+  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()
+
+  derived := nodeID(path, "Derived", NodeClass)
+  base := nodeID(path, "Base", NodeClass)
+
+  wireKinds := map[string]bool{}
+  for _, edge := range graph.Edges {
+    if edge.From != derived || edge.To != base || edge.Kind != EdgeHeritage {
+      continue
+    }
+    wireKinds[dumpEdgeKind(edge)] = true
+  }
+  if !wireKinds["extends"] || !wireKinds["implements"] {
+    t.Fatalf(
+      "Derived -> Base heritage edges = %v; want both extends and implements; edges: %v",
+      wireKinds, graph.Edges,
+    )
+  }
+}

package/internal/graph/heritage_edges_record_extends_versus_implements_origin_test.go

@@ -0,0 +1,54 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestHeritageEdgesRecordExtendsVersusImplementsOrigin verifies that a heritage
+// edge carries the clause keyword as Origin, so the dump can split the single
+// internal heritage kind into the schema's `extends` and `implements`: a class
+// superclass records "extends", a class interface list records "implements".
+//
+// One class declaration carries both clauses at once, so the test pins that the
+// keyword — not the base's declaration kind — selects the origin: `extends Sup`
+// and `implements Iface` on the same class must come out as different origins.
+//
+//  1. Compile `class Sub extends Sup implements Iface` plus the base class and
+//     interface.
+//  2. Build the graph.
+//  3. Assert the Sub->Sup heritage edge has Origin "extends" and the Sub->Iface
+//     heritage edge has Origin "implements".
+func TestHeritageEdgesRecordExtendsVersusImplementsOrigin(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export interface Iface {}
+export class Sup {}
+export class Sub extends Sup implements Iface {}
+`)
+
+  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()
+
+  sub := nodeID(path, "Sub", NodeClass)
+  sup := nodeID(path, "Sup", NodeClass)
+  iface := nodeID(path, "Iface", NodeInterface)
+
+  if got := edgeOrigin(graph, sub, sup, EdgeHeritage); got != "extends" {
+    t.Fatalf("Sub -> Sup: want heritage Origin \"extends\", got %q; edges: %v", got, graph.Edges)
+  }
+  if got := edgeOrigin(graph, sub, iface, EdgeHeritage); got != "implements" {
+    t.Fatalf("Sub -> Iface: want heritage Origin \"implements\", got %q; edges: %v", got, graph.Edges)
+  }
+}