ttsc 0.19.3 → 0.20.0

package/internal/graph/edges.go

@@ -122,10 +122,218 @@ func (g *Graph) heritageEdges(checker *shimchecker.Checker, path string, node *s
         continue
       }
       g.addEdgeAt(from, to, EdgeHeritage, origin, base.Expression.Pos(), base.Expression.End())
+      g.memberRelationEdges(checker, node, kind, typeNode, target, origin)
     }
   }
 }
 
+// memberRelationEdges records the directly declared member pairs that a
+// heritage clause makes checker-valid. The TypeScript loader used to infer
+// these from equal names after the dump was built. That made an authoritative
+// edge even when the checker rejected the container relation, and a method /
+// property kind guard could not repair it: same-kind signatures can be
+// incompatible while a method can validly satisfy a function-valued property.
+//
+// Each pair is checked independently. A whole-container assignability gate
+// would let one broken sibling erase a valid relation in the same partially
+// edited class. The pair query retains the checker's instantiated property
+// symbols, so optionality, overloads, and private/protected declaration origins
+// still use upstream propertyRelatedTo semantics.
+func (g *Graph) memberRelationEdges(
+  checker *shimchecker.Checker,
+  derivedDeclaration *shimast.Node,
+  derivedKind NodeKind,
+  baseTypeNode *shimast.Node,
+  baseTarget *Target,
+  heritageOrigin string,
+) {
+  if checker == nil || derivedDeclaration == nil || baseTypeNode == nil || baseTarget == nil || baseTarget.External {
+    return
+  }
+  derivedSymbol := derivedDeclaration.Symbol()
+  if derivedSymbol == nil || baseTarget.Symbol == nil {
+    return
+  }
+  derivedType := checker.GetDeclaredTypeOfSymbol(derivedSymbol)
+  baseType := checker.GetTypeFromTypeNode(baseTypeNode)
+  if derivedType == nil || baseType == nil {
+    return
+  }
+
+  derivedMembers := declaredTypeMembers(derivedSymbol)
+  baseMembers := declaredTypeMembers(baseTarget.Symbol)
+
+  relation := "overrides"
+  if heritageOrigin == "implements" {
+    relation = "implements"
+  }
+  for _, derivedMember := range derivedMembers {
+    derivedMemberSymbol := derivedMember.Symbol()
+    if derivedMemberSymbol == nil || derivedMemberSymbol.Name == "" ||
+      shimast.GetCombinedModifierFlags(derivedMember)&shimast.ModifierFlagsStatic != 0 ||
+      derivedMember.Kind == shimast.KindConstructor {
+      continue
+    }
+
+    derivedProperty := checker.GetPropertyOfType(derivedType, derivedMemberSymbol.Name)
+    baseProperty := checker.GetPropertyOfType(baseType, derivedMemberSymbol.Name)
+    if derivedProperty == nil || baseProperty == nil ||
+      !propertyRootsAt(checker, derivedProperty, derivedMemberSymbol) {
+      continue
+    }
+    baseMember := directMemberForProperty(checker, baseProperty, baseMembers)
+    if baseMember == nil {
+      // The heritage clause names one type; the member may live further up.
+      // `interface Child extends Root {}` with `class W implements Child`
+      // resolves `W.execute` against `Root.execute`, and the program compiles
+      // with no diagnostic — but the immediate base declares nothing, so
+      // requiring a directly declared member dropped a relation the checker
+      // had already established. Execution tracing follows these edges to
+      // reach an implementation, so the missing edge ends the trace at the
+      // abstract declaration.
+      baseMember = inheritedMemberForProperty(checker, baseProperty)
+    }
+    if baseMember == nil ||
+      !shimchecker.Checker_isPropertyAssignableTo(checker, derivedProperty, baseProperty) {
+      continue
+    }
+    if relation == "overrides" && derivedKind == NodeClass &&
+      !shimchecker.Checker_isValidClassMemberOverridePair(checker, derivedProperty, baseProperty) {
+      continue
+    }
+
+    from := graphMemberNodeID(g, derivedMember)
+    to := graphMemberNodeID(g, baseMember)
+    if from == "" || to == "" {
+      continue
+    }
+    evidence := derivedMember.Name()
+    if evidence == nil {
+      evidence = derivedMember
+    }
+    g.addEdgeAt(from, to, EdgeMemberRelation, relation, evidence.Pos(), evidence.End())
+  }
+}
+
+// declaredTypeMembers returns the members written on every class/interface
+// declaration merged into symbol. The checker sees that merged type as one
+// surface, so choosing one representative declaration would omit valid pairs
+// contributed by another declaration even though both graph nodes already
+// exist.
+func declaredTypeMembers(symbol *shimast.Symbol) []*shimast.Node {
+  if symbol == nil {
+    return nil
+  }
+  var members []*shimast.Node
+  for _, declaration := range symbol.Declarations {
+    members = append(members, classMembers(declaration)...)
+  }
+  return members
+}
+
+// inheritedMemberForProperty resolves the declaration a base type inherits
+// rather than declares, by following the property to the symbol it roots at.
+//
+// It is the fallback for what directMemberForProperty below cannot see. A
+// heritage clause names one type and the member may be declared further up:
+// `interface Child extends Root {}` with `class W implements Child` roots
+// `W.execute` at `Root.execute`, which `Child`'s own member list does not hold.
+// Static members and constructors are skipped for the same reason the direct
+// scan skips them — neither participates in a member relation.
+func inheritedMemberForProperty(
+  checker *shimchecker.Checker,
+  property *shimast.Symbol,
+) *shimast.Node {
+  if checker == nil || property == nil {
+    return nil
+  }
+  for _, root := range checker.GetRootSymbols(property) {
+    if root == nil {
+      continue
+    }
+    for _, declaration := range root.Declarations {
+      if declaration == nil ||
+        shimast.GetCombinedModifierFlags(declaration)&shimast.ModifierFlagsStatic != 0 ||
+        declaration.Kind == shimast.KindConstructor {
+        continue
+      }
+      return declaration
+    }
+  }
+  return nil
+}
+
+// directMemberForProperty maps an instantiated or transient checker property
+// back to the declaration the named base type itself owns. It answers nothing
+// for a property the base only inherits, which is what
+// inheritedMemberForProperty above then resolves.
+func directMemberForProperty(
+  checker *shimchecker.Checker,
+  property *shimast.Symbol,
+  members []*shimast.Node,
+) *shimast.Node {
+  for _, member := range members {
+    symbol := member.Symbol()
+    if symbol == nil || symbol.Name == "" ||
+      shimast.GetCombinedModifierFlags(member)&shimast.ModifierFlagsStatic != 0 ||
+      member.Kind == shimast.KindConstructor {
+      continue
+    }
+    if propertyRootsAt(checker, property, symbol) {
+      return member
+    }
+  }
+  return nil
+}
+
+func propertyRootsAt(checker *shimchecker.Checker, property, declaration *shimast.Symbol) bool {
+  if checker == nil || property == nil || declaration == nil {
+    return false
+  }
+  for _, root := range checker.GetRootSymbols(property) {
+    if root == declaration {
+      return true
+    }
+  }
+  return false
+}
+
+// graphMemberNodeID returns the existing graph node for a class or interface
+// member. It never materializes a new endpoint: member relations stay within
+// the same workspace-owned member surface Build already records.
+func graphMemberNodeID(g *Graph, member *shimast.Node) string {
+  if g == nil || member == nil || member.Symbol() == nil {
+    return ""
+  }
+  kind := NodeKind("")
+  switch {
+  case isMethodMember(member.Kind):
+    kind = NodeMethod
+  case isPropertyMember(member.Kind):
+    kind = NodeVariable
+  default:
+    return ""
+  }
+  file := shimast.GetSourceFileOfNode(member)
+  name := methodName(member.Symbol())
+  if file == nil || name == "" {
+    return ""
+  }
+  id := nodeID(file.FileName(), name, kind)
+  stored, ok := g.Nodes[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
+    }
+  }
+  return ""
+}
+
 // collectCalls records a value-call edge from each declaration to every function,
 // method, or constructor it invokes. The reference walk is attributed to the
 // nearest enclosing graph node: a top-level function, a class/interface method, a

