ttsc 0.28.5 → 0.29.0

package/driver/input_observation_test.go

@@ -75,6 +75,209 @@ func TestInputObservationFSProvesReadBytesAndMissingCandidates(t *testing.T) {
   }
 }
 
+func TestInputObservationFSPreservesPredicateSemantics(t *testing.T) {
+  t.Run("compatible-file-and-directory-predicates", testInputObservationFSKeepsFileAndDirectoryPredicatesIndependent)
+  t.Run("every-repeated-predicate-change", testInputObservationFSRejectsEveryRepeatedPredicateChange)
+  t.Run("impossible-predicate-sets", testInputObservationFSRejectsImpossiblePredicateSets)
+  t.Run("observed-candidate-failure", testTransformGraphReportsObservedCandidateFailure)
+  t.Run("rich-speculative-proof", testTransformGraphKeepsRichSpeculativeProof)
+}
+
+func testInputObservationFSKeepsFileAndDirectoryPredicatesIndependent(t *testing.T) {
+  root := t.TempDir()
+  directory := filepath.Join(root, "punycode.js")
+  if err := os.Mkdir(directory, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  observed := newInputObservationFS(DefaultFS())
+  if observed.FileExists(directory) {
+    t.Fatal("directory unexpectedly satisfied FileExists")
+  }
+  if !observed.DirectoryExists(directory) {
+    t.Fatal("directory did not satisfy DirectoryExists")
+  }
+
+  proof, failure := observed.predicateProof(directory)
+  if failure != "" {
+    t.Fatalf("compatible predicates failed proof: %q", failure)
+  }
+  if proof.FileExists == nil || *proof.FileExists {
+    t.Fatalf("FileExists proof = %#v, want false", proof.FileExists)
+  }
+  if proof.DirectoryExists == nil || !*proof.DirectoryExists {
+    t.Fatalf("DirectoryExists proof = %#v, want true", proof.DirectoryExists)
+  }
+  if proof.Realpath == nil || !proof.Realpath.OK || !filepath.IsAbs(proof.Realpath.Path) {
+    t.Fatalf("directory realpath proof = %#v, want absolute success", proof.Realpath)
+  }
+  hash, realpath, legacyFailure := observed.proof(directory)
+  if legacyFailure != "" || hash == nil || *hash != observedDirectoryDigest || realpath == nil {
+    t.Fatalf("legacy directory projection = %v, %v, failure %q", hash, realpath, legacyFailure)
+  }
+}
+
+func testInputObservationFSRejectsEveryRepeatedPredicateChange(t *testing.T) {
+  root := t.TempDir()
+  cases := []struct {
+    name     string
+    first    TransformInputObservation
+    second   TransformInputObservation
+    expected inputProofFailure
+  }{
+    {
+      name: "accessible-entries",
+      first: TransformInputObservation{
+        AccessibleEntries: &TransformInputEntriesObservation{Directories: []string{"alpha"}, Files: []string{}},
+      },
+      second: TransformInputObservation{
+        AccessibleEntries: &TransformInputEntriesObservation{Directories: []string{"alpha", "beta"}, Files: []string{}},
+      },
+      expected: inputProofAccessibleEntriesChanged,
+    },
+    {
+      name:     "directory-exists",
+      first:    TransformInputObservation{DirectoryExists: boolPointer(false)},
+      second:   TransformInputObservation{DirectoryExists: boolPointer(true)},
+      expected: inputProofDirectoryExistsChanged,
+    },
+    {
+      name:     "file-exists",
+      first:    TransformInputObservation{FileExists: boolPointer(false)},
+      second:   TransformInputObservation{FileExists: boolPointer(true)},
+      expected: inputProofFileExistsChanged,
+    },
+    {
+      name:     "read-availability",
+      first:    TransformInputObservation{ReadFile: &TransformInputReadObservation{OK: false}},
+      second:   TransformInputObservation{ReadFile: &TransformInputReadObservation{OK: true, Hash: "a"}},
+      expected: inputProofContentChanged,
+    },
+    {
+      name:     "read-content",
+      first:    TransformInputObservation{ReadFile: &TransformInputReadObservation{OK: true, Hash: "a"}},
+      second:   TransformInputObservation{ReadFile: &TransformInputReadObservation{OK: true, Hash: "b"}},
+      expected: inputProofContentChanged,
+    },
+    {
+      name:     "realpath",
+      first:    TransformInputObservation{Realpath: &TransformInputRealpathObservation{OK: false}},
+      second:   TransformInputObservation{Realpath: &TransformInputRealpathObservation{OK: true, Path: filepath.Join(root, "target")}},
+      expected: inputProofRealpathChanged,
+    },
+    {
+      name:     "stat",
+      first:    TransformInputObservation{Stat: stringPointer("missing")},
+      second:   TransformInputObservation{Stat: stringPointer("file")},
+      expected: inputProofStatChanged,
+    },
+  }
+  for _, entry := range cases {
+    t.Run(entry.name, func(t *testing.T) {
+      observed := newInputObservationFS(DefaultFS())
+      key := observed.observationKey(filepath.Join(root, entry.name))
+      observed.mergeObservation(key, observedInput{proof: entry.first})
+      observed.mergeObservation(key, observedInput{proof: entry.second})
+      if failure := observed.observations[key].failure; failure != entry.expected {
+        t.Fatalf("failure = %q, want %q", failure, entry.expected)
+      }
+    })
+  }
+}
+
+func testInputObservationFSRejectsImpossiblePredicateSets(t *testing.T) {
+  root := t.TempDir()
+  cases := []struct {
+    name   string
+    first  TransformInputObservation
+    second TransformInputObservation
+  }{
+    {
+      name:   "file-and-directory",
+      first:  TransformInputObservation{FileExists: boolPointer(true)},
+      second: TransformInputObservation{DirectoryExists: boolPointer(true)},
+    },
+    {
+      name:   "missing-file-with-readable-content",
+      first:  TransformInputObservation{FileExists: boolPointer(false)},
+      second: TransformInputObservation{ReadFile: &TransformInputReadObservation{OK: true, Hash: "a"}},
+    },
+    {
+      name: "entries-from-a-missing-directory",
+      first: TransformInputObservation{AccessibleEntries: &TransformInputEntriesObservation{
+        Directories: []string{"package"},
+        Files:       []string{},
+      }},
+      second: TransformInputObservation{DirectoryExists: boolPointer(false)},
+    },
+  }
+  for _, entry := range cases {
+    t.Run(entry.name, func(t *testing.T) {
+      observed := newInputObservationFS(DefaultFS())
+      key := observed.observationKey(filepath.Join(root, entry.name))
+      observed.mergeObservation(key, observedInput{proof: entry.first})
+      observed.mergeObservation(key, observedInput{proof: entry.second})
+      if failure := observed.observations[key].failure; failure != inputProofPredicateConflict {
+        t.Fatalf("failure = %q, want %q", failure, inputProofPredicateConflict)
+      }
+    })
+  }
+}
+
+func testTransformGraphReportsObservedCandidateFailure(t *testing.T) {
+  root := t.TempDir()
+  raced := filepath.ToSlash(filepath.Join("node_modules", "pkg.ts"))
+  unobserved := filepath.ToSlash(filepath.Join("node_modules", "pkg.tsx"))
+  observed := newInputObservationFS(DefaultFS())
+  key := observed.observationKey(filepath.Join(root, filepath.FromSlash(raced)))
+  observed.mergeObservation(key, observedInput{
+    proof: TransformInputObservation{FileExists: boolPointer(false)},
+  })
+  observed.mergeObservation(key, observedInput{
+    proof: TransformInputObservation{FileExists: boolPointer(true)},
+  })
+  graph := TransformGraph{
+    Candidates: map[string][]string{"src/main.ts": {raced, unobserved}},
+    Configs:    []string{},
+    Edges:      map[string][]string{"src/main.ts": {}},
+    Globals:    []string{},
+  }
+  graph.attachInputProof(&Program{inputObserver: observed}, root)
+  if failure := graph.InputProofFailures[raced]; failure != string(inputProofFileExistsChanged) {
+    t.Fatalf("observed candidate failure = %q, want %q", failure, inputProofFileExistsChanged)
+  }
+  if failure, found := graph.InputProofFailures[unobserved]; found {
+    t.Fatalf("wholly unobserved candidate failure = %q", failure)
+  }
+}
+
+func testTransformGraphKeepsRichSpeculativeProof(t *testing.T) {
+  root := t.TempDir()
+  candidate := filepath.ToSlash(filepath.Join("node_modules", "pkg.ts"))
+  observed := newInputObservationFS(DefaultFS())
+  key := observed.observationKey(filepath.Join(root, filepath.FromSlash(candidate)))
+  observed.mergeObservation(key, observedInput{
+    proof: TransformInputObservation{FileExists: boolPointer(true)},
+  })
+  graph := TransformGraph{
+    Candidates: map[string][]string{"src/main.ts": {candidate}},
+    Configs:    []string{},
+    Edges:      map[string][]string{"src/main.ts": {}},
+    Globals:    []string{},
+  }
+  graph.attachInputProof(&Program{inputObserver: observed}, root)
+  proof, found := graph.InputObservations[candidate]
+  if !found || proof.FileExists == nil || !*proof.FileExists {
+    t.Fatalf("rich speculative proof = %#v, %v; want FileExists true", proof, found)
+  }
+  if failure, found := graph.InputProofFailures[candidate]; found {
+    t.Fatalf("legacy projection failure superseded rich proof: %q", failure)
+  }
+}
+
+func stringPointer(value string) *string {
+  return &value
+}
+
 func TestInputObservationFSHashesCompilerDecodedText(t *testing.T) {
   root := t.TempDir()
   file := filepath.Join(root, "bom.ts")

package/driver/program.go

@@ -18,6 +18,11 @@ import (
   "github.com/microsoft/typescript-go/shim/vfs"
 )
 
+// SemanticConfigPathEnv carries the user-authored config path when an embedder
+// parses a disposable generated wrapper whose location must not become the
+// Program's semantic project root.
+const SemanticConfigPathEnv = "TTSC_SEMANTIC_CONFIG_PATH"
+
 // Diagnostic is the compilation diagnostic shape ttsc passes around. Kept
 // dependency-free (no shim types) so callers can render or inspect freely.
 //
@@ -208,10 +213,14 @@ type Program struct {
 // the program. `ForceEmit` is used by `ttsc --emit` and runtime compilation
 // so execution still works when the project defaults to `noEmit`.
 type LoadProgramOptions struct {
-  ForceEmit      bool
-  ForceNoEmit    bool
-  OutDir         string
-  SourcePreamble string
+  ForceEmit   bool
+  ForceNoEmit bool
+  OutDir      string
+  // SemanticConfigPath restores the user-authored config as the semantic
+  // project owner after parsing a disposable generated wrapper. Native command
+  // entry points set it explicitly; nested driver calls do not inherit it.
+  SemanticConfigPath string
+  SourcePreamble     string
   // SingleThreaded forces TypeScript-Go's single-threaded mode (one checker,
   // serial parse/check/emit), mirroring `tsgo --singleThreaded`.
   SingleThreaded bool
@@ -404,6 +413,9 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
   if len(diags) > 0 {
     return nil, diags, nil
   }
+  if err := applySemanticConfigPath(parsed, options.SemanticConfigPath); err != nil {
+    return nil, nil, err
+  }
   if options.ForceNoEmit {
     forceNoEmit(parsed)
   }
@@ -432,6 +444,18 @@ func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program
   return prog, nil, nil
 }
 
+func applySemanticConfigPath(parsed *tsoptions.ParsedCommandLine, semanticConfigPath string) error {
+  configured := strings.TrimSpace(semanticConfigPath)
+  if configured == "" {
+    return nil
+  }
+  if !filepath.IsAbs(configured) {
+    return fmt.Errorf("driver: semantic config path must be absolute: %s", configured)
+  }
+  parsed.ParsedConfig.CompilerOptions.ConfigFilePath = tspath.ResolvePath(configured)
+  return nil
+}
+
 // forceEmit clears noEmit and emitDeclarationOnly so the program always
 // produces JavaScript output regardless of the tsconfig settings.
 func forceEmit(parsed *tsoptions.ParsedCommandLine) {