ttsc 0.33.0 → 0.34.0

package/internal/graph/edges.go

@@ -24,7 +24,7 @@ func (g *Graph) addEdges(prog *driver.Program, selected map[string]bool, partial
     if !IsWorkspaceSourceFile(file) {
       continue
     }
-    if partial && !selected[file.FileName()] {
+    if partial && !selected[string(file.FileName())] {
       continue
     }
     g.markExports(checker, file)
@@ -34,7 +34,7 @@ func (g *Graph) addEdges(prog *driver.Program, selected map[string]bool, partial
     g.collectDocRefs(checker, file)
     g.collectLiterals(checker, file)
     if file.Statements != nil {
-      g.collectDecorators(file.FileName(), file.Statements.Nodes)
+      g.collectDecorators(string(file.FileName()), file.Statements.Nodes)
     }
   }
 }
@@ -72,7 +72,7 @@ func (g *Graph) collectHeritage(checker *shimchecker.Checker, file *shimast.Sour
   if file.Statements == nil {
     return
   }
-  g.collectHeritageIn(checker, file.FileName(), file.Statements.Nodes)
+  g.collectHeritageIn(checker, string(file.FileName()), file.Statements.Nodes)
 }
 
 // collectHeritageIn adds heritage edges for the class/interface statements in a
@@ -90,6 +90,17 @@ func (g *Graph) collectHeritageIn(checker *shimchecker.Checker, path string, sta
       if decl != nil && decl.HeritageClauses != nil {
         g.heritageEdges(checker, path, statement, NodeInterface, decl.HeritageClauses.Nodes)
       }
+    case shimast.KindVariableStatement:
+      variables := statement.AsVariableStatement().DeclarationList
+      if variables != nil && variables.AsVariableDeclarationList().Declarations != nil {
+        for _, binding := range variables.AsVariableDeclarationList().Declarations.Nodes {
+          if expression := boundClassExpression(binding); expression != nil {
+            if clauses := expression.AsClassExpression().HeritageClauses; clauses != nil {
+              g.heritageEdges(checker, path, expression, NodeClass, clauses.Nodes)
+            }
+          }
+        }
+      }
     case shimast.KindModuleDeclaration:
       g.collectHeritageIn(checker, path, moduleStatements(statement))
     }
@@ -100,10 +111,17 @@ func (g *Graph) collectHeritageIn(checker *shimchecker.Checker, path string, sta
 // records a heritage edge from node to the resolved base node.
 func (g *Graph) heritageEdges(checker *shimchecker.Checker, path string, node *shimast.Node, kind NodeKind, clauses []*shimast.Node) {
   symbol := node.Symbol()
-  if symbol == nil || symbol.Name == "" {
+  if symbol == nil || shimast.SymbolNameOf(symbol) == "" {
     return
   }
   from := nodeID(path, qualifiedName(symbol), kind)
+  if node.Kind == shimast.KindClassExpression {
+    owner := classExpressionOwner(node)
+    if owner == "" {
+      return
+    }
+    from = nodeID(path, owner, NodeVariable)
+  }
   for _, clauseNode := range clauses {
     clause := clauseNode.AsHeritageClause()
     if clause == nil || clause.Types == nil {
@@ -117,11 +135,11 @@ func (g *Graph) heritageEdges(checker *shimchecker.Checker, path string, node *s
       origin = "extends"
     }
     for _, typeNode := range clause.Types.Nodes {
-      base := typeNode.AsExpressionWithTypeArguments()
-      if base == nil || base.Expression == nil {
+      name := heritageElementName(typeNode)
+      if name == nil {
         continue
       }
-      target := g.resolve(checker, base.Expression)
+      target := g.resolve(checker, name)
       if target == nil || target.Symbol == nil {
         continue
       }
@@ -129,12 +147,23 @@ func (g *Graph) heritageEdges(checker *shimchecker.Checker, path string, node *s
       if to == "" {
         continue
       }
-      g.addEdgeAt(from, to, EdgeHeritage, origin, base.Expression.Pos(), base.Expression.End())
+      g.addEdgeAt(from, to, EdgeHeritage, origin, name.Pos(), name.End())
       g.memberRelationEdges(checker, node, kind, typeNode, target, origin)
     }
   }
 }
 
+// heritageElementName is the name a heritage clause element refers to. The
+// parser represents an interface's `extends` and a class's `implements`
+// element as a type reference when it is an entity name, and every other
+// element as an expression with type arguments.
+func heritageElementName(element *shimast.Node) *shimast.Node {
+  if element.Kind == shimast.KindTypeReference {
+    return element.AsTypeReferenceNode().TypeName
+  }
+  return element.AsExpressionWithTypeArguments().Expression
+}
+
 // memberRelationEdges records the directly declared member pairs that a
 // heritage clause makes checker-valid. Inferring them from equal names after the
 // dump was built would make an authoritative edge even when the checker rejects
@@ -183,8 +212,8 @@ func (g *Graph) memberRelationEdges(
       continue
     }
 
-    derivedProperty := checker.GetPropertyOfType(derivedType, derivedMemberSymbol.Name)
-    baseProperty := checker.GetPropertyOfType(baseType, derivedMemberSymbol.Name)
+    derivedProperty := checker.GetPropertyOfType(derivedType, shimast.SymbolNameOf(derivedMemberSymbol))
+    baseProperty := checker.GetPropertyOfType(baseType, shimast.SymbolNameOf(derivedMemberSymbol))
     if derivedProperty == nil || baseProperty == nil ||
       !propertyRootsAt(checker, derivedProperty, derivedMemberSymbol) {
       continue
@@ -233,7 +262,7 @@ func declaredTypeMembers(symbol *shimast.Symbol) []*shimast.Node {
     return nil
   }
   var members []*shimast.Node
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     members = append(members, classMembers(declaration)...)
   }
   return members
@@ -259,7 +288,7 @@ func inheritedMemberForProperty(
     if root == nil {
       continue
     }
-    for _, declaration := range root.Declarations {
+    for _, declaration := range shimast.SymbolDeclarationsOf(root) {
       if declaration == nil ||
         shimast.GetCombinedModifierFlags(declaration)&shimast.ModifierFlagsStatic != 0 ||
         declaration.Kind == shimast.KindConstructor {
@@ -327,17 +356,13 @@ func graphMemberNodeID(g *Graph, member *shimast.Node) string {
   if file == nil || name == "" {
     return ""
   }
-  id := nodeID(file.FileName(), name, kind)
+  id := nodeID(string(file.FileName()), name, kind)
   stored, ok := g.lookupNode(id)
   if !ok {
     return ""
   }
-  for _, declaration := range member.Symbol().Declarations {
-    declarationFile := shimast.GetSourceFileOfNode(declaration)
-    if declarationFile != nil && declarationFile.FileName() == stored.File &&
-      declaration.Pos() == stored.Pos && declaration.End() == stored.End {
-      return id
-    }
+  if nodeDeclaresSymbol(stored, member.Symbol()) {
+    return id
   }
   return ""
 }
@@ -348,7 +373,7 @@ func graphMemberNodeID(g *Graph, member *shimast.Node) string {
 // top-level variable binding, or the class itself for a member that is not a
 // method (a property initializer).
 func (g *Graph) collectCalls(checker *shimchecker.Checker, file *shimast.SourceFile) {
-  forEachContainer(file.FileName(), file, func(from string, node *shimast.Node) {
+  forEachContainer(string(file.FileName()), file, func(from string, node *shimast.Node) {
     g.callsWithin(checker, from, node)
   })
 }
@@ -382,6 +407,7 @@ func forEachContainerIn(path string, statements []*shimast.Node, fn func(string,
       if id := topLevelID(path, statement, NodeTypeAlias); id != "" {
         fn(id, statement)
       }
+      forEachMember(path, statement, NodeTypeAlias, fn)
     case shimast.KindEnumDeclaration:
       // An enum is a recorded node (build.go), and a member initializer can call a
       // function (`enum E { A = base() }`) or reference a type, so walk its body
@@ -420,7 +446,7 @@ func moduleID(path string) string {
 // pass recorded.
 func topLevelID(path string, statement *shimast.Node, kind NodeKind) string {
   symbol := statement.Symbol()
-  if symbol == nil || symbol.Name == "" {
+  if symbol == nil || shimast.SymbolNameOf(symbol) == "" {
     return ""
   }
   return nodeID(path, qualifiedName(symbol), kind)
@@ -433,6 +459,12 @@ func topLevelID(path string, statement *shimast.Node, kind NodeKind) string {
 // lose dependency edges the owner node carries.
 func forEachMember(path string, statement *shimast.Node, kind NodeKind, fn func(string, *shimast.Node)) {
   containerID := topLevelID(path, statement, kind)
+  if statement.Kind == shimast.KindClassExpression {
+    containerID = ""
+    if owner := classExpressionOwner(statement); owner != "" {
+      containerID = nodeID(path, owner, NodeVariable)
+    }
+  }
   for _, member := range classMembers(statement) {
     forEachClosureIn(path, member, fn)
     if isMethodMember(member.Kind) {
@@ -479,6 +511,10 @@ func heritageClauses(statement *shimast.Node) []*shimast.Node {
     if decl := statement.AsClassDeclaration(); decl != nil && decl.HeritageClauses != nil {
       return decl.HeritageClauses.Nodes
     }
+  case shimast.KindClassExpression:
+    if decl := statement.AsClassExpression(); decl != nil && decl.HeritageClauses != nil {
+      return decl.HeritageClauses.Nodes
+    }
   case shimast.KindInterfaceDeclaration:
     if decl := statement.AsInterfaceDeclaration(); decl != nil && decl.HeritageClauses != nil {
       return decl.HeritageClauses.Nodes
@@ -501,10 +537,13 @@ func forEachVariable(path string, statement *shimast.Node, fn func(string, *shim
   }
   for _, binding := range list.Declarations.Nodes {
     symbol := binding.Symbol()
-    if symbol == nil || symbol.Name == "" {
+    if symbol == nil || shimast.SymbolNameOf(symbol) == "" {
       continue
     }
     fn(nodeID(path, qualifiedName(symbol), NodeVariable), binding)
+    if expression := boundClassExpression(binding); expression != nil {
+      forEachMember(path, expression, NodeVariable, fn)
+    }
     if variable := binding.AsVariableDeclaration(); variable != nil {
       forEachObjectDeclaration(path, variable.Initializer, fn)
     }
@@ -542,6 +581,11 @@ func closureID(path string, closure *shimast.Node) string {
 // value-call edges, and property or element access as value-access edges.
 func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shimast.Node) {
   node.ForEachChild(func(child *shimast.Node) bool {
+    // Computed names and typeof inside a type surface are type dependencies,
+    // even when the language-service expression predicate accepts their names.
+    if shimast.IsPartOfTypeNode(child) || child.Kind == shimast.KindTypeQuery {
+      return false
+    }
     // The owning callable keeps aggregate body relationships across closures.
     // forEachClosureIn also records each named closure's own relationships.
     switch child.Kind {
@@ -557,7 +601,6 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
       }
       if call := child.AsCallExpression(); call != nil && call.Expression != nil {
         g.callEdge(checker, from, call.Expression, "call")
-        g.handedOffValues(checker, from, call)
       }
     case shimast.KindNewExpression:
       if newExpr := child.AsNewExpression(); newExpr != nil && newExpr.Expression != nil {
@@ -582,6 +625,12 @@ func (g *Graph) callsWithin(checker *shimchecker.Checker, from string, node *shi
       if !isInvokedAccess(child) {
         g.accessEdge(checker, from, child)
       }
+    case shimast.KindIdentifier:
+      if isValueIdentifier(child) {
+        g.accessEdge(checker, from, child)
+      }
+    case shimast.KindShorthandPropertyAssignment, shimast.KindBindingElement, shimast.KindJsxAttribute:
+      g.accessEdge(checker, from, child)
     case shimast.KindBinaryExpression:
       if target := g.assignedFunctionTarget(checker, from, child); target != "" {
         file := g.recordImplementation(target, child)
@@ -652,14 +701,14 @@ func (g *Graph) recordImplementation(id string, assignment *shimast.Node) string
     sources = map[string]bool{}
     g.ImplementationSources[id] = sources
   }
-  sources[file.FileName()] = true
+  sources[string(file.FileName())] = true
   current := g.Nodes[id]
   if current != nil && current.ImplementationFile == "" {
-    current.ImplementationFile = file.FileName()
+    current.ImplementationFile = string(file.FileName())
     current.ImplementationPos = assignment.Pos()
     current.ImplementationEnd = assignment.End()
   }
-  return file.FileName()
+  return string(file.FileName())
 }
 
 func (g *Graph) withEdgeEvidenceFile(from, file string, visit func()) {
@@ -707,29 +756,22 @@ func (g *Graph) callEdge(checker *shimchecker.Checker, from string, callee *shim
   g.valueUseEdge(checker, from, callee, EdgeValueCall, origin)
 }
 
-// handedOffValues records the workspace functions a call is handed, as uses of
-// them.
-//
-// `React.memo(ExcalidrawBase)`, `forwardRef(Impl)`, `app.use(handler)`,
-// `pipe(map(project))` — the argument is not called here and is not a property
-// read, so neither the call nor the access collector would record it, and the
-// wrapper would be a dead end: `export const Excalidraw =
-// React.memo(ExcalidrawBase)` would reach nothing of the component behind it.
-//
-// A function handed to another function is a use of it, and it is the one the
-// runtime will run. Bounded to argument position: this is the callback, the
-// wrapped component, the registered handler — not every identifier in every
-// expression.
-func (g *Graph) handedOffValues(checker *shimchecker.Checker, from string, call *shimast.CallExpression) {
-  if call.Arguments == nil {
-    return
+// isValueIdentifier uses the compiler's expression classification and excludes
+// names already represented by their enclosing access, call or JSX expression.
+// Type queries are expressions to the language service but remain type edges here.
+func isValueIdentifier(node *shimast.Node) bool {
+  parent := node.Parent
+  if parent == nil || !shimast.IsExpressionNode(node) || shimast.IsDeclarationNameOrImportPropertyName(node) || isInvokedAccess(node) {
+    return false
   }
-  for _, argument := range call.Arguments.Nodes {
-    switch argument.Kind {
-    case shimast.KindIdentifier, shimast.KindPropertyAccessExpression:
-      g.valueUseEdge(checker, from, argument, EdgeValueAccess, "")
-    }
+  switch parent.Kind {
+  case shimast.KindPropertyAccessExpression:
+    return parent.AsPropertyAccessExpression().Name() != node
+  case shimast.KindJsxOpeningElement, shimast.KindJsxSelfClosingElement, shimast.KindJsxClosingElement,
+    shimast.KindTypeQuery, shimast.KindQualifiedName:
+    return false
   }
+  return true
 }
 
 // accessEdge resolves a property or element access to its declaration and
@@ -746,6 +788,17 @@ func (g *Graph) valueUseEdge(checker *shimchecker.Checker, from string, targetEx
   if target == nil || target.Symbol == nil {
     return
   }
+  // Enum members remain outline facts on their enum rather than separate nodes.
+  // Their reads therefore depend on that enum's existing identity.
+  if kind == EdgeValueAccess && shimast.SymbolFlagsOf(target.Symbol)&shimast.SymbolFlagsEnumMember != 0 {
+    if parent := shimast.SymbolParentOf(target.Symbol); parent != nil {
+      if declaration := declarationNode(parent); declaration != nil {
+        if file := declarationFile(parent); file != nil {
+          target = &Target{Symbol: parent, File: string(file.FileName()), External: !IsWorkspaceSourceFile(file), Pos: declaration.Pos(), End: declaration.End()}
+        }
+      }
+    }
+  }
   to := g.ensureTargetNode(target)
   if to == "" || to == from {
     return
@@ -760,7 +813,7 @@ func (g *Graph) valueUseEdge(checker *shimchecker.Checker, from string, targetEx
 // the unit of truth: an `import type` or annotation-only dependency relates two
 // symbols without any runtime call.
 func (g *Graph) collectTypeRefs(checker *shimchecker.Checker, file *shimast.SourceFile) {
-  forEachContainer(file.FileName(), file, func(from string, node *shimast.Node) {
+  forEachContainer(string(file.FileName()), file, func(from string, node *shimast.Node) {
     g.typeRefsWithin(checker, from, node)
   })
 }
@@ -794,7 +847,7 @@ func (g *Graph) typeRefsWithin(checker *shimchecker.Checker, from string, node *
       if target := g.assignedFunctionTarget(checker, from, child); target != "" {
         file := ""
         if source := shimast.GetSourceFileOfNode(child); source != nil {
-          file = source.FileName()
+          file = string(source.FileName())
         }
         g.withEdgeEvidenceFile(target, file, func() {
           g.typeRefsWithin(checker, target, child.AsBinaryExpression().Right)
@@ -838,6 +891,21 @@ func (g *Graph) ensureTargetNode(target *Target) string {
   if target.File == "" {
     return ""
   }
+  if kind == NodeClass && !target.External {
+    // A named class expression's internal name denotes the same constructor
+    // its variable binds. Keep those self-references on the existing value node.
+    for _, declaration := range shimast.SymbolDeclarationsOf(target.Symbol) {
+      if declaration.Kind != shimast.KindClassExpression {
+        continue
+      }
+      if binding := classExpressionBinding(declaration); binding != nil {
+        id := nodeID(target.File, qualifiedName(binding.Symbol()), NodeVariable)
+        if stored, exists := g.lookupNode(id); exists && nodeDeclaresSymbol(stored, binding.Symbol()) {
+          return id
+        }
+      }
+    }
+  }
   if kind == NodeMethod {
     // A method node is class-qualified and only modeled when it belongs to the
     // workspace (Build recorded it). A call into a dependency's method stops at
@@ -848,26 +916,28 @@ func (g *Graph) ensureTargetNode(target *Target) string {
       return ""
     }
     id := nodeID(target.File, name, NodeMethod)
-    if _, exists := g.lookupNode(id); exists {
+    if stored, exists := g.lookupNode(id); exists && nodeDeclaresSymbol(stored, target.Symbol) {
       return id
     }
     return ""
   }
-  if kind == NodeVariable && target.External && target.Symbol.Flags&shimast.SymbolFlagsProperty != 0 {
+  if kind == NodeVariable && target.External && shimast.SymbolFlagsOf(target.Symbol)&shimast.SymbolFlagsProperty != 0 {
     return ""
   }
   name := qualifiedName(target.Symbol)
-  id := nodeID(target.File, name, kind)
-  if _, exists := g.lookupNode(id); exists {
-    return id
-  }
   if !target.External {
-    // A closure Build recorded is keyed by its scoped name
-    // (`baseCreateRenderer.patch`), which the symbol alone does not spell, so
-    // resolve it from the declaration the checker pointed at.
+    // A scoped callable must resolve before any same-named top-level node.
     if id := g.closureTargetID(target); id != "" {
       return id
     }
+  }
+  id := nodeID(target.File, name, kind)
+  if stored, exists := g.lookupNode(id); exists {
+    if nodeDeclaresSymbol(stored, target.Symbol) {
+      return id
+    }
+  }
+  if !target.External {
     // Any other workspace target Build did not record is body-scoped and
     // unnameable without collisions (a local of an anonymous callback), so its
     // name would key the same id as a same-named local of another scope and
@@ -889,10 +959,23 @@ func (g *Graph) ensureTargetNode(target *Target) string {
   return id
 }
 
+// nodeDeclaresSymbol verifies the indexed display declaration belongs to the
+// resolved symbol. Names alone cannot distinguish unindexed shadowing locals;
+// overloads and merged symbols may legitimately carry several declarations.
+func nodeDeclaresSymbol(node *Node, symbol *shimast.Symbol) bool {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
+    file := shimast.GetSourceFileOfNode(declaration)
+    if file != nil && string(file.FileName()) == node.File && declaration.Pos() == node.Pos && declaration.End() == node.End {
+      return true
+    }
+  }
+  return false
+}
+
 // closureTargetID returns the node id of a closure the checker resolved to, or ""
 // when the target is not one Build recorded.
 func (g *Graph) closureTargetID(target *Target) string {
-  for _, declaration := range target.Symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(target.Symbol) {
     if !IsClosure(declaration) {
       continue
     }
@@ -918,7 +1001,7 @@ func (g *Graph) closureTargetID(target *Target) string {
 // resolved as NodeVariable even though Build recorded the getter/setter as a
 // NodeMethod.
 func symbolNodeKind(symbol *shimast.Symbol) NodeKind {
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     switch declaration.Kind {
     case shimast.KindClassDeclaration:
       return NodeClass
@@ -939,21 +1022,21 @@ func symbolNodeKind(symbol *shimast.Symbol) NodeKind {
     }
   }
   switch {
-  case symbol.Flags&shimast.SymbolFlagsClass != 0:
+  case shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsClass != 0:
     return NodeClass
-  case symbol.Flags&shimast.SymbolFlagsInterface != 0:
+  case shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsInterface != 0:
     return NodeInterface
-  case symbol.Flags&shimast.SymbolFlagsTypeAlias != 0:
+  case shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsTypeAlias != 0:
     return NodeTypeAlias
-  case symbol.Flags&shimast.SymbolFlagsEnum != 0:
+  case shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsEnum != 0:
     return NodeEnum
-  case symbol.Flags&shimast.SymbolFlagsFunction != 0:
+  case shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsFunction != 0:
     return NodeFunction
-  case symbol.Flags&(shimast.SymbolFlagsMethod|shimast.SymbolFlagsConstructor|shimast.SymbolFlagsGetAccessor|shimast.SymbolFlagsSetAccessor) != 0:
+  case shimast.SymbolFlagsOf(symbol)&(shimast.SymbolFlagsMethod|shimast.SymbolFlagsConstructor|shimast.SymbolFlagsGetAccessor|shimast.SymbolFlagsSetAccessor) != 0:
     return NodeMethod
-  case symbol.Flags&shimast.SymbolFlagsProperty != 0:
+  case shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsProperty != 0:
     return NodeVariable
-  case symbol.Flags&shimast.SymbolFlagsVariable != 0:
+  case shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsVariable != 0:
     return NodeVariable
   default:
     return ""

package/internal/graph/edges_cover_class_level_references_test.go

@@ -65,11 +65,11 @@ export class Service<T extends Constraint> extends Base<Payload> {}
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  service := nodeID(path, "Service", NodeClass)
-  injectable := nodeID(path, "Injectable", NodeFunction)
-  base := nodeID(path, "Base", NodeClass)
-  payload := nodeID(path, "Payload", NodeInterface)
-  constraint := nodeID(path, "Constraint", NodeInterface)
+  service := nodeID(string(path), "Service", NodeClass)
+  injectable := nodeID(string(path), "Injectable", NodeFunction)
+  base := nodeID(string(path), "Base", NodeClass)
+  payload := nodeID(string(path), "Payload", NodeInterface)
+  constraint := nodeID(string(path), "Constraint", NodeInterface)
 
   // The decorator factory call is a fact, not an edge: no value-call to
   // Injectable, but a recorded decorator on the Service node.

package/internal/graph/enum_initializer_calls_are_edges_test.go

@@ -54,8 +54,8 @@ export enum E {
 
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
-  enumID := nodeID(path, "E", NodeEnum)
-  baseID := nodeID(path, "base", NodeFunction)
+  enumID := nodeID(string(path), "E", NodeEnum)
+  baseID := nodeID(string(path), "base", NodeFunction)
 
   if _, ok := graph.Nodes[enumID]; !ok {
     t.Fatalf("enum E was not recorded as a node")

package/internal/graph/enum_members_carry_their_names_on_the_enum_node_test.go

@@ -60,7 +60,7 @@ export class Cls {
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  colors, ok := graph.Nodes[nodeID(path, "Colors", NodeEnum)]
+  colors, ok := graph.Nodes[nodeID(string(path), "Colors", NodeEnum)]
   if !ok {
     t.Fatalf("missing enum node; nodes: %v", nodeIDSet(graph))
   }
@@ -76,7 +76,7 @@ export class Cls {
 
   // The expected numeric values are not written as initializers in the fixture.
   // This result check does not prove which acquisition method produced them.
-  implicit := graph.Nodes[nodeID(path, "Implicit", NodeEnum)]
+  implicit := graph.Nodes[nodeID(string(path), "Implicit", NodeEnum)]
   if implicit == nil ||
     len(implicit.EnumMembers) != 2 ||
     implicit.EnumMembers[0] != (EnumMember{Name: "First", Value: "0"}) ||
@@ -85,7 +85,7 @@ export class Cls {
   }
 
   // Three declared names must remain even when A and B share one value.
-  dup := graph.Nodes[nodeID(path, "Dup", NodeEnum)]
+  dup := graph.Nodes[nodeID(string(path), "Dup", NodeEnum)]
   if dup == nil {
     t.Fatalf("missing Dup; nodes: %v", nodeIDSet(graph))
   }
@@ -101,15 +101,15 @@ export class Cls {
 
   // Reject the two candidate variable-node IDs for the authored Red member.
   for id := range graph.Nodes {
-    if id == nodeID(path, "Colors.Red", NodeVariable) ||
-      id == nodeID(path, "Red", NodeVariable) {
+    if id == nodeID(string(path), "Colors.Red", NodeVariable) ||
+      id == nodeID(string(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 ||
+  if cls := graph.Nodes[nodeID(string(path), "Cls", NodeClass)]; cls == nil ||
     len(cls.EnumMembers) != 0 {
     t.Fatalf("a class node carried enum members: %v", cls)
   }

package/internal/graph/exports.go

@@ -42,7 +42,7 @@ func (g *Graph) markExports(checker *shimchecker.Checker, file *shimast.SourceFi
     // A re-export is an alias; unwrap it to the declaration it points at so the
     // exported flag lands on the real node, not a re-exporting index file's
     // local alias symbol (which has no node of its own).
-    if symbol.Flags&shimast.SymbolFlagsAlias != 0 {
+    if shimast.SymbolFlagsOf(symbol)&shimast.SymbolFlagsAlias != 0 {
       if aliased := shimchecker.Checker_getAliasedSymbol(checker, symbol); aliased != nil {
         symbol = aliased
       }
@@ -64,16 +64,16 @@ func (g *Graph) markExports(checker *shimchecker.Checker, file *shimast.SourceFi
 // test suite would leave no trace in the graph.
 func (g *Graph) putModuleNode(file *shimast.SourceFile) *Node {
   path := file.FileName()
-  id := nodeID(path, path, NodeModule)
+  id := nodeID(string(path), string(path), NodeModule)
   if existing, ok := g.Nodes[id]; ok {
     return existing
   }
   node := &Node{
     ID:     id,
-    Name:   path,
-    Simple: path,
+    Name:   string(path),
+    Simple: string(path),
     Kind:   NodeModule,
-    File:   path,
+    File:   string(path),
     // A module that exports is by definition part of some surface; whether it is
     // the package's front door is the package.json's to say, not the graph's.
     Exported: true,
@@ -106,7 +106,7 @@ func (g *Graph) markExportedSymbol(symbol *shimast.Symbol) (string, bool) {
   if name == "" {
     return "", false
   }
-  node, ok := g.lookupNode(nodeID(file.FileName(), name, kind))
+  node, ok := g.lookupNode(nodeID(string(file.FileName()), name, kind))
   if !ok {
     return "", false
   }

package/internal/graph/file_diagnostics_match_tsgo_code_and_location_test.go

@@ -40,7 +40,7 @@ func TestFileDiagnosticsMatchTsgoCodeAndLocation(t *testing.T) {
   defer func() { _ = prog.Close() }()
 
   main := sourceFile(t, prog, "main.ts").FileName()
-  got := FileDiagnostics(prog, main)
+  got := FileDiagnostics(prog, string(main))
 
   var match *driver.Diagnostic
   for i := range got {
@@ -55,7 +55,7 @@ func TestFileDiagnosticsMatchTsgoCodeAndLocation(t *testing.T) {
   if match.Line != 1 {
     t.Fatalf("TS2322 reported on line %d, expected line 1", match.Line)
   }
-  if match.File != main {
+  if match.File != string(main) {
     t.Fatalf("diagnostic file %q is not the queried file %q", match.File, main)
   }
   if other := FileDiagnostics(prog, filepath.Join(root, "src", "absent.ts")); len(other) != 0 {

package/internal/graph/file_diagnostics_report_code_column_and_message_test.go

@@ -49,7 +49,7 @@ func TestFileDiagnosticsReportCodeColumnAndMessage(t *testing.T) {
   defer func() { _ = prog.Close() }()
 
   main := sourceFile(t, prog, "main.ts").FileName()
-  got := FileDiagnostics(prog, main)
+  got := FileDiagnostics(prog, string(main))
 
   var match *driver.Diagnostic
   for i := range got {

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 {