typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230827

package/src/programmers/CheckerProgrammer.ts

@@ -8,12 +8,11 @@ import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
-import { IJsDocTagInfo } from "../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../schemas/metadata/IMetadataTag";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../transformers/IProject";
 
@@ -24,7 +23,6 @@ import { ICheckEntry } from "./helpers/ICheckEntry";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
-import { check_array } from "./internal/check_array";
 import { check_array_length } from "./internal/check_array_length";
 import { check_bigint } from "./internal/check_bigint";
 import { check_native } from "./internal/check_native";
@@ -128,7 +126,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(
@@ -141,15 +139,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: "",
                                 },
-                                [],
-                                [],
                             ),
                         ),
                     ),
@@ -183,8 +182,6 @@ export namespace CheckerProgrammer {
                                     from: "array",
                                     postfix: "",
                                 },
-                                [],
-                                [],
                             ),
                         ),
                     ),
@@ -292,8 +289,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: IExplore,
-            metaTags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             if (meta.any) return config.success;
 
@@ -302,10 +297,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
@@ -354,35 +352,34 @@ export namespace CheckerProgrammer {
                         add(true, getConstantValue(val));
 
             // ATOMIC VALUES
-            for (const type of meta.atomics)
-                if (AtomicPredicator.atomic(meta)(type) === false) continue;
-                else if (type === "number")
+            for (const atom of meta.atomics)
+                if (AtomicPredicator.atomic(meta)(atom.type) === false)
+                    continue;
+                else if (atom.type === "number")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_number(project, config.numeric)(importer)(
-                                metaTags,
-                            )(jsDocTags)(input),
+                            check_number(project, config.numeric)(atom)(input),
                         )(input),
                         combined: false,
                     });
-                else if (type === "bigint")
+                else if (atom.type === "bigint")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_bigint(importer)(metaTags)(jsDocTags)(input),
+                            check_bigint(project)(atom)(input),
                         )(input),
                         combined: false,
                     });
-                else if (type === "string")
+                else if (atom.type === "string")
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_string(importer)(metaTags)(jsDocTags)(input),
+                            check_string(project)(atom)(input),
                         )(input),
                         combined: false,
                     });
                 else
                     add(
                         true,
-                        ts.factory.createStringLiteral(type),
+                        ts.factory.createStringLiteral(atom.type),
                         ValueFactory.TYPEOF(input),
                     );
 
@@ -391,9 +388,7 @@ export namespace CheckerProgrammer {
                 if (AtomicPredicator.template(meta))
                     binaries.push({
                         expression: config.atomist(explore)(
-                            check_template(importer)(metaTags)(jsDocTags)(
-                                meta.templates,
-                            )(input),
+                            check_template(meta.templates)(input),
                         )(input),
                         combined: false,
                     });
@@ -441,8 +436,6 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            [],
-                            [],
                         ),
                     );
             }
@@ -466,8 +459,6 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            metaTags,
-                            jsDocTags,
                         ),
                     );
             }
@@ -475,13 +466,16 @@ export namespace CheckerProgrammer {
             // ARRAYS AND TUPLES
             if (meta.tuples.length + meta.arrays.length > 0) {
                 const install = prepare(
-                    config.atomist(explore)(
-                        check_array(importer)(
-                            meta.tuples.length === 0 ? metaTags : [],
-                        )(jsDocTags)(input),
-                    )(input),
+                    config.atomist(explore)({
+                        expected: [
+                            ...meta.tuples.map((t) => t.type.name),
+                            ...meta.arrays.map((a) => a.getName()),
+                        ].join(" | "),
+                        expression: ExpressionFactory.isArray(input),
+                        conditions: [],
+                    })(input),
                     [...meta.tuples, ...meta.arrays]
-                        .map((elem) => elem.name)
+                        .map((elem) => elem.type.name)
                         .join(" | "),
                 );
                 if (meta.arrays.length === 0)
@@ -494,8 +488,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                     // TUPLE ONLY
@@ -508,11 +500,9 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
-                else if (meta.arrays.some((elem) => elem.value.any))
+                else if (meta.arrays.some((elem) => elem.type.value.any))
                     install(null);
                 else if (meta.tuples.length === 0)
                     if (meta.arrays.length === 1)
@@ -525,8 +515,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                     else
@@ -538,8 +526,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                 else
@@ -548,8 +534,6 @@ export namespace CheckerProgrammer {
                             input,
                             [...meta.tuples, ...meta.arrays],
                             explore,
-                            metaTags,
-                            jsDocTags,
                         ),
                     );
             }
