ttsc 0.19.2 → 0.20.0

package/internal/graph/line_model.go

@@ -0,0 +1,122 @@
+package graph
+
+import (
+  "unicode/utf8"
+
+  shimcore "github.com/microsoft/typescript-go/shim/core"
+)
+
+// ECMALineStarts returns the byte offset of each logical source line. The
+// compiler is the authority for which bytes end a line, so graph evidence and
+// graph-backed LSP locations cannot drift from its LF, CRLF, CR, LS, and PS
+// coordinates.
+func ECMALineStarts(text string) []int {
+  compilerStarts := shimcore.ComputeECMALineStarts(text)
+  starts := make([]int, len(compilerStarts))
+  for i, start := range compilerStarts {
+    starts[i] = int(start)
+  }
+  return starts
+}
+
+// LineEnd returns the byte offset immediately before line's terminator, or the
+// end of text for its final logical line. starts must come from ECMALineStarts
+// for the same text.
+func LineEnd(text string, starts []int, line int) int {
+  if line < 0 || line >= len(starts) {
+    return len(text)
+  }
+  if line+1 == len(starts) {
+    return len(text)
+  }
+  for i := starts[line]; i < starts[line+1]; {
+    if lineTerminatorWidth(text, i) > 0 {
+      return i
+    }
+    _, size := utf8.DecodeRuneInString(text[i:])
+    if size == 0 {
+      return len(text)
+    }
+    i += size
+  }
+  return starts[line+1]
+}
+
+// FirstCodeOffset advances over leading whitespace and comments so a graph
+// span begins at its declaration rather than its leading trivia.
+func FirstCodeOffset(text string, pos int) int {
+  if pos < 0 {
+    return 0
+  }
+  for pos < len(text) {
+    width := sourceWhitespaceWidth(text, pos)
+    switch {
+    case width > 0:
+      pos += width
+    case text[pos] == '/' && pos+1 < len(text) && text[pos+1] == '/':
+      pos = LineCommentEnd(text, pos)
+    case text[pos] == '/' && pos+1 < len(text) && text[pos+1] == '*':
+      pos += 2
+      for pos+1 < len(text) && !(text[pos] == '*' && text[pos+1] == '/') {
+        _, size := utf8.DecodeRuneInString(text[pos:])
+        if size == 0 {
+          return len(text)
+        }
+        pos += size
+      }
+      if pos+1 < len(text) {
+        pos += 2
+      } else {
+        return len(text)
+      }
+    default:
+      return pos
+    }
+  }
+  return len(text)
+}
+
+// LineCommentEnd returns the byte offset immediately after a // comment and
+// its line terminator, or len(text) when the comment reaches EOF.
+func LineCommentEnd(text string, start int) int {
+  for i := start + 2; i < len(text); {
+    if width := lineTerminatorWidth(text, i); width > 0 {
+      return i + width
+    }
+    _, size := utf8.DecodeRuneInString(text[i:])
+    if size == 0 {
+      return len(text)
+    }
+    i += size
+  }
+  return len(text)
+}
+
+func sourceWhitespaceWidth(text string, pos int) int {
+  switch text[pos] {
+  case ' ', '\t', '\r', '\n', '\v', '\f':
+    return 1
+  }
+  r, size := utf8.DecodeRuneInString(text[pos:])
+  if r == '\u2028' || r == '\u2029' {
+    return size
+  }
+  return 0
+}
+
+func lineTerminatorWidth(text string, pos int) int {
+  switch text[pos] {
+  case '\r':
+    if pos+1 < len(text) && text[pos+1] == '\n' {
+      return 2
+    }
+    return 1
+  case '\n':
+    return 1
+  }
+  r, size := utf8.DecodeRuneInString(text[pos:])
+  if r == '\u2028' || r == '\u2029' {
+    return size
+  }
+  return 0
+}

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)
+    }
+  }
+}

package/internal/graph/literals_resolve_through_alias_indirection_test.go

@@ -0,0 +1,64 @@
+package graph
+
+import (
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestLiteralsResolveThroughAliasIndirection verifies that a union assembled out
+// of other unions reports every member it admits, including the ones no token of
+// its own declaration names.
+//
+// This is the half of #732 that was not truncation but a wrong answer of the
+// right shape. Reading `type Wide = Narrow | 'd'` off the source text finds one
+// quoted token and reports `'d'`, a complete-looking three-member type reduced
+// to one, with nothing marking the loss. Only the checker has followed Narrow.
+// The nested case (`Wider = Wide | 'e'`) pins that the resolution is not one hop
+// deep, and the checker also flattens and dedups, so `Duplicated` must report
+// `'a'` once rather than twice.
+//
+//  1. Compile a fixture whose aliases build on each other, one of them
+//     re-listing a member an aliased union already has.
+//  2. Build the graph.
+//  3. Assert each alias reports the full set it admits, deduplicated.
+func TestLiteralsResolveThroughAliasIndirection(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export type Narrow = 'a' | 'b' | 'c';
+export type Wide = Narrow | 'd';
+export type Wider = Wide | 'e';
+export type Duplicated = Narrow | 'a';
+`)
+
+  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()
+
+  // One hop: the three members reaching Wide through Narrow are Wide's too.
+  wide := literalsOf(t, graph, nodeID(path, "Wide", NodeTypeAlias))
+  if want := []string{`"a"`, `"b"`, `"c"`, `"d"`}; !slices.Equal(wide, want) {
+    t.Fatalf("alias indirection lost members: got %v, want %v", wide, want)
+  }
+  // Two hops: resolution is the type's, so depth costs nothing.
+  wider := literalsOf(t, graph, nodeID(path, "Wider", NodeTypeAlias))
+  if want := []string{`"a"`, `"b"`, `"c"`, `"d"`, `"e"`}; !slices.Equal(wider, want) {
+    t.Fatalf("nested alias indirection lost members: got %v, want %v", wider, want)
+  }
+  // A member named twice is one member; the checker has already deduped, so the
+  // list must not report `"a"` once per mention.
+  duplicated := literalsOf(t, graph, nodeID(path, "Duplicated", NodeTypeAlias))
+  if want := []string{`"a"`, `"b"`, `"c"`}; !slices.Equal(duplicated, want) {
+    t.Fatalf("a member named twice was reported twice: got %v, want %v", duplicated, want)
+  }
+}