ttsc 0.19.3 → 0.20.0

package/internal/graph/dump_checkout_paths_are_stable_test.go

@@ -0,0 +1,210 @@
+package graph
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+const portableDumpTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "noEmit": true
+  },
+  "files": ["src/main.ts", "../shared/value.ts", "../shared/types.d.ts"]
+}
+`
+
+// TestDumpCheckoutPathsAreStable verifies the whole schema-v6 consequence
+// surface, not only the path helper.
+//
+//  1. Build the same project plus sibling .ts/.d.ts under two checkout roots.
+//  2. Remove only the producer-local Project locator and require byte identity.
+//  3. Assert nodes, module names, endpoints, implementation evidence,
+//     diagnostics, manifests, and universe inputs all use one `../shared`
+//     coordinate, with the .ts internal and the .d.ts an external leaf.
+func TestDumpCheckoutPathsAreStable(t *testing.T) {
+  firstCheckout := filepath.Join(t.TempDir(), "checkout-one")
+  secondCheckout := filepath.Join(t.TempDir(), "checkout-two")
+  first := portableFixtureDump(t, firstCheckout)
+  second := portableFixtureDump(t, secondCheckout)
+
+  first.Project = ""
+  second.Project = ""
+  firstJSON, err := json.Marshal(first)
+  if err != nil {
+    t.Fatal(err)
+  }
+  secondJSON, err := json.Marshal(second)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if string(firstJSON) != string(secondJSON) {
+    t.Fatalf("checkout relocation changed the dump:\nfirst  %s\nsecond %s", firstJSON, secondJSON)
+  }
+
+  assertPortableFixturePaths(t, first)
+  if strings.Contains(string(firstJSON), filepath.ToSlash(firstCheckout)) ||
+    strings.Contains(string(secondJSON), filepath.ToSlash(secondCheckout)) {
+    t.Fatal("a producer-local checkout path escaped into schema-v6 identity")
+  }
+}
+
+func portableFixtureDump(t *testing.T, checkout string) Dump {
+  t.Helper()
+  project := filepath.Join(checkout, "app")
+  config := filepath.Join(project, "tsconfig.json")
+  mainFile := filepath.Join(project, "src", "main.ts")
+  siblingFile := filepath.Join(checkout, "shared", "value.ts")
+  declarationFile := filepath.Join(checkout, "shared", "types.d.ts")
+
+  writeFile(t, config, portableDumpTSConfig)
+  writeFile(t, mainFile, `import { sibling } from "../../shared/value";
+import type { ExternalShape } from "../../shared/types";
+export function main(input: ExternalShape): number {
+  return sibling(input.value);
+}
+`)
+  writeFile(t, siblingFile, `export function sibling(value: number): number {
+  return value;
+}
+export const broken: number = "nope";
+`)
+  writeFile(t, declarationFile, `export interface ExternalShape {
+  value: number;
+}
+`)
+
+  prog, _, err := driver.LoadProgram(project, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  defer func() { _ = prog.Close() }()
+
+  built := Build(prog)
+  // An implementation span is the one evidence path that cannot be recovered
+  // from its owner node. Point one real node at the sibling source so this
+  // end-to-end projection proves that optional path uses the same mapper too.
+  implementationFile := ""
+  for _, node := range built.Nodes {
+    if node.Kind == NodeFunction && node.Name == "sibling" {
+      implementationFile = node.File
+      break
+    }
+  }
+  if implementationFile == "" {
+    t.Fatal("fixture graph omitted sibling function")
+  }
+  for _, node := range built.Nodes {
+    if node.Kind == NodeFunction && node.Name == "main" {
+      // Use the compiler's canonical spelling rather than filepath.Join's host
+      // spelling. On Windows SourceTexts is keyed by tsgo-normalized slashes;
+      // injecting the fixture's backslash path would test a missing source-map
+      // lookup instead of the wire mapper.
+      node.ImplementationFile = implementationFile
+      node.ImplementationPos = 0
+      node.ImplementationEnd = len("export function sibling")
+      break
+    }
+  }
+
+  texts := SourceTexts(prog)
+  dump, err := NewDump(
+    built,
+    project,
+    "tsconfig.json",
+    nil,
+    texts,
+    DumpOrigin{
+      Provenance: NewProvenance(
+        Producer{Tool: "portable-fixture", Version: "test", Typescript: TypescriptVersion()},
+        []string{CapabilityUniverse, CapabilitySourceDigests, CapabilityDiagnostics},
+        []FileDigest{{File: config, Digest: "config-digest"}},
+        []RootFile{
+          {Config: config, File: mainFile},
+          {Config: config, File: siblingFile},
+          {Config: config, File: declarationFile},
+        },
+        texts,
+        nil,
+      ),
+      Diagnostics: NewDiagnostics(prog),
+    },
+  )
+  if err != nil {
+    t.Fatal(err)
+  }
+  return dump
+}
+
+func assertPortableFixturePaths(t *testing.T, dump Dump) {
+  t.Helper()
+  if dump.Tsconfig != "tsconfig.json" {
+    t.Fatalf("tsconfig coordinate = %q", dump.Tsconfig)
+  }
+
+  var internal, external, module, implemented bool
+  ids := map[string]bool{}
+  for _, node := range dump.Nodes {
+    ids[node.ID] = true
+    switch {
+    case node.Kind == string(NodeFunction) && node.Name == "sibling":
+      internal = node.File == "../shared/value.ts" && !node.External &&
+        strings.HasPrefix(node.ID, "../shared/value.ts#")
+    case node.Name == "ExternalShape":
+      external = node.File == "../shared/types.d.ts" && node.External &&
+        strings.HasPrefix(node.ID, "../shared/types.d.ts#")
+    case node.Kind == string(NodeModule) && node.File == "../shared/value.ts":
+      module = node.Name == "../shared/value.ts" &&
+        strings.Contains(node.ID, "#../shared/value.ts:module")
+    case node.Kind == string(NodeFunction) && node.Name == "main":
+      implemented = node.Implementation != nil && node.Implementation.File == "../shared/value.ts"
+    }
+  }
+  if !internal || !external || !module || !implemented {
+    t.Fatalf("portable node surfaces missing: internal=%t external=%t module=%t implementation=%t", internal, external, module, implemented)
+  }
+  for _, edge := range dump.Edges {
+    if !ids[edge.From] || !ids[edge.To] {
+      t.Fatalf("mapped edge endpoint is not a mapped node: %+v", edge)
+    }
+  }
+
+  diagnostic := false
+  for _, finding := range dump.Diagnostics {
+    if finding.Code == 2322 && finding.File == "../shared/value.ts" {
+      diagnostic = true
+    }
+  }
+  if !diagnostic {
+    t.Fatalf("sibling diagnostic did not use the shared coordinate: %+v", dump.Diagnostics)
+  }
+
+  source := false
+  for _, entry := range dump.Provenance.Sources {
+    if entry.File == "../shared/value.ts" {
+      source = true
+    }
+  }
+  if !source || len(dump.Provenance.Universe.Configs) != 1 ||
+    dump.Provenance.Universe.Configs[0].File != "tsconfig.json" {
+    t.Fatalf("manifest/config coordinates drifted: %+v", dump.Provenance)
+  }
+  roots := map[string]bool{}
+  for _, root := range dump.Provenance.Universe.Roots {
+    if root.Config != "tsconfig.json" {
+      t.Fatalf("root config coordinate = %q", root.Config)
+    }
+    roots[root.File] = true
+  }
+  for _, want := range []string{"src/main.ts", "../shared/value.ts", "../shared/types.d.ts"} {
+    if !roots[want] {
+      t.Fatalf("universe roots omit %q: %+v", want, dump.Provenance.Universe.Roots)
+    }
+  }
+}

package/internal/graph/dump_diagnostics_ride_the_generation_that_built_it_test.go

@@ -36,9 +36,12 @@ func TestDumpDiagnosticsRideTheGenerationThatBuiltIt(t *testing.T) {
   }
   defer func() { _ = prog.Close() }()
 
-  dump := NewDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{
-    Diagnostics: NewDiagnostics(prog, root),
+  dump, err := NewDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{
+    Diagnostics: NewDiagnostics(prog),
   })
+  if err != nil {
+    t.Fatal(err)
+  }
 
   var match *Diagnostic
   for i := range dump.Diagnostics {
@@ -69,7 +72,10 @@ func TestDumpDiagnosticsRideTheGenerationThatBuiltIt(t *testing.T) {
 
   // The negative twin: a caller that does not collect diagnostics publishes an
   // empty list, never a nil that would encode as JSON null.
-  quiet := NewDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  quiet, err := NewDump(Build(prog), root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
   if quiet.Diagnostics == nil {
     t.Fatal("an uncollected diagnostics list is nil, so it serializes as null rather than []")
   }

package/internal/graph/dump_paths.go

@@ -0,0 +1,172 @@
+package graph
+
+import (
+  "fmt"
+  "strings"
+
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+)
+
+// dumpPathMapper owns the schema-v6 path vocabulary for one dump. Every
+// identity-bearing path passes through this one cache, so the producer can
+// reject both an unportable filesystem root and a non-injective projection
+// before any JSON is written.
+type dumpPathMapper struct {
+  project       string
+  caseSensitive bool
+
+  physicalToWire map[string]string
+  wireToPhysical map[string]string
+  mappingErr     error
+}
+
+func newDumpPathMapper(project string) *dumpPathMapper {
+  normalized := shimtspath.NormalizePath(shimtspath.NormalizeSlashes(project))
+  mapper := &dumpPathMapper{
+    project:        normalized,
+    caseSensitive:  dumpPathRootIsCaseSensitive(normalized),
+    physicalToWire: map[string]string{},
+    wireToPhysical: map[string]string{},
+  }
+  if normalized == "" || shimtspath.GetRootLength(normalized) == 0 {
+    mapper.mappingErr = fmt.Errorf("ttscgraph: project root %q is not absolute", project)
+  }
+  return mapper
+}
+
+// mapPath returns one portable, slash-normalized coordinate:
+//
+//   - project files stay project-relative;
+//   - same-root siblings use `../` segments, preserving workspace structure;
+//   - package paths keep their full resolution context instead of collapsing
+//     to the last node_modules tail;
+//   - compiler virtual paths keep their bundled identity.
+//
+// A source on another drive or UNC share has no portable coordinate relative
+// to the project. It records a precise error; NewDump returns that error before
+// a caller can serialize the partial projection.
+func (m *dumpPathMapper) mapPath(file string) string {
+  if file == "" {
+    return ""
+  }
+  normalized := shimtspath.NormalizeSlashes(file)
+  if strings.HasPrefix(normalized, "bundled:///") {
+    return m.claim(normalized, normalized)
+  }
+  normalized = shimtspath.NormalizePath(normalized)
+  if m.project == "" || shimtspath.GetRootLength(m.project) == 0 {
+    return normalized
+  }
+
+  physical := normalized
+  if shimtspath.GetRootLength(physical) == 0 {
+    physical = shimtspath.GetNormalizedAbsolutePath(physical, m.project)
+  }
+  if !dumpPathRootsEqual(m.project, physical, m.caseSensitive) {
+    m.fail(fmt.Errorf(
+      "ttscgraph: source path %q cannot be represented relative to project %q because they are on different filesystem roots",
+      normalized,
+      m.project,
+    ))
+    return normalized
+  }
+  options := shimtspath.ComparePathsOptions{
+    CurrentDirectory:          m.project,
+    UseCaseSensitiveFileNames: m.caseSensitive,
+  }
+  wire := shimtspath.GetRelativePathFromDirectory(m.project, physical, options)
+  if shimtspath.GetRootLength(wire) != 0 {
+    m.fail(fmt.Errorf(
+      "ttscgraph: source path %q cannot be represented relative to project %q because they are on different filesystem roots",
+      normalized,
+      m.project,
+    ))
+    return normalized
+  }
+  return m.claim(physical, wire)
+}
+
+// claim records both directions of the projection. The reverse map is the
+// injectivity gate: two distinct compiler sources may never acquire one wire
+// identity, even if a future coordinate rule is added incorrectly.
+func (m *dumpPathMapper) claim(physical, wire string) string {
+  key := physical
+  if !m.caseSensitive && !strings.HasPrefix(physical, "bundled:///") {
+    key = strings.ToLower(key)
+  }
+  if previous, ok := m.physicalToWire[key]; ok {
+    if previous != wire {
+      m.fail(fmt.Errorf(
+        "ttscgraph: source path %q mapped inconsistently to %q and %q",
+        physical,
+        previous,
+        wire,
+      ))
+    }
+    return previous
+  }
+  if previous, ok := m.wireToPhysical[wire]; ok && previous != key {
+    m.fail(fmt.Errorf(
+      "ttscgraph: source paths %q and %q collide at wire identity %q",
+      previous,
+      physical,
+      wire,
+    ))
+    return wire
+  }
+  m.physicalToWire[key] = wire
+  m.wireToPhysical[wire] = key
+  return wire
+}
+
+func (m *dumpPathMapper) fail(err error) {
+  if m.mappingErr == nil {
+    m.mappingErr = err
+  }
+}
+
+func (m *dumpPathMapper) err() error { return m.mappingErr }
+
+// Windows drive and UNC roots use case-insensitive path comparison. POSIX
+// roots remain case-sensitive. This decision follows the path's own grammar so
+// synthetic Windows/UNC fixtures behave the same on every CI host.
+func dumpPathRootIsCaseSensitive(path string) bool {
+  rootLength := shimtspath.GetRootLength(path)
+  if rootLength == 0 {
+    return true
+  }
+  root := path[:rootLength]
+  return !(strings.HasPrefix(root, "//") || (len(root) >= 2 && root[1] == ':'))
+}
+
+// dumpPathRootsEqual compares filesystem roots before asking tspath for a
+// relative coordinate. tspath models a UNC root as `//server/`, which is useful
+// for URL-like path operations but too broad for a filesystem identity: on
+// Windows, `//server/share-a` and `//server/share-b` are different volumes and
+// no `../share-b` coordinate can cross between them. Include the share component
+// for that one grammar and keep tspath's roots for drive and POSIX paths.
+func dumpPathRootsEqual(left, right string, caseSensitive bool) bool {
+  leftRoot := dumpFilesystemRoot(left)
+  rightRoot := dumpFilesystemRoot(right)
+  if caseSensitive {
+    return leftRoot == rightRoot
+  }
+  return strings.EqualFold(leftRoot, rightRoot)
+}
+
+func dumpFilesystemRoot(path string) string {
+  normalized := shimtspath.NormalizeSlashes(path)
+  rootLength := shimtspath.GetRootLength(normalized)
+  if rootLength == 0 {
+    return ""
+  }
+  root := normalized[:rootLength]
+  if !strings.HasPrefix(root, "//") {
+    return root
+  }
+  remainder := normalized[rootLength:]
+  if slash := strings.IndexByte(remainder, '/'); slash >= 0 {
+    return root + remainder[:slash]
+  }
+  return root + remainder
+}

