typia 14.0.2 → 14.0.3

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

@@ -0,0 +1,161 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestReflectLiteralsEmptyUnionTransform pins issue #2377: the literal set of an
+// empty union is the empty array, not a transform error.
+//
+// The programmer admits a type argument by counting the members it can render,
+// and it renders three kinds -- constant literals, the `boolean` atomic, and
+// `null`. `null` is a `MetadataSchema` flag rather than a bucket, so it was
+// missing from the count, which made two admissible arguments look like "no
+// constant literal type found": `never`, whose union is empty on both sides of
+// the comparison, and `null`, which the public
+// `literals<T extends Atomic.Type | null>()` signature documents. `never` is
+// vacuously literal-only and `literals<never>(): never[]` has exactly one
+// inhabitant, so both must transform and run.
+//
+//  1. Transform a module whose `reflect.literals` arguments span every
+//     uninhabited spelling a caller reaches -- the keyword, an alias, an
+//     exhaustive `Exclude`, an empty `Extract`, a TypeScript-collapsed
+//     intersection, and one typia prunes itself -- plus `null`, a fully mixed
+//     literal union, and the plain `boolean` atomic.
+//  2. Execute the emitted CommonJS.
+//  3. Assert `never` yields `[]`, `null` yields `[null]`, and the arguments that
+//     already worked keep their exact members and order, including the sort the
+//     guide documents.
+func TestReflectLiteralsEmptyUnionTransform(t *testing.T) {
+  node, err := exec.LookPath("node")
+  if err != nil {
+    t.Skip("node executable not found")
+  }
+  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, "reflect-literals-empty-")
+  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(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(reflectLiteralsEmptyUnionSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  ttscTypiaTestTypecheck(t, dir)
+
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", dir,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("reflect.literals empty union transform failed: code=%d stderr=\n%s", code, errText)
+  }
+
+  runtimeDir := filepath.Join(dir, "runtime")
+  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
+    t.Fatalf("mkdir runtime dir: %v", err)
+  }
+  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
+  runtimeJS := ttscTypiaTestRewriteCommonJS(t, out)
+  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(reflectLiteralsEmptyUnionRunner), 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("reflect.literals empty union runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const reflectLiteralsEmptyUnionSource = `import typia from "typia";
+
+type Color = "red" | "green" | "blue";
+type Empty = never;
+
+// The empty union: no member on either side of the admission comparison. Every
+// spelling a caller reaches it through has to transform, not only the keyword:
+// an alias hides it behind a name, and a conditional or an exhaustive Exclude
+// is how a generic caller produces one without writing "never" at all.
+export const empty = typia.reflect.literals<never>();
+export const emptyAlias = typia.reflect.literals<Empty>();
+export const emptyExclude = typia.reflect.literals<Exclude<Color, Color>>();
+export const emptyExtract = typia.reflect.literals<Extract<Color, "cyan">>();
+
+// Uninhabited without the keyword: TypeScript collapses one to never itself,
+// while the other stays an intersection whose every distributed member typia
+// prunes away. Both are empty on both sides of the comparison, so the rule the
+// keyword exercises has to cover them too.
+export const emptyCollapsed = typia.reflect.literals<string & number>();
+export const emptyPruned = typia.reflect.literals<(string | number) & { data: number }>();
+
+// A union whose only member is the nullable flag, which carries no bucket.
+export const onlyNull = typia.reflect.literals<null>();
+
+// Controls that already transformed: the flag must join the count without
+// displacing a constant, a boolean atomic, or their order.
+export const mixed = typia.reflect.literals<"a" | 1 | true | null>();
+export const booleanAtomic = typia.reflect.literals<boolean>();
+export const booleanAtomicNull = typia.reflect.literals<boolean | null>();
+
+// Declaration order deliberately disagrees with the emitted order: values of
+// one primitive type are sorted (iterate_metadata_sort), which is the behavior
+// the reflect.literals guide states.
+export const sorted = typia.reflect.literals<"b" | "a" | 10 | 2>();
+`
+
+const reflectLiteralsEmptyUnionRunner = `const mod = require("./main.cjs");
+
+const check = (label, actual, expected) => {
+  if (Array.isArray(actual) === false) {
+    throw new Error(label + ": expected an array, got " + JSON.stringify(actual));
+  }
+  if (
+    actual.length !== expected.length ||
+    actual.some((item, index) => item !== expected[index])
+  ) {
+    throw new Error(
+      label +
+        ": expected " +
+        JSON.stringify(expected) +
+        ", got " +
+        JSON.stringify(actual),
+    );
+  }
+};
+
+check("never", mod.empty, []);
+check("never alias", mod.emptyAlias, []);
+check("exhaustive Exclude", mod.emptyExclude, []);
+check("empty Extract", mod.emptyExtract, []);
+check("collapsed intersection", mod.emptyCollapsed, []);
+check("pruned intersection", mod.emptyPruned, []);
+check("null", mod.onlyNull, [null]);
+check("mixed", mod.mixed, ["a", 1, true, null]);
+check("booleanAtomic", mod.booleanAtomic, [true, false]);
+check("booleanAtomicNull", mod.booleanAtomicNull, [true, false, null]);
+check("sorted", mod.sorted, ["a", "b", 2, 10]);
+
+console.log("ok");
+`

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

@@ -0,0 +1,92 @@
+package main
+
+import (
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestReflectLiteralsNonLiteralRejectionTransform is the negative twin of the
+// empty-union admission fixed for issue #2377.
+//
+// Widening the admission predicate so that the empty union and the bare `null`
+// flag both pass must not widen it any further: every argument that carries a
+// member the emitter cannot render still has to abort the transform. The two
+// diagnostics stay distinguishable as well, because they say different things --
+// `NO` reports that nothing literal was found at all, while `ONLY` reports that
+// something literal was found next to something that is not. Collapsing them
+// would hide which half of a mixed argument is wrong.
+//
+//  1. Transform arguments holding no literal at all: a bare atomic, `any`, and
+//     a tag-branded atomic, whose brand raises the member count without adding
+//     anything the emitter can render.
+//  2. Transform arguments mixing a renderable member with a non-literal one:
+//     `string | null`, the one-axis twin of the newly admitted `null`, and
+//     `boolean | number`, where the renderable member is an atomic rather than
+//     a constant.
+//  3. Assert each fails, and with the diagnostic its composition calls for.
+func TestReflectLiteralsNonLiteralRejectionTransform(t *testing.T) {
+  cases := []struct {
+    Name     string
+    Argument string
+    Message  string
+  }{
+    {"atomic", "string", "no constant literal type found."},
+    {"any", "any", "no constant literal type found."},
+    {"nullable atomic", "string | null", "only constant literal types are allowed."},
+    {"literal beside atomic", `"a" | number`, "only constant literal types are allowed."},
+    {"literal beside template", "`prefix${number}` | \"a\"", "only constant literal types are allowed."},
+    {"renderable atomic beside atomic", "boolean | number", "only constant literal types are allowed."},
+    {"tag branded atomic", `string & tags.Format<"uuid">`, "no constant literal type found."},
+  }
+  for _, tc := range cases {
+    tc := tc
+    t.Run(tc.Name, func(t *testing.T) {
+      project := reflectLiteralsRejectionProject(t, tc.Argument)
+      out, errText, code := ttscTypiaTestCapture(func() int {
+        return runTransform([]string{
+          "--cwd", project,
+          "--tsconfig", "tsconfig.json",
+          "--file", "src/main.ts",
+          "--output", "js",
+        })
+      })
+      if code == 0 {
+        t.Fatalf("reflect.literals<%s> transformed successfully, want rejection:\n%s", tc.Argument, out)
+      }
+      if !strings.Contains(errText, "typia transform error") {
+        t.Fatalf("reflect.literals<%s> diagnostics missing:\nstdout=%s\nstderr=%s", tc.Argument, out, errText)
+      }
+      if !strings.Contains(errText, tc.Message) {
+        t.Fatalf("reflect.literals<%s> reported the wrong reason, want %q:\n%s", tc.Argument, tc.Message, errText)
+      }
+    })
+  }
+}
+
+func reflectLiteralsRejectionProject(t *testing.T, argument string) 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, "reflect-literals-reject-")
+  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(atomicIntersectionSchemaTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  source := "import typia, { tags } from \"typia\";\n\nexport const values = typia.reflect.literals<" + argument + ">();\n"
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(source), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}

package/native/core/programmers/reflect/ReflectLiteralsProgrammer.go

@@ -29,6 +29,24 @@ func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_
       Escape:   true,
       Constant: true,
       Absorb:   true,
+      // Accept exactly what the emitter below can render: constant literals,
+      // the `boolean` atomic (the `true | false` union), and `null`. `null` is
+      // a `MetadataSchema` flag rather than a bucket, so `Size()` cannot see
+      // it; weighing it on both sides keeps `length` meaning "renderable
+      // members" against `size` meaning "members", which is what lets a
+      // rejected argument carry the diagnostic its composition calls for
+      // instead of collapsing onto `NO`.
+      //
+      // Equal counts with no member at all is an uninhabited argument: the
+      // `never` keyword, an alias or `Exclude`/`Extract` that filters
+      // everything away, or an intersection whose every distributed member
+      // prunes to never. Its literal set is empty and
+      // `literals<never>(): never[]` has exactly one inhabitant, so it emits
+      // `[]` rather than a diagnostic (issue #2377). `undefined` and `void`
+      // coalesce to the same empty metadata, but neither satisfies the public
+      // `T extends Atomic.Type | null` bound, and typia refuses to transform
+      // at all without `strictNullChecks` (`transform/transform.go`), so
+      // neither reaches this predicate.
       Validate: func(next struct {
         Metadata *nativemetadata.MetadataSchema
         Explore  nativefactories.MetadataFactory_IExplore
@@ -43,13 +61,18 @@ func (reflectLiteralsProgrammerNamespace) Write(props ReflectLiteralsProgrammer_
             length++
           }
         }
+        size := next.Metadata.Size()
+        if next.Metadata.Nullable {
+          length++
+          size++
+        }
+        if size == length {
+          return []string{}
+        }
         if length == 0 {
           return []string{string(ReflectLiteralsProgrammer_ErrorMessages_NO)}
         }
-        if next.Metadata.Size() != length {
-          return []string{string(ReflectLiteralsProgrammer_ErrorMessages_ONLY)}
-        }
-        return []string{}
+        return []string{string(ReflectLiteralsProgrammer_ErrorMessages_ONLY)}
       },
     },
     Components: nativemetadata.NewMetadataCollection(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "14.0.2",
+  "version": "14.0.3",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,8 +43,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^14.0.2",
-    "@typia/utils": "^14.0.2"
+    "@typia/interface": "^14.0.3",
+    "@typia/utils": "^14.0.3"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"