typia 14.0.0 → 14.0.2

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

@@ -0,0 +1,177 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeArgumentTransform verifies a nested call's
+// arguments report the names they write, and that their shape never withholds
+// the caller.
+//
+// The callee chain names every indirection a caller writes -- a factory, a
+// barrel, a namespace alias -- but a generic pass-through carries identity
+// through what the call is APPLIED to instead: `pick(ns).is<Foo>(x)` is rewritten
+// because `ns` holds the typia namespace, so `ns.ts` decides whether this file
+// becomes a validator at all. Reproduced: the envelope declared the caller
+// complete while reporting only `foo.ts` and `pick.ts`, so re-pointing `ns.ts`
+// would have turned the validator back into a plain call with nothing to
+// invalidate it (samchon/typia#2357).
+//
+// The twin is why the walk's answer is dropped rather than combined: a callback
+// handed to a chained array method decides nothing about which `join` the outer
+// call names, and withholding on it would cost every file that chains one.
+//
+//  1. Build a project where `main.ts` calls `pick(ns).is<Foo>(input)` for a
+//     `pick` that returns its argument, and `chain.ts` writes
+//     `["a"].map((x) => x + HIDDEN).join(",")` for a `HIDDEN` from another file.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert `main.ts` really was rewritten into a validator, so the pass-through
+//     is the shape the test intends.
+//  4. Assert `dependencies["src/main.ts"]` carries `src/ns.ts` and `src/pick.ts`,
+//     and that the file is declared complete.
+//  5. Assert `chain.ts` is declared complete and never reports `src/hidden.ts`,
+//     the name only its callback body writes.
+//  6. Assert the tagged-template spelling of the same pass-through --
+//     “tag`x${ns}`.is<Foo>(input)“ -- reports `src/ns.ts` as well, because a
+//     template is what its tag is applied to.
+func TestProjectDependenciesCalleeArgumentTransform(t *testing.T) {
+  project := projectDependenciesCalleeArgumentProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    TypeScript           map[string]string   `json:"typescript"`
+    Dependencies         map[string][]string `json:"dependencies"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  if text := envelope.TypeScript["src/main.ts"]; !strings.Contains(text, "input is Foo") {
+    t.Fatalf("the pass-through call must have been rewritten into a validator, got:\n%s", text)
+  }
+  entries := envelope.Dependencies["src/main.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/ns.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/ns.ts, the argument that makes this call typia's: %v", entries)
+  }
+  if !found["src/pick.ts"] {
+    t.Fatalf("dependencies of src/main.ts must contain src/pick.ts, the pass-through on the callee chain: %v", entries)
+  }
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  if !declared["src/main.ts"] {
+    t.Fatalf("src/main.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+  if !declared["src/chain.ts"] {
+    t.Fatalf("a callback handed to a chained array method decides no callee identity and must not withhold its file: %v", envelope.DependenciesComplete)
+  }
+  for _, entry := range envelope.Dependencies["src/chain.ts"] {
+    if entry == "src/hidden.ts" {
+      t.Fatalf("the walk must stop at a function literal, so src/hidden.ts must not be charged to src/chain.ts: %v", envelope.Dependencies["src/chain.ts"])
+    }
+  }
+  if text := envelope.TypeScript["src/tagged.ts"]; !strings.Contains(text, "input is Foo") {
+    t.Fatalf("the tagged-template pass-through must have been rewritten into a validator, got:\n%s", text)
+  }
+  tagged := map[string]bool{}
+  for _, entry := range envelope.Dependencies["src/tagged.ts"] {
+    tagged[entry] = true
+  }
+  if !tagged["src/ns.ts"] {
+    t.Fatalf("dependencies of src/tagged.ts must contain src/ns.ts, the substitution that makes this call typia's: %v", envelope.Dependencies["src/tagged.ts"])
+  }
+  if !declared["src/tagged.ts"] {
+    t.Fatalf("src/tagged.ts must be declared complete, so the reported entry is the whole bound: %v", envelope.DependenciesComplete)
+  }
+}
+
+func projectDependenciesCalleeArgumentProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-callee-argument-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "main.ts":   projectDependenciesCalleeArgumentSourceMain,
+    "ns.ts":     projectDependenciesCalleeArgumentSourceNs,
+    "pick.ts":   projectDependenciesCalleeArgumentSourcePick,
+    "foo.ts":    projectDependenciesCalleeArgumentSourceFoo,
+    "chain.ts":  projectDependenciesCalleeArgumentSourceChain,
+    "hidden.ts": projectDependenciesCalleeArgumentSourceHidden,
+    "tagged.ts": projectDependenciesCalleeArgumentSourceTagged,
+    "tag.ts":    projectDependenciesCalleeArgumentSourceTag,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeArgumentSourceMain = `import { Foo } from "./foo";
+import { ns } from "./ns";
+import { pick } from "./pick";
+
+export const check = (input: unknown) => pick(ns).is<Foo>(input);
+`
+
+const projectDependenciesCalleeArgumentSourceNs = `import typia from "typia";
+
+export const ns = typia;
+`
+
+const projectDependenciesCalleeArgumentSourcePick = `export const pick = <T>(value: T): T => value;
+`
+
+const projectDependenciesCalleeArgumentSourceFoo = `export interface Foo {
+  id: string;
+}
+`
+
+const projectDependenciesCalleeArgumentSourceChain = `import { HIDDEN } from "./hidden";
+
+export const joined = ["a"].map((x) => x + HIDDEN).join(",");
+`
+
+const projectDependenciesCalleeArgumentSourceHidden = `export const HIDDEN = "hidden";
+`
+
+const projectDependenciesCalleeArgumentSourceTagged = `import { Foo } from "./foo";
+import { ns } from "./ns";
+import { tag } from "./tag";
+
+export const check = (input: unknown) => tag` + "`" + `x${ns}` + "`" + `.is<Foo>(input);
+`
+
+const projectDependenciesCalleeArgumentSourceTag = `export const tag = <T>(_strings: TemplateStringsArray, value: T): T => value;
+`

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

@@ -0,0 +1,115 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeBarrelTransform verifies the modules an import
+// chain traverses to reach a typia callee are reported for the file that calls
+// it.
+//
+// typia decides its own call sites by the file that declares the resolved
+// signature, so a barrel between the caller and typia chooses whether the call
+// is rewritten at all: re-pointing `export { is } from "typia"` at a local
+// helper turns a generated validator back into a plain call. The consulted-type
+// touches cannot see that -- they report what the validated type is, never what
+// selected the callee -- so without this the barrel is nowhere in the reported
+// list, and a consumer that narrows to that list serves the stale validator
+// (samchon/typia#2357).
+//
+//  1. Build a project where `consumer.ts` calls `is<Alpha>` imported from
+//     `barrel.ts`, which re-exports it from `typia`.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert the call was rewritten, so the barrel really did select typia.
+//  4. Assert `dependencies["src/consumer.ts"]` contains `src/barrel.ts`, and
+//     not `src/unused.ts`, which the barrel also re-exports but this reference
+//     never traverses.
+func TestProjectDependenciesCalleeBarrelTransform(t *testing.T) {
+  project := projectDependenciesCalleeBarrelProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    TypeScript   map[string]string   `json:"typescript"`
+    Dependencies map[string][]string `json:"dependencies"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+  if text := envelope.TypeScript["src/consumer.ts"]; !strings.Contains(text, "input is") {
+    t.Fatalf("the re-exported callee must still be recognized as typia's, got:\n%s", text)
+  }
+  entries := envelope.Dependencies["src/consumer.ts"]
+  found := map[string]bool{}
+  for _, entry := range entries {
+    found[entry] = true
+  }
+  if !found["src/barrel.ts"] {
+    t.Fatalf("dependencies of src/consumer.ts must contain the barrel src/barrel.ts that selects the typia callee: %v", entries)
+  }
+  if found["src/unused.ts"] {
+    t.Fatalf("dependencies of src/consumer.ts must not contain src/unused.ts, which the barrel re-exports but this reference never traverses: %v", entries)
+  }
+}
+
+func projectDependenciesCalleeBarrelProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-callee-barrel-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "consumer.ts": projectDependenciesCalleeBarrelSourceConsumer,
+    "barrel.ts":   projectDependenciesCalleeBarrelSourceBarrel,
+    "alpha.ts":    projectDependenciesCalleeBarrelSourceAlpha,
+    "unused.ts":   projectDependenciesCalleeBarrelSourceUnused,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeBarrelSourceConsumer = `import { is } from "./barrel";
+
+import { Alpha } from "./alpha";
+
+export const checkAlpha = (input: unknown) => is<Alpha>(input);
+`
+
+const projectDependenciesCalleeBarrelSourceBarrel = `export { is } from "typia";
+export { unused } from "./unused";
+`
+
+const projectDependenciesCalleeBarrelSourceAlpha = `export interface Alpha {
+  id: string;
+}
+`
+
+const projectDependenciesCalleeBarrelSourceUnused = `export const unused = (): number => 1;
+`

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

