ttsc 0.16.2 → 0.16.5

package/internal/graph/heritage_edges_traverse_barrels_and_stop_at_external_leaves_test.go

@@ -0,0 +1,112 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestHeritageEdgesTraverseBarrelsAndStopAtExternalLeaves verifies the two edge
+// behaviors that distinguish a checker-resolved graph from a path-heuristic one:
+// a heritage edge into a barrel-re-exported base lands on the sibling source
+// that declares it (not the index file), and a heritage edge into a dependency
+// becomes an external boundary leaf that the walk does not descend into.
+//
+//  1. Compile a fixture: `Sub extends Base` where Base is re-exported through a
+//     barrel, and `SubExt extends Ext` where Ext is declared in a node_modules
+//     `.d.ts`.
+//  2. Build the graph.
+//  3. Assert the Sub->Base edge targets the real declaration in impl.ts and is
+//     not external, while the SubExt->Ext edge targets an external leaf under
+//     node_modules.
+func TestHeritageEdgesTraverseBarrelsAndStopAtExternalLeaves(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "node_modules", "dep", "package.json"), `{
+  "name": "dep",
+  "version": "1.0.0",
+  "types": "index.d.ts"
+}
+`)
+  writeFile(t, filepath.Join(root, "node_modules", "dep", "index.d.ts"), `export declare class Ext {}
+`)
+  writeFile(t, filepath.Join(root, "src", "impl.ts"), `export class Base {}
+`)
+  writeFile(t, filepath.Join(root, "src", "index.ts"), `export { Base } from "./impl";
+`)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `import { Base } from "./index";
+import { Ext } from "dep";
+export class Sub extends Base {}
+export class SubExt extends Ext {}
+`)
+
+  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)
+  mainPath := sourceFile(t, prog, "main.ts").FileName()
+  implPath := sourceFile(t, prog, "impl.ts").FileName()
+
+  // Barrel traversal: the base resolved to the sibling source, not the index.
+  base := nodeID(implPath, "Base", NodeClass)
+  if node, ok := graph.Nodes[base]; !ok || node.External {
+    t.Fatalf("Base node missing or misclassified external (barrel not traversed): %+v", node)
+  }
+  sub := nodeID(mainPath, "Sub", NodeClass)
+  if !hasEdge(graph, sub, base, EdgeHeritage) {
+    t.Fatalf("missing heritage edge Sub -> Base@impl.ts; edges: %v", graph.Edges)
+  }
+
+  // External leaf: the dependency base is a boundary leaf, kept as a node with
+  // its incoming edge but never walked into.
+  ext := findNodeByName(graph, "Ext")
+  if ext == nil {
+    t.Fatal("Ext base was not recorded as a node")
+  }
+  if !ext.External || !strings.Contains(ext.File, "/node_modules/") {
+    t.Fatalf("Ext should be an external node_modules leaf: %+v", ext)
+  }
+  subExt := nodeID(mainPath, "SubExt", NodeClass)
+  if !hasEdge(graph, subExt, ext.ID, EdgeHeritage) {
+    t.Fatalf("missing heritage edge SubExt -> Ext (external); edges: %v", graph.Edges)
+  }
+}
+
+// hasEdge reports whether the graph holds a from->to edge of the given kind.
+func hasEdge(graph *Graph, from, to string, kind EdgeKind) bool {
+  for _, edge := range graph.Edges {
+    if edge.From == from && edge.To == to && edge.Kind == kind {
+      return true
+    }
+  }
+  return false
+}
+
+// hasDecorator reports whether the graph recorded a decorator named name on the
+// node target.
+func hasDecorator(graph *Graph, target, name string) bool {
+  for _, dec := range graph.Decorators {
+    if dec.Target == target && dec.Name == name {
+      return true
+    }
+  }
+  return false
+}
+
+// findNodeByName returns the first node whose declared name is name, or nil.
+func findNodeByName(graph *Graph, name string) *Node {
+  for _, node := range graph.Nodes {
+    if node.Name == name {
+      return node
+    }
+  }
+  return nil
+}

package/internal/graph/namespace_dotted_form_qualifies_deeply_test.go

