ttsc 0.19.1 → 0.19.3

package/internal/graph/enum_members_carry_their_names_on_the_enum_node_test.go

@@ -0,0 +1,131 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestEnumMembersCarryTheirNamesOnTheEnumNode verifies that an enum records the
+// name and value of each member on its own node, and that nothing else does.
+//
+// The enum's node was always in the graph and had nothing in it (#738). Its
+// signature stops at the `{`, its members are not nodes, so the outline a class
+// gets is empty for an enum — and #732 gave it only values. The code writes
+// `Colors.Red`, never `"red"`, so a caller that had already named the enum
+// still opened the file for the one fact it came for.
+//
+// The names ride on the enum rather than on member nodes on purpose. A member
+// node would be indexing what `grep -rn "Colors.Red"` answers exactly, and it
+// would put leaves into tour flows to do it. Filling in a node the graph holds
+// is indexing; minting nodes to carry detail is not.
+//
+//  1. Compile a fixture with a string enum, an implicitly numbered one, and a
+//     class beside them.
+//  2. Build the graph.
+//  3. Assert each enum node carries its members name-and-value, that no member
+//     became a node, and that a class node carries none of this.
+func TestEnumMembersCarryTheirNamesOnTheEnumNode(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export enum Colors {
+  Red = 'red',
+  Green = 'green',
+}
+
+export enum Implicit {
+  First,
+  Second,
+}
+
+// Two members, one value: a type folds these together, a declaration does not.
+export enum Dup {
+  A = 'x',
+  B = 'x',
+  C = 'y',
+}
+
+export class Cls {
+  public value = 1;
+}
+`)
+
+  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()
+
+  colors, ok := graph.Nodes[nodeID(path, "Colors", NodeEnum)]
+  if !ok {
+    t.Fatalf("missing enum node; nodes: %v", nodeIDSet(graph))
+  }
+  want := []EnumMember{{Name: "Red", Value: `"red"`}, {Name: "Green", Value: `"green"`}}
+  if len(colors.EnumMembers) != len(want) {
+    t.Fatalf("Colors reported %v, want %v", colors.EnumMembers, want)
+  }
+  for i, member := range want {
+    if colors.EnumMembers[i] != member {
+      t.Fatalf("Colors member %d is %v, want %v", i, colors.EnumMembers[i], member)
+    }
+  }
+
+  // The values exist only in the checker here, so a scrape of the source could
+  // not produce this pairing.
+  implicit := graph.Nodes[nodeID(path, "Implicit", NodeEnum)]
+  if implicit == nil ||
+    len(implicit.EnumMembers) != 2 ||
+    implicit.EnumMembers[0] != (EnumMember{Name: "First", Value: "0"}) ||
+    implicit.EnumMembers[1] != (EnumMember{Name: "Second", Value: "1"}) {
+    t.Fatalf("implicitly numbered enum did not pair its members: %v", implicit.EnumMembers)
+  }
+
+  // Two members carrying one value. The declared type folds them into a single
+  // constituent — a type is a set — so reading the list off the type reports A
+  // and C and drops B, silently, which is #732's defect from #732's instinct:
+  // taking a declaration fact from a type. The list is the declaration's.
+  dup := graph.Nodes[nodeID(path, "Dup", NodeEnum)]
+  if dup == nil {
+    t.Fatalf("missing Dup; nodes: %v", nodeIDSet(graph))
+  }
+  if names := memberNames(dup.EnumMembers); len(names) != 3 ||
+    names[0] != "A" || names[1] != "B" || names[2] != "C" {
+    t.Fatalf("a member sharing another's value was dropped: %v", names)
+  }
+  // And the value set is right to say `"x"` once: two members, two names, but
+  // the values they admit really are two.
+  if len(dup.Literals) != 2 {
+    t.Fatalf("the value set should hold each distinct value once: %v", dup.Literals)
+  }
+
+  // The line this fix holds: the members are facts on the enum, not nodes of
+  // their own. A node per member would index what grep already answers.
+  for id := range graph.Nodes {
+    if id == nodeID(path, "Colors.Red", NodeVariable) ||
+      id == nodeID(path, "Red", NodeVariable) {
+      t.Fatalf("an enum member became a node (%s); it is a fact on the enum", id)
+    }
+  }
+
+  // The negative twin: this rides on enums only. A class's fields are member
+  // nodes and its outline comes from those.
+  if cls := graph.Nodes[nodeID(path, "Cls", NodeClass)]; cls == nil ||
+    len(cls.EnumMembers) != 0 {
+    t.Fatalf("a class node carried enum members: %v", cls)
+  }
+}
+
+func memberNames(members []EnumMember) []string {
+  out := make([]string, 0, len(members))
+  for _, member := range members {
+    out = append(out, member.Name)
+  }
+  return out
+}

package/internal/graph/graph.go

@@ -58,6 +58,32 @@ type Node struct {
   // the declaration's combined modifier flags during the build pass and emitted
   // for projections that filter on visibility and shape.
   Modifiers []string
+  // Literals is the complete value set of a type alias or enum whose declared
+  // type the checker resolved to literals, each rendered in TypeScript source
+  // form ("a", 1, true, null). It is set only when every constituent is
+  // enumerable, so a present list is the whole type and never a sample of it;
+  // a union that mixes in `string`, a type parameter, or a computed enum member
+  // has no complete answer and gets none.
+  //
+  // It is a checker fact because nothing else is sound. The value set was read
+  // off the declaration's source text for a while, which made the answer a
+  // function of line wrapping rather than of the type: a union written one
+  // member per line reported the members that fit in the snippet, an enum
+  // written across lines reported nothing at all, and `type I = Kind | 'f'`
+  // reported `'f'` while the members reaching it through `Kind` vanished (#732).
+  // The checker has already resolved every one of them, indirection included.
+  Literals []string
+  // EnumMembers is what an enum declares, in checker order: the name a caller
+  // writes and the value it carries. Empty for every other kind.
+  //
+  // The enum's node was always here and had nothing in it. `literals` says what
+  // values the enum admits, which answers a serializer; the code says
+  // `Colors.Red`, so a caller that had already named the enum still opened the
+  // file to learn what to type (#738). The members are not nodes of their own —
+  // `Colors.Red` is a literal string a grep finds exactly, and minting a node
+  // per member would grow the graph and put leaves into tour flows to index
+  // what grep already does. This fills in the node that exists instead.
+  EnumMembers []EnumMember
   // 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.
@@ -68,6 +94,14 @@ type Node struct {
   ImplementationEnd  int
 }
 
+// EnumMember is one member of an enum: the name a caller writes and the value
+// it carries, in TypeScript source form. Value is empty when the checker could
+// not fold the member's initializer to a constant.
+type EnumMember struct {
+  Name  string
+  Value string
+}
+
 // EdgeKind classifies a relationship between two nodes.
 type EdgeKind string
 

package/internal/graph/literals.go

@@ -0,0 +1,175 @@
+package graph
+
+import (
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimchecker "github.com/microsoft/typescript-go/shim/checker"
+)
+
+// collectLiterals records the value set of every type alias and enum in file
+// whose declared type resolves to literals, so a consumer asking what values a
+// type admits is answered from the checker rather than from the declaration's
+// source text.
+//
+// It runs on the checker for the reason markExports does: the syntactic reading
+// is not the real answer. A union's members are only spelled out at the
+// declaration when nothing indirects — `type Indirect = Kind | 'f'` names one
+// literal and reaches five more through an alias, and only the checker has
+// resolved that. It has also already flattened nested unions, dropped
+// duplicates, and reduced subtypes, so the constituents it hands back are the
+// type's members exactly once each.
+//
+// Enums come here too, and they need it more. An enum's members are not nodes
+// of their own — the build pass records member nodes for classes and interfaces
+// only — so its node is the only place anything about them can ride. It carries
+// two facts, and they are not the same fact: the value set the enum admits,
+// deduped because a type is a set, and the members it declares, which is the
+// list a caller writes from and which nothing folds.
+func (g *Graph) collectLiterals(checker *shimchecker.Checker, file *shimast.SourceFile) {
+  if file.Statements == nil {
+    return
+  }
+  g.collectLiteralsIn(checker, file.FileName(), file.Statements.Nodes)
+}
+
+// collectLiteralsIn walks a statement list — a file's top level, or a namespace
+// body it recurses into — and records the value set of each type alias and enum
+// it holds. It mirrors collectStatements' descent so a `namespace X { type K =
+// … }` is resolved on the node the build pass keyed by its qualified name.
+func (g *Graph) collectLiteralsIn(checker *shimchecker.Checker, path string, statements []*shimast.Node) {
+  for _, statement := range statements {
+    switch statement.Kind {
+    case shimast.KindTypeAliasDeclaration:
+      g.putLiterals(checker, path, statement, NodeTypeAlias)
+    case shimast.KindEnumDeclaration:
+      g.putLiterals(checker, path, statement, NodeEnum)
+    case shimast.KindModuleDeclaration:
+      g.collectLiteralsIn(checker, path, moduleStatements(statement))
+    }
+  }
+}
+
+// putLiterals resolves the declared type of statement's symbol and records its
+// value set on the node the build pass recorded for it. A declaration the graph
+// does not hold a node for, or whose type has no complete literal answer, is
+// left alone rather than given a partial one.
+func (g *Graph) putLiterals(checker *shimchecker.Checker, path string, statement *shimast.Node, kind NodeKind) {
+  symbol := statement.Symbol()
+  if symbol == nil || symbol.Name == "" {
+    return
+  }
+  node, ok := g.Nodes[nodeID(path, qualifiedName(symbol), kind)]
+  if !ok {
+    return
+  }
+  declared := shimchecker.Checker_getDeclaredTypeOfSymbol(checker, symbol)
+  if declared == nil {
+    return
+  }
+  if values, ok := literalValues(declared); ok {
+    node.Literals = values
+  }
+  if kind == NodeEnum {
+    node.EnumMembers = enumMembers(checker, statement)
+  }
+}
+
+// enumMembers pairs each member an enum declares with the value it carries.
+//
+// The names are the half a caller writes. `literals` answers which values the
+// enum admits, the question a serializer asks, but the code says `Colors.Red`
+// and never `"red"` — so an enum whose node the graph already held still sent a
+// caller to the file to learn what to type (#738).
+//
+// The list comes from the declaration, not from the declared type's
+// constituents, and that is not a detail. A type is a set, so the checker folds
+// two members carrying one value into one constituent: `enum Dup { A = 'x', B =
+// 'x' }` resolves to a single type, and reading names off it reports `A` and
+// loses `B` — the same silent under-report as #732, out of the same instinct to
+// take a declaration fact from a type. The value set really is one value, which
+// is why `literals` is right to say `"x"` once; the member list is two members,
+// and only the declaration says so.
+//
+// Each member's value still comes from the checker, per member, so an implicit
+// `First` reports 0 with nothing reading the source. A member the checker
+// cannot fold to a constant keeps its name and drops its value, because the
+// name is the part this is for.
+func enumMembers(checker *shimchecker.Checker, statement *shimast.Node) []EnumMember {
+  declaration := statement.AsEnumDeclaration()
+  if declaration == nil || declaration.Members == nil {
+    return nil
+  }
+  out := make([]EnumMember, 0, len(declaration.Members.Nodes))
+  for _, node := range declaration.Members.Nodes {
+    symbol := node.Symbol()
+    if symbol == nil || symbol.Name == "" {
+      continue
+    }
+    member := EnumMember{Name: symbol.Name}
+    if t := shimchecker.Checker_getTypeOfSymbol(checker, symbol); t != nil {
+      if value, ok := literalValue(t); ok {
+        member.Value = value
+      }
+    }
+    out = append(out, member)
+  }
+  if len(out) == 0 {
+    return nil
+  }
+  return out
+}
+
+// literalValues renders every constituent of t in TypeScript source form,
+// reporting false unless all of them are enumerable.
+//
+// All-or-nothing is the contract. `type T = Kind | number` admits five literals
+// and every other number besides; answering with the five would describe a type
+// that does not exist, and the caller cannot tell that answer from a complete
+// one. So a type whose members cannot all be named yields no list, and its
+// signature carries the shape instead.
+func literalValues(t *shimchecker.Type) ([]string, bool) {
+  // Types() panics on anything that is not a union, an intersection, or a
+  // template literal, so the flag test is what makes the union branch safe. A
+  // single-literal alias (`type One = 'a'`) is not a union and is its own only
+  // constituent.
+  constituents := []*shimchecker.Type{t}
+  if t.Flags()&shimchecker.TypeFlagsUnion != 0 {
+    constituents = t.Types()
+  }
+  values := make([]string, 0, len(constituents))
+  for _, constituent := range constituents {
+    value, ok := literalValue(constituent)
+    if !ok {
+      return nil, false
+    }
+    values = append(values, value)
+  }
+  if len(values) == 0 {
+    return nil, false
+  }
+  return values, true
+}
+
+// literalValue renders one constituent in TypeScript source form, reporting
+// false when it names no single value a caller could write.
+func literalValue(t *shimchecker.Type) (string, bool) {
+  flags := t.Flags()
+  switch {
+  case flags&shimchecker.TypeFlagsNull != 0:
+    return "null", true
+  case flags&shimchecker.TypeFlagsUndefined != 0:
+    return "undefined", true
+  case flags&shimchecker.TypeFlagsLiteral != 0:
+    // TypeFlagsLiteral covers an enum member too: EnumLiteral is always paired
+    // with StringLiteral or NumberLiteral on a member, and with Union on the
+    // enum type itself, which the union branch above has already opened.
+    value := t.AsLiteralType().Value()
+    if value == nil {
+      // A computed enum member the checker could not fold to a constant. It has
+      // a value at runtime that nothing here can name, so the enum has no
+      // complete answer.
+      return "", false
+    }
+    return shimchecker.ValueToString(value), true
+  }
+  return "", false
+}

package/internal/graph/literals_are_absent_when_the_type_admits_more_than_it_can_name_test.go

@@ -0,0 +1,74 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsAreAbsentWhenTheTypeAdmitsMoreThanItCanName verifies the negative
+// twin of every literal case: a type whose members cannot all be named reports
+// none of them rather than the subset that can.
+//
+// This is what lets a present `literals` mean the whole type. `Widened` admits
+// four literals and every other string besides, and a caller cannot tell a
+// four-value answer for it from a four-value answer for a genuine four-member
+// union — so it must get no answer, and read the signature instead. Each fixture
+// here is one way a constituent stops being nameable: a primitive next to the
+// literals, an unresolved type parameter, a plain primitive alias, and a
+// computed enum member whose value the checker cannot fold to a constant.
+//
+//  1. Compile a fixture holding each non-enumerable shape.
+//  2. Build the graph.
+//  3. Assert none of them recorded a value set.
+func TestLiteralsAreAbsentWhenTheTypeAdmitsMoreThanItCanName(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `declare const compute: () => number;
+
+export type Narrow = 'a' | 'b' | 'c' | 'd';
+export type Widened = Narrow | string;
+export type Generic<T> = T | 'a';
+export type Primitive = string;
+
+export enum Computed {
+  A = 'a',
+  B = compute(),
+}
+`)
+
+  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()
+
+  // The control: the shapes below differ from this one by exactly the property
+  // that makes them unnameable, so an empty result there is the rule acting and
+  // not the pass failing to run on this fixture at all.
+  if got := literalsOf(t, graph, nodeID(path, "Narrow", NodeTypeAlias)); len(got) != 4 {
+    t.Fatalf("control union did not report its four members: got %v", got)
+  }
+
+  for _, testCase := range []struct {
+    name string
+    kind NodeKind
+    why  string
+  }{
+    {"Widened", NodeTypeAlias, "a union with `string` in it admits values no list can name"},
+    {"Generic", NodeTypeAlias, "an unresolved type parameter names no value"},
+    {"Primitive", NodeTypeAlias, "a primitive is not a value set"},
+    {"Computed", NodeEnum, "a computed enum member has a value nothing here can name"},
+  } {
+    if got := literalsOf(t, graph, nodeID(path, testCase.name, testCase.kind)); len(got) != 0 {
+      t.Fatalf("%s reported a partial value set %v: %s", testCase.name, got, testCase.why)
+    }
+  }
+}

package/internal/graph/literals_cover_enum_members_the_graph_has_no_nodes_for_test.go

@@ -0,0 +1,79 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsCoverEnumMembersTheGraphHasNoNodesFor verifies that an enum
+// reports its member values, string-valued, numeric, and implicitly numbered
+// alike, however the declaration is laid out.
+//
+// An enum needed this more than a union did (#732). Its members are not nodes —
+// the build pass records member nodes for classes and interfaces only — so
+// nothing else in a details result carries them, and the old source-text scrape
+// stopped at the line holding `{`, which is the first line of every enum written
+// the ordinary way. A multi-line enum therefore reported no members at all,
+// through `literals` or otherwise, and only a single-line one answered. The
+// implicit fixture pins that the values come from the checker rather than the
+// text: nothing in `Implicit`'s source spells out 0 and 1.
+//
+//  1. Compile a fixture with a multi-line string enum, a single-line one, and an
+//     enum whose members are implicitly numbered.
+//  2. Build the graph.
+//  3. Assert each reports its resolved member values, and that the enum still
+//     has no member nodes so `literals` is genuinely the only carrier.
+func TestLiteralsCoverEnumMembersTheGraphHasNoNodesFor(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export enum Wrapped {
+  A = 'a',
+  B = 'b',
+  C = 'c',
+}
+
+export enum Flat { A = 'a', B = 'b', C = 'c' }
+
+export enum Implicit {
+  First,
+  Second,
+}
+`)
+
+  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()
+
+  // The declaration whose members the old scrape could never reach.
+  wrapped := literalsOf(t, graph, nodeID(path, "Wrapped", NodeEnum))
+  if want := []string{`"a"`, `"b"`, `"c"`}; !slices.Equal(wrapped, want) {
+    t.Fatalf("multi-line enum under-reported its members: got %v, want %v", wrapped, want)
+  }
+  // Layout is not the fact; the single-line twin must agree exactly.
+  flat := literalsOf(t, graph, nodeID(path, "Flat", NodeEnum))
+  if !slices.Equal(flat, wrapped) {
+    t.Fatalf("enum layout changed the value set: wrapped %v, flat %v", wrapped, flat)
+  }
+  // Implicitly numbered members: the values exist only in the checker, never in
+  // the source text, so a scrape of any kind cannot produce this list.
+  implicit := literalsOf(t, graph, nodeID(path, "Implicit", NodeEnum))
+  if want := []string{"0", "1"}; !slices.Equal(implicit, want) {
+    t.Fatalf("implicitly numbered enum did not report its resolved values: got %v, want %v", implicit, want)
+  }
+  // The premise: no member node exists to carry these instead, so dropping
+  // `literals` for an enum would take its members out of the graph entirely.
+  if node, ok := graph.Nodes[nodeID(path, "Wrapped.A", NodeMethod)]; ok {
+    t.Fatalf("enum member unexpectedly modeled as a node (%v); literals may no longer be the only carrier", node.ID)
+  }
+}

package/internal/graph/literals_do_not_depend_on_declaration_line_wrapping_test.go

@@ -0,0 +1,84 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsDoNotDependOnDeclarationLineWrapping verifies that collectLiterals
+// answers with the union's members whatever the declaration's layout: the same
+// eight-member type written one member per line and written on one line both
+// report all eight.
+//
+// This is the #732 regression. The value set used to be scraped out of the
+// declaration's first four lines of source text and cut to six, so completeness
+// was a function of line wrapping and of member count rather than of the type:
+// the wrapped form reported the three members that fit in the snippet, and the
+// flat form reported six of eight. Both cuts were silent. Eight members is the
+// boundary that pins both at once — it is past the old six-member cap, so a
+// reintroduced cap fails here on the flat twin instead of hiding behind a small
+// fixture.
+//
+//  1. Compile a fixture with a wrapped union and a flat union of the same eight
+//     string literals.
+//  2. Build the graph.
+//  3. Assert both nodes carry all eight values, in source form, and that the two
+//     lists are identical.
+func TestLiteralsDoNotDependOnDeclarationLineWrapping(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export type Wrapped =
+  | 'a' // a trailing comment the old snippet scrape also had to survive
+  | 'b'
+  | 'c'
+  | 'd'
+  | 'e'
+  | 'f'
+  | 'g'
+  | 'h';
+
+export type Flat = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
+`)
+
+  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()
+
+  want := []string{`"a"`, `"b"`, `"c"`, `"d"`, `"e"`, `"f"`, `"g"`, `"h"`}
+  wrapped := literalsOf(t, graph, nodeID(path, "Wrapped", NodeTypeAlias))
+  flat := literalsOf(t, graph, nodeID(path, "Flat", NodeTypeAlias))
+
+  if !slices.Equal(wrapped, want) {
+    t.Fatalf("wrapped union under-reported its members: got %v, want %v", wrapped, want)
+  }
+  if !slices.Equal(flat, want) {
+    t.Fatalf("flat union under-reported its members: got %v, want %v", flat, want)
+  }
+  // The point of the fix stated directly: layout is not allowed to change the
+  // answer for one and the same type.
+  if !slices.Equal(wrapped, flat) {
+    t.Fatalf("line wrapping changed the value set: wrapped %v, flat %v", wrapped, flat)
+  }
+}
+
+// literalsOf returns the recorded value set of the node id names, failing the
+// test when the graph holds no such node.
+func literalsOf(t *testing.T, graph *Graph, id string) []string {
+  t.Helper()
+  node, ok := graph.Nodes[id]
+  if !ok {
+    t.Fatalf("graph has no node %q; nodes: %v", id, nodeIDSet(graph))
+  }
+  return node.Literals
+}