package/internal/graph/dump_paths_are_portable_and_injective_test.go

@@ -0,0 +1,93 @@
+package graph
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestDumpPathMapperUsesPortableCoordinates verifies the schema-v6 vocabulary
+// directly, independent of the host OS running the test.
+//
+//  1. Map in-project and sibling paths for POSIX, drive, and UNC layouts.
+//  2. Keep two pnpm version/peer contexts with the same package subpath apart.
+//  3. Preserve compiler virtual identities exactly.
+func TestDumpPathMapperUsesPortableCoordinates(t *testing.T) {
+  tests := []struct {
+    name    string
+    project string
+    file    string
+    want    string
+  }{
+    {"posix-project", "/checkout/app", "/checkout/app/src/main.ts", "src/main.ts"},
+    {"posix-sibling", "/checkout/app", "/checkout/shared/src/value.ts", "../shared/src/value.ts"},
+    {"windows-project", `C:\checkout\app`, `C:\checkout\app\src\main.ts`, "src/main.ts"},
+    {"windows-sibling", `C:\checkout\app`, `C:\checkout\shared\src\value.ts`, "../shared/src/value.ts"},
+    {"unc-project", `\\server\share\checkout\app`, `\\server\share\checkout\app\src\main.ts`, "src/main.ts"},
+    {"unc-sibling", `\\server\share\checkout\app`, `\\server\share\checkout\shared\src\value.ts`, "../shared/src/value.ts"},
+    {
+      "pnpm-peer-a",
+      "/checkout/app",
+      "/checkout/app/node_modules/.pnpm/pkg@1.0.0_peer-a/node_modules/pkg/index.d.ts",
+      "node_modules/.pnpm/pkg@1.0.0_peer-a/node_modules/pkg/index.d.ts",
+    },
+    {
+      "pnpm-peer-b",
+      "/checkout/app",
+      "/checkout/app/node_modules/.pnpm/pkg@2.0.0_peer-b/node_modules/pkg/index.d.ts",
+      "node_modules/.pnpm/pkg@2.0.0_peer-b/node_modules/pkg/index.d.ts",
+    },
+    {"bundled", "/checkout/app", "bundled:///lib.es2024.d.ts", "bundled:///lib.es2024.d.ts"},
+  }
+  for _, test := range tests {
+    t.Run(test.name, func(t *testing.T) {
+      mapper := newDumpPathMapper(test.project)
+      if got := mapper.mapPath(test.file); got != test.want {
+        t.Fatalf("mapPath(%q) = %q, want %q", test.file, got, test.want)
+      }
+      if err := mapper.err(); err != nil {
+        t.Fatalf("mapPath(%q): %v", test.file, err)
+      }
+    })
+  }
+}
+
+// TestDumpPathMapperRejectsUnportableRootsAndCollisions pins both fail-closed
+// boundaries of the mapping contract.
+//
+//  1. Reject a different Windows drive and a different UNC share precisely.
+//  2. Force two physical sources through one coordinate and require a collision.
+//  3. Require NewDump to surface the root error before JSON serialization.
+func TestDumpPathMapperRejectsUnportableRootsAndCollisions(t *testing.T) {
+  for _, test := range []struct {
+    name    string
+    project string
+    file    string
+  }{
+    {"windows-drive", "C:/checkout/app", "D:/shared/value.ts"},
+    {"unc-share", "//server/share-a/app", "//server/share-b/value.ts"},
+  } {
+    t.Run(test.name, func(t *testing.T) {
+      mapper := newDumpPathMapper(test.project)
+      mapper.mapPath(test.file)
+      if err := mapper.err(); err == nil || !strings.Contains(err.Error(), "different filesystem roots") {
+        t.Fatalf("cross-root error = %v, want a precise filesystem-root rejection", err)
+      }
+    })
+  }
+
+  collision := newDumpPathMapper("/checkout/app")
+  collision.claim("/physical/one.ts", "shared.ts")
+  collision.claim("/physical/two.ts", "shared.ts")
+  if err := collision.err(); err == nil || !strings.Contains(err.Error(), "collide at wire identity") {
+    t.Fatalf("collision error = %v, want an injectivity rejection", err)
+  }
+
+  file := "D:/shared/value.ts"
+  id := nodeID(file, "value", NodeVariable)
+  _, err := NewDump(&Graph{Nodes: map[string]*Node{
+    id: &Node{ID: id, Name: "value", Simple: "value", Kind: NodeVariable, File: file},
+  }}, "C:/checkout/app", "tsconfig.json", nil, nil, DumpOrigin{})
+  if err == nil || !strings.Contains(err.Error(), "different filesystem roots") {
+    t.Fatalf("NewDump cross-root error = %v, want rejection before serialization", err)
+  }
+}

