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

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -9,11 +9,13 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+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 { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -213,7 +215,7 @@ export namespace JsonStringifyProgrammer {
             )
                 if (AtomicPredicator.template(meta)) {
                     const partial = Metadata.initialize();
-                    partial.atomics.push("string"),
+                    partial.atomics.push({ type: "string", tags: [] }),
                         unions.push({
                             type: "template literal",
                             is: () =>
@@ -245,7 +247,10 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push(constant.type);
+                                    partial.atomics.push({
+                                        type: constant.type,
+                                        tags: [],
+                                    });
                                     return partial;
                                 })(),
                                 explore,
@@ -267,7 +272,10 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push("string");
+                                    partial.atomics.push({
+                                        type: "string",
+                                        tags: [],
+                                    });
                                     return partial;
                                 })(),
                                 explore,
@@ -283,8 +291,8 @@ export namespace JsonStringifyProgrammer {
                     });
 
             /// ATOMICS
-            for (const type of meta.atomics)
-                if (AtomicPredicator.atomic(meta)(type))
+            for (const a of meta.atomics)
+                if (AtomicPredicator.atomic(meta)(a.type))
                     unions.push({
                         type: "atomic",
                         is: () =>
@@ -292,7 +300,7 @@ export namespace JsonStringifyProgrammer {
                                 input,
                                 (() => {
                                     const partial = Metadata.initialize();
-                                    partial.atomics.push(type);
+                                    partial.atomics.push(a);
                                     return partial;
                                 })(),
                                 explore,
@@ -302,14 +310,14 @@ export namespace JsonStringifyProgrammer {
                         value: () =>
                             decode_atomic(project)(importer)(
                                 input,
-                                type,
+                                a.type,
                                 explore,
                             ),
                     });
 
             // TUPLES
             for (const tuple of meta.tuples) {
-                for (const child of tuple.elements)
+                for (const child of tuple.type.elements)
                     if (StringifyPredicator.undefindable(meta))
                         throw new Error(
                             `Error on typia.json.stringify(): tuple cannot contain undefined value - (${child.getName()}).`,
@@ -340,9 +348,9 @@ export namespace JsonStringifyProgrammer {
             // ARRAYS
             if (meta.arrays.length) {
                 for (const child of meta.arrays)
-                    if (StringifyPredicator.undefindable(child.value))
+                    if (StringifyPredicator.undefindable(child.type.value))
                         throw new Error(
-                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.value.getName()}).`,
+                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.type.value.getName()}).`,
                         );
                 const value: () => ts.Expression =
                     meta.arrays.length === 1
@@ -355,7 +363,7 @@ export namespace JsonStringifyProgrammer {
                                       from: "array",
                                   },
                               )
-                        : meta.arrays.some((elem) => elem.value.any)
+                        : meta.arrays.some((elem) => elem.type.value.any)
                         ? () =>
                               ts.factory.createCallExpression(
                                   ts.factory.createIdentifier("JSON.stringify"),
@@ -512,10 +520,12 @@ export namespace JsonStringifyProgrammer {
             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)({
@@ -524,14 +534,18 @@ export namespace JsonStringifyProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(input, array, explore);
+                : decode_array_inline(config)(importer)(
+                      input,
+                      array.type,
+                      explore,
+                  );
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArray,
+            array: MetadataArrayType,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(
@@ -547,10 +561,12 @@ export namespace JsonStringifyProgrammer {
             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)({
@@ -560,7 +576,7 @@ export namespace JsonStringifyProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -570,7 +586,7 @@ export namespace JsonStringifyProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
             const children: ts.Expression[] = tuple.elements
@@ -749,7 +765,7 @@ export namespace JsonStringifyProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
+                tags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
@@ -763,7 +779,7 @@ export namespace JsonStringifyProgrammer {
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
                     factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -779,7 +795,7 @@ export namespace JsonStringifyProgrammer {
                 ts.factory.createIdentifier(
                     importer.emplaceUnion(
                         config.prefix,
-                        elements.map((e) => e.name).join(" | "),
+                        elements.map((e) => e.type.name).join(" | "),
                         () =>
                             arrow(
                                 FeatureProgrammer.parameterDeclarations(config)(
@@ -937,11 +953,11 @@ export namespace JsonStringifyProgrammer {
                 constant: true,
                 absorb: true,
                 validate: (meta) => {
-                    if (meta.atomics.find((str) => str === "bigint"))
+                    if (meta.atomics.find((a) => a.type === "bigint"))
                         throw new Error(NO_BIGINT);
                     else if (
                         meta.arrays.some(
-                            (array) => array.value.isRequired() === false,
+                            (array) => array.type.value.isRequired() === false,
                         )
                     )
                         throw new Error(NO_UNDEFINED_IN_ARRAY);

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -8,10 +8,12 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+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";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -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"),
@@ -268,10 +270,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)({
@@ -280,14 +284,18 @@ export namespace MiscCloneProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(input, array, explore);
+                : decode_array_inline(config)(importer)(
+                      input,
+                      array.type,
+                      explore,
+                  );
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArray,
+            array: MetadataArrayType,
             explore: FeatureProgrammer.IExplore,
         ) =>
             FeatureProgrammer.decode_array(config)(importer)(CloneJoiner.array)(
@@ -307,10 +315,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 +330,7 @@ export namespace MiscCloneProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -330,7 +340,7 @@ export namespace MiscCloneProgrammer {
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            tuple: MetadataTuple,
+            tuple: MetadataTupleType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression => {
             const children: ts.Expression[] = tuple.elements
@@ -627,7 +637,7 @@ export namespace MiscCloneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
+                tags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
@@ -641,7 +651,7 @@ export namespace MiscCloneProgrammer {
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
                     factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -657,7 +667,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/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

@@ -8,10 +8,12 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+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";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -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",
@@ -156,7 +158,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 +241,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)({
@@ -251,14 +255,18 @@ export namespace MiscPruneProgrammer {
                           from: "array",
                       })(input),
                   )
-                : decode_array_inline(config)(importer)(input, array, explore);
+                : decode_array_inline(config)(importer)(
+                      input,
+                      array.type,
+                      explore,
+                  );
 
     const decode_array_inline =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
-            array: MetadataArray,
+            array: MetadataArrayType,
             explore: FeatureProgrammer.IExplore,
         ): ts.Expression =>
             FeatureProgrammer.decode_array(config)(importer)(PruneJoiner.array)(
@@ -278,10 +286,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 +301,7 @@ export namespace MiscPruneProgrammer {
                   )
                 : decode_tuple_inline(project)(config)(importer)(
                       input,
-                      tuple,
+                      tuple.type,
                       explore,
                   );
 
@@ -301,7 +311,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,7 +414,7 @@ export namespace MiscPruneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
+                tags: IMetadataCommentTag[],
                 jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
@@ -418,7 +428,7 @@ export namespace MiscPruneProgrammer {
                 (explore: FeatureProgrammer.IExplore) =>
                 (input: ts.Expression): ts.ArrowFunction =>
                     factory(parameters)(input, elements, explore, [], []);
-            if (elements.every((e) => e.recursive === false))
+            if (elements.every((e) => e.type.recursive === false))
                 ts.factory.createCallExpression(
                     arrow([])(explore)(input),
                     undefined,
@@ -434,7 +444,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 +466,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,7 @@ import { ProtobufFactory } from "../../factories/ProtobufFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
@@ -253,7 +253,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 +280,7 @@ export namespace ProtobufDecodeProgrammer {
         (
             accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
             meta: Metadata,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.CaseClause[] => {
             const clauses: ts.CaseClause[] = [];
             const emplace =
@@ -323,7 +323,7 @@ export namespace ProtobufDecodeProgrammer {
                 emplace(atomic)(decode_atomic(atomic, tags));
             if (meta.natives.length) emplace("bytes")(decode_bytes("bytes"));
             for (const array of meta.arrays)
-                emplace(`Array<${array.value.getName()}>`)(
+                emplace(`Array<${array.type.value.getName()}>`)(
                     decode_array(accessor, array, required, tags),
                 );
             for (const map of meta.maps)
@@ -350,7 +350,7 @@ export namespace ProtobufDecodeProgrammer {
 
     const decode_atomic = (
         atomic: Atomic.Literal,
-        tags: IMetadataTag[],
+        tags: IMetadataCommentTag[],
     ): ts.Expression => {
         if (atomic === "string") return decode_bytes("string");
         const method =
@@ -405,7 +405,7 @@ export namespace ProtobufDecodeProgrammer {
         accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
         array: MetadataArray,
         required: boolean,
-        tags: IMetadataTag[],
+        tags: IMetadataCommentTag[],
     ): ts.Statement[] => {
         const statements: Array<ts.Expression | ts.Statement> = [];
         if (required === false)
@@ -421,13 +421,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
+            : 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") {
@@ -566,7 +566,7 @@ export namespace ProtobufDecodeProgrammer {
             accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
             map: Metadata.Entry,
             required: boolean,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Statement[] =>
             decode_entry(project)(importer)({
                 initializer: () =>
@@ -605,7 +605,7 @@ export namespace ProtobufDecodeProgrammer {
         (
             map: Metadata.Entry,
             required: boolean,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Statement[] => {
             const statements: ts.Statement[] = [
                 ...(required