typia 3.8.8 → 3.9.0-dev.20230603

package/src/programmers/PruneProgrammer.ts

@@ -4,9 +4,14 @@ import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { MetadataCollection } from "../factories/MetadataCollection";
 import { MetadataFactory } from "../factories/MetadataFactory";
+import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 
+import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
+import { MetadataArray } from "../metadata/MetadataArray";
+import { MetadataTuple } from "../metadata/MetadataTuple";
 
 import { IProject } from "../transformers/IProject";
 
@@ -16,6 +21,7 @@ import { FunctionImporter } from "./helpers/FunctionImporeter";
 import { PruneJoiner } from "./helpers/PruneJoiner";
 import { UnionExplorer } from "./helpers/UnionExplorer";
 import { decode_union_object } from "./internal/decode_union_object";
+import { wrap_metadata_rest_tuple } from "./internal/wrap_metadata_rest_tuple";
 
 export namespace PruneProgrammer {
     /**
@@ -29,36 +35,88 @@ export namespace PruneProgrammer {
     export const write =
         (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
             const importer: FunctionImporter = new FunctionImporter();
-            return FeatureProgrammer.analyze(project)({
+            return FeatureProgrammer.write(project)({
                 ...configure(project)(importer),
-                addition: (collection) => {
-                    const isFunctors =
-                        IsProgrammer.write_functors(project)(importer)(
-                            collection,
-                        );
-                    const isUnioners =
-                        IsProgrammer.write_unioners(project)(importer)(
-                            collection,
-                        );
-
-                    return [
-                        ...importer.declare(modulo),
-                        ...isFunctors.filter((_, i) =>
-                            importer.hasLocal(`$io${i}`),
-                        ),
-                        ...isUnioners.filter((_, i) =>
-                            importer.hasLocal(`$iu${i}`),
-                        ),
-                    ];
-                },
+                addition: (collection) => [
+                    ...IsProgrammer.write_function_statements(project)(
+                        importer,
+                    )(collection),
+                    ...importer.declare(modulo),
+                ],
             })(importer);
         };
 
+    const write_array_functions =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (collection: MetadataCollection): ts.VariableStatement[] =>
+            collection
+                .arrays()
+                .filter((a) => a.recursive)
+                .map((array, i) =>
+                    StatementFactory.constant(
+                        `${config.prefix}a${i}`,
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            FeatureProgrammer.parameterDeclarations(config)(
+                                TypeFactory.keyword("any"),
+                            )(ts.factory.createIdentifier("input")),
+                            TypeFactory.keyword("any"),
+                            undefined,
+                            decode_array_inline(config)(importer)(
+                                ts.factory.createIdentifier("input"),
+                                array,
+                                {
+                                    tracable: config.trace,
+                                    source: "function",
+                                    from: "array",
+                                    postfix: "",
+                                },
+                            ),
+                        ),
+                    ),
+                );
+
+    const write_tuple_functions =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (collection: MetadataCollection): ts.VariableStatement[] =>
+            collection
+                .tuples()
+                .filter((t) => t.recursive)
+                .map((tuple, i) =>
+                    StatementFactory.constant(
+                        `${config.prefix}t${i}`,
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            FeatureProgrammer.parameterDeclarations(config)(
+                                TypeFactory.keyword("any"),
+                            )(ts.factory.createIdentifier("input")),
+                            TypeFactory.keyword("any"),
+                            undefined,
+                            decode_tuple_inline(project)(config)(importer)(
+                                ts.factory.createIdentifier("input"),
+                                tuple,
+                                {
+                                    tracable: config.trace,
+                                    source: "function",
+                                    from: "array",
+                                    postfix: "",
+                                },
+                            ),
+                        ),
+                    ),
+                );
+
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
     const decode =
         (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -79,12 +137,12 @@ export namespace PruneProgrammer {
             //----
             // TUPLES
             for (const tuple of meta.tuples.filter((t) =>
-                t.some((e) => filter(e.rest ?? e)),
+                t.elements.some((e) => filter(e.rest ?? e)),
             ))
                 unions.push({
                     type: "tuple",
                     is: () =>
-                        IsProgrammer.decode(project, importer)(
+                        IsProgrammer.decode(project)(importer)(
                             input,
                             (() => {
                                 const partial = Metadata.initialize();
@@ -96,24 +154,26 @@ export namespace PruneProgrammer {
                             [],
                         ),
                     value: () =>
-                        decode_tuple(project)(importer)(input, tuple, explore),
+                        decode_tuple(project)(config)(importer)(
+                            input,
+                            tuple,
+                            explore,
+                        ),
                 });
 
             // ARRAYS
-            if (meta.arrays.filter(filter).length)
+            if (meta.arrays.filter((a) => filter(a.value)).length)
                 unions.push({
                     type: "array",
                     is: () => ExpressionFactory.isArray(input),
                     value: () =>
-                        explore_arrays(project)(importer)(
+                        explore_arrays(project)(config)(importer)(
                             input,
                             meta.arrays,
                             {
                                 ...explore,
                                 from: "array",
                             },
-                            [],
-                            [],
                         ),
                 });
 
@@ -148,7 +208,7 @@ export namespace PruneProgrammer {
                             checkArray: false,
                         })(input),
                     value: () =>
-                        explore_objects(importer)(input, meta, {
+                        explore_objects(config)(importer)(input, meta, {
                             ...explore,
                             from: "object",
                         }),
@@ -170,78 +230,134 @@ export namespace PruneProgrammer {
             return ts.factory.createBlock(statements, true);
         };
 
+    const decode_object = (importer: FunctionImporter) =>
+        FeatureProgrammer.decode_object({
+            trace: false,
+            path: false,
+            prefix: PREFIX,
+        })(importer);
+
+    const decode_array =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            array: MetadataArray,
+            explore: FeatureProgrammer.IExplore,
+        ) =>
+            array.recursive
+                ? ts.factory.createCallExpression(
+                      ts.factory.createIdentifier(
+                          importer.useLocal(`${config.prefix}a${array.index}`),
+                      ),
+                      undefined,
+                      FeatureProgrammer.argumentsArray(config)({
+                          ...explore,
+                          source: "function",
+                          from: "array",
+                      })(input),
+                  )
+                : decode_array_inline(config)(importer)(input, array, explore);
+
+    const decode_array_inline =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            array: MetadataArray,
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            FeatureProgrammer.decode_array(config)(importer)(PruneJoiner.array)(
+                input,
+                array,
+                explore,
+                [],
+                [],
+            );
+
     const decode_tuple =
         (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            tuple: MetadataTuple,
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression | ts.Block =>
+            tuple.recursive
+                ? ts.factory.createCallExpression(
+                      ts.factory.createIdentifier(
+                          importer.useLocal(`${config.prefix}t${tuple.index}`),
+                      ),
+                      undefined,
+                      FeatureProgrammer.argumentsArray(config)({
+                          ...explore,
+                          source: "function",
+                      })(input),
+                  )
+                : decode_tuple_inline(project)(config)(importer)(
+                      input,
+                      tuple,
+                      explore,
+                  );
+
+    const decode_tuple_inline =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: Metadata[],
+            tuple: MetadataTuple,
             explore: FeatureProgrammer.IExplore,
         ): ts.Block => {
-            const children: ts.ConciseBody[] = tuple
+            const children: ts.ConciseBody[] = tuple.elements
                 .map((elem, index) => [elem, index] as const)
                 .filter(([elem]) => filter(elem) && elem.rest === null)
                 .map(([elem, index]) =>
-                    decode(project)(importer)(
+                    decode(project)(config)(importer)(
                         ts.factory.createElementAccessExpression(input, index),
                         elem,
                         {
                             ...explore,
                             from: "array",
+                            postfix: explore.postfix.length
+                                ? `${explore.postfix.slice(0, -1)}[${index}]"`
+                                : `"[${index}]"`,
                         },
                     ),
                 );
             const rest = (() => {
-                if (tuple.length === 0) return null;
+                if (tuple.elements.length === 0) return null;
 
-                const last: Metadata = tuple[tuple.length - 1]!;
+                const last: Metadata = tuple.elements.at(-1)!;
                 const rest: Metadata | null = last.rest;
                 if (rest === null || filter(rest) === false) return null;
 
-                return decode(project)(importer)(
+                return decode(project)(config)(importer)(
                     ts.factory.createCallExpression(
                         IdentifierFactory.access(input)("slice"),
                         undefined,
-                        [ts.factory.createNumericLiteral(tuple.length - 1)],
+                        [
+                            ts.factory.createNumericLiteral(
+                                tuple.elements.length - 1,
+                            ),
+                        ],
                     ),
-                    (() => {
-                        const wrapper: Metadata = Metadata.initialize();
-                        wrapper.arrays.push(rest);
-                        return wrapper;
-                    })(),
+                    wrap_metadata_rest_tuple(tuple.elements.at(-1)!.rest!),
                     {
                         ...explore,
-                        start: tuple.length - 1,
+                        start: tuple.elements.length - 1,
                     },
                 );
             })();
             return PruneJoiner.tuple(children, rest);
         };
 
-    const decode_array = (project: IProject) => (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_array(configure(project)(importer))(importer)(
-            PruneJoiner.array,
-        );
-
-    const decode_object = (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_object({
-            trace: false,
-            path: false,
-            functors: FUNCTORS,
-        })(importer);
-
-    const explore_arrays =
-        (project: IProject) => (importer: FunctionImporter) =>
-            UnionExplorer.array({
-                checker: IsProgrammer.decode(project, importer),
-                decoder: decode_array(project)(importer),
-                empty: ts.factory.createReturnStatement(),
-                success: ts.factory.createTrue(),
-                failure: (input, expected) =>
-                    create_throw_error(importer)(expected)(input),
-            });
-
+    /* -----------------------------------------------------------
+        UNION TYPE EXPLORERS
+    ----------------------------------------------------------- */
     const explore_objects =
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -256,57 +372,143 @@ export namespace PruneProgrammer {
                 );
 
             return ts.factory.createCallExpression(
-                ts.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
+                ts.factory.createIdentifier(
+                    importer.useLocal(`${PREFIX}u${meta.union_index!}`),
+                ),
                 undefined,
-                [input],
+                FeatureProgrammer.argumentsArray(config)(explore)(input),
             );
         };
 
