typia 5.0.0-dev.20230814-2 → 5.0.0-dev.20230819

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { MetadataCollection } from "../../factories/MetadataCollection";
 import { ProtobufFactory } from "../../factories/ProtobufFactory";
@@ -24,6 +25,8 @@ import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 import { ProtobufWire } from "../helpers/ProtobufWire";
 import { UnionExplorer } from "../helpers/UnionExplorer";
+import { UnionPredicator } from "../helpers/UnionPredicator";
+import { decode_union_object } from "../internal/decode_union_object";
 
 export namespace ProtobufEncodeProgrammer {
     export const write =
@@ -36,25 +39,39 @@ export namespace ProtobufEncodeProgrammer {
                 project.checker,
             )(collection)(type);
 
-            // @todo
-            meta;
-            write_object_function_body;
-            write_map_function_body;
-            explore_objects;
-            explore_arrays;
+            const callEncoder =
+                (writer: string) => (factory: ts.NewExpression) =>
+                    StatementFactory.constant(
+                        writer,
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("encoder"),
+                            undefined,
+                            [factory],
+                        ),
+                    );
 
             const block: ts.Statement[] = [
                 StatementFactory.constant(
-                    "writer",
+                    "encoder",
+                    write_encoder(project)(importer)(collection)(meta),
+                ),
+                callEncoder("sizer")(
                     ts.factory.createNewExpression(
-                        importer.use("Writer"),
+                        importer.use("Sizer"),
                         undefined,
+                        [],
+                    ),
+                ),
+                callEncoder("writer")(
+                    ts.factory.createNewExpression(
+                        importer.use("Writer"),
                         undefined,
+                        [ts.factory.createIdentifier("sizer")],
                     ),
                 ),
                 ts.factory.createReturnStatement(
                     ts.factory.createCallExpression(
-                        IdentifierFactory.access(WRITER())("finish"),
+                        IdentifierFactory.access(WRITER())("buffer"),
                         undefined,
                         undefined,
                     ),
@@ -77,68 +94,108 @@ export namespace ProtobufEncodeProgrammer {
                 ts.factory.createTypeReferenceNode("Uint8Array"),
                 undefined,
                 ts.factory.createBlock(
-                    [...importer.declare(modulo), ...block],
+                    [...importer.declare(modulo, false), ...block],
                     true,
                 ),
             );
         };
 
-    const write_object_function_body =
+    const write_encoder =
         (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
-        (
-            input: ts.Expression,
-            obj: MetadataObject,
-            explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-        ): ts.Block => {
-            const top: MetadataProperty = obj.properties[0]!;
-            if (top.key.isSoleLiteral() === false)
-                return write_map_function_body(project)(config)(importer)(
-                    input,
-                    top,
-                    explore,
-                    tags,
+        (collection: MetadataCollection) =>
+        (meta: Metadata): ts.ArrowFunction => {
+            const functors = collection
+                .objects()
+                .filter((obj) => obj._Messagable())
+                .map((obj) =>
+                    StatementFactory.constant(
+                        `${PREFIX}o${obj.index}`,
+                        write_object_function(project)(importer)(
+                            ts.factory.createIdentifier("input"),
+                            obj,
+                            {
+                                source: "function",
+                                from: "object",
+                                tracable: false,
+                                postfix: "",
+                            },
+                        ),
+                    ),
                 );
-            let index: number = 1;
-            return ts.factory.createBlock(
-                obj.properties
-                    .map((property) => {
-                        const statements: ts.NodeArray<ts.Statement> = decode(
-                            project,
-                        )(config)(importer)(index)(
-                            input,
-                            property.value,
-                            explore,
-                            property.tags,
-                        ).statements;
-                        index += property.value.binarySize();
-                        return statements;
-                    })
-                    .flat(),
-                true,
+            const main = decode(project)(importer)(null)(
+                ts.factory.createIdentifier("input"),
+                meta,
+                {
+                    source: "top",
+                    from: "top",
+                    tracable: false,
+                    postfix: "",
+                },
+                [],
+            );
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("writer")],
+                TypeFactory.keyword("any"),
+                undefined,
+                ts.factory.createBlock(
+                    [
+                        ...importer.declareUnions(),
+                        ...functors,
+                        ...IsProgrammer.write_function_statements(project)(
+                            importer,
+                        )(collection),
+                        ...main.statements,
+                        ts.factory.createReturnStatement(
+                            ts.factory.createIdentifier("writer"),
+                        ),
+                    ],
+                    true,
+                ),
             );
         };
 
-    const write_map_function_body =
+    const write_object_function =
         (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            entry: Metadata.Entry,
+            obj: MetadataObject,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-        ): ts.Block => {
-            project;
-            config;
-            importer;
-            input;
-            entry;
-            explore;
-            tags;
-            return ts.factory.createBlock([], true);
+        ): ts.ArrowFunction => {
+            let index: number = 1;
+            const body: ts.Statement[] = obj.properties
+                .map((p) => {
+                    const block = decode(project)(importer)(index)(
+                        IdentifierFactory.access(input)(
+                            p.key.getSoleLiteral()!,
+                        ),
+                        p.value,
+                        explore,
+                        p.tags,
+                    );
+                    index += p.value.binarySize();
+                    return [
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createIdentifier(
+                                `// property "${p.key.getSoleLiteral()!}"`,
+                            ),
+                        ),
+                        ...block.statements,
+                    ];
+                })
+                .flat();
+
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                TypeFactory.keyword("any"),
+                undefined,
+                ts.factory.createBlock(body, true),
+            );
         };
 
     /* -----------------------------------------------------------
@@ -146,7 +203,6 @@ export namespace ProtobufEncodeProgrammer {
     ----------------------------------------------------------- */
     const decode =
         (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (index: number | null) =>
         (
@@ -155,6 +211,61 @@ export namespace ProtobufEncodeProgrammer {
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
         ): ts.Block => {
+            const wrapper: (block: ts.Block) => ts.Block =
+                meta.isRequired() && meta.nullable === false
+                    ? (block) => block
+                    : meta.isRequired() === false && meta.nullable === false
+                    ? (block) =>
+                          ts.factory.createBlock(
+                              [
+                                  ts.factory.createIfStatement(
+                                      ts.factory.createLogicalAnd(
+                                          ts.factory.createInequality(
+                                              ts.factory.createIdentifier(
+                                                  "undefined",
+                                              ),
+                                              input,
+                                          ),
+                                          ts.factory.createInequality(
+                                              ts.factory.createNull(),
+                                              input,
+                                          ),
+                                      ),
+                                      block,
+                                  ),
+                              ],
+                              true,
+                          )
+                    : meta.isRequired() === false
+                    ? (block) =>
+                          ts.factory.createBlock(
+                              [
+                                  ts.factory.createIfStatement(
+                                      ts.factory.createInequality(
+                                          ts.factory.createIdentifier(
+                                              "undefined",
+                                          ),
+                                          input,
+                                      ),
+                                      block,
+                                  ),
+                              ],
+                              true,
+                          )
+                    : (block) =>
+                          ts.factory.createBlock(
+                              [
+                                  ts.factory.createIfStatement(
+                                      ts.factory.createInequality(
+                                          ts.factory.createNull(),
+                                          input,
+                                      ),
+                                      block,
+                                  ),
+                              ],
+                              true,
+                          );
+
             // STARTS FROM ATOMIC TYPES
             const unions: IUnion[] = ProtobufUtil.atomics(meta).map((type) => ({
                 type,
@@ -164,134 +275,350 @@ export namespace ProtobufEncodeProgrammer {
                         ts.factory.createStringLiteral(type),
                         ts.factory.createTypeOfExpression(input),
                     ),
-                value: () => decode_atomic(input, type, tags),
+                value: (index) => decode_atomic(index!)(input, type, tags),
             }));
 
-            project;
-            config;
-            importer;
-            index;
-            explore;
-            unions;
+            // CONSIDER BYTES
+            if (meta.natives.length)
+                unions.push({
+                    type: "bytes",
+                    is: () =>
+                        ExpressionFactory.isInstanceOf("Uint8Array")(input),
+                    value: (index) => decode_bytes("bytes")(index!)(input),
+                });
+
+            // CONSIDER MAPS
+            if (meta.maps.length)
+                unions.push({
+                    type: "map",
+                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
+                    value: (index) =>
+                        decode_map(project)(importer)(index!)(
+                            input,
+                            meta.maps[0]!,
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                            tags,
+                        ),
+                });
 
             // CONSIDER ARRAYS
+            if (meta.arrays.length)
+                unions.push({
+                    type: "array",
+                    is: () => ExpressionFactory.isArray(input),
+                    value: (index) =>
+                        explore_arrays(project)(importer)(index!)(
+                            input,
+                            meta.arrays,
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                            tags,
+                        ),
+                });
 
             // CONSIDER OBJECTS
+            if (meta.objects.length)
+                unions.push({
+                    type: "object",
+                    is: () =>
+                        ExpressionFactory.isObject({
+                            checkNull: true,
+                            checkArray: false,
+                        })(input),
+                    value: (index) =>
+                        explore_objects(project)(importer)(0)(index)(
+                            input,
+                            meta.objects,
+                            {
+                                ...explore,
+                                from: "object",
+                            },
+                            tags,
+                        ),
+                });
 
-            // CONSIDER MAPS
-
-            return ts.factory.createBlock([]);
+            // RETURNS
+            if (unions.length === 1) return wrapper(unions[0]!.value(index));
+            else
+                return wrapper(
+                    iterate(importer)(index)(unions)(meta.getName())(input),
+                );
         };
 
-    const decode_object =
+    const iterate =
+        (importer: FunctionImporter) =>
+        (index: number | null) =>
+        (unions: IUnion[]) =>
+        (expected: string) =>
+        (input: ts.Expression) =>
+            ts.factory.createBlock(
+                [
+                    unions
+                        .map((u, i) =>
+                            ts.factory.createIfStatement(
+                                u.is(),
+                                u.value(index ? index + i : null),
+                                i === unions.length - 1
+                                    ? create_throw_error(importer)(expected)(
+                                          input,
+                                      )
+                                    : undefined,
+                            ),
+                        )
+                        .reverse()
+                        .reduce((a, b) =>
+                            ts.factory.createIfStatement(
+                                b.expression,
+                                b.thenStatement,
+                                a,
+                            ),
+                        ),
+                ],
+                true,
+            );
+
+    const decode_map =
         (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
+        (index: number) =>
         (
             input: ts.Expression,
-            object: MetadataObject,
+            map: Metadata.Entry,
             explore: FeatureProgrammer.IExplore,
+            tags: IMetadataTag[],
         ): ts.Block => {
-            project;
-            config;
-            importer;
-            input;
-            object;
-            explore;
-
+            const each: ts.Statement[] = [
+                ts.factory.createExpressionStatement(
+                    decode_tag(ProtobufWire.LEN)(index),
+                ),
+                ts.factory.createExpressionStatement(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(WRITER())("fork"),
+                        undefined,
+                        undefined,
+                    ),
+                ),
+                ...decode(project)(importer)(1)(
+                    ts.factory.createIdentifier("key"),
+                    map.key,
+                    explore,
+                    [],
+                ).statements,
+                ...decode(project)(importer)(2)(
+                    ts.factory.createIdentifier("value"),
+                    map.value,
+                    explore,
+                    tags,
+                ).statements,
+                ts.factory.createExpressionStatement(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(WRITER())("ldelim"),
+                        undefined,
+                        undefined,
+                    ),
+                ),
+            ];
             return ts.factory.createBlock(
-                [].map((exp) => ts.factory.createExpressionStatement(exp)),
+                [
+                    ts.factory.createForOfStatement(
+                        undefined,
+                        StatementFactory.entry("key")("value"),
+                        input,
+                        ts.factory.createBlock(each),
+                    ),
+                ],
                 true,
             );
         };
 
-    const decode_array =
+    const decode_object =
         (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
-        (index: number) =>
+        (index: number | null) =>
         (
             input: ts.Expression,
-            array: MetadataArray,
+            object: MetadataObject,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-        ): ts.Block =>
-            ts.factory.createBlock(
+        ): ts.Block => {
+            const top: MetadataProperty = object.properties[0]!;
+            if (top.key.isSoleLiteral() === false)
+                return decode_map(project)(importer)(index!)(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Object.entries"),
+                        [],
+                        [input],
+                    ),
+                    top,
+                    explore,
+                    tags,
+                );
+            return ts.factory.createBlock(
                 [
                     ...(index !== null
                         ? [
-                              ts.factory.createExpressionStatement(
-                                  decode_tag(ProtobufWire.LEN)(index),
+                              decode_tag(ProtobufWire.LEN)(index),
+                              ts.factory.createCallExpression(
+                                  IdentifierFactory.access(WRITER())("fork"),
+                                  undefined,
+                                  undefined,
                               ),
                           ]
                         : []),
-                    ts.factory.createForOfStatement(
-                        undefined,
-                        ts.factory.createVariableDeclarationList(
-                            [ts.factory.createVariableDeclaration("elem")],
-                            undefined,
-                        ),
-                        input,
-                        decode(project)(config)(importer)(index)(
-                            ts.factory.createIdentifier("elem"),
-                            array.value,
-                            explore,
-                            tags,
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier(
+                            `${PREFIX}o${object.index}`,
                         ),
+                        [],
+                        [input],
                     ),
-                ],
+                    ...(index !== null
+                        ? [
+                              ts.factory.createCallExpression(
+                                  IdentifierFactory.access(WRITER())("ldelim"),
+                                  undefined,
+                                  undefined,
+                              ),
+                          ]
+                        : []),
+                ].map((expr) => ts.factory.createExpressionStatement(expr)),
                 true,
             );
+        };
 
-    const decode_atomic = (
-        input: ts.Expression,
-        atomic: Atomic.Literal,
-        tags: IMetadataTag[],
-    ): ts.Block => {
-        if (atomic === "string") return decode_bytes("string")(input);
-
-        const out = (method: string): ts.Block =>
-            ts.factory.createBlock(
-                [
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(WRITER())(method),
-                        undefined,
-                        [input],
+    const decode_array =
+        (project: IProject) =>
+        (importer: FunctionImporter) =>
+        (index: number) =>
+        (
+            input: ts.Expression,
+            array: MetadataArray,
+            explore: FeatureProgrammer.IExplore,
+            tags: IMetadataTag[],
+        ): ts.Block => {
+            const wire = get_standalone_wire(array.value, tags);
+            const forLoop = (index: number | null) =>
+                ts.factory.createForOfStatement(
+                    undefined,
+                    ts.factory.createVariableDeclarationList(
+                        [ts.factory.createVariableDeclaration("elem")],
+                        ts.NodeFlags.Const,
                     ),
-                ].map((exp) => ts.factory.createExpressionStatement(exp)),
-                true,
+                    input,
+                    decode(project)(importer)(index)(
+                        ts.factory.createIdentifier("elem"),
+                        array.value,
+                        explore,
+                        tags,
+                    ),
+                );
+            const length = (block: ts.Block) =>
+                ts.factory.createBlock(
+                    [
+                        ts.factory.createIfStatement(
+                            ts.factory.createStrictInequality(
+                                ts.factory.createNumericLiteral(0),
+                                IdentifierFactory.access(input)("length"),
+                            ),
+                            block,
+                        ),
+                    ],
+                    true,
+                );
+
+            if (wire === ProtobufWire.LEN)
+                return length(ts.factory.createBlock([forLoop(index)], true));
+            return length(
+                ts.factory.createBlock(
+                    [
+                        ts.factory.createExpressionStatement(
+                            decode_tag(ProtobufWire.LEN)(index),
+                        ),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(WRITER())("fork"),
+                                undefined,
+                                undefined,
+                            ),
+                        ),
+                        forLoop(null),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(WRITER())("ldelim"),
+                                undefined,
+                                undefined,
+                            ),
+                        ),
+                    ],
+                    true,
+                ),
             );
-        if (atomic === "boolean") return out("bool");
+        };
 
-        const type: IMetadataTag.INumberType | undefined = tags.find(
-            (tag) => tag.kind === "type",
-        ) as IMetadataTag.INumberType | undefined;
-        if (atomic === "bigint")
-            return out(type?.value === "uint64" ? "uint64" : "int64");
-        else if (type === undefined || type?.value === "double")
-            return out("double");
-        else if (type.value === "float") return out("float");
-        return out(
-            type.value === "uint32" || type.value === "uint"
-                ? "uint32"
-                : type.value === "int32" || type.value === "int"
-                ? "int32"
-                : type.value === "int64"
-                ? "int64"
-                : "uint64",
-        );
-    };
+    const decode_atomic =
+        (index: number | null) =>
+        (
+            input: ts.Expression,
+            atomic: Atomic.Literal,
+            tags: IMetadataTag[],
+        ): ts.Block => {
+            if (atomic === "string")
+                return decode_bytes("string")(index!)(input);
+
+            const out =
+                (wire: ProtobufWire) =>
+                (method: string): ts.Block =>
+                    ts.factory.createBlock(
+                        [
+                            ...(index !== null
+                                ? [decode_tag(wire)(index)]
+                                : []),
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(WRITER())(method),
+                                undefined,
+                                [input],
+                            ),
+                        ].map((exp) =>
+                            ts.factory.createExpressionStatement(exp),
+                        ),
+                        true,
+                    );
+            if (atomic === "boolean") return out(ProtobufWire.VARIANT)("bool");
+
+            const type: IMetadataTag.INumberType | undefined = tags.find(
+                (tag) => tag.kind === "type",
+            ) as IMetadataTag.INumberType | undefined;
+            if (atomic === "bigint")
+                return out(ProtobufWire.VARIANT)(
+                    type?.value === "uint64" ? "uint64" : "int64",
+                );
+            else if (type === undefined || type?.value === "double")
+                return out(ProtobufWire.I64)("double");
+            else if (type.value === "float")
+                return out(ProtobufWire.I32)("float");
+            return out(ProtobufWire.VARIANT)(
+                type.value === "uint32" || type.value === "uint"
+                    ? "uint32"
+                    : type.value === "int32" || type.value === "int"
+                    ? "int32"
+                    : type.value === "int64"
+                    ? "int64"
+                    : "uint64",
+            );
+        };
 
     const decode_bytes =
         (method: "bytes" | "string") =>
