typia 5.0.0-dev.20230824 → 5.0.0-dev.20230827

package/src/programmers/CheckerProgrammer.ts

@@ -8,12 +8,8 @@ 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";
@@ -28,7 +24,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 +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(
@@ -144,16 +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: "",
                                 },
-                                [],
-                                [],
-                                [],
                             ),
                         ),
                     ),
@@ -187,8 +182,6 @@ export namespace CheckerProgrammer {
                                     from: "array",
                                     postfix: "",
                                 },
-                                [],
-                                [],
                             ),
                         ),
                     ),
@@ -296,8 +289,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 +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
@@ -364,27 +358,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 +436,6 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            [],
-                            [],
                         ),
                     );
             }
@@ -473,8 +459,6 @@ export namespace CheckerProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            metaTags,
-                            jsDocTags,
                         ),
                     );
             }
@@ -483,8 +467,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 +488,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                     // TUPLE ONLY
@@ -514,8 +500,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                 else if (meta.arrays.some((elem) => elem.type.value.any))
@@ -531,8 +515,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                     else
@@ -544,8 +526,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     from: "array",
                                 },
-                                metaTags,
-                                jsDocTags,
                             ),
                         );
                 else
@@ -554,8 +534,6 @@ export namespace CheckerProgrammer {
                             input,
                             [...meta.tuples, ...meta.arrays],
                             explore,
-                            metaTags,
-                            jsDocTags,
                         ),
                     );
             }
@@ -670,21 +648,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 +685,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 +711,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 +748,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 +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 =
@@ -831,8 +783,6 @@ export namespace CheckerProgrammer {
                               ...explore,
                               start: tuple.elements.length - 1,
                           },
-                          tagList,
-                          jsDocTags,
                       )
                     : null;
 
@@ -915,8 +865,6 @@ export namespace CheckerProgrammer {
             input: ts.Expression,
             sets: Metadata[],
             explore: IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: IJsDocTagInfo[],
         ): ts.Expression =>
             ts.factory.createCallExpression(
                 UnionExplorer.set({
@@ -928,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,
             );
@@ -941,8 +889,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 +905,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[0]`,
                                 },
-                                [],
-                                [],
                             ),
                             func(
                                 ts.factory.createElementAccessExpression(
@@ -972,8 +916,6 @@ export namespace CheckerProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[1]`,
                                 },
-                                [],
-                                [],
                             ),
                         );
                     },
@@ -984,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,
             );
@@ -997,8 +939,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 +951,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 +961,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 +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) =>
@@ -1045,45 +983,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 +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) =>
@@ -1104,28 +1039,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),

package/src/programmers/FeatureProgrammer.ts

@@ -6,10 +6,8 @@ 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 { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
+import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 
 import { IProject } from "../transformers/IProject";
@@ -191,13 +189,7 @@ export namespace FeatureProgrammer {
         T,
         Output extends ts.ConciseBody = ts.ConciseBody,
     > {
-        (
-            input: ts.Expression,
-            target: T,
-            explore: IExplore,
-            metaTags: IMetadataCommentTag[],
-            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: IMetadataCommentTag[],
-                jsDocTags: ts.JSDocTagInfo[],
             ) => ts.Expression,
         ) => {
             const rand: string = importer.increment().toString();
@@ -366,10 +348,8 @@ export namespace FeatureProgrammer {
 
             return (
                 input: ts.Expression,
-                array: MetadataArrayType,
+                array: MetadataArray,
                 explore: IExplore,
-                metaTags: IMetadataCommentTag[],
-                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);
             };
         };