typia 14.0.3 → 14.0.5

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

@@ -0,0 +1,135 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestBigintLiteralPrecisionTransform verifies a bigint literal reaches the
+// emit exactly, at any magnitude.
+//
+// `ExpressionFactory.Bigint` spelled its argument as a bare number literal, so
+// `9007199254740993n` was emitted as `BigInt(9007199254740993)` and JavaScript
+// rounded that literal to 9007199254740992 before `BigInt` ever parsed it. The
+// validator it built therefore accepted the wrong value: `is<9007199254740993n>`
+// returned true for 9007199254740992n and false for the literal it was asked
+// about. The repository already spells this hazard out for the two places that
+// avoided it -- `numericRangeFactory_bigint_literal` and `_isTypeInt64Bigint` --
+// and this factory is the one that did not.
+//
+// The factory feeds every bigint the transform emits, so the case sweeps the
+// operations that reach it rather than `is` alone.
+//
+//  1. Build validators over bigint literals past 2**53 and at the int64 bounds.
+//  2. Require the emitted code to pass the digits as a string, never as a
+//     number literal that rounds before `BigInt` sees it.
+//  3. Execute them and assert each accepts its own literal and rejects the
+//     adjacent value a rounded literal would have collapsed onto.
+func TestBigintLiteralPrecisionTransform(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, "bigint-precision-")
+  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(bigintLiteralPrecisionSource), 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("bigint precision transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  // A number-literal argument is the defect itself, so reject the spelling as
+  // well as the behavior: an emit that reads `BigInt(9007199254740993)` has
+  // already lost the value even where a later comparison happens to agree.
+  if strings.Contains(out, "BigInt(9007199254740993)") {
+    t.Fatalf("bigint literal must be passed as a string, not a number literal:\n%s", out)
+  }
+
+  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(bigintLiteralPrecisionRunner), 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("bigint precision runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const bigintLiteralPrecisionSource = `import typia from "typia";
+
+// 2**53 + 1 is the smallest integer a double cannot represent; rounding it
+// lands on 2**53, the value each validator below must reject.
+export const isUnsafe = typia.createIs<9007199254740993n>();
+export const isInt64Max = typia.createIs<9223372036854775807n>();
+export const isInt64Min = typia.createIs<-9223372036854775808n>();
+export const isUnion = typia.createIs<9007199254740993n | 9007199254740995n>();
+export const isSafe = typia.createIs<2n>();
+`
+
+const bigintLiteralPrecisionRunner = `const mod = require("./main.cjs");
+
+const check = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + ", got " + actual);
+  }
+};
+
+// Each literal is accepted, and the neighbor a rounded emit would have
+// collapsed it onto is rejected.
+check("isUnsafe(exact)", mod.isUnsafe(9007199254740993n), true);
+check("isUnsafe(rounded)", mod.isUnsafe(9007199254740992n), false);
+check("isInt64Max(exact)", mod.isInt64Max(9223372036854775807n), true);
+check("isInt64Max(rounded)", mod.isInt64Max(9223372036854775808n), false);
+check("isInt64Min(exact)", mod.isInt64Min(-9223372036854775808n), true);
+check("isInt64Min(neighbor)", mod.isInt64Min(-9223372036854775807n), false);
+check("isUnion(first)", mod.isUnion(9007199254740993n), true);
+check("isUnion(second)", mod.isUnion(9007199254740995n), true);
+check("isUnion(between)", mod.isUnion(9007199254740994n), false);
+check("isUnion(rounded)", mod.isUnion(9007199254740992n), false);
+
+// A magnitude a double does hold must keep working unchanged.
+check("isSafe(exact)", mod.isSafe(2n), true);
+check("isSafe(other)", mod.isSafe(3n), false);
+check("isSafe(number)", mod.isSafe(2), false);
+
+console.log("ok");
+`

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

@@ -0,0 +1,206 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestRecursiveContainerHelperIndexTransform verifies recursive container helpers
+// remain callable when ordinary containers precede them in collection order.
+func TestRecursiveContainerHelperIndexTransform(t *testing.T) {
+  project := recursiveContainerHelperIndexProject(t)
+  js := recursiveContainerHelperIndexTransform(t, project)
+  recursiveContainerHelperIndexRunRuntimeCases(t, project, js)
+}
+
+func recursiveContainerHelperIndexProject(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, "recursive-container-helper-index-")
+  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(recursiveContainerHelperIndexTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(recursiveContainerHelperIndexSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func recursiveContainerHelperIndexTransform(t *testing.T, project string) string {
+  t.Helper()
+  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("recursive container helper transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  return out
+}
+
+func recursiveContainerHelperIndexRunRuntimeCases(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)
+  if err := os.WriteFile(filepath.Join(runtimeDir, "feature-stub.cjs"), []byte(recursiveContainerHelperIndexFeatureStub), 0o644); err != nil {
+    t.Fatalf("write feature stub: %v", err)
+  }
+  for _, helper := range []string{
+    "_jsonStringifyNumber",
+    "_jsonStringifyString",
+    "_randomArray",
+    "_randomNumber",
+    "_randomPick",
+    "_throwTypeGuardError",
+  } {
+    js = strings.ReplaceAll(
+      js,
+      `require("typia/lib/internal/`+helper+`")`,
+      `require("./feature-stub.cjs")`,
+    )
+  }
+  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(ttscTypiaTestRewriteCommonJS(t, js)), 0o644); err != nil {
+    t.Fatalf("write runtime module: %v", err)
+  }
+  runner := filepath.Join(runtimeDir, "run.cjs")
+  if err := os.WriteFile(runner, []byte(recursiveContainerHelperIndexRuntimeRunner), 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("recursive container helper runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const recursiveContainerHelperIndexTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const recursiveContainerHelperIndexSource = `import typia from "typia";
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = JsonValue[];
+type JsonObject = { [key: string]: JsonValue };
+type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+
+interface ArrayWitness {
+  ordinary: string[];
+  value: JsonValue;
+}
+
+type RecursiveTuple = [string, RecursiveTuple | null];
+interface TupleWitness {
+  ordinary: [number];
+  value: RecursiveTuple;
+}
+
+type RandomArray = Array<string | RandomArray>;
+interface RandomArrayWitness {
+  ordinary: string[];
+  value: RandomArray;
+}
+
+export const isArray = typia.createIs<ArrayWitness>();
+export const isTuple = typia.createIs<TupleWitness>();
+export const stringifyArray = typia.json.createStringify<ArrayWitness>();
+export const stringifyTuple = typia.json.createStringify<TupleWitness>();
+export const camelArray = typia.notations.createCamel<ArrayWitness>();
+export const camelTuple = typia.notations.createCamel<TupleWitness>();
+export const cloneArray = typia.plain.createClone<ArrayWitness>();
+export const cloneTuple = typia.plain.createClone<TupleWitness>();
+export const classifyArray = typia.plain.createClassify<ArrayWitness>();
+export const classifyTuple = typia.plain.createClassify<TupleWitness>();
+export const pruneArray = typia.plain.createPrune<ArrayWitness>();
+export const pruneTuple = typia.plain.createPrune<TupleWitness>();
+export const randomArray = typia.createRandom<RandomArrayWitness>({
+  array: () => [],
+  string: () => "generated",
+});
+export const randomTuple = typia.createRandom<TupleWitness>({
+  boolean: () => false,
+  number: () => 1,
+  string: () => "generated",
+});
+`
+
+const recursiveContainerHelperIndexRuntimeRunner = `const mod = require("./main.cjs");
+
+const arrayValue = { ordinary: ["a"], value: [1, { nested: [true, null] }] };
+const tupleValue = { ordinary: [1], value: ["root", ["child", null]] };
+
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + ", got " + actual);
+  }
+};
+
+expect("is array", mod.isArray(arrayValue), true);
+expect("is tuple", mod.isTuple(tupleValue), true);
+expect("stringify array", mod.stringifyArray(arrayValue), JSON.stringify(arrayValue));
+expect("stringify tuple", mod.stringifyTuple(tupleValue), JSON.stringify(tupleValue));
+expect("notation array", mod.camelArray(arrayValue).value[1].nested[0], true);
+expect("notation tuple", mod.camelTuple(tupleValue).value[1][0], "child");
+expect("clone array", mod.cloneArray(arrayValue).value[1].nested[1], null);
+expect("clone tuple", mod.cloneTuple(tupleValue).value[1][0], "child");
+expect("classify array", mod.classifyArray(arrayValue).value[1].nested[0], true);
+expect("classify tuple", mod.classifyTuple(tupleValue).value[1][0], "child");
+
+const prunedArray = { ...arrayValue, extra: true };
+mod.pruneArray(prunedArray);
+expect("prune array", "extra" in prunedArray, false);
+const prunedTuple = { ...tupleValue, extra: true };
+mod.pruneTuple(prunedTuple);
+expect("prune tuple", "extra" in prunedTuple, false);
+
+const generatedArray = mod.randomArray();
+expect("random array", Array.isArray(generatedArray.value), true);
+const generatedTuple = mod.randomTuple();
+expect("random tuple", generatedTuple.value[0], "generated");
+`
+
+const recursiveContainerHelperIndexFeatureStub = `module.exports._jsonStringifyNumber = (value) => Number.isFinite(value) ? value : null;
+module.exports._jsonStringifyString = (value) => JSON.stringify(value);
+module.exports._randomArray = () => [];
+module.exports._randomNumber = () => 1;
+module.exports._randomPick = (values) => values[0];
+module.exports._throwTypeGuardError = (props) => { throw Object.assign(new Error(props.expected), props); };
+`

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

@@ -0,0 +1,148 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestReflectLiteralsBigintTransform verifies a bigint member comes back as a
+// bigint, exactly.
+//
+// typescript-go hands a bigint literal back as a `jsnum.PseudoBigInt`, a struct
+// in an internal package the shim does not re-export. Nothing downstream could
+// name that type, so `LiteralFactory` reflected its fields and emitted
+// `{ base10Value: "2", negative: false }` where `literals<2n>(): 2n[]` promises
+// a bigint. Normalizing the constant to `*big.Int` at the metadata boundary
+// gives every consumer a nameable exact value.
+//
+// Magnitude is the part a happy-path case would miss. A bigint exists precisely
+// to hold what a `number` cannot, so the emit is only correct if it survives
+// past 2**53.
+//
+//  1. Transform a module whose `reflect.literals` arguments span a bigint union,
+//     a bigint mixed with other literal kinds, and magnitudes on both sides of
+//     the double-precision limit including the int64 bounds.
+//  2. Execute the emitted CommonJS.
+//  3. Assert every member is `typeof "bigint"` and equal to the literal the
+//     source declared, digit for digit.
+func TestReflectLiteralsBigintTransform(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-bigint-")
+  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(reflectLiteralsBigintSource), 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 bigint 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(reflectLiteralsBigintRunner), 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 bigint runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const reflectLiteralsBigintSource = `import typia from "typia";
+
+export const small = typia.reflect.literals<1n | 2n>();
+export const mixed = typia.reflect.literals<"A" | "B" | 1 | 2n>();
+export const negative = typia.reflect.literals<-5n | 5n>();
+export const zero = typia.reflect.literals<0n>();
+
+// 2**53 + 1 is the smallest integer a double cannot hold, and the int64 bounds
+// are where a rounded literal would land on the wrong side of the range.
+export const unsafe = typia.reflect.literals<9007199254740993n>();
+export const int64 = typia.reflect.literals<-9223372036854775808n | 9223372036854775807n>();
+`
+
+const reflectLiteralsBigintRunner = `const mod = require("./main.cjs");
+
+const render = (value) =>
+  typeof value === "bigint" ? value.toString() + "n" : JSON.stringify(value);
+
+const check = (label, actual, expected) => {
+  if (Array.isArray(actual) === false) {
+    throw new Error(label + ": expected an array, got " + render(actual));
+  }
+  if (actual.length !== expected.length) {
+    throw new Error(
+      label +
+        ": expected " +
+        expected.map(render).join(", ") +
+        ", got " +
+        actual.map(render).join(", "),
+    );
+  }
+  actual.forEach((item, index) => {
+    // typeof is asserted separately: a rounded BigInt(9007199254740993) is
+    // still a bigint, and an object literal is still deep-equal to nothing, so
+    // neither check alone catches both defects.
+    if (typeof item !== typeof expected[index]) {
+      throw new Error(
+        label + "[" + index + "]: expected typeof " + typeof expected[index] +
+          ", got " + typeof item + " (" + render(item) + ")",
+      );
+    }
+    if (item !== expected[index]) {
+      throw new Error(
+        label + "[" + index + "]: expected " + render(expected[index]) +
+          ", got " + render(item),
+      );
+    }
+  });
+};
+
+check("small", mod.small, [1n, 2n]);
+check("mixed", mod.mixed, ["A", "B", 1, 2n]);
+check("negative", mod.negative, [-5n, 5n]);
+check("zero", mod.zero, [0n]);
+check("unsafe", mod.unsafe, [9007199254740993n]);
+check("int64", mod.int64, [-9223372036854775808n, 9223372036854775807n]);
+
+console.log("ok");
+`

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

@@ -7,24 +7,26 @@ import (
   "testing"
 )
 
-// TestReflectLiteralsNonLiteralRejectionTransform is the negative twin of the
-// empty-union admission fixed for issue #2377.
+// TestReflectLiteralsNonLiteralRejectionTransform verifies every argument that
+// names no listable literal is refused at compile time.
 //
-// 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.
+// `reflect.literals` hands back the members of a union, so an argument it
+// cannot enumerate has no answer to give. Refusing it is the point: emitting an
+// empty array for `never`, or dropping the half it cannot render from a mixed
+// argument, would hand the caller a list that silently disagrees with the type
+// it was derived from (issue #2377).
 //
-//  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.
+// The two diagnostics stay distinguishable because they say different things:
+// `NO` reports that nothing listable was found at all, while `ONLY` reports
+// that something listable was found beside something that is not. Collapsing
+// them would hide which half of a mixed argument is wrong.
+//
+//  1. Transform arguments naming no listable member: `never` and the bare
+//     `null` flag, which carry nothing, and `string`, `any`, and a tag-branded
+//     atomic, which carry a member that cannot be enumerated.
+//  2. Transform arguments mixing a listable member with one that is not,
+//     including `boolean | number`, where the listable half 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 {
@@ -32,13 +34,17 @@ func TestReflectLiteralsNonLiteralRejectionTransform(t *testing.T) {
     Argument string
     Message  string
   }{
+    {"never", "never", "no constant literal type found."},
+    {"never alias", "Empty", "no constant literal type found."},
+    {"exhaustive exclude", `Exclude<"a" | "b", "a" | "b">`, "no constant literal type found."},
+    {"bare null", "null", "no constant literal type found."},
     {"atomic", "string", "no constant literal type found."},
     {"any", "any", "no constant literal type found."},
-    {"nullable atomic", "string | null", "only constant literal types are allowed."},
+    {"tag branded atomic", `string & tags.Format<"uuid">`, "no constant literal type found."},
+    {"nullable atomic", "string | null", "no constant literal type found."},
     {"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