ttsc 0.26.2 → 0.28.0

package/driver/emit_plugin.go

@@ -1,7 +1,6 @@
 package driver
 
 import (
-  "context"
   "errors"
   "strings"
   "sync"
@@ -97,13 +96,30 @@ func (p *Program) EmitLinkedTransforms(writeFile shimcompiler.WriteFile) ([]Diag
 // because the emit context's update hook only records the original, it does not
 // copy `DeclarationBase.Symbol`.
 //
-// tsgo's emit resolver then walks the transformed tree in
-// MarkLinkedReferencesRecursively and, when it resolves an identifier whose
-// scope chain passes through one of those rebuilt containers, calls
-// getSymbolOfDeclaration(container) — which reads container.Symbol() and nil-
-// panics on a rebuilt class/interface/enum. Restoring the symbol from the
-// original (the symbol object is shared and node-independent for lookup) lets
-// the resolver mark references the same way it would on the parse tree.
+// #201 added this against a real panic in the walk that
+// MarkLinkedReferencesRecursively used to run over the transformed tree. That
+// walk no longer happens here — the builtin chain is built from the parse tree
+// below — so the original trigger is gone, and no probe reproduces a panic with
+// this call stubbed out.
+//
+// Keep it anyway, because the remaining exposure is unproven rather than
+// absent. tsgo's own defense against a plugin-built node is ast.IsParseTreeNode,
+// which most EmitResolver reference methods test to bail out early — and a
+// REBUILT container does not trip it. The emit context stamps
+// NodeFlagsSynthesized when its factory creates a node, but ast.updateNode then
+// ASSIGNS `updated.Flags = original.Flags` and clears the marker again, so a
+// container carrying no symbol still answers "parse tree node" and is let
+// through to checker name resolution. There resolveName reaches
+// getSymbolOfDeclaration(container), an unguarded dereference for a class,
+// class expression, or interface (enum and module are nil-checked upstream).
+// What the probes could not settle is whether the builtin transformers ever
+// actually hand a rebuilt container to one of those methods.
+//
+// Restoring the symbol from the original (the symbol object is shared and
+// node-independent for lookup) makes that path resolve the way it would on the
+// parse tree, at the cost of one walk per file. EmitContext.ParseNode is
+// unaffected either way: it walks MostOriginal before testing the predicate, so
+// it always lands on the genuine parse node.
 func restoreOriginalDeclarationSymbols(ec *shimprinter.EmitContext, node *shimast.Node) {
   if node == nil {
     return
@@ -181,7 +197,39 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       }
       shimast.SetParentInChildrenUnset(out.AsNode())
       restoreOriginalDeclarationSymbols(ec, out.AsNode())
-      for _, tr := range shimcompiler.GetScriptTransformers(ec, host, out) {
+      // Build the chain from the PARSE tree and transform the plugin's tree.
+      // Upstream passes one file to both roles only because it has no plugin
+      // pass between them: emitJSFile hands getScriptTransformers the file it
+      // parsed, then reassigns it to the transform result. Here they differ.
+      //
+      // getScriptTransformers reads its file for three things: in-JS-file, JSX
+      // language variant, and emitResolver.MarkLinkedReferencesRecursively. The
+      // first two survive UpdateSourceFile, so marking is the whole difference,
+      // and marking is a per-node checker resolution walk under the single
+      // checker mutex.
+      //
+      // Marking the plugin's tree does not merely spend that walk on nodes the
+      // binder never saw, it emits broken JavaScript. Elision reads the marks
+      // back for the file's parse-tree imports, so a reference the plugin
+      // REBUILT (a fresh identifier linked with SetOriginal, which is what any
+      // partial rewrite produces) leaves its import unmarked. The module
+      // transform still aliases that reference and elision still drops the
+      // binding the alias names: `dep_1.foo` with no `const dep_1 =
+      // require(...)`, a ReferenceError at load. The emit_plugin_rebuilt_*
+      // tests pin each import binding shape, plus the ES module lane where the
+      // whole import declaration disappears instead of just its binding.
+      //
+      // Nothing is lost by skipping the plugin's nodes. UpdateSourceFile
+      // rebuilds a SourceFile through copyFrom, which carries over neither
+      // Locals nor Symbol, and an ordinary import binds into Locals, so no
+      // resolveName branch reaches an import from a synthetic identifier. An
+      // import the plugin synthesized needs no mark at all: it has no parse
+      // original, and elision preserves it unconditionally.
+      //
+      // Marks accumulate on the checker and are never cleared, so marking one
+      // fixed tree per file also stops a second emit on the same Program from
+      // inheriting the first pass's plugin-tree marks.
+      for _, tr := range shimcompiler.GetScriptTransformers(ec, host, sf) {
         out = tr.TransformSourceFile(out)
       }
       // Print through the source-map-aware helper so a `sourceMap` /
@@ -222,12 +270,30 @@ func (p *Program) EmitWithPluginTransformers(transforms []PluginTransform, write
       }
     }
   }
-  if !options.GetEmitDeclarations() {
+  // The declaration pass below doubles as this lane's build-information pass,
+  // so it also runs for a JavaScript-only `incremental` / `composite` project
+  // that has no declarations to write at all.
+  if !options.GetEmitDeclarations() && !p.emitsBuildInfo() {
     return nil, nil
   }
 
+  // What the build information this pass writes does and does not claim.
+  //
+  // The JavaScript above was hand-assembled and written outside tsgo's
+  // emitter, so tsgo's snapshot never saw it happen and records the JS emit of
+  // every file as still pending. That error is one-directional and safe: a
+  // consumer reading it can only decide to emit again, never to skip a file
+  // ttsc actually transformed. Making the record exact would mean running
+  // tsgo's own JavaScript emit a second time and discarding its output, paying
+  // a full emit to describe work already done. Everything else in the file —
+  // the compiler version, the resolved options, per-file versions and
+  // signatures, and the declaration state this pass does produce — is accurate.
+  //
+  // ttsc itself never reads build information back (see
+  // `shimcompiler.EmitFreshWithBuildInfo`), so this asymmetry costs a ttsc
+  // rebuild nothing.
   var wfMu sync.Mutex
-  result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+  result := p.emitProgram(shimcompiler.EmitOptions{
     EmitOnly: shimcompiler.EmitOnlyDts,
     WriteFile: func(fileName string, text string, data *shimcompiler.WriteFileData) error {
       wfMu.Lock()

package/driver/graph.go

@@ -23,9 +23,10 @@ const bundledScheme = "bundled:///"
 //
 //   - Edges maps each file to its direct resolved references — imports,
 //     re-exports, `/// <reference>` targets, type reference directives, and
-//     ambient-module declaration files, type-only edges included. Direct
-//     edges are the minimal sufficient statistic; consumers that need a flat
-//     per-file list compute the reachability closure themselves.
+//     ambient-module declaration files, type-only edges included. A leaf file
+//     has an empty list so the node and its compiler-time input proof remain
+//     explicit. Direct edges are the minimal sufficient statistic; consumers
+//     that need a flat per-file list compute the reachability closure themselves.
 //   - Globals lists the files that contribute to the global scope (ambient
 //     declaration files, script files, global augmentations, `typeRoots`
 //     entries). A change to any of them can affect every file.
@@ -39,10 +40,12 @@ const bundledScheme = "bundled:///"
 // map: project-relative slash paths, falling back to slash-normalized
 // absolute paths outside the project root (see TransformOutputKey).
 type TransformGraph struct {
-  Edges      map[string][]string `json:"edges"`
-  Globals    []string            `json:"globals"`
-  Configs    []string            `json:"configs"`
-  Candidates map[string][]string `json:"candidates,omitempty"`
+  Edges          map[string][]string `json:"edges"`
+  Globals        []string            `json:"globals"`
+  Configs        []string            `json:"configs"`
+  Candidates     map[string][]string `json:"candidates,omitempty"`
+  InputHashes    map[string]*string  `json:"inputHashes,omitempty"`
+  InputRealpaths map[string]*string  `json:"inputRealpaths,omitempty"`
 }
 
 // NewTransformGraph computes the reference graph of a loaded program, keyed
@@ -69,16 +72,66 @@ func NewTransformGraph(prog *Program, cwd string) *TransformGraph {
     if shimcompiler.FileAffectsGlobalScope(file) {
       graph.Globals = append(graph.Globals, key)
     }
-    targets := referenceTargets(prog, cwd, file)
-    if len(targets) != 0 {
-      graph.Edges[key] = targets
-    }
+    // Keep leaf modules as empty adjacency-list entries. Besides making the
+    // graph's node universe explicit, this lets attachInputProof bind every
+    // source file to the bytes TypeScript-Go actually read. Omitting a leaf
+    // would let an A-B-A edit during compilation pair B's output with identical
+    // pre/post project snapshots for A.
+    graph.Edges[key] = referenceTargets(prog, cwd, file)
   }
   sort.Strings(graph.Globals)
   graph.Configs = configChain(prog, cwd)
+  graph.attachInputProof(prog, cwd)
   return graph
 }
 
+// attachInputProof pairs every graph path with the state the compiler
+// filesystem actually returned while constructing the resident Program. A
+// missing entry means proof was incomplete or contradictory; persistent hosts
+// then keep the fresh result but decline cross-build reuse.
+func (graph *TransformGraph) attachInputProof(prog *Program, cwd string) {
+  if prog == nil || prog.inputObserver == nil {
+    return
+  }
+  inputs := map[string]struct{}{}
+  for source, targets := range graph.Edges {
+    inputs[source] = struct{}{}
+    for _, target := range targets {
+      inputs[target] = struct{}{}
+    }
+  }
+  for _, input := range graph.Globals {
+    inputs[input] = struct{}{}
+  }
+  for _, input := range graph.Configs {
+    inputs[input] = struct{}{}
+  }
+  for source, candidates := range graph.Candidates {
+    inputs[source] = struct{}{}
+    for _, candidate := range candidates {
+      inputs[candidate] = struct{}{}
+    }
+  }
+  hashes := map[string]*string{}
+  realpaths := map[string]*string{}
+  for input := range inputs {
+    file := filepath.FromSlash(input)
+    if !filepath.IsAbs(file) {
+      file = filepath.Join(cwd, file)
+    }
+    hash, realpath, ok := prog.inputObserver.proof(file)
+    if !ok {
+      continue
+    }
+    hashes[input] = hash
+    realpaths[input] = realpath
+  }
+  if len(hashes) != 0 {
+    graph.InputHashes = hashes
+    graph.InputRealpaths = realpaths
+  }
+}
+
 // referenceTargets resolves one file's direct reference set to sorted envelope
 // keys, dropping bundled library files and the file itself.
 func referenceTargets(prog *Program, cwd string, file *ast.SourceFile) []string {

package/driver/input_observation.go

@@ -0,0 +1,273 @@
+package driver
+
+import (
+  "crypto/sha256"
+  "encoding/hex"
+  "path/filepath"
+  "sync"
+
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+  "github.com/microsoft/typescript-go/shim/vfs"
+)
+
+var observedDirectoryDigest = func() string {
+  digest := sha256.Sum256([]byte("ttsc:host-input:directory\x00"))
+  return hex.EncodeToString(digest[:])
+}()
+
+type observedInputKind uint8
+
+const (
+  observedInputMissing observedInputKind = iota
+  observedInputFile
+  observedInputDirectory
+)
+
+type observedInput struct {
+  contentHash *string
+  kind        observedInputKind
+  realpath    *string
+  unstable    bool
+}
+
+// inputObservationFS records the exact disk state returned through the
+// compiler filesystem. A later transform envelope can therefore prove which
+// bytes and resolution-candidate states produced its resident Program instead
+// of attaching post-compile disk hashes to an earlier result.
+type inputObservationFS struct {
+  vfs.FS
+  caseSensitive bool
+  mu            sync.Mutex
+  observations  map[string]observedInput
+}
+
+func newInputObservationFS(inner vfs.FS) *inputObservationFS {
+  return &inputObservationFS{
+    FS:            inner,
+    caseSensitive: inner.UseCaseSensitiveFileNames(),
+    observations:  map[string]observedInput{},
+  }
+}
+
+func (fs *inputObservationFS) FileExists(path string) bool {
+  exists := fs.FS.FileExists(path)
+  if exists {
+    // Existence participates in resolution, but only ReadFile returns bytes
+    // that can influence the resident Program. Do not duplicate every
+    // resolver probe with an eager file read.
+    fs.observe(path, observedInput{
+      kind:     observedInputFile,
+      realpath: fs.currentRealpath(path),
+    })
+  } else {
+    fs.observe(path, observedInput{kind: observedInputMissing})
+  }
+  return exists
+}
+
+func (fs *inputObservationFS) ReadFile(path string) (string, bool) {
+  contents, ok := fs.FS.ReadFile(path)
+  if ok {
+    digest := sha256.Sum256([]byte(contents))
+    hash := hex.EncodeToString(digest[:])
+    fs.observe(path, observedInput{
+      contentHash: &hash,
+      kind:        observedInputFile,
+      realpath:    fs.currentRealpath(path),
+    })
+  } else {
+    fs.observe(path, observedInput{kind: observedInputMissing})
+  }
+  return contents, ok
+}
+
+func (fs *inputObservationFS) DirectoryExists(path string) bool {
+  exists := fs.FS.DirectoryExists(path)
+  if exists {
+    fs.observe(path, observedInput{
+      kind:     observedInputDirectory,
+      realpath: fs.currentRealpath(path),
+    })
+  } else {
+    fs.observe(path, observedInput{kind: observedInputMissing})
+  }
+  return exists
+}
+
+func (fs *inputObservationFS) GetAccessibleEntries(path string) vfs.Entries {
+  // DirectoryExists records directory identity on the ordinary compiler path.
+  // An empty listing alone cannot distinguish a missing directory from an
+  // existing empty one without issuing an extra stat for every enumeration.
+  return fs.FS.GetAccessibleEntries(path)
+}
+
+func (fs *inputObservationFS) Stat(path string) vfs.FileInfo {
+  info := fs.FS.Stat(path)
+  if info == nil {
+    fs.observe(path, observedInput{kind: observedInputMissing})
+  } else if info.IsDir() {
+    fs.observe(path, observedInput{
+      kind:     observedInputDirectory,
+      realpath: fs.currentRealpath(path),
+    })
+  } else {
+    fs.observe(path, observedInput{
+      kind:     observedInputFile,
+      realpath: fs.currentRealpath(path),
+    })
+  }
+  return info
+}
+
+func (fs *inputObservationFS) Realpath(path string) string {
+  realpath := fs.FS.Realpath(path)
+  if realpath != "" {
+    resolved := filepath.Clean(realpath)
+    fs.observeRealpath(path, &resolved)
+  }
+  return realpath
+}
+
+func (fs *inputObservationFS) currentRealpath(path string) *string {
+  realpath := fs.FS.Realpath(path)
+  if realpath == "" {
+    return nil
+  }
+  resolved := filepath.Clean(realpath)
+  return &resolved
+}
+
+func (fs *inputObservationFS) observationKey(path string) string {
+  if !filepath.IsAbs(path) {
+    return ""
+  }
+  return shimtspath.GetCanonicalFileName(
+    shimtspath.NormalizePath(path),
+    fs.caseSensitive,
+  )
+}
+
+func (fs *inputObservationFS) observe(path string, next observedInput) {
+  key := fs.observationKey(path)
+  if key == "" {
+    return
+  }
+  fs.mu.Lock()
+  defer fs.mu.Unlock()
+  keys := []string{key}
+  // A compiler read can arrive through an 8.3, case-variant, or already-real
+  // spelling while resolution recorded the selected lexical alias. Index the
+  // returned bytes by the final physical path too, so proof can join the two
+  // observations without another disk read.
+  if next.contentHash != nil && next.realpath != nil {
+    physicalKey := fs.observationKey(*next.realpath)
+    if physicalKey != "" && physicalKey != key {
+      keys = append(keys, physicalKey)
+    }
+  }
+  for _, observationKey := range keys {
+    fs.mergeObservation(observationKey, next)
+  }
+}
+
+// mergeObservation merges one observation key while the caller holds fs.mu.
+func (fs *inputObservationFS) mergeObservation(key string, next observedInput) {
+  previous, found := fs.observations[key]
+  if !found {
+    fs.observations[key] = next
+    return
+  }
+  if previous.unstable || next.unstable || previous.kind != next.kind || !sameOptionalString(previous.realpath, next.realpath) {
+    previous.unstable = true
+    previous.contentHash = nil
+    previous.realpath = nil
+    fs.observations[key] = previous
+    return
+  }
+  if previous.contentHash != nil && next.contentHash != nil && *previous.contentHash != *next.contentHash {
+    previous.unstable = true
+    previous.contentHash = nil
+    previous.realpath = nil
+    fs.observations[key] = previous
+    return
+  }
+  if previous.contentHash == nil && next.contentHash != nil {
+    previous.contentHash = next.contentHash
+  }
+  fs.observations[key] = previous
+}
+
+func (fs *inputObservationFS) observeRealpath(path string, realpath *string) {
+  key := fs.observationKey(path)
+  if key == "" {
+    return
+  }
+  fs.mu.Lock()
+  defer fs.mu.Unlock()
+  previous, found := fs.observations[key]
+  if !found {
+    // A realpath by itself cannot prove whether the path was a file or
+    // directory. The ordinary resolver probes record that state separately.
+    return
+  }
+  if previous.unstable || !sameOptionalString(previous.realpath, realpath) {
+    previous.unstable = true
+    previous.contentHash = nil
+    previous.realpath = nil
+    fs.observations[key] = previous
+  }
+}
+
+func sameOptionalString(left, right *string) bool {
+  if left == nil || right == nil {
+    return left == nil && right == nil
+  }
+  return *left == *right
+}
+
+// proof returns a stable compiler-time state. A nil hash/realpath with ok=true
+// is an explicit JSON null for a path observed missing; ok=false means the
+// compiler never produced a complete, internally consistent observation.
+func (fs *inputObservationFS) proof(path string) (hash, realpath *string, ok bool) {
+  key := fs.observationKey(path)
+  if key == "" {
+    return nil, nil, false
+  }
+  fs.mu.Lock()
+  observation, found := fs.observations[key]
+  // TypeScript-Go can probe a lexical symlink candidate and then read the
+  // selected source by its physical filename. Reuse that exact observed read
+  // for the alias instead of issuing an eager duplicate read from FileExists.
+  if found && !observation.unstable && observation.kind == observedInputFile && observation.contentHash == nil && observation.realpath != nil {
+    targetKey := fs.observationKey(*observation.realpath)
+    target, targetFound := fs.observations[targetKey]
+    if targetFound && !target.unstable && target.kind == observedInputFile && target.contentHash != nil && sameOptionalString(target.realpath, observation.realpath) {
+      targetHash := *target.contentHash
+      observation.contentHash = &targetHash
+    }
+  }
+  fs.mu.Unlock()
+  if !found || observation.unstable {
+    return nil, nil, false
+  }
+  switch observation.kind {
+  case observedInputMissing:
+    return nil, nil, true
+  case observedInputDirectory:
+    hash := observedDirectoryDigest
+    if observation.realpath == nil {
+      return nil, nil, false
+    }
+    realpath := *observation.realpath
+    return &hash, &realpath, true
+  case observedInputFile:
+    if observation.contentHash == nil || observation.realpath == nil {
+      return nil, nil, false
+    }
+    hash := *observation.contentHash
+    realpath := *observation.realpath
+    return &hash, &realpath, true
+  default:
+    return nil, nil, false
+  }
+}

package/driver/input_observation_test.go

@@ -0,0 +1,149 @@
+package driver
+
+import (
+  "crypto/sha256"
+  "encoding/hex"
+  "os"
+  "os/exec"
+  "path/filepath"
+  "runtime"
+  "testing"
+)
+
+func TestInputObservationFSRejectsRestoredContent(t *testing.T) {
+  root := t.TempDir()
+  file := filepath.Join(root, "external.d.ts")
+  if err := os.WriteFile(file, []byte("A"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  observed := newInputObservationFS(DefaultFS())
+  if contents, ok := observed.ReadFile(file); !ok || contents != "A" {
+    t.Fatalf("first read = %q, %v", contents, ok)
+  }
+  if err := os.WriteFile(file, []byte("B"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if contents, ok := observed.ReadFile(file); !ok || contents != "B" {
+    t.Fatalf("second read = %q, %v", contents, ok)
+  }
+  if err := os.WriteFile(file, []byte("A"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if _, _, ok := observed.proof(file); ok {
+    t.Fatal("A-B-A observation unexpectedly produced reusable proof")
+  }
+}
+
+func TestInputObservationFSProvesReadBytesAndMissingCandidates(t *testing.T) {
+  root := t.TempDir()
+  file := filepath.Join(root, "selected.ts")
+  missing := filepath.Join(root, "superseding.ts")
+  contents := "export const selected = true;\n"
+  if err := os.WriteFile(file, []byte(contents), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  observed := newInputObservationFS(DefaultFS())
+  if !observed.FileExists(file) {
+    t.Fatal("selected file was not found")
+  }
+  if _, ok := observed.ReadFile(file); !ok {
+    t.Fatal("selected file was not read")
+  }
+  if observed.FileExists(missing) {
+    t.Fatal("missing candidate unexpectedly exists")
+  }
+
+  digest := sha256.Sum256([]byte(contents))
+  wantHash := hex.EncodeToString(digest[:])
+  hash, realpath, ok := observed.proof(file)
+  if !ok || hash == nil || *hash != wantHash {
+    t.Fatalf("selected proof hash = %v, %v", hash, ok)
+  }
+  wantRealpath, err := filepath.EvalSymlinks(file)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if realpath == nil || filepath.Clean(*realpath) != filepath.Clean(wantRealpath) {
+    t.Fatalf("selected proof realpath = %v, want %q", realpath, wantRealpath)
+  }
+  hash, realpath, ok = observed.proof(missing)
+  if !ok || hash != nil || realpath != nil {
+    t.Fatalf("missing proof = %v, %v, %v", hash, realpath, ok)
+  }
+}
+
+func TestInputObservationFSHashesCompilerDecodedText(t *testing.T) {
+  root := t.TempDir()
+  file := filepath.Join(root, "bom.ts")
+  text := "export const value = true;\n"
+  raw := append([]byte{0xef, 0xbb, 0xbf}, []byte(text)...)
+  if err := os.WriteFile(file, raw, 0o644); err != nil {
+    t.Fatal(err)
+  }
+  observed := newInputObservationFS(DefaultFS())
+  contents, ok := observed.ReadFile(file)
+  if !ok || contents != text {
+    t.Fatalf("compiler read = %q, %v; want decoded text", contents, ok)
+  }
+  digest := sha256.Sum256([]byte(text))
+  hash, _, ok := observed.proof(file)
+  if !ok || hash == nil || *hash != hex.EncodeToString(digest[:]) {
+    t.Fatalf("decoded proof hash = %v, %v", hash, ok)
+  }
+}
+
+func TestInputObservationFSJoinsSelectedAliasProbeToPhysicalRead(t *testing.T) {
+  root := t.TempDir()
+  target := filepath.Join(root, "target")
+  if err := os.Mkdir(target, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  physical := filepath.Join(target, "value.js")
+  contents := "export const value = true;\n"
+  if err := os.WriteFile(physical, []byte(contents), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  alias := filepath.Join(root, "alias")
+  if runtime.GOOS == "windows" {
+    command := exec.Command(
+      "node",
+      "-e",
+      `require("node:fs").symlinkSync(process.argv[1], process.argv[2], "junction")`,
+      target,
+      alias,
+    )
+    if output, err := command.CombinedOutput(); err != nil {
+      t.Skipf("directory junction unavailable on this host: %v: %s", err, output)
+    }
+  } else if err := os.Symlink(target, alias); err != nil {
+    t.Skipf("directory symlink unavailable on this host: %v", err)
+  }
+  lexical := filepath.Join(alias, "value.js")
+  observed := newInputObservationFS(DefaultFS())
+  if !observed.FileExists(lexical) {
+    t.Fatal("selected lexical alias was not found")
+  }
+  if _, ok := observed.ReadFile(physical); !ok {
+    t.Fatal("selected physical source was not read")
+  }
+
+  digest := sha256.Sum256([]byte(contents))
+  hash, realpath, ok := observed.proof(lexical)
+  if !ok || hash == nil || *hash != hex.EncodeToString(digest[:]) {
+    t.Fatalf("alias proof hash = %v, %v", hash, ok)
+  }
+  if realpath == nil {
+    t.Fatalf("alias proof realpath = nil, want %q", physical)
+  }
+  actualInfo, err := os.Stat(*realpath)
+  if err != nil {
+    t.Fatal(err)
+  }
+  expectedInfo, err := os.Stat(physical)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !os.SameFile(actualInfo, expectedInfo) {
+    t.Fatalf("alias proof realpath = %q, want %q", *realpath, physical)
+  }
+}