typia 5.0.0-dev.2023084 → 5.0.0

package/src/programmers/helpers/AtomicPredicator.ts

@@ -1,31 +1,31 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace AtomicPredicator {
-    export const constant =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const atomic =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const native = (name: string) => LIKE.has(name.toLowerCase());
-
-    export const template = (meta: Metadata): boolean =>
-        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
-}
-
-const LIKE = new Set(["boolean", "number", "string"]);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace AtomicPredicator {
+    export const constant =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const atomic =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const native = (name: string) => LIKE.has(name.toLowerCase());
+
+    export const template = (meta: Metadata): boolean =>
+        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
+}
+
+const LIKE = new Set(["boolean", "number", "string"]);

package/src/programmers/helpers/CloneJoiner.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -34,30 +35,66 @@ export namespace CloneJoiner {
         const key = ts.factory.createIdentifier("key");
         const output = ts.factory.createIdentifier("output");
 
-        const statements: ts.Statement[] = dynamic.map((entry) =>
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                        `RegExp(/${metadata_to_pattern(true)(
-                            entry.key,
-                        )}/).test`,
+        const statements: ts.Statement[] = [];
+        if (regular.length !== 0)
+            statements.push(
+                ts.factory.createIfStatement(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                            ts.factory.createArrayLiteralExpression(
+                                regular.map((r) =>
+                                    ts.factory.createStringLiteral(
+                                        r.key.getSoleLiteral()!,
+                                    ),
+                                ),
+                            ),
+                        )("some"),
+                        undefined,
+                        [
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [IdentifierFactory.parameter("regular")],
+                                undefined,
+                                undefined,
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createIdentifier("regular"),
+                                    ts.factory.createIdentifier("key"),
+                                ),
+                            ),
+                        ],
                     ),
-                    undefined,
-                    [key],
+                    ts.factory.createContinueStatement(),
                 ),
