typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

package/src/programmers/AssertProgrammer.ts

@@ -31,29 +31,65 @@ export namespace AssertProgrammer {
                 trace: true,
                 numeric: OptionPredicator.numeric(project.options),
                 equals,
-                atomist: (explore) => (tuple) => (input) =>
+                atomist: (explore) => (entry) => (input) =>
                     [
-                        ...(tuple.expression ? [tuple.expression] : []),
-                        ...tuple.tags.map((tag) =>
-                            ts.factory.createLogicalOr(
-                                tag.expression,
-                                create_guard_call(importer)(
-                                    explore.from === "top"
-                                        ? ts.factory.createTrue()
-                                        : ts.factory.createIdentifier(
-                                              "_exceptionable",
+                        ...(entry.expression ? [entry.expression] : []),
+                        ...(entry.conditions.length === 0
+                            ? []
+                            : entry.conditions.length === 1
+                            ? entry.conditions[0]!.map((cond) =>
+                                  ts.factory.createLogicalOr(
+                                      cond.expression,
+                                      create_guard_call(importer)(
+                                          explore.from === "top"
+                                              ? ts.factory.createTrue()
+                                              : ts.factory.createIdentifier(
+                                                    "_exceptionable",
+                                                ),
+                                      )(
+                                          ts.factory.createIdentifier(
+                                              explore.postfix
+                                                  ? `_path + ${explore.postfix}`
+                                                  : "_path",
                                           ),
-                                )(
-                                    ts.factory.createIdentifier(
-                                        explore.postfix
-                                            ? `_path + ${explore.postfix}`
-                                            : "_path",
-                                    ),
-                                    tag.expected,
-                                    input,
-                                ),
-                            ),
-                        ),
+                                          cond.expected,
+                                          input,
+                                      ),
+                                  ),
+                              )
+                            : [
+                                  ts.factory.createLogicalOr(
+                                      entry.conditions
+                                          .map((set) =>
+                                              set
+                                                  .map((s) => s.expression)
+                                                  .reduce((a, b) =>
+                                                      ts.factory.createLogicalAnd(
+                                                          a,
+                                                          b,
+                                                      ),
+                                                  ),
+                                          )
+                                          .reduce((a, b) =>
+                                              ts.factory.createLogicalOr(a, b),
+                                          ),
+                                      create_guard_call(importer)(
+                                          explore.from === "top"
+                                              ? ts.factory.createTrue()
+                                              : ts.factory.createIdentifier(
+                                                    "_exceptionable",
+                                                ),
+                                      )(
+                                          ts.factory.createIdentifier(
+                                              explore.postfix
+                                                  ? `_path + ${explore.postfix}`
+                                                  : "_path",
+                                          ),
+                                          entry.expected,
+                                          input,
+                                      ),
+                                  ),
+                              ]),
                     ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
                 combiner: combiner(equals)(importer),
                 joiner: joiner(equals)(importer),

package/src/programmers/CheckerProgrammer.ts

@@ -8,17 +8,14 @@ import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
-import { IJsDocTagInfo } from "../schemas/metadata/IJsDocTagInfo";
-import { IMetadataCommentTag } from "../schemas/metadata/IMetadataCommentTag";
-import { IMetadataTypeTag } from "../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../transformers/IProject";
+import { TransformerError } from "../transformers/TransformerError";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { AtomicPredicator } from "./helpers/AtomicPredicator";
@@ -28,7 +25,6 @@ import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
 import { check_array_length } from "./internal/check_array_length";
-import { check_array_tags } from "./internal/check_array_tags";
 import { check_bigint } from "./internal/check_bigint";
 import { check_native } from "./internal/check_native";
 import { check_number } from "./internal/check_number";
@@ -131,7 +127,7 @@ export namespace CheckerProgrammer {
             collection
                 .arrays()
                 .filter((a) => a.recursive)
-                .map((array, i) =>
+                .map((type, i) =>
                     StatementFactory.constant(
                         `${config.prefix}a${i}`,
                         ts.factory.createArrowFunction(
@@ -144,16 +140,16 @@ export namespace CheckerProgrammer {
                             undefined,
                             decode_array_inline(project)(config)(importer)(
                                 ts.factory.createIdentifier("input"),
-                                array,
+                                MetadataArray.create({
+                                    type,
+                                    tags: [],
+                                }),
                                 {
                                     tracable: config.trace,
                                     source: "function",
                                     from: "array",
                                     postfix: "",
                                 },
-                                [],
-                                [],
-                                [],
                             ),
                         ),
                     ),
@@ -187,8 +183,6 @@ export namespace CheckerProgrammer {
                                     from: "array",
                                     postfix: "",
                                 },
-                                [],
-                                [],
                             ),
                         ),
                     ),
@@ -215,15 +209,20 @@ export namespace CheckerProgrammer {
             prefix: config.prefix,
             initializer:
                 ({ checker }) =>
+                (importer) =>
                 (type) => {
                     const collection: MetadataCollection =
                         new MetadataCollection();
-                    const meta: Metadata = MetadataFactory.analyze(checker)({
+                    const result = MetadataFactory.analyze(checker)({
                         escape: false,
                         constant: true,
                         absorb: true,
                     })(collection)(type);
-                    return [collection, meta];
+                    if (result.success === false)
+                        throw TransformerError.from(`typia.${importer.method}`)(
+                            result.errors,
+                        );
+                    return [collection, result.data];
                 },
             addition: config.addition,
             decoder: () =>
@@ -296,8 +295,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: IExplore,
-            metaTags: IMetadataCommentTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             if (meta.any) return config.success;
 
@@ -306,10 +303,13 @@ export namespace CheckerProgrammer {
             const add = create_add(binaries)(input);
             const getConstantValue = (
                 value: number | string | bigint | boolean,
-            ) =>
-                typeof value === "string"
-                    ? ts.factory.createStringLiteral(value)
-                    : ts.factory.createIdentifier(value.toString());
+            ) => {
+                if (typeof value === "string")
+                    return ts.factory.createStringLiteral(value);
+                else if (typeof value === "bigint")
+                    return ExpressionFactory.bigint(value);
+                return ts.factory.createIdentifier(value.toString());
+            };
 
             //----
             // CHECK OPTIONAL
@@ -364,27 +364,21 @@ export namespace CheckerProgrammer {
                 else if (atom.type === "number")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_number(project, config.numeric)(
-                                atom.tags,
-                                metaTags,
-                            )(input),
+                            check_number(project, config.numeric)(atom)(input),
                         )(input),
                         combined: false,
                     });
                 else if (atom.type === "bigint")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_bigint(project)(atom.tags, metaTags)(input),
+                            check_bigint(project)(atom)(input),
                         )(input),
                         combined: false,
                     });
                 else if (atom.type === "string")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_string(project)(importer)(
-                                atom.tags,
-                                metaTags,
-                            )(input),
+                            check_string(project)(atom)(input),
                         )(input),
                         combined: false,
                     });
