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

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -7,11 +7,10 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -47,7 +46,7 @@ export namespace MiscCloneProgrammer {
             collection
                 .arrays()
                 .filter((a) => a.recursive)
-                .map((array, i) =>
+                .map((type, i) =>
                     StatementFactory.constant(
                         `${config.prefix}a${i}`,
                         ts.factory.createArrowFunction(
@@ -60,7 +59,10 @@ export namespace MiscCloneProgrammer {
                             undefined,
                             decode_array_inline(config)(importer)(
                                 ts.factory.createIdentifier("input"),
-                                array,
+                                MetadataArray.create({
+                                    type,
+                                    tags: [],
+                                }),
                                 {
                                     tracable: config.trace,
                                     source: "function",
@@ -120,8 +122,8 @@ export namespace MiscCloneProgrammer {
             // ANY TYPE
             if (
                 meta.any ||
-                meta.arrays.some((a) => a.value.any) ||
-                meta.tuples.some((t) => t.elements.every((e) => e.any))
+                meta.arrays.some((a) => a.type.value.any) ||
+                meta.tuples.some((t) => t.type.elements.every((e) => e.any))
             )
                 return ts.factory.createCallExpression(
                     importer.use("any"),
@@ -152,8 +154,6 @@ export namespace MiscCloneProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -268,10 +268,12 @@ export namespace MiscCloneProgrammer {
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
-            array.recursive
+            array.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}a${array.index}`),
+                          importer.useLocal(
+                              `${config.prefix}a${array.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -294,8 +296,6 @@ export namespace MiscCloneProgrammer {
                 input,
                 array,
                 explore,
-                [],
-                [],
             );
 
     const decode_tuple =
@@ -307,10 +307,12 @@ export namespace MiscCloneProgrammer {
             tuple: MetadataTuple,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression =>
-            tuple.recursive
+            tuple.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}t${tuple.index}`),
+                          importer.useLocal(
+                              `${config.prefix}t${tuple.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -320,7 +322,7 @@ export namespace MiscCloneProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -330,7 +332,7 @@ export namespace MiscCloneProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
             const children: ts.Expression[] = tuple.elements
@@ -495,7 +497,7 @@ export namespace MiscCloneProgrammer {
                     success: ts.factory.createTrue(),
                     failure: (input, expected) =>
                         create_throw_error(importer)(expected)(input),
-                })([])(input, sets, explore, [], []),
+                })([])(input, sets, explore),
                 undefined,
                 undefined,
             );
@@ -524,8 +526,6 @@ export namespace MiscCloneProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[0]`,
                                 },
-                                [],
-                                [],
                             ),
                             func(
                                 ts.factory.createElementAccessExpression(
@@ -537,8 +537,6 @@ export namespace MiscCloneProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[1]`,
                                 },
-                                [],
-                                [],
                             ),
                         );
                     },
@@ -568,7 +566,7 @@ export namespace MiscCloneProgrammer {
                     success: ts.factory.createTrue(),
                     failure: (input, expected) =>
                         create_throw_error(importer)(expected)(input),
-                })([])(input, maps, explore, [], []),
+                })([])(input, maps, explore),
                 undefined,
                 undefined,
             );