-                ts.factory.createBlock([
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createBinaryExpression(
-                            ts.factory.createElementAccessExpression(
-                                output,
-                                key,
-                            ),
-                            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                            entry.expression,
+            );
+        statements.push(
+            ...dynamic.map((entry) =>
+                ts.factory.createIfStatement(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier(
+                            `RegExp(/${metadata_to_pattern(true)(
+                                entry.key,
+                            )}/).test`,
                         ),
+                        undefined,
+                        [key],
                     ),
-                    ts.factory.createContinueStatement(),
-                ]),
+                    ts.factory.createBlock([
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createBinaryExpression(
+                                ts.factory.createElementAccessExpression(
+                                    output,
+                                    key,
+                                ),
+                                ts.factory.createToken(
+                                    ts.SyntaxKind.EqualsToken,
+                                ),
+                                entry.expression,
+                            ),
+                        ),
+                        ts.factory.createContinueStatement(),
+                    ]),
+                ),
             ),
         );
 

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,91 +1,91 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-export class FunctionImporter {
-    private readonly used_: Set<string> = new Set();
-    private readonly local_: Set<string> = new Set();
-    private readonly unions_: Map<string, [string, ts.ArrowFunction]> =
-        new Map();
-    private sequence_: number = 0;
-
-    public constructor(public readonly method: string) {}
-
-    public empty(): boolean {
-        return this.used_.size === 0;
-    }
-
-    public use(name: string): ts.Identifier {
-        this.used_.add(name);
-        return ts.factory.createIdentifier("$" + name);
-    }
-
-    public useLocal(name: string): string {
-        this.local_.add(name);
-        return name;
-    }
-
-    public hasLocal(name: string): boolean {
-        return this.local_.has(name);
-    }
-
-    public declare(
-        modulo: ts.LeftHandSideExpression,
-        includeUnions: boolean = true,
-    ): ts.Statement[] {
-        return [
-            ...[...this.used_].map((name) =>
-                StatementFactory.constant(
-                    "$" + name,
-                    IdentifierFactory.access(
-                        ts.factory.createParenthesizedExpression(
-                            ts.factory.createAsExpression(
-                                modulo,
-                                TypeFactory.keyword("any"),
-                            ),
-                        ),
-                    )(name),
-                ),
-            ),
-            ...(includeUnions === true
-                ? [...this.unions_.values()].map(([key, arrow]) =>
-                      StatementFactory.constant(key, arrow),
-                  )
-                : []),
-        ];
-    }
-
-    public declareUnions(): ts.Statement[] {
-        return [...this.unions_.values()].map(([key, arrow]) =>
-            StatementFactory.constant(key, arrow),
-        );
-    }
-
-    public increment(): number {
-        return ++this.sequence_;
-    }
-
-    public emplaceUnion(
-        prefix: string,
-        name: string,
-        factory: () => ts.ArrowFunction,
-    ): string {
-        const oldbie = this.unions_.get(name);
-        if (oldbie) return oldbie[0];
-
-        const index: number = this.unions_.size;
-        const accessor: string = `${prefix}p${index}`;
-
-        const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
-        this.unions_.set(name, tuple);
-        tuple[1] = factory();
-        return accessor;
-    }
-
-    public trace(): void {
-        console.log(...this.used_);
-        console.log(...this.local_);
-    }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+export class FunctionImporter {
+    private readonly used_: Set<string> = new Set();
+    private readonly local_: Set<string> = new Set();
+    private readonly unions_: Map<string, [string, ts.ArrowFunction]> =
+        new Map();
+    private sequence_: number = 0;
+
+    public constructor(public readonly method: string) {}
+
+    public empty(): boolean {
+        return this.used_.size === 0;
+    }
+
+    public use(name: string): ts.Identifier {
+        this.used_.add(name);
+        return ts.factory.createIdentifier("$" + name);
+    }
+
+    public useLocal(name: string): string {
+        this.local_.add(name);
+        return name;
+    }
+
+    public hasLocal(name: string): boolean {
+        return this.local_.has(name);
+    }
+
+    public declare(
+        modulo: ts.LeftHandSideExpression,
+        includeUnions: boolean = true,
+    ): ts.Statement[] {
+        return [
+            ...[...this.used_].map((name) =>
+                StatementFactory.constant(
+                    "$" + name,
+                    IdentifierFactory.access(
+                        ts.factory.createParenthesizedExpression(
+                            ts.factory.createAsExpression(
+                                modulo,
+                                TypeFactory.keyword("any"),
+                            ),
+                        ),
+                    )(name),
+                ),
+            ),
+            ...(includeUnions === true
+                ? [...this.unions_.values()].map(([key, arrow]) =>
+                      StatementFactory.constant(key, arrow),
+                  )
+                : []),
+        ];
+    }
+
+    public declareUnions(): ts.Statement[] {
+        return [...this.unions_.values()].map(([key, arrow]) =>
+            StatementFactory.constant(key, arrow),
+        );
+    }
+
+    public increment(): number {
+        return ++this.sequence_;
+    }
+
+    public emplaceUnion(
+        prefix: string,
+        name: string,
+        factory: () => ts.ArrowFunction,
+    ): string {
+        const oldbie = this.unions_.get(name);
+        if (oldbie) return oldbie[0];
+
+        const index: number = this.unions_.size;
+        const accessor: string = `${prefix}p${index}`;
+
+        const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
+        this.unions_.set(name, tuple);
+        tuple[1] = factory();
+        return accessor;
+    }
+
+    public trace(): void {
+        console.log(...this.used_);
+        console.log(...this.local_);
+    }
+}

package/src/programmers/helpers/ICheckEntry.ts

@@ -1,11 +1,12 @@
 import ts from "typescript";
 
 export interface ICheckEntry {
-    expression: ts.Expression;
-    tags: ICheckEntry.ITag[];
+    expected: string;
+    expression: ts.Expression | null;
+    conditions: ICheckEntry.ICondition[][];
 }
 export namespace ICheckEntry {
-    export interface ITag {
+    export interface ICondition {
         expected: string;
         expression: ts.Expression;
     }

package/src/programmers/helpers/ProtobufUtil.ts

@@ -1,29 +1,125 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { Atomic } from "../../typings/Atomic";
-
-export namespace ProtobufUtil {
-    export const getAtomics = (meta: Metadata) => {
-        const set: Set<Atomic.Literal> = new Set();
-
-        for (const a of meta.atomics) set.add(a.type);
-        for (const constant of meta.constants) set.add(constant.type);
-        if (meta.templates.length) set.add("string");
-
-        return [...set].sort(
-            (x, y) => ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!,
-        );
-    };
-
-    export const isStaticObject = (obj: MetadataObject): boolean =>
-        obj.properties.length >= 1 &&
-        obj.properties.every((p) => p.key.isSoleLiteral());
-}
-
-const ATOMIC_ORDER = new Map<Atomic.Literal, number>([
-    ["boolean", 0],
-    ["bigint", 1],
-    ["number", 2],
-    ["string", 3],
-]);
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
+
+export namespace ProtobufUtil {
+    export const isStaticObject = (obj: MetadataObject): boolean =>
+        obj.properties.length >= 1 &&
+        obj.properties.every((p) => p.key.isSoleLiteral());
+
+    export const size = (meta: Metadata): number =>
+        getAtomics(meta).length +
+        meta.arrays.length +
+        meta.tuples.length +
+        meta.natives.length +
+        meta.objects.length +
+        meta.maps.length;
+
+    export const isUnion = (meta: Metadata): boolean => size(meta) > 1;
+
+    export const getAtomics = (meta: Metadata): ProtobufAtomic[] => {
+        const set: Set<ProtobufAtomic> = new Set();
+        if (meta.templates.length) set.add("string");
+        for (const c of meta.constants)
+            if (c.type === "boolean") set.add("bool");
+            else if (c.type === "bigint") set.add("uint64");
+            else if (c.type === "number")
+                set.add(deduce_numeric_type(c.values));
+            else if (c.type === "string") set.add("string");
+        for (const atomic of meta.atomics)
+            if (atomic.type === "boolean") set.add("bool");
+            else if (atomic.type === "bigint")
+                decode_bigint(atomic.tags).forEach((t) => set.add(t));
+            else if (atomic.type === "number")
+                decode_number(atomic.tags).forEach((t) => set.add(t));
+            else if (atomic.type === "string") set.add("string");
+
+        return [...set].sort(compare);
+    };
+
+    export const getNumbers = (meta: Metadata) => {
+        const set: Set<ProtobufAtomic.Numeric> = new Set();
+        for (const c of meta.constants)
+            if (c.type === "number") set.add(deduce_numeric_type(c.values));
+        for (const atomic of meta.atomics)
+            if (atomic.type === "number")
+                decode_number(atomic.tags).forEach((t) => set.add(t));
+        return [...set].sort(compare);
+    };
+
+    export const getBigints = (meta: Metadata) => {
+        const set: Set<ProtobufAtomic.BigNumeric> = new Set();
+        for (const c of meta.constants)
+            if (c.type === "bigint") set.add("uint64");
+        for (const atomic of meta.atomics)
+            if (atomic.type === "bigint")
+                decode_bigint(atomic.tags).forEach((t) => set.add(t));
+        return [...set].sort(compare);
+    };
+
+    const compare = (x: ProtobufAtomic, y: ProtobufAtomic): number =>
+        ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!;
+}
+
+const ATOMIC_ORDER = new Map<ProtobufAtomic, number>(
+    (
+        [
+            "bool",
+            "int32",
+            "uint32",
+            "int64",
+            "uint64",
+            "float",
+            "double",
+            "string",
+        ] as const
+    ).map((str, i) => [str, i]),
+);
+
+const deduce_numeric_type = (values: number[]): ProtobufAtomic.Numeric =>
+    values.every((v) => Math.floor(v) === v)
+        ? values.every((v) => -2147483648 <= v && v <= 2147483647)
+            ? "int32"
+            : "int64"
+        : "double";
+
+const decode_bigint = (
+    typeTags: IMetadataTypeTag[][],
+): ProtobufAtomic.BigNumeric[] => {
+    if (typeTags.length === 0) return ["int64"];
+
+    const types: Set<ProtobufAtomic.BigNumeric> = new Set();
+    for (const row of typeTags) {
+        const value: ProtobufAtomic.BigNumeric | undefined = row.find(
+            (tag) =>
+                tag.kind === "type" &&
+                (tag.value === "int64" || tag.value === "uint64"),
+        )?.value;
+        types.add(value ?? "int64");
+    }
+    return [...types];
+};
+
+const decode_number = (
+    typeTags: IMetadataTypeTag[][],
+): ProtobufAtomic.Numeric[] => {
+    if (typeTags.length === 0) return ["double"];
+
+    const types: Set<ProtobufAtomic.Numeric> = new Set();
+    for (const row of typeTags) {
+        const value: ProtobufAtomic.Numeric | undefined = row.find(
+            (tag) =>
+                tag.kind === "type" &&
+                (tag.value === "int32" ||
+                    tag.value === "uint32" ||
+                    tag.value === "int64" ||
+                    tag.value === "uint64" ||
+                    tag.value === "float" ||
+                    tag.value === "double"),
+        )?.value;
+        types.add(value ?? "double");
+    }
+    return [...types];
+};

package/src/programmers/helpers/RandomJoiner.ts

@@ -3,33 +3,21 @@ import ts from "typescript";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { ICommentTag } from "../../schemas/metadata/ICommentTag";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
 import { Escaper } from "../../utils/Escaper";
 
-import { get_comment_tags } from "../internal/get_comment_tags";
-
 export namespace RandomJoiner {
-    export type Decoder = (
-        meta: Metadata,
-        tags: IMetadataTag[],
-        comments: ICommentTag[],
-    ) => ts.Expression;
+    export type Decoder = (meta: Metadata) => ts.Expression;
 
     export const array =
         (coalesce: (method: string) => ts.Expression) =>
         (decoder: Decoder) =>
         (explore: IExplore) =>
         (length: ts.Expression | undefined) =>
-        (
-            item: Metadata,
-            tags: IMetadataTag[],
-            comments: ICommentTag[],
-        ): ts.Expression => {
+        (item: Metadata): ts.Expression => {
             const generator: ts.Expression = ts.factory.createCallExpression(
                 coalesce("array"),
                 undefined,
@@ -40,7 +28,7 @@ export namespace RandomJoiner {
                         [],
                         undefined,
                         undefined,
-                        decoder(item, tags, comments),
+                        decoder(item),
                     ),
                     ...(length ? [length] : []),
                 ],
@@ -58,13 +46,11 @@ export namespace RandomJoiner {
             );
         };
 
-    export const tuple =
-        (decoder: Decoder) =>
-        (items: Metadata[], tags: IMetadataTag[], comments: ICommentTag[]) =>
-            ts.factory.createArrayLiteralExpression(
-                items.map((i) => decoder(i.rest ?? i, tags, comments)),
-                true,
-            );
+    export const tuple = (decoder: Decoder) => (elements: Metadata[]) =>
+        ts.factory.createArrayLiteralExpression(
+            elements.map((elem) => decoder(elem.rest ?? elem)),
+            true,
+        );
 
     export const object =
         (coalesce: (method: string) => ts.Expression) =>
@@ -88,11 +74,7 @@ export namespace RandomJoiner {
                             Escaper.variable(str)
                                 ? str
                                 : ts.factory.createStringLiteral(str),
-                            decoder(
-                                p.value,
-                                p.tags,
-                                get_comment_tags(false)(p.jsDocTags),
-                            ),
+                            decoder(p.value),
                         );
                     }),
                     true,
@@ -146,14 +128,10 @@ export namespace RandomJoiner {
                     ts.factory.createBinaryExpression(
                         ts.factory.createElementAccessExpression(
                             ts.factory.createIdentifier("output"),
-                            decoder(p.key, [], []),
+                            decoder(p.key),
                         ),
                         ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                        decoder(
-                            p.value,
-                            p.tags,
-                            get_comment_tags(false)(p.jsDocTags),
-                        ),
+                        decoder(p.value),
                     ),
                 ),
                 ts.factory.createCallExpression(