@@ -448,8 +442,6 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            [],
-                            [],
                         ),
                     );
             }
@@ -473,8 +465,6 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            metaTags,
-                            jsDocTags,
                         ),
                     );
             }
@@ -483,8 +473,12 @@ export namespace CheckerProgrammer {
             if (meta.tuples.length + meta.arrays.length > 0) {
                 const install = prepare(
                     config.atomist(explore)({
+                        expected: [
+                            ...meta.tuples.map((t) => t.type.name),
+                            ...meta.arrays.map((a) => a.getName()),
+                        ].join(" | "),
                         expression: ExpressionFactory.isArray(input),
-                        tags: [],
+                        conditions: [],
                     })(input),
                     [...meta.tuples, ...meta.arrays]
                         .map((elem) => elem.type.name)
@@ -500,8 +494,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                     // TUPLE ONLY
@@ -514,8 +506,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                 else if (meta.arrays.some((elem) => elem.type.value.any))
@@ -531,8 +521,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                     else
@@ -544,8 +532,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                 else
@@ -554,8 +540,6 @@ export namespace CheckerProgrammer {
                             input,
                             [...meta.tuples, ...meta.arrays],
                             explore,
-                            metaTags,
-                            jsDocTags,
                         ),
                     );
             }
@@ -670,21 +654,12 @@ export namespace CheckerProgrammer {
         (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
-        (
-            input: ts.Expression,
-            array: MetadataArray,
-            explore: IExplore,
-            metaTags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
-        ) => {
+        (input: ts.Expression, array: MetadataArray, explore: IExplore) => {
             if (array.type.recursive === false)
                 return decode_array_inline(project)(config)(importer)(
                     input,
-                    array.type,
+                    array,
                     explore,
-                    array.tags,
-                    metaTags,
-                    jsDocTags,
                 );
 
             explore = {
@@ -716,29 +691,20 @@ export namespace CheckerProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArrayType,
+            array: MetadataArray,
             explore: IExplore,
-            matrix: IMetadataTypeTag[][],
-            metaTags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression => {
-            const tagger = check_array_tags(project)(matrix, metaTags)(input);
+            const length = check_array_length(project)(array)(input);
             const main = FeatureProgrammer.decode_array({
                 prefix: config.prefix,
                 trace: config.trace,
                 path: config.path,
                 decoder: () => decode(project)(config)(importer),
-            })(importer)(config.joiner.array)(
-                input,
-                array,
-                explore,
-                metaTags,
-                jsDocTags,
-            );
-            return tagger.expression === null && tagger.tags.length === 0
+            })(importer)(config.joiner.array)(input, array, explore);
+            return length.expression === null && length.conditions.length === 0
                 ? main
                 : ts.factory.createLogicalAnd(
-                      config.atomist(explore)(tagger)(input),
+                      config.atomist(explore)(length)(input),
                       main,
                   );
         };
@@ -751,16 +717,12 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             tuple: MetadataTuple,
             explore: IExplore,
-            tagList: IMetadataCommentTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             if (tuple.type.recursive === false)
                 return decode_tuple_inline(project)(config)(importer)(
                     input,
                     tuple.type,
                     explore,
-                    tagList,
-                    jsDocTags,
                 );
             explore = {
                 ...explore,
@@ -792,8 +754,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             tuple: MetadataTupleType,
             explore: IExplore,
-            tagList: IMetadataCommentTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             const binaries: ts.Expression[] = tuple.elements
                 .filter((meta) => meta.rest === null)
@@ -808,8 +768,6 @@ export namespace CheckerProgrammer {
                                 ? `${explore.postfix.slice(0, -1)}[${index}]"`
                                 : `"[${index}]"`,
                         },
-                        tuple.of_map === true && index !== 1 ? [] : tagList,
-                        tuple.of_map === true && index !== 1 ? [] : jsDocTags,
                     ),
                 );
             const rest: ts.Expression | null =
@@ -831,8 +789,6 @@ export namespace CheckerProgrammer {
                               ...explore,
                               start: tuple.elements.length - 1,
                           },
-                          tagList,
-                          jsDocTags,
                       )
                     : null;
 
@@ -915,8 +871,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             sets: Metadata[],
             explore: IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             ts.factory.createCallExpression(
                 UnionExplorer.set({
@@ -928,7 +882,7 @@ export namespace CheckerProgrammer {
                         ts.factory.createReturnStatement(
                             config.joiner.failure(input, expected, explore),
                         ),
-                })([])(input, sets, explore, tags, jsDocTags),
+                })([])(input, sets, explore),
                 undefined,
                 undefined,
             );
@@ -941,8 +895,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             maps: Metadata.Entry[],
             explore: IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             ts.factory.createCallExpression(
                 UnionExplorer.map({
@@ -959,8 +911,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[0]`,
                                 },
-                                [],
-                                [],
                             ),
                             func(
                                 ts.factory.createElementAccessExpression(
@@ -972,8 +922,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[1]`,
                                 },
-                                [],
-                                [],
                             ),
                         );
                     },
