ttsc 0.19.2 → 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