ttsc 0.26.2 → 0.27.0

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)
+  }
+}