ttsc 0.28.5 → 0.29.0

package/cmd/ttsc/api_compile.go

@@ -10,6 +10,7 @@ import (
   "encoding/json"
   "flag"
   "fmt"
+  "os"
 
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
 
@@ -66,10 +67,11 @@ func runAPICompile(args []string) int {
   }
 
   prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
-    ForceEmit:      true,
-    SingleThreaded: *singleThreaded,
-    Checkers:       *checkers,
-    TsgoArgs:       tsgoArgs,
+    ForceEmit:          true,
+    SemanticConfigPath: os.Getenv(driver.SemanticConfigPathEnv),
+    SingleThreaded:     *singleThreaded,
+    Checkers:           *checkers,
+    TsgoArgs:           tsgoArgs,
   })
   if err != nil {
     fmt.Fprintf(stderr, "ttsc api-compile: %v\n", err)

package/cmd/ttsc/api_transform.go

@@ -10,6 +10,7 @@ import (
   "encoding/json"
   "flag"
   "fmt"
+  "os"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
   cwdutil "github.com/samchon/ttsc/packages/ttsc/internal/cwd"
@@ -71,10 +72,11 @@ func runAPITransform(args []string) int {
   }
 
   prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
-    ForceNoEmit:    true,
-    SingleThreaded: *singleThreaded,
-    Checkers:       *checkers,
-    TsgoArgs:       tsgoArgs,
+    ForceNoEmit:        true,
+    SemanticConfigPath: os.Getenv(driver.SemanticConfigPathEnv),
+    SingleThreaded:     *singleThreaded,
+    Checkers:           *checkers,
+    TsgoArgs:           tsgoArgs,
   })
   if err != nil {
     fmt.Fprintf(stderr, "ttsc api-transform: %v\n", err)

package/cmd/ttsc/build.go

@@ -69,12 +69,13 @@ func runBuild(args []string) int {
   }
 
   prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
-    ForceEmit:      *emit,
-    ForceNoEmit:    *noEmit,
-    OutDir:         *outDir,
-    SingleThreaded: *singleThreaded,
-    Checkers:       *checkers,
-    TsgoArgs:       tsgoArgs,
+    ForceEmit:          *emit,
+    ForceNoEmit:        *noEmit,
+    OutDir:             *outDir,
+    SemanticConfigPath: os.Getenv(driver.SemanticConfigPathEnv),
+    SingleThreaded:     *singleThreaded,
+    Checkers:           *checkers,
+    TsgoArgs:           tsgoArgs,
   })
   if err != nil {
     fmt.Fprintf(stderr, "ttsc: %v\n", err)

package/cmd/ttscgraph/serve.go

@@ -10,6 +10,7 @@ import (
   "io"
   "os"
   "path/filepath"
+  "runtime"
   "slices"
   "sort"
   "strings"
@@ -574,7 +575,7 @@ func (s *graphSession) captureState() error {
   if err != nil {
     return err
   }
-  inputs := auxiliaryInputs(program, configs, s.cwd)
+  inputs := auxiliaryInputs(program, s.cwd)
   for _, path := range missingRootInputs(configs, sourceHashes) {
     inputs = append(inputs, auxiliaryInput{path: path})
   }
@@ -847,23 +848,25 @@ func changedSources(previous map[string][sha256.Size]byte) (map[string]string, b
 }
 
 type diskState struct {
-  Hash         [sha256.Size]byte
-  Exists       bool
-  Realpath     string
-  IdentityOnly bool
+  DirectoryEntries bool
+  Hash             [sha256.Size]byte
+  Exists           bool
+  Realpath         string
+  IdentityOnly     bool
 }
 
-// auxiliaryInput distinguishes speculative inputs whose contents select the
+// auxiliaryInput distinguishes resolver inputs whose contents select the
 // build universe from the lexical spelling of the source the compiler already
 // selected. The resident source hash owns the latter's contents; this input
 // owns only whether the spelling still reaches the same physical file.
 type auxiliaryInput struct {
-  path         string
-  identityOnly bool
+  directoryEntries bool
+  path             string
+  identityOnly     bool
 }
 
-// captureDiskStates records the freshness state of speculative resolution
-// candidates. Most candidates do not exist, and a module specifier can name a
+// captureDiskStates records the freshness state of resolver inputs. Many do
+// not exist, and a module specifier can name a
 // path the host OS cannot even parse (`./style.css?inline`, a `data:` URL on
 // Windows), so any path that is neither a readable file nor a directory is
 // recorded as absent instead of failing the snapshot: the recorded state only
@@ -871,12 +874,18 @@ type auxiliaryInput struct {
 func captureDiskStates(inputs []auxiliaryInput) map[string]diskState {
   states := make(map[string]diskState, len(inputs))
   for _, input := range inputs {
-    state := diskState{IdentityOnly: input.identityOnly}
+    state := diskState{
+      DirectoryEntries: input.directoryEntries,
+      IdentityOnly:     input.identityOnly,
+    }
     content, err := os.ReadFile(input.path)
     if err != nil {
       if info, statErr := os.Stat(input.path); statErr == nil && info.IsDir() {
         state.Exists = true
         state.Realpath = diskRealpath(input.path)
+        if input.directoryEntries {
+          state.Hash = accessibleDirectoryEntriesHash(input.path)
+        }
       }
       states[input.path] = state
       continue
@@ -894,7 +903,11 @@ func captureDiskStates(inputs []auxiliaryInput) map[string]diskState {
 func diskStatesChanged(previous map[string]diskState) bool {
   inputs := make([]auxiliaryInput, 0, len(previous))
   for path, state := range previous {
-    inputs = append(inputs, auxiliaryInput{path: path, identityOnly: state.IdentityOnly})
+    inputs = append(inputs, auxiliaryInput{
+      directoryEntries: state.DirectoryEntries,
+      identityOnly:     state.IdentityOnly,
+      path:             path,
+    })
   }
   current := captureDiskStates(inputs)
   for path, state := range previous {
@@ -905,7 +918,7 @@ func diskStatesChanged(previous map[string]diskState) bool {
   return false
 }
 
-func auxiliaryInputs(program *driver.Program, configs []*shimtsoptions.ParsedCommandLine, cwd string) []auxiliaryInput {
+func auxiliaryInputs(program *driver.Program, cwd string) []auxiliaryInput {
   inputs := []auxiliaryInput{
     {path: filepath.Join(cwd, ".gitignore")},
     {path: filepath.Join(cwd, ".git", "info", "exclude")},
@@ -925,75 +938,17 @@ func auxiliaryInputs(program *driver.Program, configs []*shimtsoptions.ParsedCom
     for _, path := range appendAncestorInputs(nil, directory, cwd) {
       inputs = append(inputs, auxiliaryInput{path: path})
     }
-    for _, reference := range source.ReferencedFiles {
-      for _, path := range driver.FileCandidates(filepath.Join(directory, filepath.FromSlash(reference.FileName))) {
-        inputs = append(inputs, auxiliaryInput{path: path})
-      }
-    }
-    for _, reference := range source.TypeReferenceDirectives {
-      for _, path := range driver.TypeReferenceCandidates(configs, directory, cwd, reference.FileName) {
-        inputs = append(inputs, auxiliaryInput{path: path})
-      }
-    }
-    for _, specifier := range driver.SourceModuleSpecifiers(source) {
-      context := driver.ModuleResolutionContext{
-        Mode: program.TSProgram.GetModeForUsageLocation(source, specifier),
-      }
-      for _, parsed := range configs {
-        if parsed != nil && parsed.ParsedConfig != nil && parsed.ParsedConfig.CompilerOptions != nil {
-          context.Options = parsed.ParsedConfig.CompilerOptions
-          break
-        }
-      }
-      resolved := program.TSProgram.GetResolvedModuleFromModuleSpecifier(source, specifier)
-      if resolved != nil && resolved.IsResolved() {
-        predecessors := driver.ModuleResolutionPredecessors(
-          configs,
-          directory,
-          cwd,
-          specifier.Text(),
-          resolved.ResolvedFileName,
-          program.FS.UseCaseSensitiveFileNames(),
-          context,
-        )
-        for _, path := range predecessors {
-          inputs = append(inputs, auxiliaryInput{
-            path:         path,
-            identityOnly: sameExistingAuxiliaryPath(path, resolved.ResolvedFileName),
-          })
-        }
-        continue
-      }
-      for _, path := range driver.ModuleResolutionCandidates(configs, directory, cwd, specifier.Text(), context) {
-        inputs = append(inputs, auxiliaryInput{path: path})
-      }
-    }
   }
-  // Config `types` entries request type packages without any source syntax, so
-  // a missing one (e.g. a generated typeRoots package) must contribute the same
-  // candidates as a triple-slash type directive.
-  for _, parsed := range configs {
-    if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
-      continue
-    }
-    for _, name := range parsed.ParsedConfig.CompilerOptions.Types {
-      for _, path := range driver.TypeReferenceCandidates(configs, parsed.GetCurrentDirectory(), cwd, name) {
-        inputs = append(inputs, auxiliaryInput{path: path})
-      }
-    }
+  for _, input := range driver.ObserveProgramResolutions(program, cwd).Inputs {
+    inputs = append(inputs, auxiliaryInput{
+      directoryEntries: input.DirectoryEntries,
+      identityOnly:     input.IdentityOnly,
+      path:             input.Path,
+    })
   }
   return compactAuxiliaryInputs(inputs)
 }
 
-func sameExistingAuxiliaryPath(left, right string) bool {
-  leftInfo, err := os.Stat(left)
-  if err != nil {
-    return false
-  }
-  rightInfo, err := os.Stat(right)
-  return err == nil && os.SameFile(leftInfo, rightInfo)
-}
-
 func compactAuxiliaryInputs(inputs []auxiliaryInput) []auxiliaryInput {
   byPath := make(map[string]auxiliaryInput, len(inputs))
   for _, input := range inputs {
@@ -1001,6 +956,7 @@ func compactAuxiliaryInputs(inputs []auxiliaryInput) []auxiliaryInput {
       continue
     }
     if previous, exists := byPath[input.path]; exists {
+      input.directoryEntries = previous.directoryEntries || input.directoryEntries
       // A path that also participates as a manifest or other content-bearing
       // input keeps the stronger content-sensitive contract.
       input.identityOnly = previous.identityOnly && input.identityOnly
@@ -1019,6 +975,43 @@ func compactAuxiliaryInputs(inputs []auxiliaryInput) []auxiliaryInput {
   return output
 }
 
+// accessibleDirectoryEntriesHash mirrors TypeScript-Go's accessible-entry
+// classification and sorted name order for a directory enumeration input.
+func accessibleDirectoryEntriesHash(directory string) [sha256.Size]byte {
+  hash := sha256.New()
+  entries, err := os.ReadDir(directory)
+  if err == nil {
+    for _, entry := range entries {
+      kind := byte(0)
+      switch {
+      case entry.Type().IsDir():
+        kind = 'D'
+      case entry.Type().IsRegular():
+        kind = 'F'
+      case entry.Type()&os.ModeSymlink != 0 || (runtime.GOOS == "windows" && entry.Type()&os.ModeIrregular != 0):
+        if info, statErr := os.Stat(filepath.Join(directory, entry.Name())); statErr == nil {
+          if info.IsDir() {
+            kind = 'D'
+          } else if info.Mode().IsRegular() {
+            kind = 'F'
+          }
+        }
+      default:
+        continue
+      }
+      if kind == 0 {
+        continue
+      }
+      _, _ = hash.Write([]byte{kind})
+      _, _ = hash.Write([]byte(entry.Name()))
+      _, _ = hash.Write([]byte{0})
+    }
+  }
+  var digest [sha256.Size]byte
+  copy(digest[:], hash.Sum(nil))
+  return digest
+}
+
 func appendAncestorInputs(inputs []string, directory, stop string) []string {
   stop = filepath.Clean(stop)
   for current := filepath.Clean(directory); ; current = filepath.Dir(current) {

package/cmd/ttscgraph/serve_session_reloads_superseding_module_candidates_test.go

@@ -220,6 +220,32 @@ func TestServeSessionReloadsSupersedingModuleCandidates(t *testing.T) {
       }
     })
   }
+
+  t.Run("automatic_type_directory_membership", func(t *testing.T) {
+    root := t.TempDir()
+    writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "module": "commonjs", "target": "ES2022", "types": ["*"] },
+  "files": ["src/main.ts"]
+}`)
+    writeGraphFile(t, filepath.Join(root, "src", "main.ts"), "export const value = 1;\n")
+    session, err := newGraphSession(root, "tsconfig.json")
+    if err != nil {
+      t.Fatal(err)
+    }
+    defer session.Close()
+    if _, _, _, err := session.Snapshot(); err != nil {
+      t.Fatal(err)
+    }
+
+    writeGraphFile(t, filepath.Join(root, "node_modules", "@types", "generated", "index.d.ts"), "declare const generatedAmbient: string;\n")
+    dump, mode, changed, err := session.Snapshot()
+    if err != nil {
+      t.Fatal(err)
+    }
+    if dump == nil || mode != serveModeReload || !changed {
+      t.Fatalf("automatic type package appearance = dump:%v mode:%q changed:%v", dump != nil, mode, changed)
+    }
+  })
 }
 
 func hasDumpNodeAt(dump graph.Dump, name, fileSuffix string) bool {

package/cmd/ttscgraph/serve_session_tracks_all_module_specifier_forms_test.go

@@ -19,7 +19,6 @@ import legacy = require("./legacy");
 export { exported } from "./exported";
 export type Deferred = import("./types").Deferred;
 export const lazy = import("./lazy");
-export const common = require("./common");
 export const result = legacy();
 `)
 
@@ -29,7 +28,7 @@ export const result = legacy();
   }
   defer session.Close()
 
-  for _, name := range []string{"legacy.ts", "exported.ts", "types.ts", "lazy.ts", "common.ts"} {
+  for _, name := range []string{"legacy.ts", "exported.ts", "types.ts", "lazy.ts"} {
     candidate := filepath.Join(root, "src", name)
     state, ok := session.auxStates[candidate]
     if !ok {

package/driver/graph.go

@@ -32,26 +32,31 @@ const bundledScheme = "bundled:///"
 //     entries). A change to any of them can affect every file.
 //   - Configs lists the project tsconfig followed by its `extends` ancestry.
 //   - Candidates maps each importing file to the resolution probes that precede
-//     its selected module target. They are a separate class from resolved
-//     edges: a probe's file appearing or changing can change an unchanged
-//     import's meaning.
-//   - InputHashes and InputRealpaths pair graph members with the exact content
-//     state and physical identity observed by the compiler filesystem.
+//     or otherwise participate in its selected module and type-reference
+//     results. They are a separate class from resolved edges: a predicate or
+//     package manifest changing can change an unchanged reference's meaning.
+//   - ResolutionInputs lists automatic type discovery and resolution inputs
+//     whose state can affect every source file, including type-root directory
+//     membership.
+//   - InputObservations preserves the independent filesystem predicates the
+//     compiler actually asked. InputHashes and InputRealpaths retain the legacy
+//     collapsed content/identity projection for older consumers.
 //   - InputProofFailures gives a stable reason when a realized member lacks
-//     that pair. Speculative candidates are omitted because the compiler was
-//     never expected to read them.
+//     proof or a replayed resolver predicate changed.
 //
 // Keys and values use the same convention as the envelope's `typescript`
 // 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"`
-  InputHashes        map[string]*string  `json:"inputHashes,omitempty"`
-  InputRealpaths     map[string]*string  `json:"inputRealpaths,omitempty"`
-  InputProofFailures map[string]string   `json:"inputProofFailures,omitempty"`
+  Edges              map[string][]string                  `json:"edges"`
+  Globals            []string                             `json:"globals"`
+  Configs            []string                             `json:"configs"`
+  Candidates         map[string][]string                  `json:"candidates,omitempty"`
+  ResolutionInputs   []string                             `json:"resolutionInputs,omitempty"`
+  InputObservations  map[string]TransformInputObservation `json:"inputObservations,omitempty"`
+  InputHashes        map[string]*string                   `json:"inputHashes,omitempty"`
+  InputRealpaths     map[string]*string                   `json:"inputRealpaths,omitempty"`
+  InputProofFailures map[string]string                    `json:"inputProofFailures,omitempty"`
 }
 
 // NewTransformGraph computes the reference graph of a loaded program, keyed
@@ -63,11 +68,13 @@ func NewTransformGraph(prog *Program, cwd string) *TransformGraph {
   if prog == nil || prog.TSProgram == nil {
     return nil
   }
+  resolution := ObserveProgramResolutions(prog, cwd)
   graph := &TransformGraph{
-    Edges:      map[string][]string{},
-    Globals:    []string{},
-    Configs:    []string{},
-    Candidates: SupersedingModuleCandidates(prog, cwd),
+    Edges:            map[string][]string{},
+    Globals:          []string{},
+    Configs:          []string{},
+    Candidates:       resolution.Candidates,
+    ResolutionInputs: resolution.Universal,
   }
   for _, file := range prog.TSProgram.SourceFiles() {
     fileName := file.FileName()
@@ -87,6 +94,10 @@ func NewTransformGraph(prog *Program, cwd string) *TransformGraph {
   }
   sort.Strings(graph.Globals)
   graph.Configs = configChain(prog, cwd)
+  resolution.ApplyUniversalResolutionFailure(graph.Edges)
+  if len(resolution.Failures) != 0 {
+    graph.InputProofFailures = resolution.Failures
+  }
   graph.attachInputProof(prog, cwd)
   return graph
 }
@@ -123,21 +134,39 @@ func (graph *TransformGraph) attachInputProof(prog *Program, cwd string) {
       inputs[candidate] = struct{}{}
     }
   }
+  for _, input := range graph.ResolutionInputs {
+    inputs[input] = struct{}{}
+  }
   hashes := map[string]*string{}
   realpaths := map[string]*string{}
-  failures := map[string]string{}
+  observations := map[string]TransformInputObservation{}
+  failures := graph.InputProofFailures
+  if failures == nil {
+    failures = map[string]string{}
+  }
   for input := range inputs {
     file := filepath.FromSlash(input)
     if !filepath.IsAbs(file) {
       file = filepath.Join(cwd, file)
     }
-    hash, realpath, failure := prog.inputObserver.proof(file)
-    if failure != "" {
-      // Speculative candidates are allowed to lack compiler reads. Reporting
-      // only realized members keeps this diagnostic side channel bounded to
-      // inputs whose missing proof can actually refuse generation reuse.
-      if _, ok := realized[input]; ok {
-        failures[input] = string(failure)
+    observation, predicateFailure := prog.inputObserver.predicateProof(file)
+    if predicateFailure == "" {
+      observations[input] = observation
+    }
+    var hash, realpath *string
+    legacyFailure := predicateFailure
+    if predicateFailure == "" {
+      hash, realpath, legacyFailure = prog.inputObserver.proof(file)
+    }
+    if legacyFailure != "" {
+      // A resolver input can have a complete predicate proof that the legacy
+      // path-kind projection cannot represent, such as a successful file check
+      // whose content was never requested. The rich proof remains sufficient
+      // for that input; only a predicate failure, or any realized-input
+      // failure, makes the generation inadmissible.
+      _, isRealized := realized[input]
+      if isRealized || (predicateFailure != "" && predicateFailure != inputProofUnobserved) {
+        failures[input] = string(legacyFailure)
       }
       continue
     }
@@ -148,6 +177,9 @@ func (graph *TransformGraph) attachInputProof(prog *Program, cwd string) {
     graph.InputHashes = hashes
     graph.InputRealpaths = realpaths
   }
+  if len(observations) != 0 {
+    graph.InputObservations = observations
+  }
   if len(failures) != 0 {
     graph.InputProofFailures = failures
   }
@@ -158,18 +190,18 @@ func (graph *TransformGraph) attachInputProof(prog *Program, cwd string) {
 func referenceTargets(prog *Program, cwd string, file *ast.SourceFile) []string {
   paths := shimcompiler.GetReferencedFilePaths(prog.TSProgram, file)
   targets := make([]string, 0, len(paths))
-  for _, path := range paths {
-    fileName := path
+  for _, referencedPath := range paths {
     // Referenced paths are case-canonicalized tspath.Path values; recover the
-    // real spelling from the program so consumers can compare them against
-    // filesystem paths byte-for-byte.
-    if resolved := prog.TSProgram.GetSourceFileByPath(shimtspath.Path(path)); resolved != nil {
-      fileName = resolved.FileName()
-    }
-    if fileName == file.FileName() || strings.HasPrefix(fileName, bundledScheme) {
+    // resident source and its real spelling from the Program. The incremental
+    // helper can retain a raw extensionless project-reference directive even
+    // when no corresponding source became resident. That spelling is a
+    // resolver candidate, not a realized graph edge, and has no compiler-time
+    // content proof.
+    resolved := prog.TSProgram.GetSourceFileByPath(shimtspath.Path(referencedPath))
+    if resolved == nil || resolved == file || strings.HasPrefix(resolved.FileName(), bundledScheme) {
       continue
     }
-    targets = append(targets, TransformOutputKey(cwd, fileName))
+    targets = append(targets, TransformOutputKey(cwd, resolved.FileName()))
   }
   sort.Strings(targets)
   return targets