ttsc 0.33.1 → 0.34.0

package/internal/graph/build.go

@@ -75,7 +75,7 @@ func BuildFiles(prog *driver.Program, selected []string, baseNodes map[string]*N
     if !IsWorkspaceSourceFile(file) {
       continue
     }
-    if selected != nil && !selectedFiles[file.FileName()] {
+    if selected != nil && !selectedFiles[string(file.FileName())] {
       continue
     }
     g.putModuleNode(file)
@@ -139,7 +139,7 @@ func SourceTexts(prog *driver.Program) map[string]string {
     if file == nil {
       continue
     }
-    out[file.FileName()] = file.Text()
+    out[string(file.FileName())] = file.Text()
   }
   return out
 }
@@ -168,8 +168,8 @@ func SourceTextsForFiles(prog *driver.Program, files []string) map[string]string
   }
   out := make(map[string]string, len(files))
   for _, source := range prog.TSProgram.SourceFiles() {
-    if source != nil && selected[source.FileName()] {
-      out[source.FileName()] = source.Text()
+    if source != nil && selected[string(source.FileName())] {
+      out[string(source.FileName())] = source.Text()
     }
   }
   return out
@@ -184,7 +184,7 @@ func collectDeclarations(g *Graph, file *shimast.SourceFile) {
   if file.Statements == nil {
     return
   }
-  collectStatements(g, file.FileName(), file.Statements.Nodes)
+  collectStatements(g, string(file.FileName()), file.Statements.Nodes)
 }
 
 // collectStatements records a file or namespace statement list. qualifiedName
@@ -529,7 +529,7 @@ func functionBodyOfInitializer(initializer *shimast.Node) *shimast.Node {
 // code instead of just the overload header.
 func addNode(g *Graph, path string, node *shimast.Node, kind NodeKind) {
   symbol := node.Symbol()
-  if symbol == nil || symbol.Name == "" {
+  if symbol == nil || shimast.SymbolNameOf(symbol) == "" {
     return
   }
   putDeclaredNode(g, path, qualifiedName(symbol), kind, node)
@@ -722,7 +722,7 @@ func methodName(symbol *shimast.Symbol) string {
   if name, ok := structuralMemberName(symbol); ok {
     return name
   }
-  if symbol == nil || symbol.Parent == nil || symbol.Parent.Name == "" {
+  if symbol == nil || shimast.SymbolParentOf(symbol) == nil || shimast.SymbolNameOf(shimast.SymbolParentOf(symbol)) == "" {
     return ""
   }
   return qualifiedName(symbol)
@@ -733,11 +733,11 @@ func methodName(symbol *shimast.Symbol) string {
 // private declaration loses its binder counter; public literal names can contain
 // the same text. A constructor's internal-name prefix (\xFE) becomes "__".
 func simpleName(symbol *shimast.Symbol) string {
-  if symbol == nil || symbol.Name == "" {
+  if symbol == nil || shimast.SymbolNameOf(symbol) == "" {
     return ""
   }
-  name := strings.ReplaceAll(symbol.Name, "\xFE", "__")
-  for _, declaration := range symbol.Declarations {
+  name := strings.ReplaceAll(shimast.SymbolNameOf(symbol), "\xFE", "__")
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declared := declaration.Name(); declared != nil && declared.Kind == shimast.KindPrivateIdentifier {
       return stripPrivateMangling(name)
     }
@@ -787,7 +787,7 @@ func qualifiedName(symbol *shimast.Symbol) string {
   if symbol == nil {
     return ""
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if name, ok := objectDeclarationName(declaration); ok {
       return name
     }
@@ -807,14 +807,14 @@ func qualifiedName(symbol *shimast.Symbol) string {
 // module symbol is not a namespace — its declaration is the file, not a
 // `namespace` block — so a top-level declaration gets no prefix.
 func containerPrefix(symbol *shimast.Symbol) string {
-  parent := symbol.Parent
-  if parent != nil && parent.Name != "" && (isNamespaceSymbol(parent) || isTypeContainerSymbol(parent)) {
+  parent := shimast.SymbolParentOf(symbol)
+  if parent != nil && shimast.SymbolNameOf(parent) != "" && (isNamespaceSymbol(parent) || isTypeContainerSymbol(parent)) {
     return qualifiedName(parent)
   }
   // The binder does not assign Symbol.Parent to private namespace locals.
   // Their lexical namespace still owns their identity. Stop at a callable so
   // ClosureName remains the owner of function-local qualification.
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     for owner := declaration.Parent; owner != nil; owner = owner.Parent {
       if isFunctionLike(owner) {
         break
@@ -833,10 +833,10 @@ func containerPrefix(symbol *shimast.Symbol) string {
 // also module declarations, but qualifying members by their quoted or internal
 // names would produce malformed ids, so they are excluded.
 func isNamespaceSymbol(symbol *shimast.Symbol) bool {
-  if strings.HasPrefix(symbol.Name, "\"") || strings.Contains(symbol.Name, "\xFE") {
+  if strings.HasPrefix(shimast.SymbolNameOf(symbol), "\"") || strings.Contains(shimast.SymbolNameOf(symbol), "\xFE") {
     return false
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     if declaration.Kind == shimast.KindModuleDeclaration {
       return true
     }
@@ -847,7 +847,7 @@ func isNamespaceSymbol(symbol *shimast.Symbol) bool {
 // isTypeContainerSymbol reports whether symbol is a class or interface, whose
 // members the graph qualifies ("Class.method").
 func isTypeContainerSymbol(symbol *shimast.Symbol) bool {
-  return symbol.Flags&(shimast.SymbolFlagsClass|shimast.SymbolFlagsInterface) != 0
+  return shimast.SymbolFlagsOf(symbol)&(shimast.SymbolFlagsClass|shimast.SymbolFlagsInterface) != 0
 }
 
 // moduleStatements returns the member statements inside a namespace/module body,

package/internal/graph/build_files_reuses_committed_cross_file_endpoints_test.go

@@ -67,15 +67,15 @@ export class Impl implements Base {
   implFile := sourceFile(t, prog, "impl.ts").FileName()
   baseFile := sourceFile(t, prog, "base.ts").FileName()
   unrelatedFile := sourceFile(t, prog, "unrelated.ts").FileName()
-  partial := BuildFiles(prog, []string{implFile}, complete.Nodes)
+  partial := BuildFiles(prog, []string{string(implFile)}, complete.Nodes)
 
-  implMethod := nodeID(implFile, "Impl.run", NodeMethod)
-  baseMethod := nodeID(baseFile, "Base.run", NodeMethod)
+  implMethod := nodeID(string(implFile), "Impl.run", NodeMethod)
+  baseMethod := nodeID(string(baseFile), "Base.run", NodeMethod)
   if partial.Nodes[implMethod] == nil {
     t.Fatalf("partial build omitted selected method %s", implMethod)
   }
   for _, node := range partial.Nodes {
-    if node.File == baseFile || node.File == unrelatedFile {
+    if node.File == string(baseFile) || node.File == string(unrelatedFile) {
       t.Fatalf("partial build re-emitted unchanged node %s", node.ID)
     }
   }

package/internal/graph/build_records_a_node_per_top_level_declaration_test.go

@@ -80,7 +80,7 @@ export const value = 1;
     t.Fatalf("expected %d nodes, got %d: %v", len(want), declared, nodeIDSet(graph))
   }
   for name, kind := range want {
-    id := nodeID(path, name, kind)
+    id := nodeID(string(path), name, kind)
     node, ok := graph.Nodes[id]
     if !ok {
       t.Fatalf("missing node for %s (%s); have %v", name, kind, nodeIDSet(graph))

package/internal/graph/declaration_members.go

@@ -8,7 +8,7 @@ func structuralMemberName(symbol *shimast.Symbol) (string, bool) {
   if symbol == nil {
     return "", false
   }
-  for _, declaration := range symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     parent := declaration.Parent
     if parent == nil {
       continue

package/internal/graph/decorators_capture_name_and_literal_arguments_test.go

@@ -62,9 +62,9 @@ export class UsersController {
   graph := Build(prog)
   path := sourceFile(t, prog, "main.ts").FileName()
 
-  controller := nodeID(path, "UsersController", NodeClass)
-  find := nodeID(path, "UsersController.find", NodeMethod)
-  plain := nodeID(path, "UsersController.plain", NodeMethod)
+  controller := nodeID(string(path), "UsersController", NodeClass)
+  find := nodeID(string(path), "UsersController.find", NodeMethod)
+  plain := nodeID(string(path), "UsersController.plain", NodeMethod)
 
   classDec := findDecorator(graph, controller, "Controller")
   if classDec == nil {

package/internal/graph/doc_tags.go

@@ -270,7 +270,7 @@ func joinDocTagLines(text string) string {
 // relation, and privileging a tag would put one convention's name inside the
 // compiler host.
 func (g *Graph) collectDocRefs(checker *shimchecker.Checker, file *shimast.SourceFile) {
-  for _, host := range g.docHosts[file.FileName()] {
+  for _, host := range g.docHosts[string(file.FileName())] {
     for _, doc := range documentationOf(host.declaration, file) {
       g.docRefsWithin(checker, host.target, doc)
     }
@@ -312,7 +312,7 @@ func (g *Graph) recordDocHost(target string, declaration *shimast.Node) {
     g.docHosts = map[string][]docHost{}
   }
   path := file.FileName()
-  g.docHosts[path] = append(g.docHosts[path], docHost{
+  g.docHosts[string(path)] = append(g.docHosts[string(path)], docHost{
     target:      target,
     declaration: declaration,
   })

package/internal/graph/dump_paths.go

@@ -172,7 +172,8 @@ func (m *dumpPathMapper) mapPath(file string) string {
 
   rawPhysical := normalized
   if shimtspath.GetRootLength(rawPhysical) == 0 {
-    rawPhysical = shimtspath.GetNormalizedAbsolutePath(rawPhysical, m.rawProject)
+    // m.rawProject is rooted whenever m.project is: canonicalDumpPath keeps an unrooted spelling unrooted, and mapPath returned above for an unrooted m.project.
+    rawPhysical = shimtspath.GetNormalizedAbsolutePath(rawPhysical, shimtspath.RootedDirectoryPathFromAbsolute(m.rawProject))
   }
   rawKey := m.pathKey(rawPhysical)
   if wire, ok := m.rawToWire[rawKey]; ok {
@@ -187,11 +188,11 @@ func (m *dumpPathMapper) mapPath(file string) string {
     ))
     return rawPhysical
   }
-  options := shimtspath.ComparePathsOptions{
-    CurrentDirectory:          m.project,
-    UseCaseSensitiveFileNames: m.caseSensitive,
+  caseSensitivity := shimtspath.CaseInsensitive
+  if m.caseSensitive {
+    caseSensitivity = shimtspath.CaseSensitive
   }
-  wire := shimtspath.GetRelativePathFromDirectory(m.project, physical, options)
+  wire := shimtspath.RelativePathFromDirectoryWith(caseSensitivity, m.project, physical)
   if shimtspath.GetRootLength(wire) != 0 {
     m.fail(fmt.Errorf(
       "ttscgraph: source path %q cannot be represented relative to project %q because they are on different filesystem roots",

package/internal/graph/duplicate_variable_object_members_keep_first_declaration_test.go

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

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
@@ -111,7 +111,7 @@ 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)
@@ -135,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
       }
@@ -147,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
@@ -201,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
@@ -251,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
@@ -277,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 {
@@ -345,7 +356,7 @@ 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 ""
@@ -362,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)
   })
 }
@@ -435,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)
@@ -526,7 +537,7 @@ 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)
@@ -690,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()) {
@@ -779,11 +790,11 @@ func (g *Graph) valueUseEdge(checker *shimchecker.Checker, from string, targetEx
   }
   // 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 && target.Symbol.Flags&shimast.SymbolFlagsEnumMember != 0 {
-    if parent := target.Symbol.Parent; parent != nil {
+  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: file.FileName(), External: !IsWorkspaceSourceFile(file), Pos: declaration.Pos(), End: declaration.End()}
+          target = &Target{Symbol: parent, File: string(file.FileName()), External: !IsWorkspaceSourceFile(file), Pos: declaration.Pos(), End: declaration.End()}
         }
       }
     }
@@ -802,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)
   })
 }
@@ -836,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)
@@ -883,7 +894,7 @@ func (g *Graph) ensureTargetNode(target *Target) string {
   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 target.Symbol.Declarations {
+    for _, declaration := range shimast.SymbolDeclarationsOf(target.Symbol) {
       if declaration.Kind != shimast.KindClassExpression {
         continue
       }
@@ -910,7 +921,7 @@ func (g *Graph) ensureTargetNode(target *Target) string {
     }
     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)
@@ -952,9 +963,9 @@ func (g *Graph) ensureTargetNode(target *Target) string {
 // 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 symbol.Declarations {
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
     file := shimast.GetSourceFileOfNode(declaration)
-    if file != nil && file.FileName() == node.File && declaration.Pos() == node.Pos && declaration.End() == node.End {
+    if file != nil && string(file.FileName()) == node.File && declaration.Pos() == node.Pos && declaration.End() == node.End {
       return true
     }
   }
@@ -964,7 +975,7 @@ func nodeDeclaresSymbol(node *Node, symbol *shimast.Symbol) bool {
 // 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
     }
@@ -990,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
@@ -1011,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 {