ttsc 0.19.3 → 0.20.0

package/internal/graph/member_relation_edges_preserve_checker_boundaries_test.go

@@ -0,0 +1,191 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestMemberRelationEdgesPreserveCheckerBoundaries verifies the pair query
+// retains instantiated, overloaded, optional, declaration-merged, mixed-symbol,
+// and class-override semantics.
+//
+// These boundaries are exactly where comparing member names, syntax kinds, or
+// already-extracted property types diverges from the TypeScript checker. The
+// fixture intentionally contains diagnostics; every pair is judged locally so
+// valid siblings and unrelated valid declarations still produce edges.
+//
+//  1. Build generic, overloaded, optional, merged, property/method, and
+//     accessor cases.
+//  2. Require checker diagnostics for the deliberately rejected declarations.
+//  3. Assert accepted pairs produce one member relation and rejected pairs none.
+func TestMemberRelationEdgesPreserveCheckerBoundaries(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export interface Generic<T> {
+  map(input: T): T;
+  required: T;
+}
+export class StringGeneric implements Generic<string> {
+  map(input: string): string { return input; }
+  required = "valid";
+}
+export class WrongGeneric implements Generic<string> {
+  map(input: number): number { return input; }
+  required = "valid sibling";
+}
+
+export interface Parser {
+  parse(input: string): string;
+  parse(input: number): number;
+}
+export class ParserImpl implements Parser {
+  parse(input: string): string;
+  parse(input: number): number;
+  parse(input: string | number): string | number { return input; }
+}
+
+export interface OptionalContract {
+  value?: string;
+}
+export class RequiredGood implements OptionalContract {
+  value = "valid";
+}
+export interface RequiredContract {
+  value: string;
+}
+export class OptionalWrong implements RequiredContract {
+  value?: string;
+}
+
+export class MethodBase {
+  run(): void {}
+}
+export class PropertyDerived extends MethodBase {
+  run = (): void => {};
+}
+export class PropertyBase {
+  run: () => void = () => {};
+}
+export class MethodWrong extends PropertyBase {
+  run(): void {}
+}
+
+export abstract class AbstractAccessorBase {
+  abstract get label(): string;
+}
+export class AbstractPropertyDerived extends AbstractAccessorBase {
+  label = "valid";
+}
+export class ConcreteAccessorBase {
+  get label(): string { return "base"; }
+}
+export class ConcretePropertyWrong extends ConcreteAccessorBase {
+  label = "invalid";
+}
+
+export class MixedFlagBase {
+  item = "base";
+}
+export class MixedFlagDerived extends MixedFlagBase {
+  get item(): string { return "invalid"; }
+}
+export interface MixedFlagDerived {
+  item: string;
+}
+
+export interface SplitBase {
+  alpha(): string;
+}
+export interface SplitBase {
+  beta(): string;
+}
+export interface SplitDerived extends SplitBase {
+  alpha(): string;
+}
+export interface SplitDerived {
+  beta(): string;
+}
+
+export class MergedBase {}
+export interface MergedBase {
+  augment(): void;
+}
+export class MergedDerived extends MergedBase {
+  augment(): void {}
+}
+
+export class ProtectedBase {
+  protected token = "base";
+}
+export class ProtectedGood extends ProtectedBase {
+  protected token = "valid";
+}
+export class ProtectedPretender implements ProtectedBase {
+  protected token = "invalid";
+}
+`)
+
+  prog, loadDiags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(loadDiags) != 0 {
+    t.Fatalf("unexpected load diagnostics: %v", loadDiags)
+  }
+  defer func() { _ = prog.Close() }()
+  if diagnostics := prog.Diagnostics(); len(diagnostics) == 0 {
+    t.Fatal("fixture must contain checker-rejected boundary cases")
+  }
+
+  built := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+  for _, id := range []string{
+    nodeID(path, "MixedFlagDerived.item", NodeMethod),
+    nodeID(path, "MixedFlagBase.item", NodeVariable),
+  } {
+    if _, ok := built.Nodes[id]; !ok {
+      t.Fatalf("mixed-symbol boundary node %s is missing; nodes: %v", id, built.Nodes)
+    }
+  }
+  expected := []struct {
+    from   string
+    to     string
+    origin string
+  }{
+    {nodeID(path, "StringGeneric.map", NodeMethod), nodeID(path, "Generic.map", NodeMethod), "implements"},
+    {nodeID(path, "StringGeneric.required", NodeVariable), nodeID(path, "Generic.required", NodeVariable), "implements"},
+    {nodeID(path, "WrongGeneric.required", NodeVariable), nodeID(path, "Generic.required", NodeVariable), "implements"},
+    {nodeID(path, "ParserImpl.parse", NodeMethod), nodeID(path, "Parser.parse", NodeMethod), "implements"},
+    {nodeID(path, "RequiredGood.value", NodeVariable), nodeID(path, "OptionalContract.value", NodeVariable), "implements"},
+    {nodeID(path, "PropertyDerived.run", NodeVariable), nodeID(path, "MethodBase.run", NodeMethod), "overrides"},
+    {nodeID(path, "AbstractPropertyDerived.label", NodeVariable), nodeID(path, "AbstractAccessorBase.label", NodeMethod), "overrides"},
+    {nodeID(path, "SplitDerived.alpha", NodeMethod), nodeID(path, "SplitBase.alpha", NodeMethod), "overrides"},
+    {nodeID(path, "SplitDerived.beta", NodeMethod), nodeID(path, "SplitBase.beta", NodeMethod), "overrides"},
+    {nodeID(path, "MergedDerived.augment", NodeMethod), nodeID(path, "MergedBase.augment", NodeMethod), "overrides"},
+    {nodeID(path, "ProtectedGood.token", NodeVariable), nodeID(path, "ProtectedBase.token", NodeVariable), "overrides"},
+  }
+  for _, pair := range expected {
+    if got := edgeOrigin(built, pair.from, pair.to, EdgeMemberRelation); got != pair.origin {
+      t.Fatalf("%s -> %s: want %q, got %q; edges: %v", pair.from, pair.to, pair.origin, got, built.Edges)
+    }
+  }
+
+  rejected := []struct {
+    from string
+    to   string
+  }{
+    {nodeID(path, "WrongGeneric.map", NodeMethod), nodeID(path, "Generic.map", NodeMethod)},
+    {nodeID(path, "OptionalWrong.value", NodeVariable), nodeID(path, "RequiredContract.value", NodeVariable)},
+    {nodeID(path, "MethodWrong.run", NodeMethod), nodeID(path, "PropertyBase.run", NodeVariable)},
+    {nodeID(path, "ConcretePropertyWrong.label", NodeVariable), nodeID(path, "ConcreteAccessorBase.label", NodeMethod)},
+    {nodeID(path, "MixedFlagDerived.item", NodeMethod), nodeID(path, "MixedFlagBase.item", NodeVariable)},
+    {nodeID(path, "ProtectedPretender.token", NodeVariable), nodeID(path, "ProtectedBase.token", NodeVariable)},
+  }
+  for _, pair := range rejected {
+    if hasEdge(built, pair.from, pair.to, EdgeMemberRelation) {
+      t.Fatalf("checker-rejected boundary gained a member edge %s -> %s; edges: %v", pair.from, pair.to, built.Edges)
+    }
+  }
+}

package/internal/graph/member_relation_edges_reject_checker_invalid_pairs_test.go

@@ -0,0 +1,119 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestMemberRelationEdgesRejectCheckerInvalidPairs verifies that an invalid
+// heritage relation cannot still manufacture authoritative member edges.
+//
+// The former TypeScript-memory synthesis compared only names and the broad
+// method/property set, so TS2416 and TS2425 diagnostics coexisted with
+// `implements`/`overrides` edges and those edges could become runtime dispatch
+// hops. A valid class in the same erroneous Program is the negative twin: an
+// unrelated diagnostic must not globally disable checker-owned relations.
+//
+//  1. Compile invalid method/property, same-kind signature, and static/instance
+//     implementations plus an invalid class override and one valid class.
+//  2. Require the checker diagnostics that prove the fixture is rejected.
+//  3. Assert invalid pairs have no member edges while the valid class still
+//     carries its checker-backed implementation edges.
+func TestMemberRelationEdgesRejectCheckerInvalidPairs(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export interface Contract {
+  kept: string;
+  value: string;
+  run(input: string): string;
+}
+export class WrongKind implements Contract {
+  kept = "checker-valid sibling";
+  value(): void {}
+  run(input: number): number { return input; }
+}
+export class StaticOnly implements Contract {
+  static kept = "static";
+  static value = "static";
+  static run(input: string): string { return input; }
+}
+export class Valid implements Contract {
+  kept = "valid";
+  value = "valid";
+  run(input: string): string { return input; }
+}
+export class Base {
+  kept = "base";
+  value = "base";
+  run(input: string): string { return input; }
+}
+export class InvalidDerived extends Base {
+  kept = "checker-valid sibling";
+  value(): void {}
+  run(input: number): number { return input; }
+}
+`)
+
+  prog, loadDiags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(loadDiags) != 0 {
+    t.Fatalf("unexpected load diagnostics: %v", loadDiags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  diagnostics := prog.Diagnostics()
+  seen2416 := false
+  seen2425 := false
+  for _, diagnostic := range diagnostics {
+    seen2416 = seen2416 || diagnostic.Code == 2416
+    seen2425 = seen2425 || diagnostic.Code == 2425
+  }
+  if !seen2416 || !seen2425 {
+    t.Fatalf("fixture must prove incompatible member diagnostics TS2416 and TS2425; got %v", diagnostics)
+  }
+
+  built := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+  absent := []struct {
+    from string
+    to   string
+  }{
+    {nodeID(path, "WrongKind.value", NodeMethod), nodeID(path, "Contract.value", NodeVariable)},
+    {nodeID(path, "WrongKind.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod)},
+    {nodeID(path, "StaticOnly.value", NodeVariable), nodeID(path, "Contract.value", NodeVariable)},
+    {nodeID(path, "StaticOnly.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod)},
+    {nodeID(path, "InvalidDerived.value", NodeMethod), nodeID(path, "Base.value", NodeVariable)},
+    {nodeID(path, "InvalidDerived.run", NodeMethod), nodeID(path, "Base.run", NodeMethod)},
+  }
+  for _, pair := range absent {
+    if hasEdge(built, pair.from, pair.to, EdgeMemberRelation) {
+      t.Fatalf("checker-invalid pair gained an authoritative member edge %s -> %s; edges: %v", pair.from, pair.to, built.Edges)
+    }
+  }
+
+  valid := []struct {
+    from string
+    to   string
+  }{
+    {nodeID(path, "WrongKind.kept", NodeVariable), nodeID(path, "Contract.kept", NodeVariable)},
+    {nodeID(path, "Valid.value", NodeVariable), nodeID(path, "Contract.value", NodeVariable)},
+    {nodeID(path, "Valid.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod)},
+  }
+  for _, pair := range valid {
+    if got := edgeOrigin(built, pair.from, pair.to, EdgeMemberRelation); got != "implements" {
+      t.Fatalf("valid implementation pair %s -> %s lost its checker-owned edge: got %q; edges: %v", pair.from, pair.to, got, built.Edges)
+    }
+  }
+  if got := edgeOrigin(
+    built,
+    nodeID(path, "InvalidDerived.kept", NodeVariable),
+    nodeID(path, "Base.kept", NodeVariable),
+    EdgeMemberRelation,
+  ); got != "overrides" {
+    t.Fatalf("valid override sibling in an invalid class was suppressed: got %q; edges: %v", got, built.Edges)
+  }
+}

package/internal/graph/node_ids_preserve_hash_bearing_components_test.go

@@ -0,0 +1,41 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestNodeIDsPreserveHashBearingComponents verifies graph identity: quoted
+// path and symbol hashes remain structured facts through dump relativization.
+//
+// A source path and an authored private member may both contain '#'. Splitting
+// the display id at either raw occurrence made the dump lose its project
+// relative path and made consumers read the member as an id separator. The
+// codec must escape those components while keeping ordinary ids byte-identical.
+//
+//  1. Build ordinary and hash-bearing ids from their raw structured facts.
+//  2. Relativize the hash-bearing id as the dump does.
+//  3. Recover its raw file component and assert the escaped wire spelling.
+func TestNodeIDsPreserveHashBearingComponents(t *testing.T) {
+  if got, want := nodeID("src/main.ts", "main", NodeFunction), "src/main.ts#main:function"; got != want {
+    t.Fatalf("ordinary id = %q, want %q", got, want)
+  }
+  if got, want := nodeID(`C:\work\a#b\main.ts`, "label:part", NodeVariable), `C:\\work\\a\#b\\main.ts#label:part:variable`; got != want {
+    t.Fatalf("escaped id = %q, want %q", got, want)
+  } else if parts, ok := parseNodeID(got); !ok || parts.path != `C:\work\a#b\main.ts` || parts.name != "label:part" {
+    t.Fatalf("decoded id = %#v, %t; want raw path and name", parts, ok)
+  }
+
+  root := filepath.Join(t.TempDir(), "a#b")
+  file := filepath.Join(root, "src#generated", "main#file.ts")
+  id := nodeID(file, "Counter.#count", NodeVariable)
+  context := newDumpContext(root, nil)
+  got := context.relID(id)
+  want := "src\\#generated/main\\#file.ts#Counter.\\#count:variable"
+  if got != want {
+    t.Fatalf("relativized id = %q, want %q", got, want)
+  }
+  if file := nodeFile(got); file != "src#generated/main#file.ts" {
+    t.Fatalf("decoded file = %q, want raw hash-bearing relative path", file)
+  }
+}

package/internal/graph/node_modifiers_emit_union_strings_test.go

@@ -47,7 +47,10 @@ export const enum Mode {
   defer func() { _ = prog.Close() }()
 
   g := Build(prog)
-  dump := NewDump(g, root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  dump, err := NewDump(g, root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
 
   byID := make(map[string]DumpNode, len(dump.Nodes))
   for _, n := range dump.Nodes {

package/internal/graph/object_literal_members_ride_on_the_snapshot_test.go

@@ -0,0 +1,192 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestObjectLiteralMembersRideOnTheSnapshot verifies that object-literal
+// member identity is captured from the compiler AST and projected from the
+// same source snapshot as the graph.
+//
+// The details server used to reopen the live file and reconstruct this list
+// with a brace counter and regular expressions. A brace inside a block comment
+// changed that counter, while valid shorthand, literal-keyed, computed, and
+// multiline members depended on which line happened to match. This test pins
+// the ownership boundary instead: the native graph records direct AST members,
+// and the dump renders snapshot-owned, body-bounded compact signatures from
+// Program-owned text.
+//
+//  1. Compile a wrapped object literal containing comment braces, every direct
+//     static member shape, a dynamic key, a spread, and a nested object.
+//  2. Assert the variable node records only its direct statically named members
+//     in declaration order, with method/property kinds independent of trivia.
+//  3. Dump the graph and assert member lines/signatures come from the snapshot,
+//     while spread and nested members are not fabricated as outer identity.
+func TestObjectLiteralMembersRideOnTheSnapshot(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  source := `const shorthand = 1;
+const dynamic = Math.random() > 0.5 ? "a" : "b";
+const spread = { fromSpread: true };
+
+export const shape = (({
+  /* { */
+  real: 1,
+  close: "}",
+  text: "{",
+  template: ` + "`{${shorthand}}`" + `,
+  long: "` + strings.Repeat("x", 200) + `",
+  shorthand,
+  ["static-key"]: 2,
+  [""]: 4,
+  [1]: true,
+  [dynamic]: 3,
+  method() {
+    return shorthand;
+  },
+  get value() {
+    return shorthand;
+  },
+  set value(input: number) {
+    void "SETTER_BODY_MUST_NOT_APPEAR";
+  },
+  oneLineMethod() { return "METHOD_BODY_MUST_NOT_APPEAR"; },
+  get oneLineValue() { return "ACCESSOR_BODY_MUST_NOT_APPEAR"; },
+  run: () => "ARROW_BODY_MUST_NOT_APPEAR",
+  classic: function () { return "FUNCTION_BODY_MUST_NOT_APPEAR"; },
+  klass: class { method() { return "CLASS_BODY_MUST_NOT_APPEAR"; } },
+  list: ["ARRAY_CONTENT_MUST_NOT_APPEAR"],
+  nested: {
+    inner: "NESTED_BODY_MUST_NOT_APPEAR",
+  },
+  ...spread,
+  /* } */
+  afterSpread: true,
+}) as const) satisfies Record<PropertyKey, unknown>;
+`
+  writeFile(t, filepath.Join(root, "src", "main.ts"), source)
+
+  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, "shape", NodeVariable)]
+  if node == nil {
+    t.Fatalf("missing shape variable; nodes: %v", nodeIDSet(graph))
+  }
+
+  want := []ObjectMember{
+    {Name: "real", Kind: NodeVariable},
+    {Name: "close", Kind: NodeVariable},
+    {Name: "text", Kind: NodeVariable},
+    {Name: "template", Kind: NodeVariable},
+    {Name: "long", Kind: NodeVariable},
+    {Name: "shorthand", Kind: NodeVariable},
+    {Name: "static-key", Kind: NodeVariable},
+    {Name: "", Kind: NodeVariable},
+    {Name: "1", Kind: NodeVariable},
+    {Name: "method", Kind: NodeMethod},
+    {Name: "value", Kind: NodeMethod},
+    {Name: "value", Kind: NodeMethod},
+    {Name: "oneLineMethod", Kind: NodeMethod},
+    {Name: "oneLineValue", Kind: NodeMethod},
+    {Name: "run", Kind: NodeVariable},
+    {Name: "classic", Kind: NodeVariable},
+    {Name: "klass", Kind: NodeVariable},
+    {Name: "list", Kind: NodeVariable},
+    {Name: "nested", Kind: NodeVariable},
+    {Name: "afterSpread", Kind: NodeVariable},
+  }
+  if len(node.ObjectMembers) != len(want) {
+    t.Fatalf("object members = %v, want %v", node.ObjectMembers, want)
+  }
+  for i, expected := range want {
+    actual := node.ObjectMembers[i]
+    if actual.Name != expected.Name || actual.Kind != expected.Kind {
+      t.Fatalf("object member %d = %+v, want %+v", i, actual, expected)
+    }
+    if actual.Pos < 0 || actual.End <= actual.Pos {
+      t.Fatalf("object member %q has no snapshot span: %+v", actual.Name, actual)
+    }
+  }
+
+  dump, err := NewDump(graph, root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  var dumped *DumpNode
+  for i := range dump.Nodes {
+    if dump.Nodes[i].ID == "src/main.ts#shape:variable" {
+      dumped = &dump.Nodes[i]
+      break
+    }
+  }
+  if dumped == nil {
+    t.Fatalf("dump omitted shape: %+v", dump.Nodes)
+  }
+  if len(dumped.ObjectMembers) != len(want) {
+    t.Fatalf("dumped object members = %+v, want %d", dumped.ObjectMembers, len(want))
+  }
+  for _, member := range dumped.ObjectMembers {
+    if member.Line <= 0 || member.Signature == "" {
+      t.Fatalf("member lacks snapshot line/signature: %+v", member)
+    }
+    if member.Name == "inner" || member.Name == "fromSpread" || member.Name == "dynamic" {
+      t.Fatalf("non-direct or non-static member was fabricated: %+v", member)
+    }
+  }
+  if got := dumped.ObjectMembers[0]; got.Name != "real" || got.Line != 7 || got.Signature != "real: 1" {
+    t.Fatalf("comment brace corrupted the first real member: %+v", got)
+  }
+  if got := dumped.ObjectMembers[len(dumped.ObjectMembers)-1]; got.Name != "afterSpread" || got.Signature != "afterSpread: true" {
+    t.Fatalf("spread/comment boundary corrupted the following member: %+v", got)
+  }
+  signatures := map[string]string{}
+  for _, member := range dumped.ObjectMembers {
+    signatures[member.Name] = member.Signature
+  }
+  expectedSignatures := map[string]string{
+    "oneLineMethod": "oneLineMethod() {",
+    "oneLineValue":  "get oneLineValue() {",
+    "run":           "run: () =>",
+    "classic":       "classic: function () {",
+    "klass":         "klass: class",
+    "list":          "list: [",
+    "nested":        "nested: {",
+  }
+  for name, expected := range expectedSignatures {
+    if actual := signatures[name]; actual != expected {
+      t.Fatalf("signature for %q = %q, want %q", name, actual, expected)
+    }
+  }
+  for _, forbidden := range []string{
+    "METHOD_BODY_MUST_NOT_APPEAR",
+    "ACCESSOR_BODY_MUST_NOT_APPEAR",
+    "SETTER_BODY_MUST_NOT_APPEAR",
+    "ARROW_BODY_MUST_NOT_APPEAR",
+    "FUNCTION_BODY_MUST_NOT_APPEAR",
+    "CLASS_BODY_MUST_NOT_APPEAR",
+    "ARRAY_CONTENT_MUST_NOT_APPEAR",
+    "NESTED_BODY_MUST_NOT_APPEAR",
+  } {
+    for _, member := range dumped.ObjectMembers {
+      if strings.Contains(member.Signature, forbidden) {
+        t.Fatalf("signature inlined source body %q: %+v", forbidden, member)
+      }
+    }
+  }
+  if signature := signatures["long"]; len([]rune(signature)) != 160 || !strings.HasSuffix(signature, "...") {
+    t.Fatalf("long member signature is not bounded to 160 runes: %q", signature)
+  }
+}

package/internal/graph/object_member_signatures_preserve_literal_whitespace_test.go

@@ -0,0 +1,67 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestObjectMemberSignaturesPreserveLiteralWhitespace verifies that compact
+// display text never rewrites whitespace owned by a lexical value.
+//
+// strings.Fields treated quoted and template contents as trivia. It changed
+// string and regular-expression values, and its first-line cut left a multiline
+// template without a closing backtick. The outline may compact surrounding
+// syntax only when the literal itself remains byte-identical and complete.
+//
+//  1. Compile object members with spaced strings, a regexp, and a template.
+//  2. Dump the graph from the Program-owned source snapshot.
+//  3. Assert literal whitespace and the complete template delimiter survive.
+func TestObjectMemberSignaturesPreserveLiteralWhitespace(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  source := `export const shape = {
+  double: "a  b",
+  single: 'c  d',
+  regexp: /e  f/,
+  template: ` + "`left\n  right`" + `,
+};
+`
+  writeFile(t, filepath.Join(root, "src", "main.ts"), source)
+
+  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)
+  dump, err := NewDump(graph, root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  signatures := map[string]string{}
+  for _, node := range dump.Nodes {
+    if node.ID != "src/main.ts#shape:variable" {
+      continue
+    }
+    for _, member := range node.ObjectMembers {
+      signatures[member.Name] = member.Signature
+    }
+  }
+  expected := map[string]string{
+    "double":   `double: "a  b"`,
+    "single":   `single: 'c  d'`,
+    "regexp":   `regexp: /e  f/`,
+    "template": "template: `left\n  right`",
+  }
+  for name, want := range expected {
+    if got := signatures[name]; got != want {
+      t.Fatalf("signature for %q = %q, want %q", name, got, want)
+    }
+  }
+}