@@ -627,8 +625,6 @@ export namespace MiscCloneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -640,8 +636,8 @@ export namespace MiscCloneProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+                    factory(parameters)(input, elements, explore);
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -657,7 +653,7 @@ export namespace MiscCloneProgrammer {
                 ts.factory.createIdentifier(
                     importer.emplaceUnion(
                         config.prefix,
-                        elements.map((e) => e.name).join(" | "),
+                        elements.map((e) => e.type.name).join(" | "),
                         () =>
                             arrow(
                                 FeatureProgrammer.parameterDeclarations(config)(

package/src/programmers/{IsPruneProgrammer.ts → misc/MiscIsPruneProgrammer.ts}

@@ -1,15 +1,15 @@
 import ts from "typescript";
 
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { TypeFactory } from "../factories/TypeFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../transformers/IProject";
+import { IProject } from "../../transformers/IProject";
 
-import { IsProgrammer } from "./IsProgrammer";
-import { MiscPruneProgrammer } from "./misc/MiscPruneProgrammer";
+import { IsProgrammer } from "../IsProgrammer";
+import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
 
-export namespace IsPruneProgrammer {
+export namespace MiscIsPruneProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -23,7 +23,7 @@ export namespace MiscLiteralsProgrammer {
                     meta.constants
                         .map((c) => c.values.length)
                         .reduce((a, b) => a + b, 0) +
-                    meta.atomics.filter((type) => type === "boolean").length;
+                    meta.atomics.filter((a) => a.type === "boolean").length;
                 if (0 === length) throw new Error(ErrorMessages.NO);
                 else if (meta.size() !== length)
                     throw new Error(ErrorMessages.ONLY);
@@ -31,7 +31,7 @@ export namespace MiscLiteralsProgrammer {
         })(new MetadataCollection())(type);
         const values: Set<Atomic.Type | null> = new Set([
             ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
-            ...(meta.atomics.filter((type) => type === "boolean").length
+            ...(meta.atomics.filter((a) => a.type === "boolean").length
                 ? [true, false]
                 : []),
             ...(meta.nullable ? [null] : []),

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -7,11 +7,10 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -47,7 +46,7 @@ export namespace MiscPruneProgrammer {
             collection
                 .arrays()
                 .filter((a) => a.recursive)
-                .map((array, i) =>
+                .map((type, i) =>
                     StatementFactory.constant(
                         `${config.prefix}a${i}`,
                         ts.factory.createArrowFunction(
@@ -60,7 +59,10 @@ export namespace MiscPruneProgrammer {
                             undefined,
                             decode_array_inline(config)(importer)(
                                 ts.factory.createIdentifier("input"),
-                                array,
+                                MetadataArray.create({
+                                    type,
+                                    tags: [],
+                                }),
                                 {
                                     tracable: config.trace,
                                     source: "function",
@@ -130,8 +132,8 @@ export namespace MiscPruneProgrammer {
             // LIST UP UNION TYPES
             //----
             // TUPLES
-            for (const tuple of meta.tuples.filter((t) =>
-                t.elements.some((e) => filter(e.rest ?? e)),
+            for (const tuple of meta.tuples.filter((tuple) =>
+                tuple.type.elements.some((e) => filter(e.rest ?? e)),
             ))
                 unions.push({
                     type: "tuple",
@@ -144,8 +146,6 @@ export namespace MiscPruneProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -156,7 +156,7 @@ export namespace MiscPruneProgrammer {
                 });
 
             // ARRAYS
-            if (meta.arrays.filter((a) => filter(a.value)).length)
+            if (meta.arrays.filter((a) => filter(a.type.value)).length)
                 unions.push({
                     type: "array",
                     is: () => ExpressionFactory.isArray(input),
@@ -239,10 +239,12 @@ export namespace MiscPruneProgrammer {
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
-            array.recursive
+            array.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}a${array.index}`),
+                          importer.useLocal(
+                              `${config.prefix}a${array.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -265,8 +267,6 @@ export namespace MiscPruneProgrammer {
                 input,
                 array,
                 explore,
-                [],
-                [],
             );
 
     const decode_tuple =
@@ -278,10 +278,12 @@ export namespace MiscPruneProgrammer {
             tuple: MetadataTuple,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression | ts.Block =>
-            tuple.recursive
+            tuple.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(`${config.prefix}t${tuple.index}`),
+                          importer.useLocal(
+                              `${config.prefix}t${tuple.type.index}`,
+                          ),
                       ),
                       undefined,
                       FeatureProgrammer.argumentsArray(config)({
@@ -291,7 +293,7 @@ export namespace MiscPruneProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -301,7 +303,7 @@ export namespace MiscPruneProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Block => {
             const children: ts.ConciseBody[] = tuple.elements
@@ -404,8 +406,6 @@ export namespace MiscPruneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -417,8 +417,8 @@ export namespace MiscPruneProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+                    factory(parameters)(input, elements, explore);
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -434,7 +434,7 @@ export namespace MiscPruneProgrammer {
                 ts.factory.createIdentifier(
                     importer.emplaceUnion(
                         config.prefix,
-                        elements.map((e) => e.name).join(" | "),
+                        elements.map((e) => e.type.name).join(" | "),
                         () =>
                             arrow(
                                 FeatureProgrammer.parameterDeclarations(config)(
@@ -456,9 +456,9 @@ export namespace MiscPruneProgrammer {
         meta.any === false &&
         (meta.objects.length !== 0 ||
             meta.tuples.some((t) =>
-                t.elements.some((e) => filter(e.rest ?? e)),
+                t.type.elements.some((e) => filter(e.rest ?? e)),
             ) ||
-            meta.arrays.some((e) => filter(e.value)));
+            meta.arrays.some((e) => filter(e.type.value)));
 
     /* -----------------------------------------------------------
         CONFIGURATIONS

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -8,7 +8,6 @@ import { ProtobufFactory } from "../../factories/ProtobufFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
@@ -16,7 +15,7 @@ import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { IProject } from "../../transformers/IProject";
 
-import { Atomic } from "../../typings/Atomic";
+import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
@@ -166,9 +165,8 @@ export namespace ProtobufDecodeProgrammer {
                             ts.factory.createIdentifier(props.output),
                         )(p.key.getSoleLiteral()!),
                         p.value,
-                        p.tags,
                     );
-                    i += p.value.binarySize();
+                    i += ProtobufUtil.size(p.value);
                     return clause;
                 })
                 .flat();
@@ -253,7 +251,7 @@ export namespace ProtobufDecodeProgrammer {
                       undefined,
                       [],
                   )
-                : value.atomics.some((str) => str === "string") ||
+                : value.atomics.some((a) => a.type === "string") ||
                   value.constants.some(
                       (c) =>
                           c.type === "string" && c.values.some((v) => v === ""),
@@ -280,7 +278,6 @@ export namespace ProtobufDecodeProgrammer {
         (
             accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
             meta: Metadata,
-            tags: IMetadataTag[],
         ): ts.CaseClause[] => {
             const clauses: ts.CaseClause[] = [];
             const emplace =
@@ -320,20 +317,15 @@ export namespace ProtobufDecodeProgrammer {
 
             const required: boolean = meta.isRequired() && !meta.nullable;
             for (const atomic of ProtobufUtil.getAtomics(meta))
-                emplace(atomic)(decode_atomic(atomic, tags));
+                emplace(atomic)(decode_atomic(meta)(atomic));
             if (meta.natives.length) emplace("bytes")(decode_bytes("bytes"));
             for (const array of meta.arrays)
-                emplace(`Array<${array.value.getName()}>`)(
-                    decode_array(accessor, array, required, tags),
+                emplace(`Array<${array.type.value.getName()}>`)(
+                    decode_array(accessor, array, required),
                 );
             for (const map of meta.maps)
                 emplace(`Map<string, ${map.value.getName()}>`)(
-                    decode_map(project)(importer)(
-                        accessor,
-                        map,
-                        required,
-                        tags,
-                    ),
+                    decode_map(project)(importer)(accessor, map, required),
                 );
             for (const obj of meta.objects)
                 emplace(obj.name)(
@@ -348,49 +340,31 @@ export namespace ProtobufDecodeProgrammer {
             return clauses;
         };
 
-    const decode_atomic = (
-        atomic: Atomic.Literal,
-        tags: IMetadataTag[],
-    ): ts.Expression => {
-        if (atomic === "string") return decode_bytes("string");
-        const method =
-            atomic === "bigint"
-                ? tags.find((t) => t.kind === "type" && t.value === "uint64")
-                    ? "uint64"
-                    : "int64"
-                : atomic === "number"
-                ? (() => {
-                      const type = tags.find((t) => t.kind === "type");
-                      if (type === undefined) return "double";
-                      return type.value === "int" || type.value === "int32"
-                          ? "int32"
-                          : type.value === "uint" || type.value === "uint32"
-                          ? "uint32"
-                          : type.value === "int64"
-                          ? "int64"
-                          : type.value === "uint64"
-                          ? "uint64"
-                          : type.value === "float"
-                          ? "float"
-                          : "double";
-                  })()
-                : "bool";
-        const call = ts.factory.createCallExpression(
-            IdentifierFactory.access(ts.factory.createIdentifier("reader"))(
-                method,
-            ),
-            undefined,
-            undefined,
-        );
-        return atomic === "number" &&
-            (method === "int64" || method === "uint64")
-            ? ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("Number"),
-                  undefined,
-                  [call],
-              )
-            : call;
-    };
+    const decode_atomic =
+        (meta: Metadata) =>
+        (atomic: ProtobufAtomic): ts.Expression => {
+            if (atomic === "string") return decode_bytes("string");
+
+            const call: ts.CallExpression = ts.factory.createCallExpression(
+                IdentifierFactory.access(ts.factory.createIdentifier("reader"))(
+                    atomic,
+                ),
+                undefined,
+                undefined,
+            );
+            if (atomic !== "int64" && atomic !== "uint64") return call;
+
+            const isNumber: boolean = ProtobufUtil.getNumbers(meta).some(
+                (n) => n === atomic,
+            );
+            return isNumber
+                ? ts.factory.createCallExpression(
+                      ts.factory.createIdentifier("Number"),
+                      undefined,
+                      [call],
+                  )
+                : call;
+        };
 
     const decode_bytes = (method: "bytes" | "string"): ts.Expression =>
         ts.factory.createCallExpression(
@@ -405,7 +379,6 @@ export namespace ProtobufDecodeProgrammer {
         accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
         array: MetadataArray,
         required: boolean,
-        tags: IMetadataTag[],
     ): ts.Statement[] => {
         const statements: Array<ts.Expression | ts.Statement> = [];
         if (required === false)
@@ -421,13 +394,13 @@ export namespace ProtobufDecodeProgrammer {
                     ),
                 ),
             );
-        const atomics = ProtobufUtil.getAtomics(array.value);
+        const atomics = ProtobufUtil.getAtomics(array.type.value);
         const decoder = atomics.length
-            ? () => decode_atomic(atomics[0]!, tags)
-            : array.value.natives.length
+            ? () => decode_atomic(array.type.value)(atomics[0]!)
+            : array.type.value.natives.length
             ? () => decode_bytes("bytes")
-            : array.value.objects.length
-            ? () => decode_regular_object(false)(array.value.objects[0]!)
+            : array.type.value.objects.length
+            ? () => decode_regular_object(false)(array.type.value.objects[0]!)
             : null;
         if (decoder === null) throw new Error("Never reach here.");
         else if (atomics.length && atomics[0] !== "string") {
@@ -556,7 +529,7 @@ export namespace ProtobufDecodeProgrammer {
                         ts.factory.createToken(ts.SyntaxKind.EqualsToken),
                         ts.factory.createIdentifier("entry.value"),
                     ),
-            })(top, required, top.tags);
+            })(top, required);
         };
 
     const decode_map =
@@ -566,7 +539,6 @@ export namespace ProtobufDecodeProgrammer {
             accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
             map: Metadata.Entry,
             required: boolean,
-            tags: IMetadataTag[],
         ): ts.Statement[] =>
             decode_entry(project)(importer)({
                 initializer: () =>
@@ -593,7 +565,7 @@ export namespace ProtobufDecodeProgrammer {
                             ts.factory.createIdentifier("entry.value"),
                         ],
                     ),
-            })(map, required, tags);
+            })(map, required);
 
     const decode_entry =
         (project: IProject) =>
@@ -602,11 +574,7 @@ export namespace ProtobufDecodeProgrammer {
             initializer: () => ts.Expression;
             setter: () => ts.Expression;
         }) =>
-        (
-            map: Metadata.Entry,
-            required: boolean,
-            tags: IMetadataTag[],
-        ): ts.Statement[] => {
+        (map: Metadata.Entry, required: boolean): ts.Statement[] => {
             const statements: ts.Statement[] = [
                 ...(required
                     ? []
@@ -646,14 +614,12 @@ export namespace ProtobufDecodeProgrammer {
                         key: MetadataFactory.soleLiteral("key"),
                         value: map.key,
                         description: null,
-                        tags: [],
                         jsDocTags: [],
                     }),
                     MetadataProperty.create({
                         key: MetadataFactory.soleLiteral("value"),
                         value: map.value,
                         description: null,
-                        tags,
                         jsDocTags: [],
                     }),
                 ]),