ttsc 0.19.3 → 0.20.0

package/driver/windowsjunction/windowsjunction.go

@@ -0,0 +1,40 @@
+// Package windowsjunction creates a Windows directory junction without
+// interpolating filesystem paths into cmd.exe syntax.
+package windowsjunction
+
+import (
+  "fmt"
+  "os"
+  "os/exec"
+  "strings"
+)
+
+const (
+  linkEnvironment   = "TTSC_WINDOWS_JUNCTION_LINK"
+  targetEnvironment = "TTSC_WINDOWS_JUNCTION_TARGET"
+)
+
+// Create makes link a directory junction that points to target.
+func Create(link, target string) error {
+  // mklink is a cmd.exe builtin. Feed a constant command over stdin and use
+  // delayed environment expansion so Go never has to quote a command string
+  // for cmd.exe. Delayed values are substituted after cmd has classified the
+  // command's metacharacters, keeping every character in each path as data.
+  cmd := exec.Command("cmd.exe", "/d", "/q", "/v:on")
+  cmd.Stdin = strings.NewReader(
+    "mklink /J \"!TTSC_WINDOWS_JUNCTION_LINK!\" \"!TTSC_WINDOWS_JUNCTION_TARGET!\"\r\nexit /b !errorlevel!\r\n",
+  )
+  cmd.Env = append(
+    os.Environ(),
+    linkEnvironment+"="+link,
+    targetEnvironment+"="+target,
+  )
+  if out, err := cmd.CombinedOutput(); err != nil {
+    return fmt.Errorf(
+      "mklink /J failed: %v: %s",
+      err,
+      strings.TrimSpace(string(out)),
+    )
+  }
+  return nil
+}

package/go.mod

@@ -8,6 +8,7 @@ go 1.26
 // stabilizes.
 replace (
 	github.com/microsoft/typescript-go/shim/ast => ./shim/ast
+	github.com/microsoft/typescript-go/shim/astnav => ./shim/astnav
 	github.com/microsoft/typescript-go/shim/bundled => ./shim/bundled
 	github.com/microsoft/typescript-go/shim/checker => ./shim/checker
 	github.com/microsoft/typescript-go/shim/compiler => ./shim/compiler
@@ -26,6 +27,7 @@ replace (
 
 require (
 	github.com/microsoft/typescript-go/shim/ast v0.0.0
+	github.com/microsoft/typescript-go/shim/astnav v0.0.0
 	github.com/microsoft/typescript-go/shim/bundled v0.0.0
 	github.com/microsoft/typescript-go/shim/checker v0.0.0
 	github.com/microsoft/typescript-go/shim/compiler v0.0.0

package/internal/graph/build.go

@@ -28,12 +28,22 @@ func Build(prog *driver.Program) *Graph {
   return g
 }
 
-// SourceTexts maps each program source file to its text — the evidence input
-// NewDump needs to turn a node or edge byte span into a line/column.
+// SourceTexts maps every program source to the resident checker text.
+// Declaration and virtual bundled files are included because external graph
+// leaves still carry facts and spans the source manifest must attest to.
 func SourceTexts(prog *driver.Program) map[string]string {
-  files := prog.SourceFiles()
+  if prog == nil || prog.TSProgram == nil {
+    return map[string]string{}
+  }
+  // Discarded on purpose: this returns text, not an error channel. A failed
+  // apply reaches the dump through `NewDiagnostics`, which asks `Diagnostics`.
+  _ = prog.ApplyLinkedPlugins()
+  files := prog.TSProgram.SourceFiles()
   out := make(map[string]string, len(files))
   for _, file := range files {
+    if file == nil {
+      continue
+    }
     out[file.FileName()] = file.Text()
   }
   return out
@@ -114,6 +124,7 @@ func collectVariables(g *Graph, path string, statement *shimast.Node) {
   }
   for _, binding := range list.Declarations.Nodes {
     addNode(g, path, binding, NodeVariable)
+    g.collectObjectMembers(path, binding)
     collectClosures(g, path, binding)
   }
 }
@@ -398,18 +409,41 @@ func putDeclaredNode(g *Graph, path, name string, kind NodeKind, declaration *sh
     }
   }
   g.Nodes[id] = &Node{
-    ID:        id,
-    Name:      name,
-    Simple:    simpleName(declaration.Symbol()),
-    Kind:      kind,
-    File:      path,
-    Pos:       declaration.Pos(),
-    End:       declaration.End(),
-    Modifiers: declarationModifiers(declaration),
+    ID:           id,
+    Name:         name,
+    Simple:       simpleName(declaration.Symbol()),
+    Kind:         kind,
+    File:         path,
+    Pos:          declaration.Pos(),
+    End:          declaration.End(),
+    SignatureEnd: declarationSignatureEnd(declaration),
+    Modifiers:    declarationModifiers(declaration),
   }
   g.bodyNodes[id] = hasBody
 }
 
+// declarationSignatureEnd is the offset where a declaration's head ends, or 0
+// when this declaration has no body to bound.
+//
+// It reuses the boundary walk the object-member outline already uses, which
+// stops at the construct that opens a body — a block, an object or array
+// literal, a class expression, or an arrow's `=>`. Reusing it keeps one
+// definition of "where the head ends" for both outlines rather than two that
+// can disagree.
+//
+// A boundary at or before the declaration's own start, or past its end, is no
+// boundary; those report 0 and leave the consumer on its existing behavior.
+func declarationSignatureEnd(declaration *shimast.Node) int {
+  if declaration == nil {
+    return 0
+  }
+  boundary, found := sourceBodyBoundary(declaration)
+  if !found || boundary.end <= declaration.Pos() || boundary.end > declaration.End() {
+    return 0
+  }
+  return boundary.end
+}
+
 // declarationModifiers maps a declaration's combined modifier flags onto the
 // wire-string subset of the TtscGraphNodeModifier union. Only flags with an
 // exact union member are emitted, in a stable order; an unknown string would

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
@@ -65,24 +65,42 @@ type DumpEnumMember struct {
   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"`
-  Literals       []string         `json:"literals,omitempty"`
-  EnumMembers    []DumpEnumMember `json:"enumMembers,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
@@ -128,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
@@ -173,6 +192,8 @@ func NewDump(g *Graph, project, tsconfig string, ignored map[string]bool, source
       // 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],
@@ -201,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
@@ -220,19 +241,23 @@ 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
@@ -248,10 +273,42 @@ func dumpEnumMembers(members []EnumMember) []DumpEnumMember {
   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, "", "  ")
   }
@@ -267,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()
@@ -310,6 +371,8 @@ func wireEdgeKind(kind EdgeKind, origin string) string {
       return "extends"
     }
     return "implements"
+  case EdgeMemberRelation:
+    return origin
   default:
     return string(kind)
   }
@@ -335,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.
 //
@@ -377,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
@@ -412,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) {
@@ -421,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.
@@ -473,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.