@@ -0,0 +1,60 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestNamespaceDottedFormQualifiesDeeply covers the chained-module shape that a
+// single-level namespace test does not: `namespace A.B.C { … }` is parsed as a
+// ModuleDeclaration whose body is another ModuleDeclaration, so moduleStatements
+// must descend through the chain and qualifiedName must build the full dotted
+// prefix. A regression in either would silently drop every declaration in a
+// dotted (or deeply nested) namespace — the idiom of .d.ts-heavy and
+// proto-generated codebases.
+func TestNamespaceDottedFormQualifiesDeeply(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 namespace A.B.C {
+  export function deep(): void {}
+}
+
+export function caller(): void {
+  A.B.C.deep();
+}
+`)
+
+  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()
+
+  deep := nodeID(path, "A.B.C.deep", NodeFunction)
+  caller := nodeID(path, "caller", NodeFunction)
+
+  if _, ok := graph.Nodes[deep]; !ok {
+    t.Fatalf("missing deeply-namespaced node %q; nodes: %v", deep, graph.Nodes)
+  }
+  if !hasEdge(graph, caller, deep, EdgeValueCall) {
+    t.Fatalf("missing value-call edge caller -> A.B.C.deep; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/namespace_members_become_qualified_nodes_and_edges_test.go

@@ -0,0 +1,100 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestNamespaceMembersBecomeQualifiedNodesAndEdges verifies that declarations
+// inside a `namespace` are first-class graph nodes, keyed by their
+// namespace-qualified name, and that edges cross the namespace boundary in both
+// directions. A top-level-statements-only walk recorded none of this: every
+// namespaced declaration and every edge touching one was silently dropped.
+//
+// The fixture exercises four relationships:
+//
+//   - intra-namespace call:        Service.run   -> Service.helper
+//   - top-level into a namespace:  bootstrap     -> Service.run
+//   - namespaced method type-ref:  Service.Worker.process -> Payload
+//   - namespaced type referenced:  WorkerRef     -> Service.Worker
+func TestNamespaceMembersBecomeQualifiedNodesAndEdges(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 Payload {}
+
+export namespace Service {
+  export function helper(): void {}
+
+  export function run(): void {
+    helper();
+  }
+
+  export class Worker {
+    process(p: Payload): void {
+      void p;
+    }
+  }
+}
+
+export function bootstrap(): void {
+  Service.run();
+}
+
+export type WorkerRef = Service.Worker;
+`)
+
+  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()
+
+  serviceHelper := nodeID(path, "Service.helper", NodeFunction)
+  serviceRun := nodeID(path, "Service.run", NodeFunction)
+  serviceWorker := nodeID(path, "Service.Worker", NodeClass)
+  workerProcess := nodeID(path, "Service.Worker.process", NodeMethod)
+  bootstrap := nodeID(path, "bootstrap", NodeFunction)
+  workerRef := nodeID(path, "WorkerRef", NodeTypeAlias)
+  payload := nodeID(path, "Payload", NodeInterface)
+
+  // The namespaced declarations are nodes in their own right.
+  for _, id := range []string{serviceHelper, serviceRun, serviceWorker, workerProcess} {
+    if _, ok := graph.Nodes[id]; !ok {
+      t.Errorf("missing namespaced node %q", id)
+    }
+  }
+
+  if !hasEdge(graph, serviceRun, serviceHelper, EdgeValueCall) {
+    t.Errorf("missing value-call edge Service.run -> Service.helper (intra-namespace)")
+  }
+  if !hasEdge(graph, bootstrap, serviceRun, EdgeValueCall) {
+    t.Errorf("missing value-call edge bootstrap -> Service.run (top-level into namespace)")
+  }
+  if !hasEdge(graph, workerProcess, payload, EdgeTypeRef) {
+    t.Errorf("missing type-ref edge Service.Worker.process -> Payload (namespaced method)")
+  }
+  if !hasEdge(graph, workerRef, serviceWorker, EdgeTypeRef) {
+    t.Errorf("missing type-ref edge WorkerRef -> Service.Worker (namespaced type referenced)")
+  }
+  if t.Failed() {
+    t.Logf("nodes: %d, edges: %v", len(graph.Nodes), graph.Edges)
+  }
+}