@@ -0,0 +1,285 @@
+package main
+
+import (
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestProjectDependenciesCalleeInferenceTransform verifies a nested call whose
+// identity comes from an inferred return type or a borrowed constant withholds
+// its file, while the same indirection written with a type keeps it.
+//
+// The callee walk reports which files a callee's name resolves through, and for
+// the OUTERMOST callee that is the whole answer: the identity is the resolved
+// declaration, whose file is reported. One call in it stops being the answer,
+// because there the identity is the inner call's return type. `const getNs = ()
+// => ns` and `const FLAG = RAW` both carry it from a file no name on the chain
+// writes, so reporting the names without admitting that declared the caller
+// complete while an edit to the unreported file deleted the generated validator
+// outright (samchon/typia#2360).
+//
+// A function DECLARATION with an inferred return type is the same defect one
+// keyword apart, and it needs its own case: the shared boundedness predicate
+// calls every callable bounded, because the type walk emits one as `typeof x
+// === "function"` and never reads its signature. On this channel the signature
+// is the whole question.
+//
+// The bounded twins are what keep the fix from degenerating into "withhold on
+// every nested call": an indirection with a written return type pins its
+// identity in the file that declares it, and that file must stay declared.
+//
+// The third shape samchon/typia#2360 reports -- an overload selected by a
+// borrowed VALUE -- is NOT pinned here, and the fixture keeps it as the record
+// of that. `const FLAG = RAW` is structurally identical to `const ns = typia`,
+// whose caller must stay declared (samchon/typia#2357), so no boundedness
+// answer separates them; reporting the initializer chain would.
+//
+//  1. Build a project with three unbounded shapes -- a computed argument, a
+//     computed callee, and a function declaration with an inferred return type
+//     -- plus a written-type twin for the `const` and the `function` spellings,
+//     and the borrowed-value overload that stays declared.
+//  2. Run project transform mode and decode the JSON envelope.
+//  3. Assert each file really was rewritten into a validator, so the test is
+//     measuring the shape it intends rather than a call typia never touched.
+//  4. Assert the three unbounded files are absent from `dependenciesComplete`.
+//  5. Assert both annotated twins are present, and that a file whose OUTERMOST
+//     callee resolves to a local `const helper = () => ...` keeps its
+//     declaration -- that name decides nothing, and charging it costs 65 more
+//     files across the test workspaces than the fix needs.
+func TestProjectDependenciesCalleeInferenceTransform(t *testing.T) {
+  project := projectDependenciesCalleeInferenceProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--output", "ts",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("project transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  var envelope struct {
+    TypeScript           map[string]string   `json:"typescript"`
+    Dependencies         map[string][]string `json:"dependencies"`
+    DependenciesComplete []string            `json:"dependenciesComplete"`
+  }
+  if err := json.Unmarshal([]byte(out), &envelope); err != nil {
+    t.Fatalf("decode envelope: %v\n%s", err, out)
+  }
+
+  // Guard first: an assertion about dependencies means nothing on a file the
+  // transform never rewrote, and that is exactly how this class hides.
+  for _, file := range []string{
+    "src/main_computed_arg.ts",
+    "src/main_computed_callee.ts",
+    "src/main_overload.ts",
+    "src/main_annotated.ts",
+    "src/main_function.ts",
+    "src/main_function_annotated.ts",
+    "src/main_outermost.ts",
+  } {
+    if text := envelope.TypeScript[file]; !strings.Contains(text, "input is Foo") {
+      t.Fatalf("%s must have been rewritten into a validator, got:\n%s", file, text)
+    }
+  }
+
+  declared := map[string]bool{}
+  for _, key := range envelope.DependenciesComplete {
+    declared[key] = true
+  }
+  for _, file := range []string{
+    "src/main_computed_arg.ts",
+    "src/main_computed_callee.ts",
+    "src/main_function.ts",
+  } {
+    if declared[file] {
+      t.Fatalf(
+        "%s must be withheld: its callee identity comes from an inferred "+
+          "return type or a borrowed constant, and %v does not name the file "+
+          "that decides it",
+        file,
+        envelope.Dependencies[file],
+      )
+    }
+  }
+  for _, file := range []string{
+    "src/main_annotated.ts",
+    "src/main_function_annotated.ts",
+  } {
+    if declared[file] {
+      continue
+    }
+    t.Fatalf(
+      "%s must stay declared: its indirection carries a written return type, "+
+        "so the reported files do pin the identity. Withholding it means the "+
+        "boundedness answer stopped reading the written type: %v",
+      file,
+      envelope.DependenciesComplete,
+    )
+  }
+  if !declared["src/main_outermost.ts"] {
+    t.Fatalf(
+      "src/main_outermost.ts must stay declared: its outermost callee IS the "+
+        "declaration it resolves to, so a local arrow with an inferred return "+
+        "type decides nothing. Withholding it means the nested guard is gone, "+
+        "which costs 65 more files across the test workspaces: %v",
+      envelope.DependenciesComplete,
+    )
+  }
+}
+
+func projectDependenciesCalleeInferenceProject(t *testing.T) string {
+  t.Helper()
+  root := ttscTypiaTestRepoRoot(t)
+  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    t.Fatalf("mkdir temp base: %v", err)
+  }
+  dir, err := os.MkdirTemp(base, "project-dependencies-callee-inference-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() { _ = os.RemoveAll(dir) })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(projectDependenciesEnvelopeTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  for name, body := range map[string]string{
+    "foo.ts":                     projectDependenciesCalleeInferenceSourceFoo,
+    "ns.ts":                      projectDependenciesCalleeInferenceSourceNs,
+    "getns.ts":                   projectDependenciesCalleeInferenceSourceGetNs,
+    "pick.ts":                    projectDependenciesCalleeInferenceSourcePick,
+    "rawflag.ts":                 projectDependenciesCalleeInferenceSourceRawFlag,
+    "flag.ts":                    projectDependenciesCalleeInferenceSourceFlag,
+    "other.ts":                   projectDependenciesCalleeInferenceSourceOther,
+    "sel.ts":                     projectDependenciesCalleeInferenceSourceSel,
+    "main_computed_arg.ts":       projectDependenciesCalleeInferenceSourceComputedArg,
+    "main_computed_callee.ts":    projectDependenciesCalleeInferenceSourceComputedCallee,
+    "main_overload.ts":           projectDependenciesCalleeInferenceSourceOverload,
+    "main_annotated.ts":          projectDependenciesCalleeInferenceSourceAnnotated,
+    "main_function.ts":           projectDependenciesCalleeInferenceSourceFunction,
+    "main_function_annotated.ts": projectDependenciesCalleeInferenceSourceFunctionAnnotated,
+    "main_outermost.ts":          projectDependenciesCalleeInferenceSourceOutermost,
+  } {
+    if err := os.WriteFile(filepath.Join(src, name), []byte(body), 0o644); err != nil {
+      t.Fatalf("write %s: %v", name, err)
+    }
+  }
+  return dir
+}
+
+const projectDependenciesCalleeInferenceSourceFoo = `export interface Foo {
+  id: string;
+}
+`
+
+const projectDependenciesCalleeInferenceSourceNs = `import typia from "typia";
+
+export const ns = typia;
+`
+
+// The return type is inferred, so nothing written here says the result is
+// typia's namespace; `ns.ts` decides it and no name on the callee chain reaches
+// that file.
+const projectDependenciesCalleeInferenceSourceGetNs = `import { ns } from "./ns";
+
+export const getNs = () => ns;
+
+export const getNsAnnotated: () => typeof ns = () => ns;
+
+export function getNsFn() {
+  return ns;
+}
+
+export function getNsFnAnnotated(): typeof ns {
+  return ns;
+}
+`
+
+const projectDependenciesCalleeInferenceSourcePick = `export const pick = <T>(value: T): T => value;
+`
+
+const projectDependenciesCalleeInferenceSourceRawFlag = `export const RAW = 1;
+`
+
+// The value is borrowed from another file, so the overload this selects is
+// decided by `rawflag.ts`.
+const projectDependenciesCalleeInferenceSourceFlag = `import { RAW } from "./rawflag";
+
+export const FLAG = RAW;
+`
+
+const projectDependenciesCalleeInferenceSourceOther = `export const other = {
+  is: <T>(_input: unknown): _input is T => false,
+};
+`
+
+const projectDependenciesCalleeInferenceSourceSel = `import typia from "typia";
+
+import { other } from "./other";
+
+export function sel(x: 0): typeof other;
+export function sel(x: 1): typeof typia;
+export function sel(x: number): unknown {
+  return x === 1 ? typia : other;
+}
+`
+
+const projectDependenciesCalleeInferenceSourceComputedArg = `import { Foo } from "./foo";
+import { getNs } from "./getns";
+import { pick } from "./pick";
+
+export const check = (input: unknown) => pick(getNs()).is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceComputedCallee = `import { Foo } from "./foo";
+import { getNs } from "./getns";
+
+export const check = (input: unknown) => getNs().is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceOverload = `import { Foo } from "./foo";
+import { FLAG } from "./flag";
+import { sel } from "./sel";
+
+export const check = (input: unknown) => sel(FLAG).is<Foo>(input);
+`
+
+// The bounded twin: the indirection's return type is written, so `getns.ts`
+// pins the identity and this file must keep its declaration.
+const projectDependenciesCalleeInferenceSourceAnnotated = `import { Foo } from "./foo";
+import { getNsAnnotated } from "./getns";
+
+export const check = (input: unknown) => getNsAnnotated().is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceFunction = `import { Foo } from "./foo";
+import { getNsFn } from "./getns";
+
+export const check = (input: unknown) => getNsFn().is<Foo>(input);
+`
+
+const projectDependenciesCalleeInferenceSourceFunctionAnnotated = `import { Foo } from "./foo";
+import { getNsFnAnnotated } from "./getns";
+
+export const check = (input: unknown) => getNsFnAnnotated().is<Foo>(input);
+`
+
+// The outermost callee's identity IS the declaration it resolves to, so a local
+// arrow with an inferred return type decides nothing here and must not withhold
+// the file. Measured: charging it drops the eight test workspaces from 806
+// declared to 741.
+const projectDependenciesCalleeInferenceSourceOutermost = `import typia from "typia";
+
+import { Foo } from "./foo";
+
+const label = () => "x";
+
+export const check = (input: unknown) => typia.is<Foo>(input) && label() !== "";
+`