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

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -8,11 +8,9 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
@@ -68,7 +66,7 @@ export namespace JsonStringifyProgrammer {
             collection
                 .arrays()
                 .filter((a) => a.recursive)
-                .map((array, i) =>
+                .map((type, i) =>
                     StatementFactory.constant(
                         `${config.prefix}a${i}`,
                         ts.factory.createArrowFunction(
@@ -81,7 +79,10 @@ export namespace JsonStringifyProgrammer {
                             undefined,
                             decode_array_inline(config)(importer)(
                                 ts.factory.createIdentifier("input"),
-                                array,
+                                MetadataArray.create({
+                                    type,
+                                    tags: [],
+                                }),
                                 {
                                     tracable: config.trace,
                                     source: "function",
@@ -215,7 +216,9 @@ export namespace JsonStringifyProgrammer {
             )
                 if (AtomicPredicator.template(meta)) {
                     const partial = Metadata.initialize();
-                    partial.atomics.push({ type: "string", tags: [] }),
+                    partial.atomics.push(
+                        MetadataAtomic.create({ type: "string", tags: [] }),
+                    ),
                         unions.push({
                             type: "template literal",
                             is: () =>
@@ -223,8 +226,6 @@ export namespace JsonStringifyProgrammer {
                                     input,
                                     partial,
                                     explore,
-                                    [],
-                                    [],
                                 ),
                             value: () =>
                                 decode_atomic(project)(importer)(
@@ -247,15 +248,15 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push({
-                                        type: constant.type,
-                                        tags: [],
-                                    });
+                                    partial.atomics.push(
+                                        MetadataAtomic.create({
+                                            type: constant.type,
+                                            tags: [],
+                                        }),
+                                    );
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_atomic(project)(importer)(
@@ -272,15 +273,15 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push({
-                                        type: "string",
-                                        tags: [],
-                                    });
+                                    partial.atomics.push(
+                                        MetadataAtomic.create({
+                                            type: "string",
+                                            tags: [],
+                                        }),
+                                    );
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_constant_string(project)(importer)(
@@ -304,8 +305,6 @@ export namespace JsonStringifyProgrammer {
                                     return partial;
                                 })(),
                                 explore,
-                                [],
-                                [],
                             ),
                         value: () =>
                             decode_atomic(project)(importer)(
@@ -333,8 +332,6 @@ export namespace JsonStringifyProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -534,23 +531,19 @@ export namespace JsonStringifyProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(
-                      input,
-                      array.type,
-                      explore,
-                  );
+                : decode_array_inline(config)(importer)(input, array, explore);
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArrayType,
+            array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(
                 StringifyJoiner.array,
-            )(input, array, explore, [], []);
+            )(input, array, explore);
 
     const decode_tuple =
         (project: IProject) =>
@@ -765,8 +758,6 @@ export namespace JsonStringifyProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -778,7 +769,7 @@ export namespace JsonStringifyProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
+                    factory(parameters)(input, elements, explore);
             if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
@@ -921,8 +912,6 @@ export namespace JsonStringifyProgrammer {
                             input,
                             meta,
                             explore,
-                            [],
-                            [],
                         ),
                     decoder: () => decode_object(importer),
                     joiner: StringifyJoiner.object(importer),

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -7,11 +7,8 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -49,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(
@@ -62,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",
@@ -154,8 +154,6 @@ export namespace MiscCloneProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -284,26 +282,20 @@ export namespace MiscCloneProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(
-                      input,
-                      array.type,
-                      explore,
-                  );
+                : decode_array_inline(config)(importer)(input, array, explore);
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArrayType,
+            array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(CloneJoiner.array)(
                 input,
                 array,
                 explore,
-                [],
-                [],
             );
 
     const decode_tuple =
@@ -505,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,
             );
@@ -534,8 +526,6 @@ export namespace MiscCloneProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[0]`,
                                 },
-                                [],
-                                [],
                             ),
                             func(
                                 ts.factory.createElementAccessExpression(
@@ -547,8 +537,6 @@ export namespace MiscCloneProgrammer {
                                     ...explore,
                                     postfix: `${explore.postfix}[1]`,
                                 },
-                                [],
-                                [],
                             ),
                         );
                     },
@@ -578,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,
             );
@@ -637,8 +625,6 @@ export namespace MiscCloneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -650,7 +636,7 @@ export namespace MiscCloneProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
+                    factory(parameters)(input, elements, explore);
             if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),

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/MiscPruneProgrammer.ts

@@ -7,11 +7,8 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -49,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(
@@ -62,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",
@@ -146,8 +146,6 @@ export namespace MiscPruneProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -255,26 +253,20 @@ export namespace MiscPruneProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(
-                      input,
-                      array.type,
-                      explore,
-                  );
+                : decode_array_inline(config)(importer)(input, array, explore);
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArrayType,
+            array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression =>
             FeatureProgrammer.decode_array(config)(importer)(PruneJoiner.array)(
                 input,
                 array,
                 explore,
-                [],
-                [],
             );
 
     const decode_tuple =
@@ -414,8 +406,6 @@ export namespace MiscPruneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -427,7 +417,7 @@ export namespace MiscPruneProgrammer {
                 (parameters: ts.ParameterDeclaration[]) =>
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, [], []);
+                    factory(parameters)(input, elements, explore);
             if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),

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 { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 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();
@@ -280,7 +278,6 @@ export namespace ProtobufDecodeProgrammer {
         (
             accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
             meta: Metadata,
-            tags: IMetadataCommentTag[],
         ): 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.type.value.getName()}>`)(
-                    decode_array(accessor, array, required, tags),
+                    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: IMetadataCommentTag[],
-    ): 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: IMetadataCommentTag[],
     ): ts.Statement[] => {
         const statements: Array<ts.Expression | ts.Statement> = [];
         if (required === false)
@@ -423,7 +396,7 @@ export namespace ProtobufDecodeProgrammer {
             );
         const atomics = ProtobufUtil.getAtomics(array.type.value);
         const decoder = atomics.length
-            ? () => decode_atomic(atomics[0]!, tags)
+            ? () => decode_atomic(array.type.value)(atomics[0]!)
             : array.type.value.natives.length
             ? () => decode_bytes("bytes")
             : array.type.value.objects.length
@@ -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: IMetadataCommentTag[],
         ): 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: IMetadataCommentTag[],
-        ): 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: [],
                     }),
                 ]),