package/internal/graph/node_identity_is_position_invariant_test.go

@@ -0,0 +1,84 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestNodeIdentityIsPositionInvariant verifies that a declaration keeps the same
+// node id after lines are inserted above it. A byte-offset or line-number key
+// would re-key every declaration below an edit, forcing a future incremental
+// layer to churn the whole graph; the realpath + name + kind key does not.
+//
+// The probe rewrites the same file with a comment and blank lines prepended,
+// shifting every offset below, and asserts (a) the reload actually changed the
+// source text, so the result is not a stale cached read, and (b) the node-id set
+// is identical across the shift.
+//
+//  1. Compile a fixture, capture its node ids and source text.
+//  2. Rewrite the same file with leading lines that shift every offset.
+//  3. Assert the text changed but the node-id set did not.
+func TestNodeIdentityIsPositionInvariant(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  main := filepath.Join(root, "src", "main.ts")
+
+  writeFile(t, main, `export function fn(): void {}
+export const value = 1;
+`)
+  firstIDs, firstText := buildSnapshot(t, root)
+
+  writeFile(t, main, `// a leading comment that shifts every offset below it
+
+export function fn(): void {}
+
+export const value = 1;
+`)
+  secondIDs, secondText := buildSnapshot(t, root)
+
+  if firstText == secondText {
+    t.Fatal("the reload returned identical source text; the probe is reading a stale cache, not the shifted file")
+  }
+  if len(firstIDs) != 2 {
+    t.Fatalf("expected 2 nodes, got %d: %v", len(firstIDs), firstIDs)
+  }
+  if !equalStringSets(firstIDs, secondIDs) {
+    t.Fatalf("node identity changed when positions shifted:\n first=%v\n second=%v", firstIDs, secondIDs)
+  }
+}
+
+// buildSnapshot compiles root, then returns the built graph's node-id set and
+// the source text of main.ts so the caller can confirm a reload took effect.
+func buildSnapshot(t *testing.T, root string) (map[string]bool, string) {
+  t.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() }()
+
+  text := sourceFile(t, prog, "main.ts").Text()
+  ids := map[string]bool{}
+  for id := range Build(prog).Nodes {
+    ids[id] = true
+  }
+  return ids, text
+}
+
+// equalStringSets reports whether a and b hold the same keys.
+func equalStringSets(a, b map[string]bool) bool {
+  if len(a) != len(b) {
+    return false
+  }
+  for key := range a {
+    if !b[key] {
+      return false
+    }
+  }
+  return true
+}

package/internal/graph/node_modifiers_emit_union_strings_test.go

