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

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -3,11 +3,11 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { MetadataCollection } from "../../factories/MetadataCollection";
+import { NumericRangeFactory } from "../../factories/NumericRangeFactory";
 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";
@@ -15,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 { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -128,7 +128,6 @@ export namespace ProtobufEncodeProgrammer {
                     tracable: false,
                     postfix: "",
                 },
-                [],
             );
             return ts.factory.createArrowFunction(
                 undefined,
@@ -170,9 +169,8 @@ export namespace ProtobufEncodeProgrammer {
                         ),
                         p.value,
                         explore,
-                        p.tags,
                     );
-                    index += p.value.binarySize();
+                    index += ProtobufUtil.size(p.value);
                     return [
                         ts.factory.createExpressionStatement(
                             ts.factory.createIdentifier(
@@ -205,7 +203,6 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             meta: Metadata,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
         ): ts.Block => {
             const wrapper: (block: ts.Block) => ts.Block =
                 meta.isRequired() && meta.nullable === false
@@ -263,18 +260,47 @@ export namespace ProtobufEncodeProgrammer {
                           );
 
             // STARTS FROM ATOMIC TYPES
-            const unions: IUnion[] = ProtobufUtil.getAtomics(meta).map(
-                (type) => ({
-                    type,
-                    wire: () => null!,
-                    is: () =>
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral(type),
-                            ts.factory.createTypeOfExpression(input),
-                        ),
-                    value: (index) => decode_atomic(index!)(input, type, tags),
-                }),
-            );
+            const unions: IUnion[] = [];
+            const numbers = ProtobufUtil.getNumbers(meta);
+            const bigints = ProtobufUtil.getBigints(meta);
+
+            for (const atom of ProtobufUtil.getAtomics(meta))
+                if (atom === "bool")
+                    unions.push({
+                        type: "bool",
+                        is: () =>
+                            ts.factory.createStrictEquality(
+                                ts.factory.createStringLiteral("boolean"),
+                                ts.factory.createTypeOfExpression(input),
+                            ),
+                        value: (index) => decode_bool(index)(input),
+                    });
+                else if (
+                    atom === "int32" ||
+                    atom === "uint32" ||
+                    atom === "float" ||
+                    atom === "double"
+                )
+                    unions.push(decode_number(project)(numbers)(atom)(input));
+                else if (atom === "int64" || atom === "uint64")
+                    if (numbers.some((n) => n === atom))
+                        unions.push(
+                            decode_number(project)(numbers)(atom)(input),
+                        );
+                    else
+                        unions.push(
+                            decode_bigint(project)(bigints)(atom)(input),
+                        );
+                else if (atom === "string")
+                    unions.push({
+                        type: "string",
+                        is: () =>
+                            ts.factory.createStrictEquality(
+                                ts.factory.createStringLiteral("string"),
+                                ts.factory.createTypeOfExpression(input),
+                            ),
+                        value: (index) => decode_bytes("string")(index!)(input),
+                    });
 
             // CONSIDER BYTES
             if (meta.natives.length)
@@ -298,7 +324,6 @@ export namespace ProtobufEncodeProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            tags,
                         ),
                 });
 
@@ -315,7 +340,6 @@ export namespace ProtobufEncodeProgrammer {
                                 ...explore,
                                 from: "array",
                             },
-                            tags,
                         ),
                 });
 
@@ -336,7 +360,6 @@ export namespace ProtobufEncodeProgrammer {
                                 ...explore,
                                 from: "object",
                             },
-                            tags,
                         ),
                 });
 