+    const explore_arrays =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            elements: MetadataArray[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            explore_array_like_union_types(config)(importer)(
+                UnionExplorer.array({
+                    checker: IsProgrammer.decode(project)(importer),
+                    decoder: decode_array(config)(importer),
+                    empty: ts.factory.createStringLiteral("[]"),
+                    success: ts.factory.createTrue(),
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                }),
+            )(input, elements, explore);
+
+    const explore_array_like_union_types =
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        <T extends MetadataArray | MetadataTuple>(
+            factory: (
+                parameters: ts.ParameterDeclaration[],
+            ) => (
+                input: ts.Expression,
+                elements: T[],
+                explore: FeatureProgrammer.IExplore,
+                tags: IMetadataTag[],
+                jsDocTags: IJsDocTagInfo[],
+            ) => ts.ArrowFunction,
+        ) =>
+        (
+            input: ts.Expression,
+            elements: T[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression => {
+            const arrow =
+                (parameters: ts.ParameterDeclaration[]) =>
+                (explore: FeatureProgrammer.IExplore) =>
+                (input: ts.Expression): ts.ArrowFunction =>
+                    factory(parameters)(input, elements, explore, [], []);
+            if (elements.every((e) => e.recursive === false))
+                ts.factory.createCallExpression(
+                    arrow([])(explore)(input),
+                    undefined,
+                    [],
+                );
+
+            explore = {
+                ...explore,
+                source: "function",
+                from: "array",
+            };
+            return ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    importer.emplaceUnion(
+                        config.prefix,
+                        elements.map((e) => e.name).join(" | "),
+                        () =>
+                            arrow(
+                                FeatureProgrammer.parameterDeclarations(config)(
+                                    TypeFactory.keyword("any"),
+                                )(ts.factory.createIdentifier("input")),
+                            )({
+                                ...explore,
+                                postfix: "",
+                            })(ts.factory.createIdentifier("input")),
+                    ),
+                ),
+                undefined,
+                FeatureProgrammer.argumentsArray(config)(explore)(input),
+            );
+        };
+
+    // @todo -> must filter out recursive visit
     const filter = (meta: Metadata): boolean =>
         meta.any === false &&
         (meta.objects.length !== 0 ||
-            meta.tuples.some((t) => t.some((e) => filter(e.rest ?? e))) ||
-            meta.arrays.some((e) => filter(e)));
+            meta.tuples.some((t) =>
+                t.elements.some((e) => filter(e.rest ?? e)),
+            ) ||
+            meta.arrays.some((e) => filter(e.value)));
 
     /* -----------------------------------------------------------
         CONFIGURATIONS
     ----------------------------------------------------------- */