@@ -0,0 +1,118 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestNodeModifiersEmitUnionStrings verifies that the dump records a declaration's
+// syntactic modifiers as wire strings drawn only from the TtscGraphNodeModifier
+// union, mapping the combined modifier flags of a class, a static/readonly
+// property, an accessibility-qualified async method, and an exported const onto
+// their union members.
+//
+// The TypeScript loader runs `typia.assert<ITtscGraphDump>` over this dump, so a
+// modifier string outside the union would reject the whole graph. The assertion
+// pins both the exact strings emitted and the negative twin — a member with no
+// modifier must carry none — so an over-broad flag mapping cannot slip through.
+//
+//  1. Compile a fixture with `export abstract class`, a `static readonly`
+//     property, a `private async` method, a plain method, and `export const enum`
+//     (the `const` keyword that is a modifier, unlike a `const` variable).
+//  2. Build and marshal the dump.
+//  3. Assert each node's modifiers are exactly the expected union strings, the
+//     plain method has none, and every emitted string is a union member.
+func TestNodeModifiersEmitUnionStrings(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export abstract class Service {
+  static readonly config: number = 1;
+  private async run(): Promise<void> {}
+  plain(): void {}
+}
+export const enum Mode {
+  On,
+}
+`)
+
+  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)
+  dump := NewDump(g, root, "tsconfig.json", nil, SourceTexts(prog))
+
+  byID := make(map[string]DumpNode, len(dump.Nodes))
+  for _, n := range dump.Nodes {
+    byID[n.ID] = n
+  }
+
+  want := map[string][]string{
+    "src/main.ts#Service:class":           {"export", "abstract"},
+    "src/main.ts#Service.config:variable": {"static", "readonly"},
+    "src/main.ts#Service.run:method":      {"async", "private"},
+    "src/main.ts#Mode:enum":               {"export", "const"},
+  }
+  for id, expected := range want {
+    node, ok := byID[id]
+    if !ok {
+      t.Fatalf("missing node %q; have %v", id, dumpNodeIDs(dump))
+    }
+    if !equalStrings(node.Modifiers, expected) {
+      t.Fatalf("node %q modifiers = %v, want %v", id, node.Modifiers, expected)
+    }
+  }
+
+  // Negative twin: a member with no modifier keyword emits no modifiers.
+  plain, ok := byID["src/main.ts#Service.plain:method"]
+  if !ok {
+    t.Fatalf("missing plain method node; have %v", dumpNodeIDs(dump))
+  }
+  if len(plain.Modifiers) != 0 {
+    t.Fatalf("plain method modifiers = %v, want none", plain.Modifiers)
+  }
+
+  // Every emitted modifier is a member of the TtscGraphNodeModifier union, since
+  // an unknown string would reject the dump under typia.assert.
+  union := map[string]bool{
+    "export": true, "default": true, "declare": true, "abstract": true,
+    "static": true, "readonly": true, "async": true, "const": true,
+    "public": true, "private": true, "protected": true, "optional": true,
+  }
+  for _, n := range dump.Nodes {
+    for _, m := range n.Modifiers {
+      if !union[m] {
+        t.Fatalf("node %q emitted non-union modifier %q", n.ID, m)
+      }
+    }
+  }
+}
+
+// equalStrings reports whether two string slices have the same elements in order.
+func equalStrings(a, b []string) bool {
+  if len(a) != len(b) {
+    return false
+  }
+  for i := range a {
+    if a[i] != b[i] {
+      return false
+    }
+  }
+  return true
+}
+
+// dumpNodeIDs returns a dump's node ids for failure messages.
+func dumpNodeIDs(d Dump) []string {
+  ids := make([]string, 0, len(d.Nodes))
+  for _, n := range d.Nodes {
+    ids = append(ids, n.ID)
+  }
+  return ids
+}

package/internal/graph/nodes_are_marked_exported_through_the_export_table_test.go

@@ -0,0 +1,61 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestNodesAreMarkedExportedThroughTheExportTable verifies that markExports flags
+// a node as Exported from the checker's module export table, not from a syntactic
+// `export` modifier — so a declaration exported by a separate `export { Service }`
+// statement counts, while an unexported sibling does not.
+//
+// The export surface drives the public-API projection, and the codebases the
+// graph targets export most of their surface through `export { … }` and barrel
+// re-exports rather than inline modifiers. A modifier-only scan would miss
+// Service here; the export-table walk must catch it, and must still leave the
+// unexported Internal alone.
+//
+//  1. Compile a fixture declaring `class Service` and `class Internal`, exporting
+//     only Service through a trailing `export { Service }` statement.
+//  2. Build the graph.
+//  3. Assert the Service node is Exported and the Internal node is not.
+func TestNodesAreMarkedExportedThroughTheExportTable(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `class Service {}
+class Internal {}
+export { Service };
+`)
+
+  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()
+
+  service := graph.Nodes[nodeID(path, "Service", NodeClass)]
+  internal := graph.Nodes[nodeID(path, "Internal", NodeClass)]
+  if service == nil || internal == nil {
+    t.Fatalf("Build did not record both classes; have %v", nodeIDSet(graph))
+  }
+
+  // Exported via a separate `export { Service }` statement — no inline modifier,
+  // so only the checker export table reveals it.
+  if !service.Exported {
+    t.Fatalf("Service should be marked Exported through the export table")
+  }
+  // Negative twin: Internal is never exported, so the public-API projection must
+  // not surface it.
+  if internal.Exported {
+    t.Fatalf("Internal is not exported but was marked Exported")
+  }
+}

package/internal/graph/overload_implementation_replaces_signature_test.go

@@ -0,0 +1,54 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestOverloadImplementationReplacesSignature verifies that an overload set's
+// graph node points at the executable implementation, not the first signature.
+// Overload-heavy APIs otherwise force agents to re-open the file to see the
+// calls that the graph already attributed to the node.
+func TestOverloadImplementationReplacesSignature(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export class Query {
+  join(name: string): this
+  join(name: string, alias?: string): this {
+    return this.realJoin(name, alias)
+  }
+
+  private realJoin(name: string, alias?: string): this {
+    return this
+  }
+}
+`)
+
+  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)
+  file := sourceFile(t, prog, "main.ts")
+  path := file.FileName()
+  id := nodeID(path, "Query.join", NodeMethod)
+  node := graph.Nodes[id]
+  if node == nil {
+    t.Fatalf("missing node Query.join; have %v", nodeIDSet(graph))
+  }
+  source := file.Text()[node.Pos:node.End]
+  if !strings.Contains(source, "return this.realJoin") {
+    t.Fatalf("expected Query.join node to cover the implementation body, got:\n%s", source)
+  }
+  if !hasEdge(graph, id, nodeID(path, "Query.realJoin", NodeMethod), EdgeValueCall) {
+    t.Fatalf("missing value-call edge Query.join -> Query.realJoin; edges: %v", graph.Edges)
+  }
+}