package/internal/graph/literals_render_every_value_in_typescript_source_form_test.go

@@ -0,0 +1,77 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsRenderEveryValueInTypescriptSourceForm verifies that each kind of
+// literal a union can hold reaches the wire as the way it is written, and that
+// the rendering is the checker's own rather than this package's.
+//
+// Source form is what makes the list readable as the type: it is the only
+// rendering that tells `1` from `"1"` and `true` from `"true"`, which bare
+// contents cannot, and the old string-only scrape could not report a numeric
+// union at all. The escaping fixture is why the checker's `ValueToString` is
+// used instead of a local formatter — a quote inside a value has to come back
+// escaped the way TypeScript escapes it, and Go's own quoting is not that.
+//
+//  1. Compile a fixture with a string, numeric, boolean, bigint, nullable, and
+//     escaped-string union.
+//  2. Build the graph.
+//  3. Assert each value set renders in TypeScript source form.
+func TestLiteralsRenderEveryValueInTypescriptSourceForm(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export type Strings = 'a' | 'b';
+export type Numbers = 1 | 2 | 3;
+export type Bools = true | false;
+export type Bigints = 1n | 2n;
+export type Nullable = 'a' | null;
+export type Optional = 'a' | undefined;
+export type Escaped = 'he said "hi"' | "it's" | 'tab\there';
+export type Mixed = 'a' | 1 | true;
+`)
+
+  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()
+
+  for _, testCase := range []struct {
+    name string
+    want []string
+  }{
+    // A string keeps its quotes, so the list reads as the type does.
+    {"Strings", []string{`"a"`, `"b"`}},
+    // Numbers were absent entirely under the string-only scrape.
+    {"Numbers", []string{"1", "2", "3"}},
+    {"Bools", []string{"false", "true"}},
+    {"Bigints", []string{"1n", "2n"}},
+    // A unit type that is not a literal still names one value a caller writes,
+    // so the set stays complete rather than dropping to nothing.
+    {"Nullable", []string{"null", `"a"`}},
+    {"Optional", []string{"undefined", `"a"`}},
+    // The checker's escaping, not Go's: an inner double quote is backslashed,
+    // an apostrophe is not re-quoted, and a tab stays an escape rather than a
+    // raw control character.
+    {"Escaped", []string{`"he said \"hi\""`, `"it's"`, `"tab\there"`}},
+    // Kinds mix in one union, and source form is what keeps them apart.
+    {"Mixed", []string{`"a"`, "1", "true"}},
+  } {
+    got := literalsOf(t, graph, nodeID(path, testCase.name, NodeTypeAlias))
+    if !slices.Equal(got, testCase.want) {
+      t.Fatalf("%s rendered %v, want %v", testCase.name, got, testCase.want)
+    }
+  }
+}