@@ -984,7 +932,7 @@ export namespace CheckerProgrammer {
                         ts.factory.createReturnStatement(
                             config.joiner.failure(input, expected, explore),
                         ),
-                })([])(input, maps, explore, tags, jsDocTags),
+                })([])(input, maps, explore),
                 undefined,
                 undefined,
             );
@@ -997,8 +945,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             tuples: MetadataTuple[],
             explore: IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
                 UnionExplorer.tuple({
@@ -1011,7 +957,7 @@ export namespace CheckerProgrammer {
                             config.joiner.failure(input, expected, explore),
                         ),
                 }),
-            )(input, tuples, explore, tags, jsDocTags);
+            )(input, tuples, explore);
 
     const explore_arrays =
         (project: IProject) =>
@@ -1021,8 +967,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             arrays: MetadataArray[],
             explore: IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
                 UnionExplorer.array({
@@ -1035,7 +979,7 @@ export namespace CheckerProgrammer {
                             config.joiner.failure(input, expected, explore),
                         ),
                 }),
-            )(input, arrays, explore, tags, jsDocTags);
+            )(input, arrays, explore);
 
     const explore_arrays_and_tuples =
         (project: IProject) =>
@@ -1045,45 +989,42 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             elements: Array<MetadataArray | MetadataTuple>,
             explore: IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
                 UnionExplorer.array_or_tuple({
-                    checker: (front, target, explore, tags, jsDocTags, array) =>
+                    checker: (front, target, explore, array) =>
                         target instanceof MetadataTuple
                             ? decode_tuple(project)(config)(importer)(
                                   front,
                                   target,
                                   explore,
-                                  tags,
-                                  jsDocTags,
                               )
                             : config.atomist(explore)({
+                                  expected: elements
+                                      .map((elem) =>
+                                          elem instanceof MetadataArray
+                                              ? elem.getName()
+                                              : elem.type.name,
+                                      )
+                                      .join(" | "),
                                   expression: decode(project)(config)(importer)(
                                       front,
                                       target,
                                       explore,
-                                      tags,
-                                      jsDocTags,
                                   ),
-                                  tags: check_array_length(tags)(array),
+                                  conditions: [],
                               })(array),
-                    decoder: (input, target, explore, tags, jsDocTags) =>
+                    decoder: (input, target, explore) =>
                         target instanceof MetadataTuple
                             ? decode_tuple(project)(config)(importer)(
                                   input,
                                   target,
                                   explore,
-                                  tags,
-                                  jsDocTags,
                               )
                             : decode_array(project)(config)(importer)(
                                   input,
                                   target,
                                   explore,
-                                  tags,
-                                  jsDocTags,
                               ),
                     empty: config.success,
                     success: config.success,
@@ -1092,7 +1033,7 @@ export namespace CheckerProgrammer {
                             config.joiner.failure(input, expected, explore),
                         ),
                 }),
-            )(input, elements, explore, tags, jsDocTags);
+            )(input, elements, explore);
 
     const explore_array_like_union_types =
         (config: IConfig) =>
@@ -1104,28 +1045,18 @@ export namespace CheckerProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: IExplore,
-                tags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
             input: ts.Expression,
             elements: T[],
             explore: IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression => {
             const arrow =
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(
-                        input,
-                        elements,
-                        explore,
-                        tags,
-                        jsDocTags,
-                    );
+                    factory(parameters)(input, elements, explore);
             if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),