typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/programmers/CloneProgrammer.ts

@@ -1,12 +1,17 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 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,37 +21,102 @@ import { CloneJoiner } from "./helpers/CloneJoiner";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
 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 CloneProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
     export const write =
-        (p: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter(p.tsc);
-            return FeatureProgrammer.analyze(p)({
-                ...CONFIG(p)(importer),
-                addition: (collection) => {
-                    const isFunctors =
-                        IsProgrammer.write_functors(p)(importer)(collection);
-                    const isUnioners =
-                        IsProgrammer.write_unioners(p)(importer)(collection);
-
-                    return [
-                        ...importer.declare(modulo),
-                        ...isFunctors.filter((_, i) =>
-                            importer.hasLocal(`$io${i}`),
-                        ),
-                        ...isUnioners.filter((_, i) =>
-                            importer.hasLocal(`$iu${i}`),
-                        ),
-                    ];
-                },
+        (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
+            const importer: FunctionImporter = new FunctionImporter();
+            return FeatureProgrammer.write(project)({
+                ...configure(project)(importer),
+                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 =
-        (p: IProject) =>
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -56,10 +126,10 @@ export namespace CloneProgrammer {
             // ANY TYPE
             if (
                 meta.any ||
-                meta.arrays.some((a) => a.any) ||
-                meta.tuples.some((t) => t.every((e) => e.any))
+                meta.arrays.some((a) => a.value.any) ||
+                meta.tuples.some((t) => t.elements.every((e) => e.any))
             )
-                return p.tsc.factory.createCallExpression(
+                return ts.factory.createCallExpression(
                     importer.use("any"),
                     undefined,
                     [input],
@@ -79,9 +149,9 @@ export namespace CloneProgrammer {
             if (meta.resolved !== null)
                 unions.push({
                     type: "resolved",
-                    is: () => IsProgrammer.decode_to_json(p.tsc)(true)(input),
+                    is: () => IsProgrammer.decode_to_json(true)(input),
                     value: () =>
-                        decode_to_json(p)(importer)(
+                        decode_to_json(project)(config)(importer)(
                             input,
                             meta.resolved!,
                             explore,
@@ -93,7 +163,7 @@ export namespace CloneProgrammer {
                 unions.push({
                     type: "tuple",
                     is: () =>
-                        IsProgrammer.decode(p)(importer)(
+                        IsProgrammer.decode(project)(importer)(
                             input,
                             (() => {
                                 const partial = Metadata.initialize();
@@ -105,24 +175,26 @@ export namespace CloneProgrammer {
                             [],
                         ),
                     value: () =>
-                        decode_tuple(p)(importer)(input, tuple, explore),
+                        decode_tuple(project)(config)(importer)(
+                            input,
+                            tuple,
+                            explore,
+                        ),
                 });
 
             // ARRAYS
             if (meta.arrays.length)
                 unions.push({
                     type: "array",
-                    is: () => ExpressionFactory.isArray(p.tsc)(input),
+                    is: () => ExpressionFactory.isArray(input),
                     value: () =>
-                        explore_arrays(p)(importer)(
+                        explore_arrays(project)(config)(importer)(
                             input,
                             meta.arrays,
                             {
                                 ...explore,
                                 from: "array",
                             },
-                            [],
-                            [],
                         ),
                 });
 
@@ -130,34 +202,29 @@ export namespace CloneProgrammer {
             if (meta.sets.length)
                 unions.push({
                     type: "set",
-                    is: () =>
-                        ExpressionFactory.isInstanceOf(p.tsc)("Set")(input),
-                    value: () => p.tsc.factory.createIdentifier("{}"),
+                    is: () => ExpressionFactory.isInstanceOf("Set")(input),
+                    value: () => ts.factory.createIdentifier("{}"),
                 });
             if (meta.maps.length)
                 unions.push({
                     type: "map",
-                    is: () =>
-                        ExpressionFactory.isInstanceOf(p.tsc)("Map")(input),
-                    value: () => p.tsc.factory.createIdentifier("{}"),
+                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
+                    value: () => ts.factory.createIdentifier("{}"),
                 });
             for (const native of meta.natives)
                 unions.push({
                     type: "native",
-                    is: () =>
-                        ExpressionFactory.isInstanceOf(p.tsc)(native)(input),
+                    is: () => ExpressionFactory.isInstanceOf(native)(input),
                     value: () =>
                         native === "Boolean" ||
                         native === "Number" ||
                         native === "String"
-                            ? p.tsc.factory.createCallExpression(
-                                  IdentifierFactory.access(p.tsc)(input)(
-                                      "valueOf",
-                                  ),
+                            ? ts.factory.createCallExpression(
+                                  IdentifierFactory.access(input)("valueOf"),
                                   undefined,
                                   undefined,
                               )
-                            : p.tsc.factory.createIdentifier("{}"),
+                            : ts.factory.createIdentifier("{}"),
                 });
 
             // OBJECTS
@@ -165,12 +232,12 @@ export namespace CloneProgrammer {
                 unions.push({
                     type: "object",
                     is: () =>
-                        ExpressionFactory.isObject(p.tsc)({
+                        ExpressionFactory.isObject({
                             checkNull: true,
                             checkArray: false,
                         })(input),
                     value: () =>
-                        explore_objects(p.tsc)(importer)(input, meta, {
+                        explore_objects(config)(importer)(input, meta, {
                             ...explore,
                             from: "object",
                         }),
@@ -179,30 +246,31 @@ export namespace CloneProgrammer {
             // COMPOSITION
             let last: ts.Expression = input;
             for (const u of unions.reverse())
-                last = p.tsc.factory.createConditionalExpression(
+                last = ts.factory.createConditionalExpression(
                     u.is(),
                     undefined,
                     u.value(),
                     undefined,
                     last,
                 );
-            return p.tsc.factory.createAsExpression(
+            return ts.factory.createAsExpression(
                 last,
-                TypeFactory.keyword(p.tsc)("any"),
+                TypeFactory.keyword("any"),
             );
         };
 
     const decode_to_json =
-        (p: IProject) =>
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             resolved: Metadata,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
-            return decode(p)(importer)(
-                p.tsc.factory.createCallExpression(
-                    IdentifierFactory.access(p.tsc)(input)("toJSON"),
+            return decode(project)(config)(importer)(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(input)("toJSON"),
                     undefined,
                     [],
                 ),
@@ -211,80 +279,133 @@ export namespace CloneProgrammer {
             );
         };
 
+    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,
+        ) =>
+            FeatureProgrammer.decode_array(config)(importer)(CloneJoiner.array)(
+                input,
+                array,
+                explore,
+                [],
+                [],
+            );
+
     const decode_tuple =
-        (p: IProject) =>
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            tuple: MetadataTuple,
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            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.Expression => {
-            const children: ts.Expression[] = tuple
+            const children: ts.Expression[] = tuple.elements
                 .filter((m) => m.rest === null)
                 .map((elem, index) =>
-                    decode(p)(importer)(
-                        p.tsc.factory.createElementAccessExpression(
-                            input,
-                            index,
-                        ),
+                    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) return null;
 
-                return decode(p)(importer)(
-                    p.tsc.factory.createCallExpression(
-                        IdentifierFactory.access(p.tsc)(input)("slice"),
+                return decode(project)(config)(importer)(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(input)("slice"),
                         undefined,
-                        [p.tsc.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 CloneJoiner.tuple(p.tsc)(children, rest);
+            return CloneJoiner.tuple(children, rest);
         };
 
-    const decode_array = (p: IProject, importer: FunctionImporter) =>
-        FeatureProgrammer.decode_array(p.tsc)(CONFIG(p)(importer))(importer)(
-            CloneJoiner.array(p.tsc),
-        );
-
-    const decode_object = (tsc: typeof ts) => (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_object(tsc)({
-            trace: false,
-            path: false,
-            functors: FUNCTORS,
-        })(importer);
-
-    const explore_arrays = (p: IProject) => (importer: FunctionImporter) =>
-        UnionExplorer.array(p.tsc)({
-            checker: IsProgrammer.decode(p)(importer),
-            decoder: decode_array(p, importer),
-            empty: p.tsc.factory.createReturnStatement(),
-            success: p.tsc.factory.createTrue(),
-            failure: (input, expected) =>
-                create_throw_error(p.tsc)(importer, input, expected),
-        });
-
+    /* -----------------------------------------------------------
+        EXPLORERS FOR UNION TYPES
+    ----------------------------------------------------------- */
     const explore_objects =
-        (tsc: typeof ts) =>
+        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -292,89 +413,176 @@ export namespace CloneProgrammer {
             explore: FeatureProgrammer.IExplore,
         ) => {
             if (meta.objects.length === 1)
-                return decode_object(tsc)(importer)(
+                return decode_object(importer)(
                     input,
                     meta.objects[0]!,
                     explore,
                 );
 
-            return tsc.factory.createCallExpression(
-                tsc.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
+            return ts.factory.createCallExpression(
+                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.createIdentifier("[]"),
+                    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),
             );
         };
 
     /* -----------------------------------------------------------
         CONFIGURATIONS
     ----------------------------------------------------------- */
-    const FUNCTORS = "$co";
-    const UNIONERS = "$cu";
-
-    const CONFIG =
-        (p: IProject) =>
-        (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
-            types: {
-                input: (type, name) =>
-                    p.tsc.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(p)(type),
-                    ),
-                output: (type, name) =>
-                    p.tsc.factory.createTypeReferenceNode(
-                        `typia.Primitive<${
-                            name ?? TypeFactory.getFullName(p)(type)
-                        }>`,
+    const PREFIX = "$c";
+
+    const configure =
+        (project: IProject) =>
+        (importer: FunctionImporter): FeatureProgrammer.IConfig => {
+            const config: FeatureProgrammer.IConfig = {
+                types: {
+                    input: (type, name) =>
+                        ts.factory.createTypeReferenceNode(
+                            name ??
+                                TypeFactory.getFullName(project.checker)(type),
+                        ),
+                    output: (type, name) =>
+                        ts.factory.createTypeReferenceNode(
+                            `typia.Primitive<${
+                                name ??
+                                TypeFactory.getFullName(project.checker)(type)
+                            }>`,
+                        ),
+                },
+                prefix: PREFIX,
+                trace: false,
+                path: false,
+                initializer,
+                decoder: () => decode(project)(config)(importer),
+                objector: {
+                    checker: () => IsProgrammer.decode(project)(importer),
+                    decoder: () => decode_object(importer),
+                    joiner: CloneJoiner.object,
+                    unionizer: decode_union_object(
+                        IsProgrammer.decode_object(importer),
+                    )(decode_object(importer))((exp) => exp)(
+                        (input, expected) =>
+                            create_throw_error(importer)(expected)(input),
                     ),
-            },
-            functors: FUNCTORS,
-            unioners: UNIONERS,
-            trace: false,
-            path: false,
-            initializer,
-            decoder: decode(p)(importer),
-            objector: OBJECTOR(p)(importer),
-        });
-
-    const OBJECTOR =
-        (p: IProject) =>
-        (importer: FunctionImporter): FeatureProgrammer.IConfig.IObjector => ({
-            checker: IsProgrammer.decode(p)(importer),
-            decoder: decode_object(p.tsc)(importer),
-            joiner: CloneJoiner.object(p.tsc),
-            unionizer: decode_union_object(p.tsc)(
-                IsProgrammer.decode_object(p.tsc)(importer),
-            )(decode_object(p.tsc)(importer))((exp) => exp)((value, expected) =>
-                create_throw_error(p.tsc)(importer, value, expected),
-            ),
-            failure: (input, expected) =>
-                create_throw_error(p.tsc)(importer, input, expected),
-        });
+                    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"] =
-        (p) => (type) => {
+        ({ checker }) =>
+        (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(p)({
+            const meta = MetadataFactory.analyze(checker)({
                 resolve: true,
                 constant: true,
+                absorb: true,
             })(collection)(type);
             return [collection, meta];
         };
 
     const create_throw_error =
-        (tsc: typeof ts) =>
-        (importer: FunctionImporter, value: ts.Expression, expected: string) =>
-            tsc.factory.createExpressionStatement(
-                tsc.factory.createCallExpression(
+        (importer: FunctionImporter) =>
+        (expected: string) =>
+        (value: ts.Expression) =>
+            ts.factory.createExpressionStatement(
+                ts.factory.createCallExpression(
                     importer.use("throws"),
                     [],
                     [
-                        tsc.factory.createObjectLiteralExpression(
+                        ts.factory.createObjectLiteralExpression(
                             [
-                                tsc.factory.createPropertyAssignment(
+                                ts.factory.createPropertyAssignment(
                                     "expected",
-                                    tsc.factory.createStringLiteral(expected),
+                                    ts.factory.createStringLiteral(expected),
                                 ),
-                                tsc.factory.createPropertyAssignment(
+                                ts.factory.createPropertyAssignment(
                                     "value",
                                     value,
                                 ),