package/internal/graph/dump_uses_ecma_line_terminators_test.go

@@ -0,0 +1,87 @@
+package graph
+
+import (
+  "encoding/json"
+  "path/filepath"
+  "testing"
+)
+
+// TestDumpUsesECMALineTerminators verifies graph dump evidence and compact
+// source display use the compiler's complete ECMAScript line model.
+//
+// The graph used to split only on LF, so a CR, LS, or PS file placed every
+// declaration on line one and let a leading // comment consume the rest of the
+// file. Each fixture drives a real compiler program and checks the independent
+// dump coordinates, comment compaction, and regular-expression boundary.
+//
+// 1. Compile the same two-function project with each ECMAScript terminator.
+// 2. Marshal its graph and find both declarations and the call edge.
+// 3. Assert their evidence and source helpers agree on the three logical lines.
+func TestDumpUsesECMALineTerminators(t *testing.T) {
+  cases := []struct {
+    name       string
+    terminator string
+  }{
+    {name: "LF", terminator: "\n"},
+    {name: "CRLF", terminator: "\r\n"},
+    {name: "CR", terminator: "\r"},
+    {name: "LS", terminator: "\u2028"},
+    {name: "PS", terminator: "\u2029"},
+  }
+  for _, tc := range cases {
+    t.Run(tc.name, func(t *testing.T) {
+      source := "// lead comment" + tc.terminator +
+        "export function alpha(): number { return beta(); }" + tc.terminator +
+        "export function beta(): number { return 1; }"
+      root := t.TempDir()
+      writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+      writeFile(t, filepath.Join(root, "src", "main.ts"), source)
+
+      var dump Dump
+      if err := json.Unmarshal(dumpBytes(t, root), &dump); err != nil {
+        t.Fatalf("dump is not valid JSON: %v", err)
+      }
+      nodes := map[string]*DumpNode{}
+      for i := range dump.Nodes {
+        node := &dump.Nodes[i]
+        if node.Kind == "function" {
+          nodes[node.Name] = node
+        }
+      }
+      for _, name := range []string{"alpha", "beta"} {
+        node := nodes[name]
+        if node == nil || node.Evidence == nil {
+          t.Fatalf("missing %s evidence: %+v", name, dump.Nodes)
+        }
+      }
+      if got := nodes["alpha"].Evidence; got.StartLine != 2 || got.StartCol != 1 {
+        t.Fatalf("alpha evidence = line %d col %d, want line 2 col 1", got.StartLine, got.StartCol)
+      }
+      if got := nodes["beta"].Evidence; got.StartLine != 3 || got.StartCol != 1 {
+        t.Fatalf("beta evidence = line %d col %d, want line 3 col 1", got.StartLine, got.StartCol)
+      }
+
+      var call *DumpEdge
+      for i := range dump.Edges {
+        edge := &dump.Edges[i]
+        if edge.Kind == "calls" && edge.From == "src/main.ts#alpha:function" {
+          call = edge
+          break
+        }
+      }
+      if call == nil || call.Evidence == nil || call.Evidence.StartLine != 2 {
+        t.Fatalf("alpha call evidence = %+v, want line 2", call)
+      }
+
+      if lines := newLineStarts(source); len(lines) != 3 {
+        t.Fatalf("line starts = %v, want three logical lines", lines)
+      }
+      if got := compactObjectMemberSignature("// lead" + tc.terminator + "value: 1"); got != "// lead"+tc.terminator+"value: 1" {
+        t.Fatalf("compact signature = %q, want line comment to end before value", got)
+      }
+      if got := regularExpressionEnd("/line"+tc.terminator+"next/", 0); got != 0 {
+        t.Fatalf("regular-expression end = %d, want reject a cross-line literal", got)
+      }
+    })
+  }
+}