package/internal/graph/graph.go

@@ -1,6 +1,8 @@
 package graph
 
 import (
+  "strings"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
 )
 
@@ -84,11 +86,25 @@ type Node struct {
   // per member would grow the graph and put leaves into tour flows to index
   // what grep already does. This fills in the node that exists instead.
   EnumMembers []EnumMember
+  // ObjectMembers is the direct, statically named outline of an object literal
+  // assigned to this variable. It is captured from the compiler AST, in source
+  // order, so comments and lexical trivia cannot change member identity. The
+  // positions point into the same Program-owned source snapshot NewDump uses to
+  // render the compact signature and line carried on the wire.
+  ObjectMembers []ObjectMember
   // Pos and End bound the declaration in its source file (byte offsets). They
   // are for display, never identity, so an edit that shifts them does not re-key
   // the node.
-  Pos                int
-  End                int
+  Pos int
+  End int
+  // SignatureEnd bounds the declaration head — everything up to where the body
+  // opens. A consumer that guessed the boundary by scanning physical lines both
+  // leaked implementation text when a declaration shared its line with its body
+  // and stopped early when the head itself contained a brace, because a line is
+  // not a declaration boundary and a brace is not always a body. The compiler
+  // knows where the body starts, so it says so here. Zero when the declaration
+  // has no body to bound, in which case the whole declaration is the head.
+  SignatureEnd       int
   ImplementationFile string
   ImplementationPos  int
   ImplementationEnd  int
@@ -102,6 +118,24 @@ type EnumMember struct {
   Value string
 }
 
+// ObjectMember is one direct, statically named property, method, or accessor of
+// an object-literal variable. A spread has no declaration name of its own and a
+// dynamic computed key cannot be named soundly, so neither fabricates a member.
+type ObjectMember struct {
+  Name string
+  Kind NodeKind
+  Pos  int
+  End  int
+  // SignatureEnd is the AST boundary before a nested value body. When the
+  // boundary lands at an opening token's full start, SignatureTokenLen says how
+  // many source bytes belong to the outline (`{`, `[`, or `class`). A true
+  // SignatureBoundary permits whitespace-normalizing a multiline declaration
+  // through that safe endpoint; otherwise the outline stops at its first line.
+  SignatureEnd      int
+  SignatureBoundary bool
+  SignatureTokenLen int
+}
+
 // EdgeKind classifies a relationship between two nodes.
 type EdgeKind string
 
@@ -109,6 +143,13 @@ const (
   // EdgeHeritage is an `extends` / `implements` relationship from a class or
   // interface to a base it derives from.
   EdgeHeritage EdgeKind = "heritage"
+  // EdgeMemberRelation is a checker-verified relationship from a directly
+  // declared member to the directly declared base member it implements or
+  // overrides. Origin is "implements" or "overrides" and becomes the wire
+  // kind. Keeping this separate from EdgeHeritage prevents a member fact from
+  // being confused with the syntactic container clause that led the checker to
+  // compare the two types.
+  EdgeMemberRelation EdgeKind = "member-relation"
   // EdgeValueCall is a runtime use from one declaration of the function, method,
   // or constructor it invokes: a call, a `new T()`, a `<Component/>` JSX use, or
   // a tagged-template tag. Uses of a dependency's method are not modeled (the
@@ -142,7 +183,8 @@ type Edge struct {
   // (calls / instantiates / renders, extends / implements) without the
   // MCP-facing model losing the distinction. It is "" for kinds that need no
   // split (type-ref, value-access). For EdgeValueCall it is "call", "new",
-  // "jsx", or "tagged"; for EdgeHeritage it is "extends" or "implements".
+  // "jsx", or "tagged"; for EdgeHeritage it is "extends" or "implements";
+  // for EdgeMemberRelation it is "implements" or "overrides".
   Origin string
   Pos    int
   End    int
@@ -182,7 +224,103 @@ type edgeKey struct {
 }
 
 // nodeID builds the position-invariant identity for a symbol named name,
-// declared as kind in the source file at path.
+// declared as kind in the source file at path. The visible grammar remains
+// path#name:kind, but path and name quote a literal backslash and hash so a
+// consumer never has to guess which hash separates the two components.
 func nodeID(path string, name string, kind NodeKind) string {
-  return path + "#" + name + ":" + string(kind)
+  return escapeNodeIDPart(path) + "#" + escapeNodeIDPart(name) + ":" + string(kind)
+}
+
+// nodeIDParts are the structured facts carried by a symbol id. File nodes are
+// raw paths rather than symbol ids, so parseNodeID deliberately rejects them.
+type nodeIDParts struct {
+  path string
+  name string
+  kind NodeKind
+}
+
+// parseNodeID recovers the structured path, name, and kind from an id emitted
+// by nodeID. It also accepts older ids whose ordinary components were not
+// escaped, so a newer reader can still consume a pre-codec dump.
+func parseNodeID(id string) (nodeIDParts, bool) {
+  hash := nodeIDHash(id)
+  if hash < 0 {
+    return nodeIDParts{}, false
+  }
+  tail := id[hash+1:]
+  colon := strings.LastIndex(tail, ":")
+  if colon <= 0 || colon == len(tail)-1 {
+    return nodeIDParts{}, false
+  }
+  return nodeIDParts{
+    path: unescapeNodeIDPart(id[:hash]),
+    name: unescapeNodeIDPart(tail[:colon]),
+    kind: NodeKind(tail[colon+1:]),
+  }, true
+}
+
+// nodeFile recovers the raw source path embedded in a symbol id. An id without
+// a symbol component is a file id, and therefore has no node-file component.
+func nodeFile(id string) string {
+  parts, ok := parseNodeID(id)
+  if !ok {
+    return ""
+  }
+  return parts.path
+}
+
+// NodeFile is the graph-symbol provider's shared view of the node-id grammar.
+// Keeping the parser here prevents its LSP path comparison from drifting from
+// the dump producer's edge-evidence lookup.
+func NodeFile(id string) string {
+  return nodeFile(id)
+}
+
+func escapeNodeIDPart(value string) string {
+  value = strings.ReplaceAll(value, "\\", "\\\\")
+  return strings.ReplaceAll(value, "#", "\\#")
+}
+
+func unescapeNodeIDPart(value string) string {
+  var out strings.Builder
+  out.Grow(len(value))
+  for i := 0; i < len(value); i++ {
+    if value[i] == '\\' && i+1 < len(value) {
+      next := value[i+1]
+      if next == '#' || (next == '\\' && !legacyUNCStart(value, i)) {
+        i++
+      }
+    }
+    out.WriteByte(value[i])
+  }
+  return out.String()
+}
+
+// legacyUNCStart distinguishes an older raw UNC path (\\server) from a new
+// codec spelling (\\\\server). The former predates backslash escaping and must
+// remain readable by a current consumer.
+func legacyUNCStart(value string, index int) bool {
+  return index == 0 && len(value) > 2 && value[2] != '\\' && value[2] != '#'
+}
+
+func nodeIDHash(id string) int {
+  for i := 0; i < len(id); i++ {
+    if id[i] != '#' {
+      continue
+    }
+    if i == 0 || id[i-1] != '\\' || escapedBackslash(id, i-1) {
+      return i
+    }
+  }
+  return -1
+}
+
+// escapedBackslash reports whether slash is itself escaped by the run before
+// it. Only an odd run quotes the following hash.
+func escapedBackslash(id string, slash int) bool {
+  count := 0
+  for i := slash; i >= 0 && id[i] == '\\'; i-- {
+    count++
+  }
+  return count%2 == 0
 }

package/internal/graph/line_model.go

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

package/internal/graph/member_relation_edges_follow_checker_validity_test.go

@@ -0,0 +1,85 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestMemberRelationEdgesFollowCheckerValidity verifies that native graph
+// member relationships preserve the structurally valid shapes the TypeScript
+// checker accepts, including shapes whose syntax kinds differ.
+//
+// A method/property equality gate would drop two valid implementations here: a
+// getter satisfying a readonly property and a method satisfying a
+// function-valued property. The graph must follow checker assignability rather
+// than replace one name heuristic with a kind heuristic.
+//
+//  1. Compile a class implementing an interface through ordinary methods plus
+//     the two valid cross-kind shapes, and a class overriding an abstract base.
+//  2. Build the native graph.
+//  3. Assert every directly declared checker-valid pair has the correct member
+//     relation while constructors never become override edges.
+func TestMemberRelationEdgesFollowCheckerValidity(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `export interface Contract {
+  run(input: string): string;
+  readonly name: string;
+  callback: () => void;
+}
+export class Implementation implements Contract {
+  run(input: string): string { return input; }
+  get name(): string { return "implementation"; }
+  callback(): void {}
+}
+export abstract class Base {
+  constructor(readonly seed: string) {}
+  abstract act(input: string): string;
+  property: () => void = () => {};
+}
+export class Derived extends Base {
+  constructor() { super("seed"); }
+  act(input: string): string { return input; }
+  property: () => void = () => {};
+}
+`)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected load diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+  if diagnostics := prog.Diagnostics(); len(diagnostics) != 0 {
+    t.Fatalf("fixture must be checker-valid: %v", diagnostics)
+  }
+
+  built := Build(prog)
+  path := sourceFile(t, prog, "main.ts").FileName()
+  assertions := []struct {
+    from   string
+    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"},
+  }
+  for _, assertion := range assertions {
+    if got := edgeOrigin(built, assertion.from, assertion.to, EdgeMemberRelation); got != assertion.origin {
+      t.Fatalf("%s -> %s: want %q member relation, got %q; edges: %v", assertion.from, assertion.to, assertion.origin, got, built.Edges)
+    }
+  }
+
+  derivedConstructor := nodeID(path, "Derived.__constructor", NodeMethod)
+  baseConstructor := nodeID(path, "Base.__constructor", NodeMethod)
+  if hasEdge(built, derivedConstructor, baseConstructor, EdgeMemberRelation) {
+    t.Fatalf("constructors are not member overrides; edges: %v", built.Edges)
+  }
+}