ttsc 0.19.2 → 0.20.0

package/internal/graph/dump.go

@@ -4,7 +4,6 @@ import (
   "bufio"
   "encoding/json"
   "io"
-  "path/filepath"
   "sort"
   "strings"
 )
@@ -16,11 +15,12 @@ import (
 //
 //   - internal node kinds map straight through (NodeTypeAlias is already "type");
 //   - one EdgeValueCall splits by Origin into "calls" / "instantiates" /
-//     "renders", and EdgeHeritage into "extends" / "implements";
+//     "renders", EdgeHeritage into "extends" / "implements", and
+//     EdgeMemberRelation into "implements" / "overrides";
 //   - byte spans become 1-based line/col Evidence ranges;
 //   - decorator facts ride on their target node;
-//   - file paths are project-relative and the output is sorted, so the dump is
-//     deterministic and diffable.
+//   - file paths use one portable, injective project coordinate and the output
+//     is sorted, so the dump is deterministic and diffable.
 //
 // Structural derivations the schema also defines (file nodes, contains/exports
 // edges) are left to the TypeScript loader, which has the node set in hand and
@@ -56,22 +56,51 @@ type DumpDecorator struct {
   Arguments []DumpDecoratorArgument `json:"arguments"`
 }
 
+// DumpEnumMember is one member of an enum on the wire: the name a caller writes
+// and the value it carries. `value` is omitted for a member the checker could
+// not fold to a constant — the name still stands, and the name is what a caller
+// asking about the enum came for.
+type DumpEnumMember struct {
+  Name  string `json:"name"`
+  Value string `json:"value,omitempty"`
+}
+
+// DumpObjectMember is one direct object-literal member carried on its variable
+// node. Line and Signature are rendered from the same Program-owned source text
+// as the node evidence, so the outline cannot race a later disk write.
+type DumpObjectMember struct {
+  Name      string `json:"name"`
+  Kind      string `json:"kind"`
+  Line      int    `json:"line,omitempty"`
+  Signature string `json:"signature,omitempty"`
+}
+
 // DumpNode is the wire shape of a graph node. Lowercase json keys are the
 // contract; the Go field names are not.
 type DumpNode struct {
-  ID             string          `json:"id"`
-  Kind           string          `json:"kind"`
-  Name           string          `json:"name"`
-  QualifiedName  string          `json:"qualifiedName,omitempty"`
-  File           string          `json:"file"`
-  External       bool            `json:"external"`
-  Ignored        bool            `json:"ignored,omitempty"`
-  Exported       bool            `json:"exported,omitempty"`
-  Closure        bool            `json:"closure,omitempty"`
-  Modifiers      []string        `json:"modifiers,omitempty"`
-  Evidence       *DumpEvidence   `json:"evidence,omitempty"`
-  Implementation *DumpEvidence   `json:"implementation,omitempty"`
-  Decorators     []DumpDecorator `json:"decorators,omitempty"`
+  ID            string `json:"id"`
+  Kind          string `json:"kind"`
+  Name          string `json:"name"`
+  QualifiedName string `json:"qualifiedName,omitempty"`
+  // Signature is the declaration head, cut where the compiler says the body
+  // opens. A consumer that reconstructed it 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 — a type-literal
+  // parameter, an object return type, a destructured parameter. Neither is a
+  // guess the consumer can win, so the producer renders it here.
+  Signature      string             `json:"signature,omitempty"`
+  File           string             `json:"file"`
+  External       bool               `json:"external"`
+  Ignored        bool               `json:"ignored,omitempty"`
+  Exported       bool               `json:"exported,omitempty"`
+  Closure        bool               `json:"closure,omitempty"`
+  Modifiers      []string           `json:"modifiers,omitempty"`
+  Literals       []string           `json:"literals,omitempty"`
+  EnumMembers    []DumpEnumMember   `json:"enumMembers,omitempty"`
+  ObjectMembers  []DumpObjectMember `json:"objectMembers,omitempty"`
+  Evidence       *DumpEvidence      `json:"evidence,omitempty"`
+  Implementation *DumpEvidence      `json:"implementation,omitempty"`
+  Decorators     []DumpDecorator    `json:"decorators,omitempty"`
 }
 
 // DumpEdge is the wire shape of a graph edge. Lowercase json keys are the
@@ -117,12 +146,13 @@ type DumpOrigin struct {
 }
 
 // NewDump projects a built graph onto the export shape. project is the absolute
-// project root used to relativize file paths and node ids; ignored is the
-// git-ignored source set (nil for a non-git project); sources maps a source
-// file's path to its text so byte spans become line/col evidence (nil omits
-// evidence); origin is the snapshot evidence that proves where the facts came
-// from.
-func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin) Dump {
+// root of the portable path coordinate; ignored is the git-ignored source set
+// (nil for a non-git project); sources maps a source file's physical path to its
+// text so byte spans become line/col evidence (nil omits evidence); origin is
+// the snapshot evidence that proves where the facts came from. It returns an
+// error before serialization when a path is on another filesystem root or two
+// physical sources would collide at one wire identity.
+func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin) (Dump, error) {
   ctx := newDumpContext(project, sources)
 
   // Decorators ride on their target node; group by the internal node id before
@@ -148,16 +178,22 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
       name, qualified = ctx.rel(name), ""
     }
     nodes = append(nodes, DumpNode{
-      ID:             ctx.relID(n.ID),
-      Kind:           string(n.Kind),
-      Name:           name,
-      QualifiedName:  qualified,
-      File:           ctx.rel(n.File),
-      External:       n.External,
-      Ignored:        ignored[n.File],
-      Exported:       n.Exported,
-      Closure:        n.Closure,
-      Modifiers:      n.Modifiers,
+      ID:            ctx.relID(n.ID),
+      Kind:          string(n.Kind),
+      Name:          name,
+      QualifiedName: qualified,
+      File:          ctx.rel(n.File),
+      External:      n.External,
+      Ignored:       ignored[n.File],
+      Exported:      n.Exported,
+      Closure:       n.Closure,
+      Modifiers:     n.Modifiers,
+      // Uncapped, like every other fact here: the dump is the whole graph and
+      // the MCP layer is what applies a response cap and marks it.
+      Literals:       n.Literals,
+      EnumMembers:    dumpEnumMembers(n.EnumMembers),
+      ObjectMembers:  ctx.objectMembers(n),
+      Signature:      ctx.declarationSignature(n),
       Evidence:       withoutFile(ctx.evidence(n.File, n.Pos, n.End)),
       Implementation: ctx.evidence(n.ImplementationFile, n.ImplementationPos, n.ImplementationEnd),
       Decorators:     decByNode[n.ID],
@@ -186,7 +222,7 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
 
   // The schema version describes this code, not the caller's belief about it,
   // so stamp it here rather than trusting what came in.
-  provenance := origin.Provenance
+  provenance := ctx.provenance(origin.Provenance)
   provenance.SchemaVersion = DumpSchemaVersion
 
   // A nil slice encodes as JSON null, and null is not an empty list: a reader
@@ -205,25 +241,74 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
     provenance.Universe.Roots = []RootFile{}
   }
 
-  diagnostics := origin.Diagnostics
+  diagnostics := ctx.diagnostics(origin.Diagnostics)
   if diagnostics == nil {
     diagnostics = []Diagnostic{}
   }
 
-  return Dump{
+  dump := Dump{
     Project:     project,
-    Tsconfig:    tsconfig,
+    Tsconfig:    ctx.rel(tsconfig),
     Provenance:  provenance,
     Diagnostics: diagnostics,
     Nodes:       nodes,
     Edges:       edges,
   }
+  if err := ctx.pathError(); err != nil {
+    return Dump{}, err
+  }
+  return dump, nil
+}
+
+// dumpEnumMembers projects an enum's members onto the wire shape, nil for a
+// node that declares none so the key stays off every other kind.
+func dumpEnumMembers(members []EnumMember) []DumpEnumMember {
+  if len(members) == 0 {
+    return nil
+  }
+  out := make([]DumpEnumMember, 0, len(members))
+  for _, member := range members {
+    out = append(out, DumpEnumMember{Name: member.Name, Value: member.Value})
+  }
+  return out
+}
+
+// objectMembers projects AST-owned object member identity and snapshot-owned
+// display text. A missing source omits only line/signature; identity still came
+// from the AST and therefore remains sound.
+func (c *dumpContext) objectMembers(node *Node) []DumpObjectMember {
+  if len(node.ObjectMembers) == 0 {
+    return nil
+  }
+  out := make([]DumpObjectMember, 0, len(node.ObjectMembers))
+  for _, member := range node.ObjectMembers {
+    dumped := DumpObjectMember{
+      Name: member.Name,
+      Kind: objectMemberWireKind(member.Kind),
+    }
+    if evidence := c.evidence(node.File, member.Pos, member.End); evidence != nil {
+      dumped.Line = evidence.StartLine
+    }
+    dumped.Signature = c.objectMemberSignature(node.File, member)
+    out = append(out, dumped)
+  }
+  return out
+}
+
+func objectMemberWireKind(kind NodeKind) string {
+  if kind == NodeMethod {
+    return "method"
+  }
+  return "property"
 }
 
 // MarshalDump serializes a built graph to the export JSON, indented when pretty.
 // See NewDump for the parameters.
 func MarshalDump(g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin, pretty bool) ([]byte, error) {
-  d := NewDump(g, project, tsconfig, ignored, sources, origin)
+  d, err := NewDump(g, project, tsconfig, ignored, sources, origin)
+  if err != nil {
+    return nil, err
+  }
   if pretty {
     return json.MarshalIndent(d, "", "  ")
   }
@@ -239,12 +324,16 @@ func MarshalDump(g *Graph, project, tsconfig string, ignored map[string]bool, so
 // copy of it held live beside the first — half a gigabyte of peak heap that
 // bought nothing, because the bytes were already exactly what stdout wanted.
 func EncodeDump(w io.Writer, g *Graph, project, tsconfig string, ignored map[string]bool, sources map[string]string, origin DumpOrigin, pretty bool) error {
+  dump, err := NewDump(g, project, tsconfig, ignored, sources, origin)
+  if err != nil {
+    return err
+  }
   buffered := bufio.NewWriterSize(w, 1<<20)
   encoder := json.NewEncoder(buffered)
   if pretty {
     encoder.SetIndent("", "  ")
   }
-  if err := encoder.Encode(NewDump(g, project, tsconfig, ignored, sources, origin)); err != nil {
+  if err := encoder.Encode(dump); err != nil {
     return err
   }
   return buffered.Flush()
@@ -282,6 +371,8 @@ func wireEdgeKind(kind EdgeKind, origin string) string {
       return "extends"
     }
     return "implements"
+  case EdgeMemberRelation:
+    return origin
   default:
     return string(kind)
   }
@@ -307,41 +398,30 @@ func nodeNames(n *Node) (simple, qualified string) {
   return n.Simple, n.Name
 }
 
-// dumpContext relativizes paths and turns byte spans into line/col evidence,
-// caching a per-file line index so a large file's many edges cost O(log n) each
-// instead of a re-scan.
+// dumpContext maps paths and turns byte spans into line/col evidence, caching a
+// per-file line index so a large file's many edges cost O(log n) each instead
+// of a re-scan.
 type dumpContext struct {
-  project string
+  paths   *dumpPathMapper
   sources map[string]string
   lines   map[string]lineStarts
 }
 
 func newDumpContext(project string, sources map[string]string) *dumpContext {
   return &dumpContext{
-    project: strings.TrimRight(filepath.ToSlash(project), "/"),
+    paths:   newDumpPathMapper(project),
     sources: sources,
     lines:   map[string]lineStarts{},
   }
 }
 
-// rel makes a source file path project-relative; an external path keeps its
-// node_modules-relative tail so a dependency leaf stays readable.
+// rel delegates every identity-bearing path to the dump's one cached mapper.
 func (c *dumpContext) rel(file string) string {
-  f := filepath.ToSlash(file)
-  if c.project != "" {
-    if f == c.project {
-      return ""
-    }
-    if strings.HasPrefix(f, c.project+"/") {
-      return f[len(c.project)+1:]
-    }
-  }
-  if i := strings.LastIndex(f, "/node_modules/"); i >= 0 {
-    return f[i+1:]
-  }
-  return f
+  return c.paths.mapPath(file)
 }
 
+func (c *dumpContext) pathError() error { return c.paths.err() }
+
 // relID relativizes the path portion of a node id ("path#qualifiedName:kind").
 // An id with no path (a future virtual node) is returned unchanged.
 //
@@ -349,17 +429,15 @@ func (c *dumpContext) rel(file string) string {
 // both relativize. Every other node is named by a symbol, which passes through
 // untouched.
 func (c *dumpContext) relID(id string) string {
-  hash := strings.Index(id, "#")
-  if hash < 0 {
+  parts, ok := parseNodeID(id)
+  if !ok {
     return id
   }
-  head, tail := c.rel(id[:hash]), id[hash+1:]
-  suffix := ":" + string(NodeModule)
-  if strings.HasSuffix(tail, suffix) {
-    name := strings.TrimSuffix(tail, suffix)
-    return head + "#" + c.rel(name) + suffix
+  name := parts.name
+  if parts.kind == NodeModule {
+    name = c.rel(name)
   }
-  return head + "#" + tail
+  return nodeID(c.rel(parts.path), name, parts.kind)
 }
 
 // evidence builds the line/col span for a byte range in file, or nil when the
@@ -384,7 +462,7 @@ func (c *dumpContext) evidence(file string, pos, end int) *DumpEvidence {
   // leading whitespace and doc comments before the token. Advance to the first
   // code character so the line/column point at the declaration, not its banner
   // or its indentation.
-  pos = firstCodeOffset(text, pos)
+  pos = FirstCodeOffset(text, pos)
   sl, sc := ls.at(pos)
   ev := &DumpEvidence{File: c.rel(file), StartLine: sl, StartCol: sc}
   if end > pos && end <= len(text) {
@@ -393,36 +471,178 @@ func (c *dumpContext) evidence(file string, pos, end int) *DumpEvidence {
   return ev
 }
 
-// firstCodeOffset advances past leading trivia: whitespace, // line comments,
-// and /* */ block comments from pos to the first code byte, or len(text) if
-// the rest is all trivia. It mirrors how a token's real start is found, so an
-// evidence span lands on the declaration rather than the comment above it.
-func firstCodeOffset(text string, pos int) int {
-  i := pos
-  for i < len(text) {
+// declarationSignature renders a declaration's head from the same
+// Program-owned source text as its evidence, so the outline cannot race a later
+// disk write. Empty when the producer could not bound the head, which leaves the
+// consumer on its existing line scan rather than handing it a wrong cut.
+func (c *dumpContext) declarationSignature(n *Node) string {
+  if n == nil || n.SignatureEnd <= n.Pos || c.sources == nil {
+    return ""
+  }
+  text, ok := c.sources[n.File]
+  if !ok {
+    return ""
+  }
+  pos := FirstCodeOffset(text, n.Pos)
+  end := min(n.SignatureEnd, len(text))
+  if pos >= end {
+    return ""
+  }
+  return strings.TrimSpace(text[pos:end])
+}
+
+// objectMemberSignature reproduces the compact outline details has historically
+// returned, but slices it from Program-owned text while the dump is built
+// instead of reopening the live file later.
+func (c *dumpContext) objectMemberSignature(file string, member ObjectMember) string {
+  pos, end := member.Pos, member.SignatureEnd
+  if pos < 0 || end <= pos || c.sources == nil {
+    return ""
+  }
+  text, ok := c.sources[file]
+  if !ok || pos > len(text) {
+    return ""
+  }
+  pos = FirstCodeOffset(text, pos)
+  if end > len(text) {
+    end = len(text)
+  }
+  if member.SignatureTokenLen > 0 {
+    end = FirstCodeOffset(text, end)
+    end = min(end+member.SignatureTokenLen, len(text))
+  }
+  if pos >= end {
+    return ""
+  }
+  if pos >= end {
+    return ""
+  }
+  signature := strings.TrimSuffix(compactObjectMemberSignature(text[pos:end]), ",")
+  const maxObjectMemberSignatureRunes = 160
+  runes := []rune(signature)
+  if len(runes) > maxObjectMemberSignatureRunes {
+    signature = string(runes[:maxObjectMemberSignatureRunes-3]) + "..."
+  }
+  return signature
+}
+
+// compactObjectMemberSignature collapses trivia outside lexical values while
+// leaving quoted strings, template literals, regular expressions, and comments
+// byte-for-byte intact. A display outline may be compact, but changing literal
+// whitespace would change the declaration it claims to quote.
+func compactObjectMemberSignature(text string) string {
+  var out strings.Builder
+  pendingSpace := false
+  for i := 0; i < len(text); {
+    if width := sourceWhitespaceWidth(text, i); width > 0 {
+      pendingSpace = out.Len() > 0
+      i += width
+      continue
+    }
+    if pendingSpace {
+      out.WriteByte(' ')
+      pendingSpace = false
+    }
+
+    end := i + 1
+    switch text[i] {
+    case '\'', '"':
+      end = quotedSourceEnd(text, i, text[i])
+    case '`':
+      end = templateSourceEnd(text, i)
+    case '/':
+      switch {
+      case i+1 < len(text) && text[i+1] == '/':
+        end = LineCommentEnd(text, i)
+      case i+1 < len(text) && text[i+1] == '*':
+        end = blockCommentEnd(text, i)
+      default:
+        if candidate := regularExpressionEnd(text, i); candidate > i {
+          end = candidate
+        }
+      }
+    }
+    out.WriteString(text[i:end])
+    i = end
+  }
+  return strings.TrimSpace(out.String())
+}
+
+func quotedSourceEnd(text string, start int, quote byte) int {
+  escaped := false
+  for i := start + 1; i < len(text); i++ {
+    if escaped {
+      escaped = false
+      continue
+    }
+    if text[i] == '\\' {
+      escaped = true
+      continue
+    }
+    if text[i] == quote {
+      return i + 1
+    }
+  }
+  return len(text)
+}
+
+// templateSourceEnd returns the last unescaped backtick in the member span.
+// This deliberately treats substitutions and nested templates as one protected
+// lexical region: preserving a little extra spacing is safer than compacting
+// whitespace that belongs to either template's value.
+func templateSourceEnd(text string, start int) int {
+  end := len(text)
+  for i := len(text) - 1; i > start; i-- {
+    if text[i] == '`' && !sourceByteEscaped(text, i) {
+      return i + 1
+    }
+  }
+  return end
+}
+
+func sourceByteEscaped(text string, pos int) bool {
+  slashes := 0
+  for i := pos - 1; i >= 0 && text[i] == '\\'; i-- {
+    slashes++
+  }
+  return slashes%2 == 1
+}
+
+func blockCommentEnd(text string, start int) int {
+  if end := strings.Index(text[start+2:], "*/"); end >= 0 {
+    return start + 2 + end + 2
+  }
+  return len(text)
+}
+
+// regularExpressionEnd conservatively protects a slash-delimited region when
+// one closes on the same source line. Division can look the same without parser
+// context; preserving its spaces is harmless, while compacting a real regular
+// expression would change its pattern.
+func regularExpressionEnd(text string, start int) int {
+  escaped := false
+  inClass := false
+  for i := start + 1; i < len(text); i++ {
     switch {
-    case text[i] == ' ' || text[i] == '\t' || text[i] == '\r' || text[i] == '\n':
+    case lineTerminatorWidth(text, i) > 0:
+      return start
+    case escaped:
+      escaped = false
+    case text[i] == '\\':
+      escaped = true
+    case text[i] == '[':
+      inClass = true
+    case text[i] == ']':
+      inClass = false
+    case text[i] == '/' && !inClass:
       i++
-    case text[i] == '/' && i+1 < len(text) && text[i+1] == '/':
-      i += 2
-      for i < len(text) && text[i] != '\n' {
+      for i < len(text) && ((text[i] >= 'a' && text[i] <= 'z') || (text[i] >= 'A' && text[i] <= 'Z')) {
         i++
       }
-    case text[i] == '/' && i+1 < len(text) && text[i+1] == '*':
-      i += 2
-      for i+1 < len(text) && !(text[i] == '*' && text[i+1] == '/') {
-        i++
-      }
-      if i+1 < len(text) {
-        i += 2
-      } else {
-        i = len(text)
-      }
-    default:
       return i
     }
   }
-  return i
+  return start
 }
 
 // edgeEvidence is the evidence range for an edge's source expression.
@@ -445,28 +665,12 @@ func withoutFile(ev *DumpEvidence) *DumpEvidence {
   return ev
 }
 
-// nodeFile recovers the source file path embedded in a node id
-// ("path#qualifiedName:kind"); "" for an id without a path.
-func nodeFile(id string) string {
-  if hash := strings.Index(id, "#"); hash >= 0 {
-    return id[:hash]
-  }
-  return ""
-}
-
 // lineStarts holds the byte offset of each line's start, so an offset maps to a
 // 1-based line/column by binary search.
 type lineStarts []int
 
 func newLineStarts(text string) lineStarts {
-  starts := make(lineStarts, 1, 1+strings.Count(text, "\n"))
-  starts[0] = 0
-  for i := 0; i < len(text); i++ {
-    if text[i] == '\n' {
-      starts = append(starts, i+1)
-    }
-  }
-  return starts
+  return lineStarts(ECMALineStarts(text))
 }
 
 // at returns the 1-based line and column of a byte offset.