ttsc 0.33.1 → 0.34.0

package/internal/graph/function_locals_do_not_collide_test.go

@@ -64,17 +64,17 @@ export function outerB(): number {
   path := sourceFile(t, prog, "main.ts").FileName()
 
   for _, owner := range []string{"outerA", "outerB"} {
-    localID := nodeID(path, owner+".inner", NodeFunction)
+    localID := nodeID(string(path), owner+".inner", NodeFunction)
     if local := graph.Nodes[localID]; local == nil || local.Name != owner+".inner" {
       t.Fatalf("missing scoped local %s.inner; nodes: %v", owner, nodeIDSet(graph))
     }
-    if !hasEdge(graph, nodeID(path, owner, NodeFunction), localID, EdgeValueCall) {
+    if !hasEdge(graph, nodeID(string(path), owner, NodeFunction), localID, EdgeValueCall) {
       t.Fatalf("missing %s -> %s.inner call; edges: %v", owner, owner, graph.Edges)
     }
   }
 
   // No unqualified function-local node is minted...
-  if _, ok := graph.Nodes[nodeID(path, "inner", NodeFunction)]; ok {
+  if _, ok := graph.Nodes[nodeID(string(path), "inner", NodeFunction)]; ok {
     t.Fatalf("a function-local 'inner' was minted as a node (would collide across scopes)")
   }
   // ...so no edge points at a phantom shared 'inner'.

package/internal/graph/heritage_edges_cover_implements_and_interface_extends_test.go

@@ -58,11 +58,11 @@ export class Unrelated {
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  base := nodeID(path, "Base", NodeInterface)
-  derived := nodeID(path, "Derived", NodeInterface)
-  impl := nodeID(path, "Impl", NodeClass)
-  unrelated := nodeID(path, "Unrelated", NodeClass)
-  greet := nodeID(path, "Unrelated.greet", NodeMethod)
+  base := nodeID(string(path), "Base", NodeInterface)
+  derived := nodeID(string(path), "Derived", NodeInterface)
+  impl := nodeID(string(path), "Impl", NodeClass)
+  unrelated := nodeID(string(path), "Unrelated", NodeClass)
+  greet := nodeID(string(path), "Unrelated.greet", NodeMethod)
 
   // Interface `extends`: Derived inherits Base.
   if !hasEdge(graph, derived, base, EdgeHeritage) {

package/internal/graph/heritage_edges_keep_extends_and_implements_to_same_base_test.go

@@ -48,8 +48,8 @@ export class Derived extends Base implements Base {}
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  derived := nodeID(path, "Derived", NodeClass)
-  base := nodeID(path, "Base", NodeClass)
+  derived := nodeID(string(path), "Derived", NodeClass)
+  base := nodeID(string(path), "Base", NodeClass)
 
   wireKinds := map[string]bool{}
   for _, edge := range graph.Edges {

package/internal/graph/heritage_edges_record_extends_versus_implements_origin_test.go

@@ -47,9 +47,9 @@ export class Sub extends Sup implements Iface {}
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  sub := nodeID(path, "Sub", NodeClass)
-  sup := nodeID(path, "Sup", NodeClass)
-  iface := nodeID(path, "Iface", NodeInterface)
+  sub := nodeID(string(path), "Sub", NodeClass)
+  sup := nodeID(string(path), "Sup", NodeClass)
+  iface := nodeID(string(path), "Iface", NodeInterface)
 
   if got := edgeOrigin(graph, sub, sup, EdgeHeritage); got != "extends" {
     t.Fatalf("Sub -> Sup: want heritage Origin \"extends\", got %q; edges: %v", got, graph.Edges)

package/internal/graph/heritage_edges_traverse_barrels_and_stop_at_external_leaves_test.go

@@ -63,11 +63,11 @@ export class SubExt extends Ext {}
   implPath := sourceFile(t, prog, "impl.ts").FileName()
 
   // Barrel traversal: the base resolved to the sibling source, not the index.
-  base := nodeID(implPath, "Base", NodeClass)
+  base := nodeID(string(implPath), "Base", NodeClass)
   if node, ok := graph.Nodes[base]; !ok || node.External {
     t.Fatalf("Base node missing or misclassified external (barrel not traversed): %+v", node)
   }
-  sub := nodeID(mainPath, "Sub", NodeClass)
+  sub := nodeID(string(mainPath), "Sub", NodeClass)
   if !hasEdge(graph, sub, base, EdgeHeritage) {
     t.Fatalf("missing heritage edge Sub -> Base@impl.ts; edges: %v", graph.Edges)
   }
@@ -81,7 +81,7 @@ export class SubExt extends Ext {}
   if !ext.External || !strings.Contains(ext.File, "/node_modules/") {
     t.Fatalf("Ext should be an external node_modules leaf: %+v", ext)
   }
-  subExt := nodeID(mainPath, "SubExt", NodeClass)
+  subExt := nodeID(string(mainPath), "SubExt", NodeClass)
   if !hasEdge(graph, subExt, ext.ID, EdgeHeritage) {
     t.Fatalf("missing heritage edge SubExt -> Ext (external); edges: %v", graph.Edges)
   }

package/internal/graph/literals.go

@@ -28,7 +28,7 @@ func (g *Graph) collectLiterals(checker *shimchecker.Checker, file *shimast.Sour
   if file.Statements == nil {
     return
   }
-  g.collectLiteralsIn(checker, file.FileName(), file.Statements.Nodes)
+  g.collectLiteralsIn(checker, string(file.FileName()), file.Statements.Nodes)
 }
 
 // collectLiteralsIn walks a statement list — a file's top level, or a namespace
@@ -54,7 +54,7 @@ func (g *Graph) collectLiteralsIn(checker *shimchecker.Checker, path string, sta
 // 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 == "" {
+  if symbol == nil || shimast.SymbolNameOf(symbol) == "" {
     return
   }
   node, ok := g.Nodes[nodeID(path, qualifiedName(symbol), kind)]
@@ -103,7 +103,7 @@ func enumMembers(checker *shimchecker.Checker, statement *shimast.Node) []EnumMe
     if symbol == nil {
       continue
     }
-    member := EnumMember{Name: symbol.Name}
+    member := EnumMember{Name: shimast.SymbolNameOf(symbol)}
     if t := shimchecker.Checker_getTypeOfSymbol(checker, symbol); t != nil {
       if value, ok := literalValue(t); ok {
         member.Value = value

package/internal/graph/literals_are_absent_when_the_type_admits_more_than_it_can_name_test.go

@@ -58,7 +58,7 @@ export enum Computed {
 
   // A nonempty control detects omission of the entire literal pass; this count
   // does not independently check the control's four values.
-  if got := literalsOf(t, graph, nodeID(path, "Narrow", NodeTypeAlias)); len(got) != 4 {
+  if got := literalsOf(t, graph, nodeID(string(path), "Narrow", NodeTypeAlias)); len(got) != 4 {
     t.Fatalf("control union did not report its four members: got %v", got)
   }
 
@@ -72,7 +72,7 @@ export enum Computed {
     {"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 {
+    if got := literalsOf(t, graph, nodeID(string(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

@@ -54,24 +54,24 @@ export enum Implicit {
   path := sourceFile(t, prog, "main.ts").FileName()
 
   // Multiline declaration with independent literal expected values.
-  wrapped := literalsOf(t, graph, nodeID(path, "Wrapped", NodeEnum))
+  wrapped := literalsOf(t, graph, nodeID(string(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))
+  flat := literalsOf(t, graph, nodeID(string(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 have literal semantic expectations; no numeric
   // initializers are written, but this does not certify the acquisition method.
-  implicit := literalsOf(t, graph, nodeID(path, "Implicit", NodeEnum))
+  implicit := literalsOf(t, graph, nodeID(string(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)
   }
   // Reject this particular method-node identity; other enum detail fields and
   // member-node spellings are not examined.
-  if node, ok := graph.Nodes[nodeID(path, "Wrapped.A", NodeMethod)]; ok {
+  if node, ok := graph.Nodes[nodeID(string(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

@@ -57,8 +57,8 @@ export type Flat = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h';
   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))
+  wrapped := literalsOf(t, graph, nodeID(string(path), "Wrapped", NodeTypeAlias))
+  flat := literalsOf(t, graph, nodeID(string(path), "Flat", NodeTypeAlias))
 
   if !slices.Equal(wrapped, want) {
     t.Fatalf("wrapped union under-reported its members: got %v, want %v", wrapped, want)

package/internal/graph/literals_render_every_value_in_typescript_source_form_test.go

@@ -69,7 +69,7 @@ export type Mixed = 'a' | 1 | true;
     // 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))
+    got := literalsOf(t, graph, nodeID(string(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

@@ -46,18 +46,18 @@ export type Duplicated = Narrow | 'a';
   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))
+  wide := literalsOf(t, graph, nodeID(string(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 authored hops; this result check does not measure resolution cost.
-  wider := literalsOf(t, graph, nodeID(path, "Wider", NodeTypeAlias))
+  wider := literalsOf(t, graph, nodeID(string(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))
+  duplicated := literalsOf(t, graph, nodeID(string(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)
   }

package/internal/graph/member_relation_edges_follow_checker_validity_test.go

@@ -71,11 +71,11 @@ export class Derived extends Base {
     to     string
     origin string
   }{
-    {nodeID(path, "Implementation.run", NodeMethod), nodeID(path, "Contract.run", NodeMethod), "implements"},
-    {nodeID(path, "Implementation.name", NodeMethod), nodeID(path, "Contract.name", NodeVariable), "implements"},
-    {nodeID(path, "Implementation.callback", NodeMethod), nodeID(path, "Contract.callback", NodeVariable), "implements"},
-    {nodeID(path, "Derived.act", NodeMethod), nodeID(path, "Base.act", NodeMethod), "overrides"},
-    {nodeID(path, "Derived.property", NodeVariable), nodeID(path, "Base.property", NodeVariable), "overrides"},
+    {nodeID(string(path), "Implementation.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod), "implements"},
+    {nodeID(string(path), "Implementation.name", NodeMethod), nodeID(string(path), "Contract.name", NodeVariable), "implements"},
+    {nodeID(string(path), "Implementation.callback", NodeMethod), nodeID(string(path), "Contract.callback", NodeVariable), "implements"},
+    {nodeID(string(path), "Derived.act", NodeMethod), nodeID(string(path), "Base.act", NodeMethod), "overrides"},
+    {nodeID(string(path), "Derived.property", NodeVariable), nodeID(string(path), "Base.property", NodeVariable), "overrides"},
   }
   for _, assertion := range assertions {
     if got := edgeOrigin(built, assertion.from, assertion.to, EdgeMemberRelation); got != assertion.origin {
@@ -83,8 +83,8 @@ export class Derived extends Base {
     }
   }
 
-  derivedConstructor := nodeID(path, "Derived.__constructor", NodeMethod)
-  baseConstructor := nodeID(path, "Base.__constructor", NodeMethod)
+  derivedConstructor := nodeID(string(path), "Derived.__constructor", NodeMethod)
+  baseConstructor := nodeID(string(path), "Base.__constructor", NodeMethod)
   if built.Nodes[derivedConstructor] == nil || built.Nodes[baseConstructor] == nil {
     t.Fatalf("missing fixture constructor nodes; nodes: %v", nodeIDSet(built))
   }

package/internal/graph/member_relation_edges_preserve_checker_boundaries_test.go

@@ -149,8 +149,8 @@ export class ProtectedPretender implements ProtectedBase {
   built := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
   for _, id := range []string{
-    nodeID(path, "MixedFlagDerived.item", NodeMethod),
-    nodeID(path, "MixedFlagBase.item", NodeVariable),
+    nodeID(string(path), "MixedFlagDerived.item", NodeMethod),
+    nodeID(string(path), "MixedFlagBase.item", NodeVariable),
   } {
     if _, ok := built.Nodes[id]; !ok {
       t.Fatalf("mixed-symbol boundary node %s is missing; nodes: %v", id, built.Nodes)
@@ -161,17 +161,17 @@ export class ProtectedPretender implements ProtectedBase {
     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"},
+    {nodeID(string(path), "StringGeneric.map", NodeMethod), nodeID(string(path), "Generic.map", NodeMethod), "implements"},
+    {nodeID(string(path), "StringGeneric.required", NodeVariable), nodeID(string(path), "Generic.required", NodeVariable), "implements"},
+    {nodeID(string(path), "WrongGeneric.required", NodeVariable), nodeID(string(path), "Generic.required", NodeVariable), "implements"},
+    {nodeID(string(path), "ParserImpl.parse", NodeMethod), nodeID(string(path), "Parser.parse", NodeMethod), "implements"},
+    {nodeID(string(path), "RequiredGood.value", NodeVariable), nodeID(string(path), "OptionalContract.value", NodeVariable), "implements"},
+    {nodeID(string(path), "PropertyDerived.run", NodeVariable), nodeID(string(path), "MethodBase.run", NodeMethod), "overrides"},
+    {nodeID(string(path), "AbstractPropertyDerived.label", NodeVariable), nodeID(string(path), "AbstractAccessorBase.label", NodeMethod), "overrides"},
+    {nodeID(string(path), "SplitDerived.alpha", NodeMethod), nodeID(string(path), "SplitBase.alpha", NodeMethod), "overrides"},
+    {nodeID(string(path), "SplitDerived.beta", NodeMethod), nodeID(string(path), "SplitBase.beta", NodeMethod), "overrides"},
+    {nodeID(string(path), "MergedDerived.augment", NodeMethod), nodeID(string(path), "MergedBase.augment", NodeMethod), "overrides"},
+    {nodeID(string(path), "ProtectedGood.token", NodeVariable), nodeID(string(path), "ProtectedBase.token", NodeVariable), "overrides"},
   }
   for _, pair := range expected {
     if got := edgeOrigin(built, pair.from, pair.to, EdgeMemberRelation); got != pair.origin {
@@ -183,12 +183,12 @@ export class ProtectedPretender implements ProtectedBase {
     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)},
+    {nodeID(string(path), "WrongGeneric.map", NodeMethod), nodeID(string(path), "Generic.map", NodeMethod)},
+    {nodeID(string(path), "OptionalWrong.value", NodeVariable), nodeID(string(path), "RequiredContract.value", NodeVariable)},
+    {nodeID(string(path), "MethodWrong.run", NodeMethod), nodeID(string(path), "PropertyBase.run", NodeVariable)},
+    {nodeID(string(path), "ConcretePropertyWrong.label", NodeVariable), nodeID(string(path), "ConcreteAccessorBase.label", NodeMethod)},
+    {nodeID(string(path), "MixedFlagDerived.item", NodeMethod), nodeID(string(path), "MixedFlagBase.item", NodeVariable)},
+    {nodeID(string(path), "ProtectedPretender.token", NodeVariable), nodeID(string(path), "ProtectedBase.token", NodeVariable)},
   }
   for _, pair := range rejected {
     if built.Nodes[pair.from] == nil || built.Nodes[pair.to] == nil {

package/internal/graph/member_relation_edges_reject_checker_invalid_pairs_test.go

@@ -84,12 +84,12 @@ export class InvalidDerived extends Base {
     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)},
+    {nodeID(string(path), "WrongKind.value", NodeMethod), nodeID(string(path), "Contract.value", NodeVariable)},
+    {nodeID(string(path), "WrongKind.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod)},
+    {nodeID(string(path), "StaticOnly.value", NodeVariable), nodeID(string(path), "Contract.value", NodeVariable)},
+    {nodeID(string(path), "StaticOnly.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod)},
+    {nodeID(string(path), "InvalidDerived.value", NodeMethod), nodeID(string(path), "Base.value", NodeVariable)},
+    {nodeID(string(path), "InvalidDerived.run", NodeMethod), nodeID(string(path), "Base.run", NodeMethod)},
   }
   for _, pair := range absent {
     if built.Nodes[pair.from] == nil || built.Nodes[pair.to] == nil {
@@ -104,9 +104,9 @@ export class InvalidDerived extends Base {
     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)},
+    {nodeID(string(path), "WrongKind.kept", NodeVariable), nodeID(string(path), "Contract.kept", NodeVariable)},
+    {nodeID(string(path), "Valid.value", NodeVariable), nodeID(string(path), "Contract.value", NodeVariable)},
+    {nodeID(string(path), "Valid.run", NodeMethod), nodeID(string(path), "Contract.run", NodeMethod)},
   }
   for _, pair := range valid {
     if got := edgeOrigin(built, pair.from, pair.to, EdgeMemberRelation); got != "implements" {
@@ -115,8 +115,8 @@ export class InvalidDerived extends Base {
   }
   if got := edgeOrigin(
     built,
-    nodeID(path, "InvalidDerived.kept", NodeVariable),
-    nodeID(path, "Base.kept", NodeVariable),
+    nodeID(string(path), "InvalidDerived.kept", NodeVariable),
+    nodeID(string(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/namespace_dotted_form_qualifies_deeply_test.go

@@ -57,8 +57,8 @@ export function caller(): void {
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  deep := nodeID(path, "A.B.C.deep", NodeFunction)
-  caller := nodeID(path, "caller", NodeFunction)
+  deep := nodeID(string(path), "A.B.C.deep", NodeFunction)
+  caller := nodeID(string(path), "caller", NodeFunction)
 
   if _, ok := graph.Nodes[deep]; !ok {
     t.Fatalf("missing deeply-namespaced node %q; nodes: %v", deep, graph.Nodes)

package/internal/graph/namespace_members_become_qualified_nodes_and_edges_test.go

@@ -77,13 +77,13 @@ export type WorkerRef = Service.Worker;
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  serviceHelper := nodeID(path, "Service.helper", NodeFunction)
-  serviceRun := nodeID(path, "Service.run", NodeFunction)
-  serviceWorker := nodeID(path, "Service.Worker", NodeClass)
-  workerProcess := nodeID(path, "Service.Worker.process", NodeMethod)
-  bootstrap := nodeID(path, "bootstrap", NodeFunction)
-  workerRef := nodeID(path, "WorkerRef", NodeTypeAlias)
-  payload := nodeID(path, "Payload", NodeInterface)
+  serviceHelper := nodeID(string(path), "Service.helper", NodeFunction)
+  serviceRun := nodeID(string(path), "Service.run", NodeFunction)
+  serviceWorker := nodeID(string(path), "Service.Worker", NodeClass)
+  workerProcess := nodeID(string(path), "Service.Worker.process", NodeMethod)
+  bootstrap := nodeID(string(path), "bootstrap", NodeFunction)
+  workerRef := nodeID(string(path), "WorkerRef", NodeTypeAlias)
+  payload := nodeID(string(path), "Payload", NodeInterface)
 
   // The namespaced declarations are nodes in their own right.
   for _, id := range []string{serviceHelper, serviceRun, serviceWorker, workerProcess} {

package/internal/graph/namespace_private_declarations_keep_lexical_identity_test.go

@@ -58,28 +58,28 @@ export const c = hidden();
       "hidden": NodeFunction, "Local": NodeClass, "Local.method": NodeMethod,
       "Shape": NodeInterface, "Shape.value": NodeVariable, "Alias": NodeTypeAlias, "local": NodeVariable,
     } {
-      if node := g.Nodes[nodeID(file, prefix+"."+name, kind)]; node == nil || node.Name != prefix+"."+name || node.End <= node.Pos {
+      if node := g.Nodes[nodeID(string(file), prefix+"."+name, kind)]; node == nil || node.Name != prefix+"."+name || node.End <= node.Pos {
         t.Errorf("missing lexical declaration %s.%s", prefix, name)
       }
     }
   }
   for _, name := range []string{"A.hidden", "B.hidden", "hidden", "A.Deep.hidden", "A.factory.hidden"} {
-    id := nodeID(file, name, NodeFunction)
+    id := nodeID(string(file), name, NodeFunction)
     if g.Nodes[id] == nil {
       t.Errorf("missing %s", name)
     }
-    if got := hasEdge(g, id, nodeID(file, "target", NodeFunction), EdgeValueCall); got != (name == "B.hidden") {
+    if got := hasEdge(g, id, nodeID(string(file), "target", NodeFunction), EdgeValueCall); got != (name == "B.hidden") {
       t.Errorf("%s calls target = %t, want %t", name, got, name == "B.hidden")
     }
   }
   for caller, target := range map[string]string{"A.a": "A.hidden", "B.b": "B.hidden", "c": "hidden", "A.Deep.d": "A.Deep.hidden"} {
     for _, candidate := range []string{"A.hidden", "B.hidden", "hidden", "A.Deep.hidden", "A.factory.hidden"} {
-      if got := hasEdge(g, nodeID(file, caller, NodeVariable), nodeID(file, candidate, NodeFunction), EdgeValueCall); got != (candidate == target) {
+      if got := hasEdge(g, nodeID(string(file), caller, NodeVariable), nodeID(string(file), candidate, NodeFunction), EdgeValueCall); got != (candidate == target) {
         t.Errorf("%s -> %s = %t, want %t", caller, candidate, got, candidate == target)
       }
     }
   }
-  if !hasEdge(g, nodeID(file, "A.factory", NodeFunction), nodeID(file, "A.factory.hidden", NodeFunction), EdgeValueCall) {
+  if !hasEdge(g, nodeID(string(file), "A.factory", NodeFunction), nodeID(string(file), "A.factory.hidden", NodeFunction), EdgeValueCall) {
     t.Error("factory lost its own hidden closure")
   }
 }

package/internal/graph/nodes_are_marked_exported_through_the_export_table_test.go

@@ -42,8 +42,8 @@ export { Service };
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  service := graph.Nodes[nodeID(path, "Service", NodeClass)]
-  internal := graph.Nodes[nodeID(path, "Internal", NodeClass)]
+  service := graph.Nodes[nodeID(string(path), "Service", NodeClass)]
+  internal := graph.Nodes[nodeID(string(path), "Internal", NodeClass)]
   if service == nil || internal == nil {
     t.Fatalf("Build did not record both classes; have %v", nodeIDSet(graph))
   }

package/internal/graph/object_literal_declarations_resolve_calls_test.go

@@ -84,8 +84,8 @@ export namespace Names {
   }
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
-  caller := nodeID(path, "caller", NodeFunction)
-  helper := nodeID(path, "helper", NodeFunction)
+  caller := nodeID(string(path), "caller", NodeFunction)
+  helper := nodeID(string(path), "helper", NodeFunction)
   for _, item := range []struct {
     name     string
     kind     NodeKind
@@ -109,7 +109,7 @@ export namespace Names {
     {"api.computed", NodeMethod, EdgeValueCall},
     {"api.value", NodeMethod, EdgeValueAccess},
   } {
-    id := nodeID(path, item.name, item.kind)
+    id := nodeID(string(path), item.name, item.kind)
     node := graph.Nodes[id]
     if node == nil || node.Pos <= 0 || node.End <= node.Pos {
       t.Errorf("missing member/span %s: %+v", item.name, node)
@@ -122,12 +122,12 @@ export namespace Names {
       t.Errorf("missing member-to-helper relation from %s", item.name)
     }
   }
-  if !hasEdge(graph, nodeID(path, "control", NodeFunction), nodeID(path, "Control.run", NodeMethod), EdgeValueCall) {
+  if !hasEdge(graph, nodeID(string(path), "control", NodeFunction), nodeID(string(path), "Control.run", NodeMethod), EdgeValueCall) {
     t.Error("ordinary class method call was lost")
   }
   for _, name := range []string{`Names.api["a[\"\"]"]`, `Names.api.a[""]`} {
-    id := nodeID(path, name, NodeMethod)
-    if graph.Nodes[id] == nil || !hasEdge(graph, nodeID(path, "Names.caller", NodeFunction), id, EdgeValueCall) || !hasEdge(graph, id, helper, EdgeValueCall) {
+    id := nodeID(string(path), name, NodeMethod)
+    if graph.Nodes[id] == nil || !hasEdge(graph, nodeID(string(path), "Names.caller", NodeFunction), id, EdgeValueCall) || !hasEdge(graph, id, helper, EdgeValueCall) {
       t.Errorf("namespace object identity/relationships missing: %s", name)
     }
   }
@@ -146,18 +146,18 @@ export namespace Names {
     {"Control.prefix__#7@#read", "prefix__#7@#read", NodeMethod, EdgeValueAccess},
     {"Control.#value", "#value", NodeMethod, EdgeValueCall},
   } {
-    id := nodeID(path, item.qualified, item.kind)
+    id := nodeID(string(path), item.qualified, item.kind)
     node := graph.Nodes[id]
     if node == nil || node.Simple != item.simple || node.Pos <= 0 || node.End <= node.Pos {
       t.Errorf("literal/private identity %q: %+v, want simple %q", item.qualified, node, item.simple)
       continue
     }
     if item.qualified == "Control.#value" {
-      if !hasEdge(graph, nodeID(path, "Control.__#41@#value", NodeMethod), id, EdgeValueCall) {
+      if !hasEdge(graph, nodeID(string(path), "Control.__#41@#value", NodeMethod), id, EdgeValueCall) {
         t.Error("public literal method lost its distinct private call target")
       }
     } else if len(item.qualified) >= len("Control.") && item.qualified[:len("Control.")] == "Control." {
-      if !hasEdge(graph, nodeID(path, "control", NodeFunction), id, item.relation) {
+      if !hasEdge(graph, nodeID(string(path), "control", NodeFunction), id, item.relation) {
         t.Errorf("missing control caller relation to %q", item.qualified)
       }
     }

package/internal/graph/object_literal_members_ride_on_the_snapshot_test.go

@@ -82,7 +82,7 @@ export const shape = (({
 
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
-  node := graph.Nodes[nodeID(path, "shape", NodeVariable)]
+  node := graph.Nodes[nodeID(string(path), "shape", NodeVariable)]
   if node == nil {
     t.Fatalf("missing shape variable; nodes: %v", nodeIDSet(graph))
   }

package/internal/graph/overload_implementation_replaces_signature_test.go

@@ -50,7 +50,7 @@ func TestOverloadImplementationReplacesSignature(t *testing.T) {
   graph := Build(prog)
   file := sourceFile(t, prog, "main.ts")
   path := file.FileName()
-  id := nodeID(path, "Query.join", NodeMethod)
+  id := nodeID(string(path), "Query.join", NodeMethod)
   node := graph.Nodes[id]
   if node == nil {
     t.Fatalf("missing node Query.join; have %v", nodeIDSet(graph))
@@ -59,7 +59,7 @@ func TestOverloadImplementationReplacesSignature(t *testing.T) {
   if !strings.Contains(source, "return this.realJoin") {
     t.Fatalf("expected Query.join node to cover the implementation body, got:\n%s", source)
   }
-  if !hasEdge(graph, id, nodeID(path, "Query.realJoin", NodeMethod), EdgeValueCall) {
+  if !hasEdge(graph, id, nodeID(string(path), "Query.realJoin", NodeMethod), EdgeValueCall) {
     t.Fatalf("missing value-call edge Query.join -> Query.realJoin; edges: %v", graph.Edges)
   }
 }

package/internal/graph/property_member_edges_remain_owner_visible_test.go

@@ -56,12 +56,12 @@ export interface Contract {
 
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
-  dep := nodeID(path, "Dep", NodeInterface)
-  makeDep := nodeID(path, "makeDep", NodeFunction)
-  service := nodeID(path, "Service", NodeClass)
-  serviceDep := nodeID(path, "Service.dep", NodeVariable)
-  contract := nodeID(path, "Contract", NodeInterface)
-  contractDep := nodeID(path, "Contract.dep", NodeVariable)
+  dep := nodeID(string(path), "Dep", NodeInterface)
+  makeDep := nodeID(string(path), "makeDep", NodeFunction)
+  service := nodeID(string(path), "Service", NodeClass)
+  serviceDep := nodeID(string(path), "Service.dep", NodeVariable)
+  contract := nodeID(string(path), "Contract", NodeInterface)
+  contractDep := nodeID(string(path), "Contract.dep", NodeVariable)
 
   for _, id := range []string{serviceDep, contractDep} {
     if _, ok := graph.Nodes[id]; !ok {

package/internal/graph/resolve.go

@@ -126,7 +126,7 @@ func Resolve(checker *shimchecker.Checker, ref *shimast.Node) *Target {
   if symbol == nil {
     return nil
   }
-  if symbol.Flags&shimast.SymbolFlagsAlias != 0 {
+  if shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsAlias != 0 {
     if aliased := shimchecker.Checker_getAliasedSymbol(checker, symbol); aliased != nil {
       symbol = aliased
     }
@@ -136,7 +136,7 @@ func Resolve(checker *shimchecker.Checker, ref *shimast.Node) *Target {
     target.Pos = declaration.Pos()
     target.End = declaration.End()
     if file := shimast.GetSourceFileOfNode(declaration); file != nil {
-      target.File = file.FileName()
+      target.File = string(file.FileName())
       target.External = !IsWorkspaceSourceFile(file)
     }
   }
@@ -156,27 +156,27 @@ func declarationFile(symbol *shimast.Symbol) *shimast.SourceFile {
 }
 
 func declarationNode(symbol *shimast.Symbol) *shimast.Node {
-  if len(symbol.Declarations) == 0 {
+  if len(shimast.SymbolDeclarationsOf(symbol)) == 0 {
     return nil
   }
   // Prefer a non-declaration-file declaration. A declaration-merged symbol (a
   // class paired with an interface, or a function with a namespace) can list a
   // `.d.ts` declaration first; classifying by it would mark a real workspace
   // symbol external and sever it from the graph.
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if file := shimast.GetSourceFileOfNode(declaration); file != nil && !file.IsDeclarationFile && declaration.Body() != nil {
       return declaration
     }
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if file := shimast.GetSourceFileOfNode(declaration); file != nil && !file.IsDeclarationFile {
       return declaration
     }
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declaration.Body() != nil {
       return declaration
     }
   }
-  return symbol.Declarations[0]
+  return shimast.SymbolDeclarationsOf(symbol)[0]
 }