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

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -24,7 +24,9 @@ export namespace ProtobufAssertDecodeProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker)(type),
+                    `typia.Resolved<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
@@ -41,10 +43,14 @@ export namespace ProtobufAssertDecodeProgrammer {
                     ),
                     StatementFactory.constant(
                         "assert",
-                        AssertProgrammer.write(project)(modulo)(false)(
-                            type,
-                            name,
-                        ),
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
                     ),
                     StatementFactory.constant(
                         "output",
@@ -55,10 +61,13 @@ export namespace ProtobufAssertDecodeProgrammer {
                         ),
                     ),
                     ts.factory.createReturnStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("assert"),
-                            undefined,
-                            [ts.factory.createIdentifier("output")],
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("assert"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            TypeFactory.keyword("any"),
                         ),
                     ),
                 ]),

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";
@@ -26,7 +26,9 @@ export namespace ProtobufDecodeProgrammer {
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string): ts.ArrowFunction => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             const collection: MetadataCollection = new MetadataCollection();
             const meta: Metadata = ProtobufFactory.metadata(modulo.getText())(
                 project.checker,
@@ -60,7 +62,9 @@ export namespace ProtobufDecodeProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker)(type),
+                    `typia.Resolved<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock(
@@ -249,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 === ""),
@@ -276,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 =
@@ -319,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)
@@ -346,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 =
@@ -401,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)
@@ -417,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") {
@@ -562,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: () =>
@@ -601,7 +605,7 @@ export namespace ProtobufDecodeProgrammer {
         (
             map: Metadata.Entry,
             required: boolean,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Statement[] => {
             const statements: ts.Statement[] = [
                 ...(required

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -7,7 +7,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";
@@ -30,7 +30,7 @@ export namespace ProtobufEncodeProgrammer {
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string): ts.ArrowFunction => {
-            const importer = new FunctionImporter();
+            const importer = new FunctionImporter(modulo.getText());
             const collection = new MetadataCollection();
             const meta: Metadata = ProtobufFactory.metadata(modulo.getText())(
                 project.checker,
@@ -205,7 +205,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             const wrapper: (block: ts.Block) => ts.Block =
                 meta.isRequired() && meta.nullable === false
@@ -388,7 +388,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             map: Metadata.Entry,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             const each: ts.Statement[] = [
                 ts.factory.createExpressionStatement(
@@ -442,7 +442,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             object: MetadataObject,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             const top: MetadataProperty = object.properties[0]!;
             if (top.key.isSoleLiteral() === false)
@@ -502,9 +502,9 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
-            const wire = get_standalone_wire(array.value, tags);
+            const wire = get_standalone_wire(array.type.value, tags);
             const forLoop = (index: number | null) =>
                 ts.factory.createForOfStatement(
                     undefined,
@@ -515,7 +515,7 @@ export namespace ProtobufEncodeProgrammer {
                     input,
                     decode(project)(importer)(index)(
                         ts.factory.createIdentifier("elem"),
-                        array.value,
+                        array.type.value,
                         explore,
                         tags,
                     ),
@@ -568,7 +568,7 @@ export namespace ProtobufEncodeProgrammer {
         (
             input: ts.Expression,
             atomic: Atomic.Literal,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
         ): ts.Block => {
             if (atomic === "string")
                 return decode_bytes("string")(index!)(input);
@@ -593,9 +593,9 @@ export namespace ProtobufEncodeProgrammer {
                     );
             if (atomic === "boolean") return out(ProtobufWire.VARIANT)("bool");
 
-            const type: IMetadataTag.INumberType | undefined = tags.find(
+            const type: IMetadataCommentTag.INumberType | undefined = tags.find(
                 (tag) => tag.kind === "type",
-            ) as IMetadataTag.INumberType | undefined;
+            ) as IMetadataCommentTag.INumberType | undefined;
             if (atomic === "bigint")
                 return out(ProtobufWire.VARIANT)(
                     type?.value === "uint64" ? "uint64" : "int64",
@@ -641,7 +641,7 @@ export namespace ProtobufEncodeProgrammer {
 
     const get_standalone_wire = (
         meta: Metadata,
-        tags: IMetadataTag[],
+        tags: IMetadataCommentTag[],
     ): ProtobufWire => {
         if (
             meta.arrays.length ||
@@ -655,9 +655,9 @@ export namespace ProtobufEncodeProgrammer {
         if (v === "string") return ProtobufWire.LEN;
         else if (v === "boolean" || v === "bigint") return ProtobufWire.VARIANT;
 
-        const type: IMetadataTag.INumberType | undefined = tags.find(
+        const type: IMetadataCommentTag.INumberType | undefined = tags.find(
             (t) => t.kind === "type",
-        ) as IMetadataTag.INumberType | undefined;
+        ) as IMetadataCommentTag.INumberType | undefined;
         if (type === undefined) return ProtobufWire.I64;
         else if (type.value === "float") return ProtobufWire.I32;
         return ProtobufWire.VARIANT;
@@ -675,7 +675,7 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             indexes?: Map<MetadataObject, number>,
         ): ts.Block => {
             if (targets.length === 1)

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -25,7 +25,10 @@ export namespace ProtobufIsDecodeProgrammer {
                 ],
                 ts.factory.createUnionTypeNode([
                     ts.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(project.checker)(type),
+                        `typia.Resolved<${
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
+                        }>`,
                     ),
                     ts.factory.createLiteralTypeNode(ts.factory.createNull()),
                 ]),
@@ -33,7 +36,14 @@ export namespace ProtobufIsDecodeProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.write(project)(modulo)(false)(type, name),
+                        IsProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
                     ),
                     StatementFactory.constant(
                         "decode",

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { MetadataCollection } from "../../factories/MetadataCollection";
 import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
@@ -104,14 +104,14 @@ export namespace ProtobufMessageProgrammer {
     ----------------------------------------------------------- */
     const decode =
         (ptr: IPointer<number>) =>
-        (tags: IMetadataTag[]) =>
+        (tags: IMetadataCommentTag[]) =>
         (meta: Metadata): string => {
             const elements: Set<string> = new Set();
             if (meta.natives.length) elements.add("bytes");
             for (const atomic of ProtobufUtil.getAtomics(meta))
                 elements.add(decode_atomic(tags)(atomic));
             for (const array of meta.arrays)
-                elements.add(`repeated ${decode(ptr)(tags)(array.value)}`);
+                elements.add(`repeated ${decode(ptr)(tags)(array.type.value)}`);
             for (const obj of meta.objects)
                 elements.add(
                     is_dynamic_object(obj)
@@ -135,7 +135,7 @@ export namespace ProtobufMessageProgrammer {
         };
 
     const decode_atomic =
-        (tags: IMetadataTag[]) =>
+        (tags: IMetadataCommentTag[]) =>
         (literal: Atomic.Literal): string => {
             if (literal === "boolean") return "bool";
             else if (literal === "bigint")
@@ -146,7 +146,7 @@ export namespace ProtobufMessageProgrammer {
                     : "int64";
             else if (literal === "number") {
                 const type = tags.find((t) => t.kind === "type") as
-                    | IMetadataTag.INumberType
+                    | IMetadataCommentTag.INumberType
                     | undefined;
                 if (type?.value === undefined) return "double";
                 else if (type.value === "int") return "int32";
@@ -158,7 +158,7 @@ export namespace ProtobufMessageProgrammer {
 
     const decode_map =
         (ptr: IPointer<number>) =>
-        (tags: IMetadataTag[]) =>
+        (tags: IMetadataCommentTag[]) =>
         (prop: Metadata.Entry): string =>
             `map<${decode(ptr)([])(prop.key)}, ${decode(ptr)(tags)(
                 prop.value,

package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -24,9 +24,9 @@ export namespace ProtobufValidateDecodeProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<${
+                    `typia.IValidation<typia.Resolved<${
                         name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
+                    }>>`,
                 ),
                 undefined,
                 ts.factory.createBlock([