@@ -664,20 +648,12 @@ export namespace CheckerProgrammer {
         (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
-        (
-            input: ts.Expression,
-            array: MetadataArray,
-            explore: IExplore,
-            metaTags: IMetadataTag[],
-            jsDocTags: IJsDocTagInfo[],
-        ) => {
-            if (array.recursive === false)
+        (input: ts.Expression, array: MetadataArray, explore: IExplore) => {
+            if (array.type.recursive === false)
                 return decode_array_inline(project)(config)(importer)(
                     input,
                     array,
                     explore,
-                    metaTags,
-                    jsDocTags,
                 );
 
             explore = {
@@ -688,7 +664,9 @@ export namespace CheckerProgrammer {
             return ts.factory.createLogicalOr(
                 ts.factory.createCallExpression(
                     ts.factory.createIdentifier(
-                        importer.useLocal(`${config.prefix}a${array.index}`),
+                        importer.useLocal(
+                            `${config.prefix}a${array.type.index}`,
+                        ),
                     ),
                     undefined,
                     FeatureProgrammer.argumentsArray(config)({
@@ -697,7 +675,7 @@ export namespace CheckerProgrammer {
                         from: "array",
                     })(input),
                 ),
-                config.joiner.failure(input, array.name, explore),
+                config.joiner.failure(input, array.type.name, explore),
             );
         };
 
@@ -705,12 +683,25 @@ export namespace CheckerProgrammer {
         (project: IProject) =>
         (config: IConfig) =>
         (importer: FunctionImporter) =>
-            FeatureProgrammer.decode_array({
+        (
+            input: ts.Expression,
+            array: MetadataArray,
+            explore: IExplore,
+        ): ts.Expression => {
+            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);
+            })(importer)(config.joiner.array)(input, array, explore);
+            return length.expression === null && length.conditions.length === 0
+                ? main
+                : ts.factory.createLogicalAnd(
+                      config.atomist(explore)(length)(input),
+                      main,
+                  );
+        };
 
     const decode_tuple =
         (project: IProject) =>
@@ -720,16 +711,12 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             tuple: MetadataTuple,
             explore: IExplore,
-            tagList: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
-            if (tuple.recursive === false)
+            if (tuple.type.recursive === false)
                 return decode_tuple_inline(project)(config)(importer)(
                     input,
-                    tuple,
+                    tuple.type,
                     explore,
-                    tagList,
-                    jsDocTags,
                 );
             explore = {
                 ...explore,
@@ -739,7 +726,9 @@ export namespace CheckerProgrammer {
             return ts.factory.createLogicalOr(
                 ts.factory.createCallExpression(
                     ts.factory.createIdentifier(
-                        importer.useLocal(`${config.prefix}t${tuple.index}`),
+                        importer.useLocal(
+                            `${config.prefix}t${tuple.type.index}`,
+                        ),
                     ),
                     undefined,
                     FeatureProgrammer.argumentsArray(config)({
@@ -747,7 +736,7 @@ export namespace CheckerProgrammer {
                         source: "function",
                     })(input),
                 ),
-                config.joiner.failure(input, tuple.name, explore),
+                config.joiner.failure(input, tuple.type.name, explore),
             );
         };
 
@@ -757,10 +746,8 @@ export namespace CheckerProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: IExplore,
-            tagList: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             const binaries: ts.Expression[] = tuple.elements
                 .filter((meta) => meta.rest === null)
@@ -775,8 +762,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 =
@@ -798,8 +783,6 @@ export namespace CheckerProgrammer {
                               ...explore,
                               start: tuple.elements.length - 1,
                           },
-                          tagList,
-                          jsDocTags,
                       )
                     : null;
 
@@ -882,8 +865,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             sets: Metadata[],
             explore: IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             ts.factory.createCallExpression(
                 UnionExplorer.set({
@@ -895,7 +876,7 @@ export namespace CheckerProgrammer {
                         ts.factory.createReturnStatement(
                             config.joiner.failure(input, expected, explore),
                         ),
-                })([])(input, sets, explore, tags, jsDocTags),
+                })([])(input, sets, explore),
                 undefined,
                 undefined,
             );
@@ -908,8 +889,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             maps: Metadata.Entry[],
             explore: IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             ts.factory.createCallExpression(
                 UnionExplorer.map({
@@ -926,8 +905,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[0]`,
                                 },
-                                [],
-                                [],
                             ),
                             func(
                                 ts.factory.createElementAccessExpression(
@@ -939,8 +916,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[1]`,
                                 },
-                                [],
-                                [],
                             ),
                         );
                     },
@@ -951,7 +926,7 @@ export namespace CheckerProgrammer {
                         ts.factory.createReturnStatement(
                             config.joiner.failure(input, expected, explore),
                         ),
-                })([])(input, maps, explore, tags, jsDocTags),
+                })([])(input, maps, explore),
                 undefined,
                 undefined,
             );
@@ -964,8 +939,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             tuples: MetadataTuple[],
             explore: IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
                 UnionExplorer.tuple({
@@ -978,7 +951,7 @@ export namespace CheckerProgrammer {
                             config.joiner.failure(input, expected, explore),
                         ),
                 }),
-            )(input, tuples, explore, tags, jsDocTags);
+            )(input, tuples, explore);
 
     const explore_arrays =
         (project: IProject) =>