-    const FUNCTORS = "$po";
-    const UNIONERS = "$pu";
+    const PREFIX = "$p";
 
     const configure =
         (project: IProject) =>
-        (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
-            types: {
-                input: (type, name) =>
-                    ts.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(project.checker)(type),
+        (importer: FunctionImporter): FeatureProgrammer.IConfig => {
+            const config: FeatureProgrammer.IConfig = {
+                types: {
+                    input: (type, name) =>
+                        ts.factory.createTypeReferenceNode(
+                            name ??
+                                TypeFactory.getFullName(project.checker)(type),
+                        ),
+                    output: () => TypeFactory.keyword("void"),
+                },
+                prefix: PREFIX,
+                trace: false,
+                path: false,
+                initializer,
+                decoder: () => decode(project)(config)(importer),
+                objector: {
+                    checker: () => IsProgrammer.decode(project)(importer),
+                    decoder: () => decode_object(importer),
+                    joiner: PruneJoiner.object,
+                    unionizer: decode_union_object(
+                        IsProgrammer.decode_object(importer),
+                    )(decode_object(importer))((exp) => exp)(
+                        (value, expected) =>
+                            create_throw_error(importer)(expected)(value),
                     ),
-                output: () => TypeFactory.keyword("void"),
-            },
-            functors: FUNCTORS,
-            unioners: UNIONERS,
-            trace: false,
-            path: false,
-            initializer,
-            decoder: decode(project)(importer),
-            objector: objector(project)(importer),
-        });
-
-    const objector =
-        (project: IProject) =>
-        (importer: FunctionImporter): FeatureProgrammer.IConfig.IObjector => ({
-            checker: IsProgrammer.decode(project, importer),
-            decoder: decode_object(importer),
-            joiner: PruneJoiner.object,
-            unionizer: decode_union_object(
-                IsProgrammer.decode_object(importer),
-            )(decode_object(importer))((exp) => exp)((value, expected) =>
-                create_throw_error(importer)(expected)(value),
-            ),
-            failure: (input, expected) =>
-                create_throw_error(importer)(expected)(input),
-        });
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                },
+                generator: {
+                    arrays: () => write_array_functions(config)(importer),
+                    tuples: () =>
+                        write_tuple_functions(project)(config)(importer),
+                },
+            };
+            return config;
+        };
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
@@ -315,6 +517,7 @@ export namespace PruneProgrammer {
             const meta = MetadataFactory.analyze(checker)({
                 resolve: false,
                 constant: true,
+                absorb: true,
             })(collection)(type);
             return [collection, meta];
         };