typia 14.0.0 → 14.0.2

package/native/cmd/ttsc-typia/transform.go

@@ -103,7 +103,7 @@ func runTransform(args []string) int {
       fmt.Fprintln(stderr, "ttsc-typia transform: --out requires --file")
       return 2
     }
-    return runTransformProject(prog, cwd, typiaTransform, &transformDiags)
+    return runTransformProject(prog, cwd, typiaTransform, &transformDiags, &extras)
   }
 
   absFile := *file
@@ -190,11 +190,25 @@ func runTransformSingle(
 // dependencies[F]), so graph is added alongside dependencies, not a replacement.
 // Every section keys through driver.TransformOutputKey, so the consumer joins
 // them by key.
+//
+// A third section, `dependenciesComplete`, names the files whose `dependencies`
+// entry is the whole story, and for those the consumer stops unioning: it
+// derives dependencies[F] ∪ configs ∪ candidates and drops reach(edges, F) and
+// globals. That is the difference between re-validating the reference closure
+// of a file and re-validating the handful of declarations typia read, paid once
+// per delivered module, and for the majority of a project's files -- the ones
+// with no typia call at all -- between the closure and nothing.
+//
+// The declaration transfers responsibility, so it is made per file and only
+// where the collector could bound the file's inputs; the dependency listener
+// and the diagnostic report this function wires are what decide that
+// (samchon/typia#2357). See transformDependencyCollector.Unbound.
 func runTransformProject(
   prog *driver.Program,
   cwd string,
   typiaTransform driver.PluginTransform,
   transformDiags *[]typiaTransformDiagnostic,
+  extras *nativecontext.ITypiaContext_Extras,
 ) int {
   out := transformProjectOutput{
     Diagnostics: []transformCompilerDiagnostic{},
@@ -209,8 +223,27 @@ func runTransformProject(
     sf := prog.SourceFile(fileName)
     return sf != nil && prog.TSProgram.IsLibFile(sf)
   })
-  schemametadata.MetadataDependency_listen(prog.Checker, collector.Touch)
+  // Only this host declares completeness, which is why only this host asks the
+  // analysis to admit what it could not bound: every such admission costs one
+  // file its declaration and nothing else.
+  schemametadata.MetadataDependency_listen(prog.Checker, schemametadata.MetadataDependency_IListener{
+    File:      collector.Touch,
+    Callee:    collector.TouchCallee,
+    Unbounded: collector.Unbound,
+  })
   defer schemametadata.MetadataDependency_release(prog.Checker)
+  // A diagnostic means typia could not finish lowering a call in the file being
+  // transformed, so what the analysis consulted before giving up is not that
+  // file's whole input set: an edit to a declaration it never reached could make
+  // the same call succeed and publish different text. The build fails either
+  // way, but a false claim is still false, so withhold the declaration rather
+  // than reason about how far the analysis got. The transformer reads `extras`
+  // on every call, so wrapping it through the pointer reaches the loop below.
+  reportDiagnostic := extras.AddDiagnostic
+  extras.AddDiagnostic = func(diag *nativecontext.ITypiaDiagnostic) int {
+    collector.Unbound()
+    return reportDiagnostic(diag)
+  }
   for _, sf := range prog.SourceFiles() {
     if sf.IsDeclarationFile {
       continue
@@ -221,8 +254,16 @@ func runTransformProject(
     }
     collector.Begin(key)
     out.TypeScript[key] = transformFileToTypeScript(prog, typiaTransform, sf)
+    collector.End()
   }
   out.Dependencies = collector.ToJSON()
+  // The config chain is the one input that stays universal for a declared file,
+  // and it reaches the consumer through this same envelope's graph. Declaring
+  // completeness without a graph would leave nothing universal behind, so a
+  // tsconfig edit would stop invalidating the files the declaration narrowed.
+  if out.Graph != nil {
+    out.DependenciesComplete = collector.ToCompleteJSON(out.TypeScript)
+  }
   for _, diag := range *transformDiags {
     out.Diagnostics = append(out.Diagnostics, transformDiagnosticToCompilerDiagnostic(diag))
   }
@@ -359,24 +400,62 @@ type transformProjectOutput struct {
   // files are excluded (toolchain-versioned, not project inputs);
   // `node_modules` declaration files are included.
   Dependencies map[string][]string `json:"dependencies,omitempty"`
+  // DependenciesComplete lists the TypeScript keys whose Dependencies entry is
+  // exhaustive: nothing outside that entry, the file itself, and the universal
+  // config chain can change the file's transformed text. The consumer stops
+  // widening those files with the reference closure and the global-scope set.
+  //
+  // Unlisted is always the safe answer, so the list carries only what the
+  // collector could bound. An older ttsc ignores the field; 0.19.3 and newer
+  // narrow on it.
+  DependenciesComplete []string `json:"dependenciesComplete,omitempty"`
 }
 
 // transformDependencyCollector accumulates the consulted-declaration files the
 // metadata dependency listener reports while one project file is transformed,
-// attributing them to that file's envelope key.
+// attributing them to that file's envelope key, and decides which of those keys
+// may be declared complete.
 type transformDependencyCollector struct {
   cwd     string
   current string
   files   map[string]map[string]bool
+  // unbounded holds the keys withheld from the completeness declaration. It is
+  // a set of exclusions rather than a set of admissions because every path that
+  // learns a file cannot be bounded runs while that file is being transformed,
+  // whereas nothing ever proves the opposite: a file is declarable exactly when
+  // no such path fired for it.
+  unbounded map[string]bool
   // isLibraryFile reports the compiler's own classification of a file as a
   // default library. Classification must come from the program, never from a
   // filename pattern: a project's own ambient declaration file may legitimately
   // be named `lib.custom.d.ts`, and dropping it by basename silently loses
   // cache invalidation for the types it declares (samchon/typia#2108).
   isLibraryFile func(fileName string) bool
-  // values memoizes fileName -> envelope value ("" for a dropped file): the
-  // listener reports the same declaration files repeatedly across call sites.
-  values map[string]string
+  // values memoizes fileName -> rendered envelope value: the listener reports
+  // the same declaration files repeatedly across call sites.
+  values map[string]transformDependencyValue
+}
+
+// transformDependencyBundledScheme is the prefix tsgo gives its embedded default
+// libraries, and the one `driver.NewTransformGraph` drops from the host-owned
+// reference graph.
+const transformDependencyBundledScheme = "bundled:///"
+
+// transformDependencyValue is one reported file rendered for the envelope: its
+// key, or the reason it was dropped. The reasons differ in what they cost a
+// completeness declaration, so they cannot both collapse to an empty value.
+type transformDependencyValue struct {
+  // key is the envelope value, empty when the file was dropped.
+  key string
+  // withhold marks a file this envelope cannot report but the host-owned bound
+  // still carries, so narrowing to the reported list would lose it.
+  withhold bool
+  // libraryOnly marks a withhold whose only cause is the compiler classifying
+  // the file as a default library. Such a file can change a consulted type and
+  // so a generated validator, but never which declaration a call resolves to,
+  // which is why the identity channel drops it without withholding
+  // (samchon/typia#2361).
+  libraryOnly bool
 }
 
 func newTransformDependencyCollector(
@@ -387,7 +466,8 @@ func newTransformDependencyCollector(
     cwd:           cwd,
     isLibraryFile: isLibraryFile,
     files:         map[string]map[string]bool{},
-    values:        map[string]string{},
+    unbounded:     map[string]bool{},
+    values:        map[string]transformDependencyValue{},
   }
 }
 
@@ -396,11 +476,61 @@ func (collector *transformDependencyCollector) Begin(key string) {
   collector.current = key
 }
 
+// End closes the attribution window Begin opened. Nothing consults the checker
+// between two files today, so this changes no output; it is what keeps that
+// true, because a touch that arrives outside a window is dropped rather than
+// charged -- or worse, withheld -- against whichever file happened to run last.
+func (collector *transformDependencyCollector) End() {
+  collector.current = ""
+}
+
+// Unbound withholds the completeness declaration from the file being
+// transformed. The file keeps its reported dependencies and falls back to the
+// host-owned reference-closure bound, which is what an unlisted file gets and
+// is always sound. Its callers name the reasons: an input the analysis could
+// only read from an inferred position, a consulted on-disk default library, and
+// a call typia could not lower.
+func (collector *transformDependencyCollector) Unbound() {
+  if collector.current == "" {
+    return
+  }
+  collector.unbounded[collector.current] = true
+}
+
 // Touch records one consulted declaration file for the current key. Default
 // library files, virtual URI sources (e.g. tsgo's `bundled:///` libraries),
 // and the transformed file itself are dropped so the envelope carries only
 // actionable project inputs.
+//
+// A drop the host-owned bound does not share also withholds the current file's
+// completeness declaration: the graph still carries that file, so a narrowed
+// file would stop watching an input the default bound watches.
 func (collector *transformDependencyCollector) Touch(fileName string) {
+  collector.touch(fileName, true)
+}
+
+// TouchCallee records one file reached while deciding WHICH declaration a call
+// resolves to, and does not let a default library withhold the current file.
+//
+// A default library is dropped from the reported list either way -- that
+// contract is samchon/typia#2108's -- but the withholding beside it belongs to
+// the type channel alone. Under `libReplacement` a replaced library can change
+// a generated validator, so a file that consulted one has to give up its
+// declaration. It can never change which declaration a call resolves to:
+// callExpressionTransformer_targetModule recognizes typia's own calls by a path
+// ending in `/typia/lib/<file>.d.ts` or `/typia/src/<file>.ts`, and a file the
+// compiler classifies as a default library satisfies neither wherever it sits
+// on disk. Withholding there cost a file its declaration for calling
+// `table.get(...)`, and under `noembed` -- where every library is a real file --
+// for calling anything at all (samchon/typia#2361).
+//
+// A virtual non-`bundled:///` scheme still withholds on both channels: that drop
+// is about being unwatchable, not about being a library.
+func (collector *transformDependencyCollector) TouchCallee(fileName string) {
+  collector.touch(fileName, false)
+}
+
+func (collector *transformDependencyCollector) touch(fileName string, library bool) {
   if collector.current == "" {
     return
   }
@@ -409,7 +539,10 @@ func (collector *transformDependencyCollector) Touch(fileName string) {
     value = collector.value(fileName)
     collector.values[fileName] = value
   }
-  if value == "" || value == collector.current {
+  if value.withhold && (library || value.libraryOnly == false) {
+    collector.Unbound()
+  }
+  if value.key == "" || value.key == collector.current {
     return
   }
   set := collector.files[collector.current]
@@ -417,19 +550,36 @@ func (collector *transformDependencyCollector) Touch(fileName string) {
     set = map[string]bool{}
     collector.files[collector.current] = set
   }
-  set[value] = true
+  set[value.key] = true
 }
 
-// value renders one reported file as its envelope value, or "" when the file
-// must be dropped: virtual URI sources (e.g. tsgo's `bundled:///` embedded
-// libraries) cannot be watched, and files the compiler classifies as default
-// libraries (on-disk in `noembed` or `libReplacement` configurations) are
-// toolchain inputs, not project inputs.
-func (collector *transformDependencyCollector) value(fileName string) string {
-  if strings.Contains(fileName, "://") || collector.isLibraryFile(fileName) {
-    return ""
-  }
-  return driver.TransformOutputKey(collector.cwd, fileName)
+// value renders one reported file as its envelope value, or records why it must
+// be dropped.
+//
+// tsgo's embedded libraries under `bundled:///` are nobody's input:
+// `driver.NewTransformGraph` skips that exact prefix, so dropping them leaves
+// the reported list and the host-owned bound in agreement and costs a
+// completeness declaration nothing. Any other URI scheme is unwatchable for us
+// but still reaches the graph, so it is dropped AND withheld -- the asymmetry
+// only runs in the safe direction.
+//
+// A file the compiler classifies as a default library is a toolchain input
+// rather than a project input, which is why the envelope has never reported one.
+// Under `noembed` or `libReplacement` it is nevertheless a real path that
+// `graph.globals` carries, so the default bound watches it while a narrowed file
+// would not. Keep dropping it from the reported list -- that contract is
+// #2108's -- and withhold the declaration from the file that consulted it.
+func (collector *transformDependencyCollector) value(fileName string) transformDependencyValue {
+  if strings.HasPrefix(fileName, transformDependencyBundledScheme) {
+    return transformDependencyValue{}
+  }
+  if strings.Contains(fileName, "://") {
+    return transformDependencyValue{withhold: true}
+  }
+  if collector.isLibraryFile(fileName) {
+    return transformDependencyValue{withhold: true, libraryOnly: true}
+  }
+  return transformDependencyValue{key: driver.TransformOutputKey(collector.cwd, fileName)}
 }
 
 // ToJSON renders the collected sets as the envelope's `dependencies` map with
@@ -456,6 +606,30 @@ func (collector *transformDependencyCollector) ToJSON() map[string][]string {
   return output
 }
 
+// ToCompleteJSON renders the envelope's `dependenciesComplete` list: every key
+// the transform published except the ones the collector could not bound.
+//
+// The published map is the input rather than the entries of ToJSON. A file typia
+// never touched reports no dependency at all, and that empty entry is the
+// strongest claim in the envelope -- nothing outside the file can change a
+// faithful re-print -- so reading the dependency map instead would drop the
+// majority of the narrowing on the floor. Taking the same map the consumer keys
+// on also makes the list a subset of it by construction.
+func (collector *transformDependencyCollector) ToCompleteJSON(published map[string]string) []string {
+  output := make([]string, 0, len(published))
+  for key := range published {
+    if collector.unbounded[key] {
+      continue
+    }
+    output = append(output, key)
+  }
+  if len(output) == 0 {
+    return nil
+  }
+  sort.Strings(output)
+  return output
+}
+
 type transformCompilerDiagnostic struct {
   File        *string `json:"file"`
   Category    string  `json:"category"`