typia 13.1.1 → 13.1.19

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

@@ -0,0 +1,194 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNativeGenericNameGuardIsTransform verifies that a user type whose name
+// begins with WeakMap/WeakSet is not misdetected as the native generic.
+//
+// Native generic detection matched WeakMap/WeakSet with a bare
+// strings.HasPrefix(name, generic.Name) while the Map/Set siblings require the
+// name to be exactly the generic. A user interface named WeakMapLike therefore
+// took the native path and emitted `input instanceof WeakMap`, so
+// typia.is<WeakMapLike>({...}) returned false (issue #2181). The guard now
+// admits a native only when the stripped name equals the generic, so a genuine
+// WeakMap<K, V>/WeakSet<T> stays native while WeakMapLike validates its shape.
+//
+//  1. Transform typia.is calls for WeakMapLike, WeakSetLike, WeakMapEntry, a
+//     MapLike control, and genuine WeakMap<object, number>/WeakSet<object>.
+//  2. Assert the emitted TypeScript keeps the native `instanceof` path for the
+//     genuine generics.
+//  3. Execute the emitted validators so the user-named objects validate as
+//     their shape while the genuine natives still accept only their instance.
+func TestNativeGenericNameGuardIsTransform(t *testing.T) {
+  project := nativeGenericNameGuardProject(t)
+  ts := nativeGenericNameGuardTransform(t, project, "ts")
+  for _, needle := range []string{"instanceof WeakMap", "instanceof WeakSet"} {
+    if !strings.Contains(ts, needle) {
+      t.Fatalf("expected genuine native path %q in transform output:\n%s", needle, ts)
+    }
+  }
+  nativeGenericNameGuardRunRuntimeCases(t, project, nativeGenericNameGuardTransform(t, project, "js"))
+}
+
+func nativeGenericNameGuardProject(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, "native-generic-name-guard-")
+  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(nativeGenericNameGuardTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(nativeGenericNameGuardSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func nativeGenericNameGuardTransform(t *testing.T, project string, output string) string {
+  t.Helper()
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", output,
+    })
+  })
+  if code != 0 {
+    t.Fatalf("native generic name guard transform failed: output=%s code=%d stderr=\n%s", output, code, errText)
+  }
+  return out
+}
+
+func nativeGenericNameGuardRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(nativeGenericNameGuardRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  if output, err := cmd.CombinedOutput(); err != nil {
+    t.Fatalf("native generic name guard runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const nativeGenericNameGuardTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const nativeGenericNameGuardSource = `import typia from "typia";
+
+interface WeakMapLike {
+  id: number;
+  count: number;
+}
+interface WeakSetLike {
+  id: number;
+  count: number;
+}
+interface WeakMapEntry {
+  id: number;
+  count: number;
+}
+interface MapLike {
+  id: number;
+  count: number;
+}
+
+export const isWeakMapLike = (input: unknown): boolean =>
+  typia.is<WeakMapLike>(input);
+export const isWeakSetLike = (input: unknown): boolean =>
+  typia.is<WeakSetLike>(input);
+export const isWeakMapEntry = (input: unknown): boolean =>
+  typia.is<WeakMapEntry>(input);
+export const isMapLike = (input: unknown): boolean =>
+  typia.is<MapLike>(input);
+export const isNativeWeakMap = (input: unknown): boolean =>
+  typia.is<WeakMap<object, number>>(input);
+export const isNativeWeakSet = (input: unknown): boolean =>
+  typia.is<WeakSet<object>>(input);
+`
+
+const nativeGenericNameGuardRuntimeRunner = `const mod = require("./main.cjs");
+
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + ", got " + actual);
+  }
+};
+
+const shaped = { id: 1, count: 2 };
+
+// A user interface whose name is merely prefixed by a native generic must
+// validate against its declared shape, not the native instanceof path.
+expect("WeakMapLike accepts its shape", mod.isWeakMapLike(shaped), true);
+expect("WeakMapLike rejects a missing property", mod.isWeakMapLike({ id: 1 }), false);
+expect("WeakMapLike rejects a wrong property type", mod.isWeakMapLike({ id: 1, count: "2" }), false);
+expect("WeakMapLike rejects a real WeakMap", mod.isWeakMapLike(new WeakMap()), false);
+
+expect("WeakSetLike accepts its shape", mod.isWeakSetLike(shaped), true);
+expect("WeakSetLike rejects a missing property", mod.isWeakSetLike({ id: 1 }), false);
+expect("WeakSetLike rejects a real WeakSet", mod.isWeakSetLike(new WeakSet()), false);
+
+expect("WeakMapEntry accepts its shape", mod.isWeakMapEntry(shaped), true);
+expect("WeakMapEntry rejects a missing property", mod.isWeakMapEntry({ id: 1 }), false);
+
+// MapLike is the already-guarded control: it stays a plain object exactly as
+// the WeakMap*/WeakSet* names now do.
+expect("MapLike control accepts its shape", mod.isMapLike(shaped), true);
+expect("MapLike control rejects a missing property", mod.isMapLike({ id: 1 }), false);
+
+// Genuine native generics always carry angle brackets, so the exact-name guard
+// keeps them on the native instanceof path unchanged.
+expect("native WeakMap accepts an instance", mod.isNativeWeakMap(new WeakMap()), true);
+expect("native WeakMap rejects a plain object", mod.isNativeWeakMap(shaped), false);
+expect("native WeakMap rejects a WeakSet", mod.isNativeWeakMap(new WeakSet()), false);
+
+expect("native WeakSet accepts an instance", mod.isNativeWeakSet(new WeakSet()), true);
+expect("native WeakSet rejects a plain object", mod.isNativeWeakSet(shaped), false);
+expect("native WeakSet rejects a WeakMap", mod.isNativeWeakSet(new WeakMap()), false);
+`

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

@@ -0,0 +1,204 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestNativeNameCollisionIsTransform pins the runtime and emit behavior of
+// typia.is / assert / validate for a user type whose name collides with a
+// built-in native (#2200).
+//
+// Native classification matched a type against the simples table by name alone,
+// so a user `interface File { name; size }` yielded the base name "File", matched
+// iterate_metadata_native_simples["File"], and emitted `input instanceof File` —
+// ignoring the user's own members. Every valid `File` value was therefore
+// rejected, and in a runtime without the DOM/File global the check threw a
+// ReferenceError. The same struck `Blob`, `Date`, the typed arrays, and every
+// other simples name.
+//
+// After the fix native classification requires the matched symbol to be declared
+// in a `.d.ts` declaration file (a TypeScript default library or an ambient
+// package such as @types/node), which a real built-in always is and a user type
+// in a `.ts` module never is. A colliding user type then falls through to the
+// structural object path and validates against its declared members, while a
+// genuine native (`Date`, `Uint8Array`) keeps its native `instanceof` check.
+//
+//  1. Transform is / validate for user interfaces named File and Blob, a near-miss
+//     control (Filer), and the genuine natives Date and Uint8Array.
+//  2. Assert the emitted TypeScript drops `instanceof File` / `instanceof Blob`
+//     for the user types while keeping `instanceof Date` / `instanceof Uint8Array`
+//     for the real natives.
+//  3. Execute the emitted validators in Node against the boundary matrix, and
+//     require the runner to report the exact executed case count so a runner that
+//     silently skipped cases cannot pass as a false green.
+func TestNativeNameCollisionIsTransform(t *testing.T) {
+  project := nativeNameCollisionProject(t)
+  js := nativeNameCollisionTransform(t, project)
+  for _, gone := range []string{"instanceof File", "instanceof Blob"} {
+    if strings.Contains(js, gone) {
+      t.Fatalf("expected user type collision %q to be reclassified structurally, but it survived in:\n%s", gone, js)
+    }
+  }
+  for _, kept := range []string{"instanceof Date", "instanceof Uint8Array"} {
+    if !strings.Contains(js, kept) {
+      t.Fatalf("expected genuine native path %q to remain in transform output:\n%s", kept, js)
+    }
+  }
+  nativeNameCollisionRunRuntimeCases(t, project, js)
+}
+
+func nativeNameCollisionProject(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, "native-name-collision-")
+  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(finiteOptionNumberLeafTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(nativeNameCollisionSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func nativeNameCollisionTransform(t *testing.T, project string) string {
+  t.Helper()
+  payload := `[{"config":{"transform":"typia/lib/transform"},"name":"typia","stage":"transform"}]`
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+      "--plugins-json", payload,
+    })
+  })
+  if code != 0 {
+    t.Fatalf("native name collision transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func nativeNameCollisionRunRuntimeCases(t *testing.T, project string, js string) {
+  t.Helper()
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  runtimeDir := filepath.Join(project, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(nativeNameCollisionRuntimeRunner), 0o644); err != nil {
+    t.Fatalf("write runtime runner: %v", err)
+  }
+  cmd := exec.Command(node, runner)
+  cmd.Dir = runtimeDir
+  output, err := cmd.CombinedOutput()
+  if err != nil {
+    t.Fatalf("native name collision runtime cases failed: %v\n%s", err, output)
+  }
+  const expected = "RAN 23 CASES"
+  if !strings.Contains(string(output), expected) {
+    t.Fatalf("native name collision runner did not report %q; got:\n%s", expected, output)
+  }
+}
+
+const nativeNameCollisionSource = `import typia from "typia";
+
+interface File {
+  name: string;
+  size: number;
+}
+interface Blob {
+  size: number;
+  type: string;
+}
+interface Filer {
+  name: string;
+}
+
+export const isFile = typia.createIs<File>();
+export const validateFile = typia.createValidate<File>();
+export const isBlob = typia.createIs<Blob>();
+export const isFiler = typia.createIs<Filer>();
+
+export const isDate = typia.createIs<Date>();
+export const isU8 = typia.createIs<Uint8Array>();
+`
+
+const nativeNameCollisionRuntimeRunner = `const mod = require("./main.cjs");
+
+let ran = 0;
+const eq = (name, actual, expected) => {
+  ran += 1;
+  if (actual !== expected) {
+    throw new Error(name + ": expected " + expected + " but got " + actual);
+  }
+};
+
+// A user interface named File must validate against its own members, not the
+// native File instanceof path (#2200 core cases).
+eq("isFile valid", mod.isFile({ name: "a", size: 1 }), true);
+eq("isFile missing size", mod.isFile({ name: "a" }), false);
+eq("isFile missing name", mod.isFile({ size: 1 }), false);
+eq("isFile wrong size type", mod.isFile({ name: "a", size: "1" }), false);
+eq("isFile null", mod.isFile(null), false);
+eq("isFile primitive", mod.isFile(5), false);
+
+// validate shares the structural object path, so it agrees with is and names no
+// File expected type.
+eq("validateFile valid", mod.validateFile({ name: "a", size: 1 }).success, true);
+eq("validateFile invalid", mod.validateFile({ name: "a" }).success, false);
+
+// A user interface named Blob is structural too.
+eq("isBlob valid", mod.isBlob({ size: 1, type: "x" }), true);
+eq("isBlob missing type", mod.isBlob({ size: 1 }), false);
+eq("isBlob null", mod.isBlob(null), false);
+
+// A near-miss name that is not a native was always structural and stays so.
+eq("isFiler valid", mod.isFiler({ name: "a" }), true);
+eq("isFiler invalid", mod.isFiler({}), false);
+
+// Genuine natives keep their instanceof check and accept a real instance while
+// rejecting a plain object of the same shape.
+eq("isDate real", mod.isDate(new Date()), true);
+eq("isDate plain object", mod.isDate({}), false);
+eq("isDate null", mod.isDate(null), false);
+
+eq("isU8 real", mod.isU8(new Uint8Array(4)), true);
+eq("isU8 plain object", mod.isU8({}), false);
+eq("isU8 array", mod.isU8([1, 2, 3]), false);
+eq("isU8 null", mod.isU8(null), false);
+
+// A user File/Blob value is not a real native instance, and a real native is not
+// a user shape: the two classifications stay disjoint.
+eq("isFile rejects a real Date", mod.isFile(new Date()), false);
+eq("isDate rejects a user File shape", mod.isDate({ name: "a", size: 1 }), false);
+eq("isBlob rejects a real Date", mod.isBlob(new Date()), false);
+
+console.log("RAN " + ran + " CASES");
+`

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

@@ -18,20 +18,22 @@ import (
 // addresses tuples by fixed leading positions, so the honest resolution is
 // a compile-time rejection, mirroring the json.schemas bigint precedent.
 //
-//  1. Require leading-rest and middle-rest tuples to be rejected: the call
-//     stays untransformed and a transform diagnostic is recorded (the same
-//     convention the duplicate-Sequence protobuf fixture pins; in build and
-//     project modes these diagnostics fail the compilation).
+//  1. Require leading-rest and middle-rest tuples to be rejected: the transform
+//     records a diagnostic naming the offending tuple, which every host --
+//     single-file included since samchon/typia#2117 -- reports while refusing to
+//     publish an artifact.
 //  2. Require trailing-rest tuples to keep compiling and validating
 //     correctly at every length.
 func TestNonTrailingRestTupleTransform(t *testing.T) {
   t.Run("leading rest rejected", func(t *testing.T) {
     nonTrailingRestExpectRejection(t, "leading-",
-      "export const validate = typia.createValidate<[...unknown[], string]>();")
+      "export const validate = typia.createValidate<[...unknown[], string]>();",
+      "[...unknown[], string]")
   })
   t.Run("middle rest rejected", func(t *testing.T) {
     nonTrailingRestExpectRejection(t, "middle-",
-      "export const validate = typia.createValidate<[number, ...boolean[], string]>();")
+      "export const validate = typia.createValidate<[number, ...boolean[], string]>();",
+      "[number, ...boolean[], string]")
   })
   t.Run("trailing rest keeps working", func(t *testing.T) {
     nonTrailingRestTrailingControl(t)
@@ -66,7 +68,12 @@ func nonTrailingRestProject(t *testing.T, prefix string, body string) string {
   return dir
 }
 
-func nonTrailingRestExpectRejection(t *testing.T, prefix string, body string) {
+// nonTrailingRestExpectRejection requires the rejection to reach the caller as a
+// diagnostic naming `tuple`, with no artifact published. This previously asserted
+// code 0 and inspected the untransformed call in stdout; that success code was
+// the samchon/typia#2117 defect, and in `js` mode the surviving `.createValidate()`
+// was only type erasure, so the diagnostic is the load-bearing evidence anyway.
+func nonTrailingRestExpectRejection(t *testing.T, prefix string, body string, tuple string) {
   t.Helper()
   project := nonTrailingRestProject(t, prefix, body)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -77,11 +84,16 @@ func nonTrailingRestExpectRejection(t *testing.T, prefix string, body string) {
       "--output", "js",
     })
   })
-  if code != 0 {
-    t.Fatalf("single-file transform should stay inspectable: code=%d stderr=\n%s", code, errText)
+  if code != 3 {
+    t.Fatalf("non-trailing rest tuple should be rejected with code 3: code=%d stdout=\n%s\nstderr=\n%s", code, out, errText)
+  }
+  if !strings.Contains(errText, "error TS(typia.createValidate):") ||
+    !strings.Contains(errText, tuple) ||
+    !strings.Contains(errText, "non-trailing rest element in tuple type is not supported.") {
+    t.Fatalf("rejection diagnostic did not name the tuple and cause:\n%s", errText)
   }
-  if !strings.Contains(out, ".createValidate()") {
-    t.Fatalf("non-trailing rest tuple call should stay untransformed:\n%s", out)
+  if out != "" {
+    t.Fatalf("rejected transform published an artifact:\n%s", out)
   }
 }