package/internal/graph/property_member_edges_remain_owner_visible_test.go

@@ -0,0 +1,83 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestPropertyMemberEdgesRemainOwnerVisible verifies property-member nodes are
+// additive rather than replacing class/interface owner-level edges.
+//
+// Property nodes give MCP precise evidence for state/property flows, but broad
+// architecture questions still need `Service -> Dep` and `Service -> makeDep`
+// without already knowing `Service.dep`.
+//
+//  1. Compile a class property with both a type reference and initializer call,
+//     plus an interface property signature.
+//  2. Build the graph.
+//  3. Assert both the owner node and the property node expose the same
+//     dependency evidence.
+func TestPropertyMemberEdgesRemainOwnerVisible(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export interface Dep {
+  value: string
+}
+
+export function makeDep(): Dep {
+  return { value: "ok" }
+}
+
+export class Service {
+  dep: Dep = makeDep()
+}
+
+export interface Contract {
+  dep: Dep
+}
+`)
+
+  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()
+  dep := nodeID(path, "Dep", NodeInterface)
+  makeDep := nodeID(path, "makeDep", NodeFunction)
+  service := nodeID(path, "Service", NodeClass)
+  serviceDep := nodeID(path, "Service.dep", NodeVariable)
+  contract := nodeID(path, "Contract", NodeInterface)
+  contractDep := nodeID(path, "Contract.dep", NodeVariable)
+
+  for _, id := range []string{serviceDep, contractDep} {
+    if _, ok := graph.Nodes[id]; !ok {
+      t.Fatalf("missing property node %s; nodes: %v", id, nodeIDSet(graph))
+    }
+  }
+  if !hasEdge(graph, serviceDep, dep, EdgeTypeRef) {
+    t.Fatalf("missing type-ref edge Service.dep -> Dep; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, serviceDep, makeDep, EdgeValueCall) {
+    t.Fatalf("missing value-call edge Service.dep -> makeDep; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, service, dep, EdgeTypeRef) {
+    t.Fatalf("missing owner type-ref edge Service -> Dep; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, service, makeDep, EdgeValueCall) {
+    t.Fatalf("missing owner value-call edge Service -> makeDep; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, contractDep, dep, EdgeTypeRef) {
+    t.Fatalf("missing type-ref edge Contract.dep -> Dep; edges: %v", graph.Edges)
+  }
+  if !hasEdge(graph, contract, dep, EdgeTypeRef) {
+    t.Fatalf("missing owner type-ref edge Contract -> Dep; edges: %v", graph.Edges)
+  }
+}