@@ -988,8 +961,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             arrays: MetadataArray[],
             explore: IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             explore_array_like_union_types(config)(importer)(
                 UnionExplorer.array({
@@ -1002,7 +973,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) =>
@@ -1012,45 +983,42 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             elements: Array<MetadataArray | MetadataTuple>,
             explore: IExplore,
-            tags: IMetadataTag[],
-            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,
@@ -1059,7 +1027,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) =>
@@ -1071,29 +1039,19 @@ export namespace CheckerProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: IExplore,
-                tags: IMetadataTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
             input: ts.Expression,
             elements: T[],
             explore: IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression => {
             const arrow =
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(
-                        input,
-                        elements,
-                        explore,
-                        tags,
-                        jsDocTags,
-                    );
-            if (elements.every((e) => e.recursive === false))
+                    factory(parameters)(input, elements, explore);
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -1109,7 +1067,7 @@ export namespace CheckerProgrammer {
                     ts.factory.createIdentifier(
                         importer.emplaceUnion(
                             config.prefix,
-                            elements.map((e) => e.name).join(" | "),
+                            elements.map((e) => e.type.name).join(" | "),
                             () =>
                                 arrow(
                                     FeatureProgrammer.parameterDeclarations(
@@ -1128,7 +1086,7 @@ export namespace CheckerProgrammer {
                 ),
                 config.joiner.failure(
                     input,
-                    elements.map((e) => e.name).join(" | "),
+                    elements.map((e) => e.type.name).join(" | "),
                     explore,
                 ),
             );

package/src/programmers/FeatureProgrammer.ts

@@ -6,8 +6,6 @@ import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
-import { IJsDocTagInfo } from "../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../schemas/metadata/IMetadataTag";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
@@ -191,13 +189,7 @@ export namespace FeatureProgrammer {
         T,
         Output extends ts.ConciseBody = ts.ConciseBody,
     > {
-        (
-            input: ts.Expression,
-            target: T,
-            explore: IExplore,
-            metaTags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
-        ): Output;
+        (input: ts.Expression, target: T, explore: IExplore): Output;
     }
 
     /* -----------------------------------------------------------
@@ -220,8 +212,6 @@ export namespace FeatureProgrammer {
                     from: "top",
                     postfix: '""',
                 },
-                [],
-                [],
             );
 
             // RETURNS THE OPTIMAL ARROW FUNCTION
@@ -324,18 +314,12 @@ export namespace FeatureProgrammer {
                 ),
                 TypeFactory.keyword("any"),
                 undefined,
-                explorer(
-                    input,
-                    meta,
-                    {
-                        tracable: config.path || config.trace,
-                        source: "function",
-                        from: "object",
-                        postfix: "",
-                    },
-                    [],
-                    [],
-                ),
+                explorer(input, meta, {
+                    tracable: config.path || config.trace,
+                    source: "function",
+                    from: "object",
+                    postfix: "",
+                }),
             );
     };
 
@@ -349,8 +333,6 @@ export namespace FeatureProgrammer {
             combiner: (
                 input: ts.Expression,
                 arrow: ts.ArrowFunction,
-                metaTags: IMetadataTag[],
-                jsDocTags: ts.JSDocTagInfo[],
             ) => ts.Expression,
         ) => {
             const rand: string = importer.increment().toString();
@@ -368,8 +350,6 @@ export namespace FeatureProgrammer {
                 input: ts.Expression,
                 array: MetadataArray,
                 explore: IExplore,
-                metaTags: IMetadataTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => {
                 const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
                     undefined,
@@ -385,7 +365,7 @@ export namespace FeatureProgrammer {
                     undefined,
                     config.decoder()(
                         ValueFactory.INPUT("elem"),
-                        array.value,
+                        array.type.value,
                         {
                             tracable: explore.tracable,
                             source: explore.source,
@@ -394,11 +374,9 @@ export namespace FeatureProgrammer {
                                 explore.postfix,
                             )(rand),
                         },
-                        metaTags,
-                        jsDocTags,
                     ),
                 );
-                return combiner(input, arrow, metaTags, jsDocTags);
+                return combiner(input, arrow);
             };
         };