typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

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

@@ -7,6 +7,7 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { Atomic } from "../../typings/Atomic";
 
@@ -14,7 +15,7 @@ import { ArrayUtil } from "../../utils/ArrayUtil";
 
 export namespace MiscLiteralsProgrammer {
     export const write = (project: IProject) => (type: ts.Type) => {
-        const meta: Metadata = MetadataFactory.analyze(project.checker)({
+        const result = MetadataFactory.analyze(project.checker)({
             escape: true,
             constant: true,
             absorb: true,
@@ -24,11 +25,15 @@ export namespace MiscLiteralsProgrammer {
                         .map((c) => c.values.length)
                         .reduce((a, b) => a + b, 0) +
                     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);
+                if (0 === length) return [ErrorMessages.NO];
+                else if (meta.size() !== length) return [ErrorMessages.ONLY];
+                return [];
             },
         })(new MetadataCollection())(type);
+        if (result.success === false)
+            throw TransformerError.from(`typia.misc.literals`)(result.errors);
+
+        const meta: Metadata = result.data;
         const values: Set<Atomic.Type | null> = new Set([
             ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
             ...(meta.atomics.filter((a) => a.type === "boolean").length
@@ -59,6 +64,6 @@ export namespace MiscLiteralsProgrammer {
 }
 
 enum ErrorMessages {
-    NO = "Error on typia.literals(): no literal type found.",
-    ONLY = "Error on typia.literals(): only literal type allowed.",
+    NO = "no constant literal type found.",
+    ONLY = "only constant literal types are allowed.",
 }

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -7,15 +7,13 @@ 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";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -49,7 +47,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 +60,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 +147,6 @@ export namespace MiscPruneProgrammer {
                                 return partial;
                             })(),
                             explore,
-                            [],
-                            [],
                         ),
                     value: () =>
                         decode_tuple(project)(config)(importer)(
@@ -255,26 +254,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 +407,6 @@ export namespace MiscPruneProgrammer {
                 input: ts.Expression,
                 elements: T[],
                 explore: FeatureProgrammer.IExplore,
-                tags: IMetadataCommentTag[],
-                jsDocTags: IJsDocTagInfo[],
             ) => ts.ArrowFunction,
         ) =>
         (
@@ -427,7 +418,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),
@@ -516,14 +507,19 @@ export namespace MiscPruneProgrammer {
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
+        (importer) =>
         (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const result = MetadataFactory.analyze(checker)({
                 escape: false,
                 constant: true,
                 absorb: true,
             })(collection)(type);
-            return [collection, meta];
+            if (result.success === false)
+                throw TransformerError.from(`typia.misc.${importer.method}`)(
+                    result.errors,
+                );
+            return [collection, result.data];
         };
 
     const create_throw_error =

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: [],
                     }),
                 ]),