ttsc 0.33.0 → 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,14 +184,12 @@ 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 the nodes for a statement list — the file's top
-// level, or the body of a namespace it recurses into. A member's id is built
-// from its symbol, which already carries the enclosing namespace in its parent
-// chain, so a node recorded here and an edge target resolved later agree without
-// the walk having to thread the namespace name through.
+// collectStatements records a file or namespace statement list. qualifiedName
+// combines compiler symbol ownership with lexical namespaces for private
+// declarations, keeping indexed nodes and later resolved targets consistent.
 func collectStatements(g *Graph, path string, statements []*shimast.Node) {
   for _, statement := range statements {
     switch statement.Kind {
@@ -214,6 +212,7 @@ func collectStatements(g *Graph, path string, statements []*shimast.Node) {
       collectMembers(g, path, statement)
     case shimast.KindTypeAliasDeclaration:
       addNode(g, path, statement, NodeTypeAlias)
+      collectMembers(g, path, statement)
     case shimast.KindEnumDeclaration:
       addNode(g, path, statement, NodeEnum)
     case shimast.KindVariableStatement:
@@ -242,6 +241,9 @@ func collectVariables(g *Graph, path string, statement *shimast.Node) {
   for _, binding := range list.Declarations.Nodes {
     addNode(g, path, binding, NodeVariable)
     g.collectObjectMembers(path, binding)
+    if expression := boundClassExpression(binding); expression != nil {
+      collectMembers(g, path, expression)
+    }
     collectClosures(g, path, binding)
   }
 }
@@ -527,15 +529,15 @@ 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)
 }
 
-// collectMembers records callable members (method, constructor, accessor) and
-// property members of a class or interface declaration, keyed by their
-// class-qualified names so resolved member references land on the same node.
+// collectMembers records callable and property members of modeled type and
+// class declarations. Structural and lexical owner names are shared with
+// checker-resolved targets, including parameter properties and bound literals.
 func collectMembers(g *Graph, path string, statement *shimast.Node) {
   for _, member := range classMembers(statement) {
     name := methodName(member.Symbol())
@@ -650,20 +652,44 @@ func declarationHasImplementation(declaration *shimast.Node, kind NodeKind) bool
   }
 }
 
-// classMembers returns the member nodes of a class or interface declaration, or
-// nil for anything else.
+// classMembers returns direct class/interface members, constructor parameter
+// properties and named nested type-literal members. Type aliases and bound class
+// expressions use the same member surface for indexing and edge attribution.
 func classMembers(statement *shimast.Node) []*shimast.Node {
+  var members []*shimast.Node
   switch statement.Kind {
   case shimast.KindClassDeclaration:
     if decl := statement.AsClassDeclaration(); decl != nil && decl.Members != nil {
-      return decl.Members.Nodes
+      members = decl.Members.Nodes
+    }
+  case shimast.KindClassExpression:
+    if decl := statement.AsClassExpression(); decl != nil && decl.Members != nil {
+      members = decl.Members.Nodes
     }
   case shimast.KindInterfaceDeclaration:
     if decl := statement.AsInterfaceDeclaration(); decl != nil && decl.Members != nil {
-      return decl.Members.Nodes
+      members = decl.Members.Nodes
+    }
+  case shimast.KindTypeAliasDeclaration:
+    return typeLiteralMembers(statement.Type())
+  }
+  var extra []*shimast.Node
+  for _, member := range members {
+    if member.Kind == shimast.KindConstructor {
+      for _, parameter := range member.Parameters() {
+        if isParameterProperty(parameter) {
+          extra = append(extra, parameter)
+        }
+      }
     }
+    extra = append(extra, typeLiteralMembers(member.Type())...)
   }
-  return nil
+  if len(extra) == 0 {
+    return members
+  }
+  result := make([]*shimast.Node, 0, len(members)+len(extra))
+  result = append(result, members...)
+  return append(result, extra...)
 }
 
 // isMethodMember reports whether a class/interface member kind is a callable the
@@ -680,7 +706,7 @@ func isMethodMember(kind shimast.Kind) bool {
 
 func isPropertyMember(kind shimast.Kind) bool {
   switch kind {
-  case shimast.KindPropertyDeclaration, shimast.KindPropertySignature:
+  case shimast.KindPropertyDeclaration, shimast.KindPropertySignature, shimast.KindParameter:
     return true
   default:
     return false
@@ -693,7 +719,10 @@ func isPropertyMember(kind shimast.Kind) bool {
 // symbol.Parent is the class/interface symbol, set by the binder for every
 // member.
 func methodName(symbol *shimast.Symbol) string {
-  if symbol == nil || symbol.Parent == nil || symbol.Parent.Name == "" {
+  if name, ok := structuralMemberName(symbol); ok {
+    return name
+  }
+  if symbol == nil || shimast.SymbolParentOf(symbol) == nil || shimast.SymbolNameOf(shimast.SymbolParentOf(symbol)) == "" {
     return ""
   }
   return qualifiedName(symbol)
@@ -704,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)
     }
@@ -758,11 +787,14 @@ 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
     }
   }
+  if name, ok := structuralMemberName(symbol); ok {
+    return name
+  }
   name := simpleName(symbol)
   if prefix := containerPrefix(symbol); prefix != "" {
     return prefix + "." + name
@@ -775,13 +807,23 @@ 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 == "" {
-    return ""
-  }
-  if 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 shimast.SymbolDeclarationsOf(symbol) {
+    for owner := declaration.Parent; owner != nil; owner = owner.Parent {
+      if isFunctionLike(owner) {
+        break
+      }
+      if owner.Kind == shimast.KindModuleDeclaration && owner.Symbol() != nil && isNamespaceSymbol(owner.Symbol()) {
+        return qualifiedName(owner.Symbol())
+      }
+    }
+  }
   return ""
 }
 
@@ -791,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
     }
@@ -805,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

@@ -0,0 +1,143 @@
+package graph
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// structuralMemberName replaces anonymous type/class binder containers with
+// the declaration that names them. An unbound literal has no stable owner.
+func structuralMemberName(symbol *shimast.Symbol) (string, bool) {
+  if symbol == nil {
+    return "", false
+  }
+  for _, declaration := range shimast.SymbolDeclarationsOf(symbol) {
+    parent := declaration.Parent
+    if parent == nil {
+      continue
+    }
+    var owner string
+    switch {
+    case parent.Kind == shimast.KindTypeLiteral:
+      owner = typeLiteralOwner(parent)
+    case parent.Kind == shimast.KindClassExpression:
+      owner = classExpressionOwner(parent)
+    case isParameterProperty(declaration):
+      class := parent.Parent
+      if class != nil && class.Kind == shimast.KindClassExpression {
+        owner = classExpressionOwner(class)
+      } else if class != nil && class.Symbol() != nil {
+        owner = qualifiedName(class.Symbol())
+      }
+    }
+    if owner != "" {
+      return appendObjectMemberName(owner, simpleName(symbol)), true
+    }
+  }
+  return "", false
+}
+
+// typeLiteralOwner follows only type structure with a named declaration owner;
+// a function return or parameter type is not a property of that function.
+func typeLiteralOwner(literal *shimast.Node) string {
+  for node := literal.Parent; node != nil; node = node.Parent {
+    switch node.Kind {
+    case shimast.KindUnionType, shimast.KindIntersectionType, shimast.KindParenthesizedType:
+      continue
+    case shimast.KindTypeAliasDeclaration, shimast.KindPropertySignature, shimast.KindPropertyDeclaration:
+      if node.Symbol() != nil {
+        return qualifiedName(node.Symbol())
+      }
+    }
+    break
+  }
+  return ""
+}
+
+// typeLiteralMembers enumerates statically owned literal members once in AST
+// order, including literals nested under named properties and intersections.
+func typeLiteralMembers(typeNode *shimast.Node) []*shimast.Node {
+  if typeNode == nil {
+    return nil
+  }
+  var members []*shimast.Node
+  var walk func(*shimast.Node)
+  walk = func(node *shimast.Node) {
+    if node.Kind == shimast.KindTypeLiteral {
+      literal := node.AsTypeLiteralNode()
+      if typeLiteralOwner(node) == "" || literal.Members == nil {
+        return
+      }
+      for _, member := range literal.Members.Nodes {
+        if _, ok := staticObjectMemberName(member.Name()); !ok {
+          continue
+        }
+        members = append(members, member)
+        walkType := member.Type()
+        if walkType != nil {
+          walk(walkType)
+        }
+      }
+      return
+    }
+    switch node.Kind {
+    case shimast.KindUnionType, shimast.KindIntersectionType, shimast.KindParenthesizedType:
+      node.ForEachChild(func(child *shimast.Node) bool { walk(child); return false })
+    }
+  }
+  walk(typeNode)
+  return members
+}
+
+// isParameterProperty admits constructor parameters with a property modifier,
+// leaving ordinary parameters local to their constructor.
+func isParameterProperty(node *shimast.Node) bool {
+  return node.Kind == shimast.KindParameter && node.Parent != nil && node.Parent.Kind == shimast.KindConstructor &&
+    shimast.GetCombinedModifierFlags(node)&shimast.ModifierFlagsParameterPropertyModifier != 0
+}
+
+// boundClassExpression unwraps the transparent expression forms around a
+// variable's class initializer, without guessing classes returned by factories.
+func boundClassExpression(binding *shimast.Node) *shimast.Node {
+  variable := binding.AsVariableDeclaration()
+  if variable == nil {
+    return nil
+  }
+  node := variable.Initializer
+  for node != nil {
+    switch node.Kind {
+    case shimast.KindClassExpression:
+      return node
+    case shimast.KindParenthesizedExpression, shimast.KindAsExpression, shimast.KindSatisfiesExpression,
+      shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
+      node = node.Expression()
+    default:
+      return nil
+    }
+  }
+  return nil
+}
+
+// classExpressionOwner uses the outer binding even for a named expression;
+// its internal class name is private to that expression's body.
+func classExpressionOwner(expression *shimast.Node) string {
+  if binding := classExpressionBinding(expression); binding != nil {
+    return qualifiedName(binding.Symbol())
+  }
+  return ""
+}
+
+// classExpressionBinding preserves the actual declaration behind an owner
+// name, so a shadowing local cannot borrow a same-named indexed value.
+func classExpressionBinding(expression *shimast.Node) *shimast.Node {
+  for parent := expression.Parent; parent != nil; parent = parent.Parent {
+    switch parent.Kind {
+    case shimast.KindParenthesizedExpression, shimast.KindAsExpression, shimast.KindSatisfiesExpression,
+      shimast.KindTypeAssertionExpression, shimast.KindNonNullExpression:
+      continue
+    case shimast.KindVariableDeclaration:
+      if parent.Symbol() != nil && boundClassExpression(parent) == expression {
+        return parent
+      }
+    }
+    break
+  }
+  return nil
+}

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