+        (index: number) =>
         (input: ts.Expression): ts.Block =>
             ts.factory.createBlock(
                 [
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(WRITER())("uint32"),
-                        undefined,
-                        [IdentifierFactory.access(input)("length")],
-                    ),
+                    decode_tag(ProtobufWire.LEN)(index),
                     ts.factory.createCallExpression(
                         IdentifierFactory.access(WRITER())(method),
                         undefined,
@@ -310,37 +637,139 @@ export namespace ProtobufEncodeProgrammer {
                 [ts.factory.createNumericLiteral((index << 3) | wire)],
             );
 
+    const get_standalone_wire = (
+        meta: Metadata,
+        tags: IMetadataTag[],
+    ): ProtobufWire => {
+        if (
+            meta.arrays.length ||
+            meta.objects.length ||
+            meta.maps.length ||
+            meta.natives.length
+        )
+            return ProtobufWire.LEN;
+
+        const v = ProtobufUtil.atomics(meta)[0]!;
+        if (v === "string") return ProtobufWire.LEN;
+        else if (v === "boolean" || v === "bigint") return ProtobufWire.VARIANT;
+
+        const type: IMetadataTag.INumberType | undefined = tags.find(
+            (t) => t.kind === "type",
+        ) as IMetadataTag.INumberType | undefined;
+        if (type === undefined) return ProtobufWire.I64;
+        else if (type.value === "float") return ProtobufWire.I32;
+        return ProtobufWire.VARIANT;
+    };
+
     /* -----------------------------------------------------------
         EXPLORERS
     ----------------------------------------------------------- */
     const explore_objects =
         (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
+        (level: number) =>
+        (index: number | null) =>
         (
             input: ts.Expression,
-            meta: Metadata,
+            targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
-        ) =>
-            meta.objects.length === 1
-                ? decode_object(project)(config)(importer)(
-                      input,
-                      meta.objects[0]!,
-                      explore,
-                  )
-                : ts.factory.createCallExpression(
-                      ts.factory.createIdentifier(
-                          importer.useLocal(
-                              `${config.prefix}u${meta.union_index!}`,
-                          ),
-                      ),
-                      undefined,
-                      FeatureProgrammer.argumentsArray(config)(explore)(input),
-                  );
+            tags: IMetadataTag[],
+        ): ts.Block => {
+            if (targets.length === 1)
+                return decode_object(project)(importer)(index)(
+                    input,
+                    targets[0]!,
+                    explore,
+                    tags,
+                );
+
+            const expected: string = `(${targets
+                .map((t) => t.name)
+                .join(" | ")})`;
+
+            // POSSIBLE TO SPECIALIZE?
+            const specList = UnionPredicator.object(targets);
+            if (specList.length === 0) {
+                const condition: ts.Expression = decode_union_object(
+                    IsProgrammer.decode_object(importer),
+                )((i, o, e) =>
+                    ExpressionFactory.selfCall(
+                        decode_object(project)(importer)(index)(i, o, e, tags),
+                    ),
+                )((expr) => expr)((value, expected) =>
+                    create_throw_error(importer)(expected)(value),
+                )(input, targets, explore);
+                return StatementFactory.block(condition);
+            }
+            const remained: MetadataObject[] = targets.filter(
+                (t) => specList.find((s) => s.object === t) === undefined,
+            );
+
+            // DO SPECIALIZE
+            const condition: ts.IfStatement = specList
+                .filter((spec) => spec.property.key.getSoleLiteral() !== null)
+                .map((spec, i, array) => {
+                    const key: string = spec.property.key.getSoleLiteral()!;
+                    const accessor: ts.Expression =
+                        IdentifierFactory.access(input)(key);
+                    const pred: ts.Expression = spec.neighbour
+                        ? IsProgrammer.decode(project)(importer)(
+                              accessor,
+                              spec.property.value,
+                              {
+                                  ...explore,
+                                  tracable: false,
+                                  postfix: IdentifierFactory.postfix(key),
+                              },
+                              tags,
+                              [],
+                          )
+                        : ExpressionFactory.isRequired(accessor);
+                    return ts.factory.createIfStatement(
+                        pred,
+                        ts.factory.createReturnStatement(
+                            ExpressionFactory.selfCall(
+                                decode_object(project)(importer)(index)(
+                                    input,
+                                    spec.object,
+                                    explore,
+                                    tags,
+                                ),
+                            ),
+                        ),
+                        i === array.length - 1
+                            ? remained.length
+                                ? ts.factory.createReturnStatement(
+                                      ExpressionFactory.selfCall(
+                                          explore_objects(project)(importer)(
+                                              level + 1,
+                                          )(index)(
+                                              input,
+                                              remained,
+                                              explore,
+                                              tags,
+                                          ),
+                                      ),
+                                  )
+                                : create_throw_error(importer)(expected)(input)
+                            : undefined,
+                    );
+                })
+                .reverse()
+                .reduce((a, b) =>
+                    ts.factory.createIfStatement(
+                        b.expression,
+                        b.thenStatement,
+                        a,
+                    ),
+                );
+
+            // RETURNS WITH CONDITIONS
+            return ts.factory.createBlock([condition], true);
+        };
 
     const explore_arrays =
         (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (index: number) =>
         (
@@ -348,37 +777,43 @@ export namespace ProtobufEncodeProgrammer {
             elements: MetadataArray[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-        ): ts.Expression =>
-            explore_array_like_union_types(config)(importer)(
-                UnionExplorer.array({
-                    checker: IsProgrammer.decode(project)(importer),
-                    decoder: (input, target, explore, tags) =>
-                        ts.factory.createCallExpression(
-                            ts.factory.createArrowFunction(
-                                undefined,
-                                undefined,
-                                [],
-                                undefined,
-                                undefined,
-                                decode_array(project)(config)(importer)(index)(
-                                    input,
-                                    target,
-                                    explore,
-                                    tags,
-                                ),
-                            ),
-                            undefined,
-                            undefined,
-                        ),
-                    empty: ts.factory.createStringLiteral("[]"),
-                    success: ts.factory.createTrue(),
-                    failure: (input, expected) =>
-                        create_throw_error(importer)(expected)(input),
-                }),
-            )(input, elements, explore, tags);
+        ): ts.Block =>
+            elements.length === 1
+                ? decode_array(project)(importer)(index)(
+                      input,
+                      elements[0]!,
+                      explore,
+                      tags,
+                  )
+                : explore_array_like_union_types(importer)(
+                      UnionExplorer.array({
+                          checker: IsProgrammer.decode(project)(importer),
+                          decoder: (input, target, explore, tags) =>
+                              ts.factory.createCallExpression(
+                                  ts.factory.createArrowFunction(
+                                      undefined,
+                                      undefined,
+                                      [],
+                                      undefined,
+                                      undefined,
+                                      decode_array(project)(importer)(index)(
+                                          input,
+                                          target,
+                                          explore,
+                                          tags,
+                                      ),
+                                  ),
+                                  undefined,
+                                  undefined,
+                              ),
+                          empty: ts.factory.createStringLiteral("[]"),
+                          success: ts.factory.createTrue(),
+                          failure: (input, expected) =>
+                              create_throw_error(importer)(expected)(input),
+                      }),
+                  )(input, elements, explore, tags);
 
     const explore_array_like_union_types =
-        (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         <T extends MetadataArray | MetadataTuple>(
             factory: (
@@ -396,17 +831,19 @@ export namespace ProtobufEncodeProgrammer {
             elements: T[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-        ): ts.Expression => {
+        ): ts.Block => {
             const arrow =
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
                     factory(parameters)(input, elements, explore, tags, []);
             if (elements.every((e) => e.recursive === false))
-                ts.factory.createCallExpression(
-                    arrow([])(explore)(input),
-                    undefined,
-                    [],
+                return StatementFactory.block(
+                    ts.factory.createCallExpression(
+                        arrow([])(explore)(input),
+                        undefined,
+                        [],
+                    ),
                 );
 
             explore = {
@@ -414,31 +851,39 @@ export namespace ProtobufEncodeProgrammer {
                 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")),
+            return StatementFactory.block(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        importer.emplaceUnion(
+                            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),
                 ),
-                undefined,
-                FeatureProgrammer.argumentsArray(config)(explore)(input),
             );
         };
 
     /* -----------------------------------------------------------
         CONFIGURATIONS
     ----------------------------------------------------------- */
-    // const PREFIX = "$pe";
+    const PREFIX = "$pe";
+    const CONFIG = {
+        path: false,
+        trace: false,
+    };
 
     const create_throw_error =
         (importer: FunctionImporter) =>
@@ -471,7 +916,6 @@ const WRITER = () => ts.factory.createIdentifier("writer");
 
 interface IUnion {
     type: string;
-    wire: () => ProtobufWire;
     is: () => ts.Expression;
     value: (index: number | null) => ts.Block;
 }