@@ -388,7 +411,6 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             map: Metadata.Entry,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
         ): ts.Block => {
             const each: ts.Statement[] = [
                 ts.factory.createExpressionStatement(
@@ -405,13 +427,11 @@ export namespace ProtobufEncodeProgrammer {
                     ts.factory.createIdentifier("key"),
                     map.key,
                     explore,
-                    [],
                 ).statements,
                 ...decode(project)(importer)(2)(
                     ts.factory.createIdentifier("value"),
                     map.value,
                     explore,
-                    tags,
                 ).statements,
                 ts.factory.createExpressionStatement(
                     ts.factory.createCallExpression(
@@ -442,7 +462,6 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             object: MetadataObject,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
         ): ts.Block => {
             const top: MetadataProperty = object.properties[0]!;
             if (top.key.isSoleLiteral() === false)
@@ -454,7 +473,6 @@ export namespace ProtobufEncodeProgrammer {
                     ),
                     top,
                     explore,
-                    tags,
                 );
             return ts.factory.createBlock(
                 [
@@ -502,9 +520,8 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             array: MetadataArray,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
         ): ts.Block => {
-            const wire = get_standalone_wire(array.value, tags);
+            const wire = get_standalone_wire(array.type.value);
             const forLoop = (index: number | null) =>
                 ts.factory.createForOfStatement(
                     undefined,
@@ -515,9 +532,8 @@ export namespace ProtobufEncodeProgrammer {
                     input,
                     decode(project)(importer)(index)(
                         ts.factory.createIdentifier("elem"),
-                        array.value,
+                        array.type.value,
                         explore,
-                        tags,
                     ),
                 );
             const length = (block: ts.Block) =>
@@ -563,56 +579,94 @@ export namespace ProtobufEncodeProgrammer {
             );
         };
 
-    const decode_atomic =
-        (index: number | null) =>
-        (
-            input: ts.Expression,
-            atomic: Atomic.Literal,
-            tags: IMetadataTag[],
-        ): ts.Block => {
-            if (atomic === "string")
-                return decode_bytes("string")(index!)(input);
-
-            const out =
-                (wire: ProtobufWire) =>
-                (method: string): ts.Block =>
-                    ts.factory.createBlock(
-                        [
-                            ...(index !== null
-                                ? [decode_tag(wire)(index)]
-                                : []),
-                            ts.factory.createCallExpression(
-                                IdentifierFactory.access(WRITER())(method),
-                                undefined,
-                                [input],
-                            ),
-                        ].map((exp) =>
-                            ts.factory.createExpressionStatement(exp),
+    const decode_bool = (index: number | null) => (input: ts.Expression) =>
+        ts.factory.createBlock(
+            [
+                ...(index !== null
+                    ? [decode_tag(ProtobufWire.VARIANT)(index)]
+                    : []),
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(WRITER())("bool"),
+                    undefined,
+                    [input],
+                ),
+            ].map((exp) => ts.factory.createExpressionStatement(exp)),
+            true,
+        );
+
+    const decode_number =
+        (project: IProject) =>
+        (candidates: ProtobufAtomic.Numeric[]) =>
+        (type: ProtobufAtomic.Numeric) =>
+        (input: ts.Expression): IUnion => ({
+            type,
+            is: () =>
+                candidates.length === 1
+                    ? ts.factory.createStrictEquality(
+                          ts.factory.createStringLiteral("number"),
+                          ts.factory.createTypeOfExpression(input),
+                      )
+                    : ts.factory.createLogicalAnd(
+                          ts.factory.createStrictEquality(
+                              ts.factory.createStringLiteral("number"),
+                              ts.factory.createTypeOfExpression(input),
+                          ),
+                          NumericRangeFactory.number(project.context)(type)(
+                              input,
+                          ),
+                      ),
+            value: (index) =>
+                ts.factory.createBlock(
+                    [
+                        ...(index !== null
+                            ? [decode_tag(get_numeric_wire(type))(index)]
+                            : []),
+                        ts.factory.createCallExpression(
+                            IdentifierFactory.access(WRITER())(type),
+                            undefined,
+                            [input],
                         ),
-                        true,
-                    );
-            if (atomic === "boolean") return out(ProtobufWire.VARIANT)("bool");
-
-            const type: IMetadataTag.INumberType | undefined = tags.find(
-                (tag) => tag.kind === "type",
-            ) as IMetadataTag.INumberType | undefined;
-            if (atomic === "bigint")
-                return out(ProtobufWire.VARIANT)(
-                    type?.value === "uint64" ? "uint64" : "int64",
-                );
-            else if (type === undefined) return out(ProtobufWire.I64)("double");
-            else if (type.value === "float")
-                return out(ProtobufWire.I32)("float");
-            return out(ProtobufWire.VARIANT)(
-                type.value === "uint32" || type.value === "uint"
-                    ? "uint32"
-                    : type.value === "int32" || type.value === "int"
-                    ? "int32"
-                    : type.value === "int64"
-                    ? "int64"
-                    : "uint64",
-            );
-        };
+                    ].map((exp) => ts.factory.createExpressionStatement(exp)),
+                    true,
+                ),
+        });
+
+    const decode_bigint =
+        (project: IProject) =>
+        (candidates: ProtobufAtomic.BigNumeric[]) =>
+        (type: ProtobufAtomic.BigNumeric) =>
+        (input: ts.Expression): IUnion => ({
+            type,
+            is: () =>
+                candidates.length === 1
+                    ? ts.factory.createStrictEquality(
+                          ts.factory.createStringLiteral("bigint"),
+                          ts.factory.createTypeOfExpression(input),
+                      )
+                    : ts.factory.createLogicalAnd(
+                          ts.factory.createStrictEquality(
+                              ts.factory.createStringLiteral("bigint"),
+                              ts.factory.createTypeOfExpression(input),
+                          ),
+                          NumericRangeFactory.bigint(project.context)(type)(
+                              input,
+                          ),
+                      ),
+            value: (index) =>
+                ts.factory.createBlock(
+                    [
+                        ...(index !== null
+                            ? [decode_tag(ProtobufWire.VARIANT)(index)]
+                            : []),
+                        ts.factory.createCallExpression(
+                            IdentifierFactory.access(WRITER())(type),
+                            undefined,
+                            [input],
+                        ),
+                    ].map((exp) => ts.factory.createExpressionStatement(exp)),
+                    true,
+                ),
+        });
 
     const decode_bytes =
         (method: "bytes" | "string") =>
@@ -639,10 +693,7 @@ export namespace ProtobufEncodeProgrammer {
                 [ts.factory.createNumericLiteral((index << 3) | wire)],
             );
 
-    const get_standalone_wire = (
-        meta: Metadata,
-        tags: IMetadataTag[],
-    ): ProtobufWire => {
+    const get_standalone_wire = (meta: Metadata): ProtobufWire => {
         if (
             meta.arrays.length ||
             meta.objects.length ||
@@ -653,16 +704,25 @@ export namespace ProtobufEncodeProgrammer {
 
         const v = ProtobufUtil.getAtomics(meta)[0]!;
         if (v === "string") return ProtobufWire.LEN;
-        else if (v === "boolean" || v === "bigint") return ProtobufWire.VARIANT;
-
-        const type: IMetadataTag.INumberType | undefined = tags.find(
-            (t) => t.kind === "type",
-        ) as IMetadataTag.INumberType | undefined;
-        if (type === undefined) return ProtobufWire.I64;
-        else if (type.value === "float") return ProtobufWire.I32;
-        return ProtobufWire.VARIANT;
+        else if (
+            v === "bool" ||
+            v === "int32" ||
+            v === "uint32" ||
+            v === "int64" ||
+            v === "uint64"
+        )
+            return ProtobufWire.VARIANT;
+        else if (v === "float") return ProtobufWire.I32;
+        return ProtobufWire.I64;
     };
 
+    const get_numeric_wire = (type: ProtobufAtomic.Numeric) =>
+        type === "double"
+            ? ProtobufWire.I64
+            : type === "float"
+            ? ProtobufWire.I32
+            : ProtobufWire.VARIANT;
+
     /* -----------------------------------------------------------
         EXPLORERS
     ----------------------------------------------------------- */
@@ -675,13 +735,12 @@ export namespace ProtobufEncodeProgrammer {
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
             indexes?: Map<MetadataObject, number>,
         ): ts.Block => {
             if (targets.length === 1)
                 return decode_object(project)(importer)(
                     indexes ? indexes.get(targets[0]!)! : index,
-                )(input, targets[0]!, explore, tags);
+                )(input, targets[0]!, explore);
 
             const expected: string = `(${targets
                 .map((t) => t.name)
@@ -700,7 +759,6 @@ export namespace ProtobufEncodeProgrammer {
                             i,
                             o,
                             e,
-                            tags,
                         ),
                     ),
                 )((expr) => expr)((value, expected) =>
@@ -728,8 +786,6 @@ export namespace ProtobufEncodeProgrammer {
                                   tracable: false,
                                   postfix: IdentifierFactory.postfix(key),
                               },
-                              tags,
-                              [],
                           )
                         : ExpressionFactory.isRequired(accessor);
                     return ts.factory.createIfStatement(
@@ -738,7 +794,7 @@ export namespace ProtobufEncodeProgrammer {
                             ExpressionFactory.selfCall(
                                 decode_object(project)(importer)(
                                     indexes!.get(spec.object)!,
-                                )(input, spec.object, explore, tags),
+                                )(input, spec.object, explore),
                             ),
                         ),
                         i === array.length - 1
@@ -751,8 +807,7 @@ export namespace ProtobufEncodeProgrammer {
                                               input,
                                               remained,
                                               explore,
-                                              tags,
-                                              indexes,
+                                              indexes!,
                                           ),
                                       ),
                                   )

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -3,14 +3,11 @@ import ts from "typescript";
 import { MetadataCollection } from "../../factories/MetadataCollection";
 import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
 import { IProject } from "../../transformers/IProject";
 
-import { Atomic } from "../../typings/Atomic";
-
 import { MapUtil } from "../../utils/MapUtil";
 import { NameEncoder } from "../../utils/NameEncoder";
 
@@ -85,7 +82,7 @@ export namespace ProtobufMessageProgrammer {
         return obj.properties
             .map((prop) => {
                 const key: string = prop.key.getSoleLiteral()!;
-                const type: string = decode(ptr)(prop.tags)(prop.value);
+                const type: string = decode(ptr)(prop.value);
                 return type.indexOf("${name}") !== -1
                     ? type.replace("${name}", key)
                     : `${
@@ -104,22 +101,20 @@ export namespace ProtobufMessageProgrammer {
     ----------------------------------------------------------- */
     const decode =
         (ptr: IPointer<number>) =>
-        (tags: IMetadataTag[]) =>
         (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));
+                elements.add(atomic);
             for (const array of meta.arrays)
-                elements.add(`repeated ${decode(ptr)(tags)(array.value)}`);
+                elements.add(`repeated ${decode(ptr)(array.type.value)}`);
             for (const obj of meta.objects)
                 elements.add(
                     is_dynamic_object(obj)
-                        ? decode_map(ptr)(tags)(obj.properties[0]!)
+                        ? decode_map(ptr)(obj.properties[0]!)
                         : NameEncoder.encode(obj.name),
                 );
-            for (const map of meta.maps)
-                elements.add(decode_map(ptr)(tags)(map));
+            for (const map of meta.maps) elements.add(decode_map(ptr)(map));
             return elements.size === 1
                 ? [...elements][0]!
                 : [
@@ -134,35 +129,10 @@ export namespace ProtobufMessageProgrammer {
                   ].join("\n");
         };
 
-    const decode_atomic =
-        (tags: IMetadataTag[]) =>
-        (literal: Atomic.Literal): string => {
-            if (literal === "boolean") return "bool";
-            else if (literal === "bigint")
-                return tags.find(
-                    (t) => t.kind === "type" && t.value === "uint64",
-                )
-                    ? "uint64"
-                    : "int64";
-            else if (literal === "number") {
-                const type = tags.find((t) => t.kind === "type") as
-                    | IMetadataTag.INumberType
-                    | undefined;
-                if (type?.value === undefined) return "double";
-                else if (type.value === "int") return "int32";
-                else if (type.value === "uint") return "uint32";
-                else return type.value;
-            }
-            return literal;
-        };
-
     const decode_map =
         (ptr: IPointer<number>) =>
-        (tags: IMetadataTag[]) =>
         (prop: Metadata.Entry): string =>
-            `map<${decode(ptr)([])(prop.key)}, ${decode(ptr)(tags)(
-                prop.value,
-            )}>`;
+            `map<${decode(ptr)(prop.key)}, ${decode(ptr)(prop.value)}>`;
 }
 
 interface Hierarchy {

package/src/schemas/json/IJsonSchema.ts

@@ -1,8 +1,9 @@
 import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../metadata/IMetadataTag";
 
 import { Atomic } from "../../typings/Atomic";
 
+import { Type } from "../../tags/Type";
+
 export type IJsonSchema = IJsonSchema.Known | IJsonSchema.IUnknown;
 export namespace IJsonSchema {
     export type Known =
@@ -36,14 +37,8 @@ export namespace IJsonSchema {
         default?: Atomic.Mapper[Literal];
     }
     export interface IString extends IAtomic<"string"> {
-        /**
-         * @type uint
-         */
-        minLength?: number;
-        /**
-         * @type uint
-         */
-        maxLength?: number;
+        minLength?: number & Type<"uint32">;
+        maxLength?: number & Type<"uint32">;
         pattern?: string;
         format?: string;
     }
@@ -55,20 +50,11 @@ export namespace IJsonSchema {
         multipleOf?: number;
     }
     export interface IInteger extends IAtomic<"integer"> {
-        /**
-         * @type int
-         */
-        minimum?: number;
-        /**
-         * @type int
-         */
-        maximum?: number;
+        minimum?: number & Type<"int32">;
+        maximum?: number & Type<"int32">;
         exclusiveMinimum?: boolean;
         exclusiveMaximum?: boolean;
-        /**
-         * @type int
-         */
-        multipleOf?: number;
+        multipleOf?: number & Type<"int32">;
     }
     export interface IBoolean extends IAtomic<"boolean"> {}
 
@@ -77,26 +63,14 @@ export namespace IJsonSchema {
     ----------------------------------------------------------- */
     export interface IArray extends ISignificant<"array"> {
         items: IJsonSchema;
-        /**
-         * @type uint
-         */
-        minItems?: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
+        minItems?: number & Type<"uint32">;
+        maxItems?: number & Type<"uint32">;
         "x-typia-tuple"?: ITuple;
     }
     export interface ITuple extends ISignificant<"array"> {
         items: IJsonSchema[];
-        /**
-         * @type uint
-         */
-        minItems: number;
-        /**
-         * @type uint
-         */
-        maxItems?: number;
+        minItems: number & Type<"uint32">;
+        maxItems?: number & Type<"uint32">;
     }
     export interface IReference extends IAttribute {
         $ref: string;
@@ -124,7 +98,6 @@ export namespace IJsonSchema {
         deprecated?: boolean;
         title?: string;
         description?: string;
-        "x-typia-metaTags"?: IMetadataTag[];
         "x-typia-jsDocTags"?: IJsDocTagInfo[];
         "x-typia-required"?: boolean;
         "x-typia-optional"?: boolean;

package/src/schemas/metadata/IMetadata.ts

@@ -1,8 +1,8 @@
-import { Atomic } from "../../typings/Atomic";
-
+import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataConstant } from "./IMetadataConstant";
 import { IMetadataEntry } from "./IMetadataEntry";
 import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadata {
     any: boolean;
@@ -11,14 +11,20 @@ export interface IMetadata {
     nullable: boolean;
     functional: boolean;
 
-    atomics: Atomic.Literal[];
+    atomics: IMetadataAtomic[];
     constants: IMetadataConstant[];
     templates: IMetadata[][];
     escaped: IMetadataEscaped | null;
 
     rest: IMetadata | null;
-    arrays: string[];
-    tuples: string[];
+    arrays: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
+    tuples: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
     objects: string[];
     aliases: string[];
 

package/src/schemas/metadata/IMetadataAlias.ts

@@ -1,6 +1,5 @@
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
 
 export interface IMetadataAlias {
     name: string;
@@ -8,7 +7,6 @@ export interface IMetadataAlias {
     nullables: boolean[];
 
     description: string | null;
-    tags: IMetadataTag[];
     jsDocTags: IJsDocTagInfo[];
     recursive: boolean;
 }

package/src/schemas/metadata/IMetadataArray.ts

@@ -1,10 +1,7 @@
-import { IMetadata } from "./IMetadata";
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataArray {
-    name: string;
-    value: IMetadata;
-
-    nullables: boolean[];
-    recursive: boolean;
-    index: number | null;
+    type: IMetadataArrayType;
+    tags: IMetadataTypeTag[][];
 }