package/internal/graph/duplicate_variable_object_members_keep_first_declaration_test.go

@@ -0,0 +1,61 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestDuplicateVariableObjectMembersKeepFirstDeclaration verifies that a legal
+// repeated var declaration cannot attach its initializer to the first node.
+//
+// Variable symbols merge across declarations, while graph node identity keeps
+// the first declaration. Collecting object members after every add used to
+// combine the first declaration's span with the second declaration's members,
+// producing a node that never existed in the compiler snapshot.
+//
+//  1. Compile two var declarations with the same symbol and different objects.
+//  2. Assert the graph keeps the first declaration and its direct member.
+//  3. Dump the graph and assert the same member remains on the wire.
+func TestDuplicateVariableObjectMembersKeepFirstDeclaration(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export var duplicate = { first: 1 };
+export var duplicate = { second: 2 };
+`)
+
+  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()
+  node := graph.Nodes[nodeID(path, "duplicate", NodeVariable)]
+  if node == nil {
+    t.Fatalf("missing duplicate variable; nodes: %v", nodeIDSet(graph))
+  }
+  if len(node.ObjectMembers) != 1 || node.ObjectMembers[0].Name != "first" {
+    t.Fatalf("first declaration members were overwritten: %+v", node.ObjectMembers)
+  }
+
+  dump, err := NewDump(graph, root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  for _, dumped := range dump.Nodes {
+    if dumped.ID != "src/main.ts#duplicate:variable" {
+      continue
+    }
+    if len(dumped.ObjectMembers) != 1 || dumped.ObjectMembers[0].Name != "first" || dumped.ObjectMembers[0].Signature != "first: 1" {
+      t.Fatalf("dump mixed declarations: %+v", dumped.ObjectMembers)
+    }
+    return
+  }
+  t.Fatalf("dump omitted duplicate variable: %+v", dump.Nodes)
+}