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

package/src/programmers/RandomProgrammer.ts

@@ -9,11 +9,13 @@ import { TemplateFactory } from "../factories/TemplateFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 
 import { ICommentTag } from "../schemas/metadata/ICommentTag";
-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";
 
@@ -27,15 +29,27 @@ export namespace RandomProgrammer {
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (init?: ts.Expression) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             return (type: ts.Type, name?: string) => {
                 // INITIALIZE METADATA
                 const collection: MetadataCollection = new MetadataCollection();
                 const meta: Metadata = MetadataFactory.analyze(project.checker)(
                     {
-                        resolve: true,
+                        escape: false,
                         constant: true,
                         absorb: true,
+                        validate: (meta) => {
+                            if (meta.natives.some((n) => n === "WeakSet"))
+                                throw new Error(
+                                    `Error on ${modulo.getText()}(): WeakSet is not supported.`,
+                                );
+                            else if (meta.natives.some((n) => n === "WeakMap"))
+                                throw new Error(
+                                    `Error on ${modulo.getText()}(): WeakMap is not supported.`,
+                                );
+                        },
                     },
                 )(collection)(type);
 
@@ -67,7 +81,7 @@ export namespace RandomProgrammer {
                         ),
                     ],
                     ts.factory.createTypeReferenceNode(
-                        `typia.Primitive<${
+                        `typia.Resolved<${
                             name ??
                             TypeFactory.getFullName(project.checker)(type)
                         }>`,
@@ -213,7 +227,7 @@ export namespace RandomProgrammer {
         (explore: IExplore) =>
         (
             meta: Metadata,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ): ts.Expression => {
             const expressions: ts.Expression[] = [];
@@ -223,7 +237,7 @@ export namespace RandomProgrammer {
                 );
 
             // NULL COALESCING
-            if (meta.isRequired() === false)
+            if (meta.isRequired() === false || meta.functional === true)
                 expressions.push(ts.factory.createIdentifier("undefined"));
             if (meta.nullable === true)
                 expressions.push(ts.factory.createNull());
@@ -236,21 +250,21 @@ export namespace RandomProgrammer {
             // ATOMIC VARIABLES
             for (const template of meta.templates)
                 expressions.push(decode_template(importer)(explore)(template));
-            for (const atomic of meta.atomics)
-                if (atomic === "boolean")
+            for (const a of meta.atomics)
+                if (a.type === "boolean")
                     expressions.push(decode_boolean(importer));
-                else if (atomic === "number")
-                    expressions.push(decode_number(importer)(tags)(comments));
-                else if (atomic === "string")
-                    expressions.push(decode_string(importer)(tags)(comments));
-                else if (atomic === "bigint")
-                    expressions.push(decode_bigint(importer)(tags)(comments));
+                else if (a.type === "number")
+                    expressions.push(decode_number(importer)(tags, comments));
+                else if (a.type === "string")
+                    expressions.push(decode_string(importer)(tags, comments));
+                else if (a.type === "bigint")
+                    expressions.push(decode_bigint(importer)(tags, comments));
 
             // INSTANCE TYPES
-            if (meta.resolved)
+            if (meta.escaped)
                 expressions.push(
                     decode(importer)(explore)(
-                        meta.resolved.returns,
+                        meta.escaped.returns,
                         tags,
                         comments,
                     ),
@@ -266,17 +280,19 @@ export namespace RandomProgrammer {
             for (const o of meta.objects)
                 expressions.push(decode_object(importer)(explore)(o));
             for (const native of meta.natives)
-                if (native === "Boolean")
-                    expressions.push(decode_boolean(importer));
-                else if (native === "Number")
-                    expressions.push(decode_number(importer)(tags)(comments));
-                else if (native === "String")
-                    expressions.push(decode_string(importer)(tags)(comments));
-                else expressions.push(ts.factory.createIdentifier("{}"));
-            if (meta.sets.length || meta.maps.length)
-                expressions.push(ts.factory.createIdentifier("{}"));
-
-            // PRIMITIVE TYPES
+                expressions.push(
+                    decode_native(importer)(native, tags, comments),
+                );
+            for (const set of meta.sets)
+                expressions.push(
+                    decode_set(importer)(explore)(set, tags, comments),
+                );
+            for (const map of meta.maps)
+                expressions.push(
+                    decode_map(importer)(explore)(map, tags, comments),
+                );
+
+            // PICK UP A TYPE
             if (expressions.length === 1) return expressions[0]!;
             return ts.factory.createCallExpression(
                 ts.factory.createCallExpression(
@@ -329,8 +345,10 @@ export namespace RandomProgrammer {
 
     const decode_number =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[]) =>
-        (comments: ICommentTag[]): ts.Expression => {
+        (
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ): ts.Expression => {
             const type = tags.find(
                 (t) =>
                     t.kind === "type" &&
@@ -378,8 +396,7 @@ export namespace RandomProgrammer {
 
     const decode_bigint =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[]) =>
-        (comments: ICommentTag[]): ts.Expression =>
+        (tags: IMetadataCommentTag[], comments: ICommentTag[]): ts.Expression =>
             random_custom(COALESCE(importer))("bigint")(comments)(
                 RandomRanger.number({
                     type: tags.find(
@@ -407,8 +424,7 @@ export namespace RandomProgrammer {
 
     const decode_string =
         (importer: FunctionImporter) =>
-        (tags: IMetadataTag[]) =>
-        (comments: ICommentTag[]): ts.Expression =>
+        (tags: IMetadataCommentTag[], comments: ICommentTag[]): ts.Expression =>
             random_custom(COALESCE(importer))("string")(comments)(
                 (() => {
                     for (const t of tags)
@@ -447,7 +463,7 @@ export namespace RandomProgrammer {
         (explore: IExplore) =>
         (
             array: MetadataArray,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ) => {
             const length: ts.Expression | undefined = RandomRanger.length(
@@ -461,10 +477,10 @@ export namespace RandomProgrammer {
                 minimum: "minItems",
                 maximum: "maxItems",
             })(tags);
-            if (array.recursive)
+            if (array.type.recursive)
                 return ts.factory.createCallExpression(
                     ts.factory.createIdentifier(
-                        importer.useLocal(PREFIX.array(array.index!)),
+                        importer.useLocal(PREFIX.array(array.type.index!)),
                     ),
                     undefined,
                     [
@@ -480,7 +496,7 @@ export namespace RandomProgrammer {
                 );
             const expr: ts.Expression = RandomJoiner.array(COALESCE(importer))(
                 decode(importer)(explore),
-            )(explore)(length)(array.value, tags, comments);
+            )(explore)(length)(array.type.value, tags, comments);
             return explore.recursive
                 ? ts.factory.createConditionalExpression(
                       ts.factory.createLogicalAnd(
@@ -503,13 +519,13 @@ export namespace RandomProgrammer {
         (explore: IExplore) =>
         (
             tuple: MetadataTuple,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ): ts.Expression =>
-            tuple.recursive
+            tuple.type.recursive
                 ? ts.factory.createCallExpression(
                       ts.factory.createIdentifier(
-                          importer.useLocal(PREFIX.tuple(tuple.index!)),
+                          importer.useLocal(PREFIX.tuple(tuple.type.index!)),
                       ),
                       undefined,
                       [
@@ -523,7 +539,7 @@ export namespace RandomProgrammer {
                       ],
                   )
                 : RandomJoiner.tuple(decode(importer)(explore))(
-                      tuple.elements,
+                      tuple.type.elements,
                       tags,
                       comments,
                   );
@@ -555,6 +571,308 @@ export namespace RandomProgrammer {
                       ]
                     : undefined,
             );
+
+    /* -----------------------------------------------------------
+        NATIVE CLASSES
+    ----------------------------------------------------------- */
+    const decode_set =
+        (importer: FunctionImporter) =>
+        (explore: IExplore) =>
+        (
+            meta: Metadata,
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ) =>
+            ts.factory.createNewExpression(
+                ts.factory.createIdentifier("Set"),
+                undefined,
+                [
+                    decode_array(importer)(explore)(
+                        MetadataArray.create({
+                            tags: [],
+                            type: MetadataArrayType.create({
+                                value: meta,
+                                recursive: false,
+                                index: null,
+                                nullables: [],
+                                name: `Set<${meta.getName()}>`,
+                            }),
+                        }),
+                        tags,
+                        comments,
+                    ),
+                ],
+            );
+
+    const decode_map =
+        (importer: FunctionImporter) =>
+        (explore: IExplore) =>
+        (
+            m: Metadata.Entry,
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ) =>
+            ts.factory.createNewExpression(
+                ts.factory.createIdentifier("Map"),
+                undefined,
+                [
+                    decode_array(importer)(explore)(
+                        MetadataArray.create({
+                            tags: [],
+                            type: MetadataArrayType.create({
+                                name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+                                index: null,
+                                recursive: false,
+                                nullables: [],
+                                value: Metadata.create({
+                                    ...Metadata.initialize(),
+                                    tuples: [
+                                        (() => {
+                                            const type =
+                                                MetadataTupleType.create({
+                                                    name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                                                    index: null,
+                                                    recursive: false,
+                                                    nullables: [],
+                                                    elements: [m.key, m.value],
+                                                });
+                                            type.of_map = true;
+                                            return MetadataTuple.create({
+                                                type,
+                                                tags: [],
+                                            });
+                                        })(),
+                                    ],
+                                }),
+                            }),
+                        }),
+                        tags,
+                        comments,
+                    ),
+                ],
+            );
+
+    const decode_native =
+        (importer: FunctionImporter) =>
+        (
+            type: string,
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ): ts.Expression => {
+            if (type === "Boolean") return decode_boolean(importer);
+            else if (type === "Number")
+                return decode_number(importer)(tags, comments);
+            else if (type === "String")
+                return decode_string(importer)(tags, comments);
+            else if (type === "Date") return decode_native_date(importer);
+            else if (
+                type === "Uint8Array" ||
+                type === "Uint8ClampedArray" ||
+                type === "Uint16Array" ||
+                type === "Uint32Array" ||
+                type === "BigUint64Array" ||
+                type === "Int8Array" ||
+                type === "Int16Array" ||
+                type === "Int32Array" ||
+                type === "BigInt64Array" ||
+                type === "Float32Array" ||
+                type === "Float64Array"
+            )
+                return decode_native_byte_array(importer)(type);
+            else if (type === "ArrayBuffer" || type === "SharedArrayBuffer")
+                return decode_native_array_buffer(importer)(type);
+            else if (type === "DataView")
+                return decode_native_data_view(importer);
+            else
+                return ts.factory.createNewExpression(
+                    ts.factory.createIdentifier(type),
+                    undefined,
+                    [],
+                );
+        };
+
+    const decode_native_date = (importer: FunctionImporter) =>
+        ts.factory.createNewExpression(
+            ts.factory.createIdentifier("Date"),
+            undefined,
+            [
+                ts.factory.createCallExpression(
+                    COALESCE(importer)("datetime"),
+                    undefined,
+                    [],
+                ),
+            ],
+        );
+
+    const decode_native_byte_array =
+        (importer: FunctionImporter) =>
+        (
+            type:
+                | "Uint8Array"
+                | "Uint8ClampedArray"
+                | "Uint16Array"
+                | "Uint32Array"
+                | "BigUint64Array"
+                | "Int8Array"
+                | "Int16Array"
+                | "Int32Array"
+                | "BigInt64Array"
+                | "Float32Array"
+                | "Float64Array",
+        ): ts.Expression => {
+            new BigInt64Array();
+            const [minimum, maximum]: [number, number] = (() => {
+                if (type === "Uint8Array" || type === "Uint8ClampedArray")
+                    return [0, 255];
+                else if (type === "Uint16Array") return [0, 65535];
+                else if (type === "Uint32Array") return [0, 4294967295];
+                else if (type === "BigUint64Array")
+                    return [0, 18446744073709551615];
+                else if (type === "Int8Array") return [-128, 127];
+                else if (type === "Int16Array") return [-32768, 32767];
+                else if (type === "Int32Array")
+                    return [-2147483648, 2147483647];
+                else if (type === "BigInt64Array")
+                    return [-9223372036854775808, 9223372036854775807];
+                else if (type === "Float32Array")
+                    return [-1.175494351e38, 3.4028235e38];
+                return [Number.MIN_VALUE, Number.MAX_VALUE];
+            })();
+            const literal =
+                type === "BigInt64Array" || type === "BigUint64Array"
+                    ? ExpressionFactory.bigint
+                    : ts.factory.createNumericLiteral;
+            return ts.factory.createNewExpression(
+                ts.factory.createIdentifier(type),
+                [],
+                [
+                    ts.factory.createCallExpression(
+                        COALESCE(importer)("array"),
+                        undefined,
+                        [
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [],
+                                TypeFactory.keyword("any"),
+                                undefined,
+                                ts.factory.createCallExpression(
+                                    COALESCE(importer)(
+                                        type === "Float32Array" ||
+                                            type === "Float64Array"
+                                            ? "number"
+                                            : type === "BigInt64Array" ||
+                                              type === "BigUint64Array"
+                                            ? "bigint"
+                                            : "integer",
+                                    ),
+                                    undefined,
+                                    [literal(minimum), literal(maximum)],
+                                ),
+                            ),
+                        ],
+                    ),
+                ],
+            );
+        };
+
+    const decode_native_array_buffer =
+        (importer: FunctionImporter) =>
+        (type: "ArrayBuffer" | "SharedArrayBuffer"): ts.Expression =>
+            type === "ArrayBuffer"
+                ? IdentifierFactory.access(
+                      decode_native_byte_array(importer)("Uint8Array"),
+                  )("buffer")
+                : ExpressionFactory.selfCall(
+                      ts.factory.createBlock(
+                          [
+                              StatementFactory.constant(
+                                  "length",
+                                  ts.factory.createCallExpression(
+                                      COALESCE(importer)("integer"),
+                                      undefined,
+                                      [],
+                                  ),
+                              ),
+                              StatementFactory.constant(
+                                  "buffer",
+                                  ts.factory.createNewExpression(
+                                      ts.factory.createIdentifier(
+                                          "SharedArrayBuffer",
+                                      ),
+                                      [],
+                                      [ts.factory.createIdentifier("length")],
+                                  ),
+                              ),
+                              StatementFactory.constant(
+                                  "bytes",
+                                  ts.factory.createNewExpression(
+                                      ts.factory.createIdentifier("Uint8Array"),
+                                      [],
+                                      [ts.factory.createIdentifier("buffer")],
+                                  ),
+                              ),
+                              ts.factory.createExpressionStatement(
+                                  ts.factory.createCallExpression(
+                                      IdentifierFactory.access(
+                                          ts.factory.createIdentifier("bytes"),
+                                      )("set"),
+                                      undefined,
+                                      [
+                                          ts.factory.createCallExpression(
+                                              COALESCE(importer)("array"),
+                                              undefined,
+                                              [
+                                                  ts.factory.createArrowFunction(
+                                                      undefined,
+                                                      undefined,
+                                                      [],
+                                                      TypeFactory.keyword(
+                                                          "any",
+                                                      ),
+                                                      undefined,
+                                                      ts.factory.createCallExpression(
+                                                          COALESCE(importer)(
+                                                              "integer",
+                                                          ),
+                                                          undefined,
+                                                          [
+                                                              ts.factory.createNumericLiteral(
+                                                                  0,
+                                                              ),
+                                                              ts.factory.createNumericLiteral(
+                                                                  255,
+                                                              ),
+                                                          ],
+                                                      ),
+                                                  ),
+                                                  ts.factory.createIdentifier(
+                                                      "length",
+                                                  ),
+                                              ],
+                                          ),
+                                          ts.factory.createNumericLiteral(0),
+                                      ],
+                                  ),
+                              ),
+                              ts.factory.createReturnStatement(
+                                  ts.factory.createIdentifier("buffer"),
+                              ),
+                          ],
+                          true,
+                      ),
+                  );
+
+    const decode_native_data_view = (importer: FunctionImporter) =>
+        ts.factory.createNewExpression(
+            ts.factory.createIdentifier("DataView"),
+            [],
+            [
+                IdentifierFactory.access(
+                    decode_native_byte_array(importer)("Uint8Array"),
+                )("buffer"),
+            ],
+        );
 }
 
 type Atomic = boolean | number | string | bigint;
@@ -568,6 +886,7 @@ const PREFIX = {
     array: (i: number) => `$ra${i}`,
     tuple: (i: number) => `$rt${i}`,
 };
+
 const COALESCE = (importer: FunctionImporter) => (name: string) =>
     ExpressionFactory.coalesce(
         ts.factory.createPropertyAccessChain(

package/src/programmers/ValidateProgrammer.ts

@@ -19,7 +19,9 @@ export namespace ValidateProgrammer {
         (modulo: ts.LeftHandSideExpression) =>
         (equals: boolean) =>
         (type: ts.Type, name?: string) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
 
             const is = IsProgrammer.write(project)(modulo, true)(equals)(
                 type,
@@ -34,7 +36,7 @@ export namespace ValidateProgrammer {
                     equals,
                     atomist: (explore) => (tuple) => (input) =>
                         [
-                            tuple.expression,
+                            ...(tuple.expression ? [tuple.expression] : []),
                             ...tuple.tags.map((tag) =>
                                 ts.factory.createLogicalOr(
                                     tag.expression,

package/src/programmers/helpers/AtomicPredicator.ts

@@ -8,7 +8,7 @@ export namespace AtomicPredicator {
     export const constant =
         (meta: Metadata) =>
         (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name) &&
+            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
             !ArrayUtil.has(
                 meta.natives,
                 (native) => native.toLowerCase() === name,
@@ -25,7 +25,7 @@ export namespace AtomicPredicator {
     export const native = (name: string) => LIKE.has(name.toLowerCase());
 
     export const template = (meta: Metadata): boolean =>
-        !ArrayUtil.has(meta.atomics, (type) => type === "string");
+        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
 }
 
 const LIKE = new Set(["boolean", "number", "string"]);

package/src/programmers/helpers/FunctionImporeter.ts

@@ -11,6 +11,8 @@ export class FunctionImporter {
         new Map();
     private sequence_: number = 0;
 
+    public constructor(public readonly method: string) {}
+
     public empty(): boolean {
         return this.used_.size === 0;
     }

package/src/programmers/helpers/ICheckEntry.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 export interface ICheckEntry {
-    expression: ts.Expression;
+    expression: ts.Expression | null;
     tags: ICheckEntry.ITag[];
 }
 export namespace ICheckEntry {

package/src/programmers/helpers/ProtobufUtil.ts

@@ -7,7 +7,7 @@ export namespace ProtobufUtil {
     export const getAtomics = (meta: Metadata) => {
         const set: Set<Atomic.Literal> = new Set();
 
-        for (const atomic of meta.atomics) set.add(atomic);
+        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");
 

package/src/programmers/helpers/RandomJoiner.ts

@@ -4,7 +4,7 @@ import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
 import { ICommentTag } from "../../schemas/metadata/ICommentTag";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
@@ -16,7 +16,7 @@ import { get_comment_tags } from "../internal/get_comment_tags";
 export namespace RandomJoiner {
     export type Decoder = (
         meta: Metadata,
-        tags: IMetadataTag[],
+        tags: IMetadataCommentTag[],
         comments: ICommentTag[],
     ) => ts.Expression;
 
@@ -27,7 +27,7 @@ export namespace RandomJoiner {
         (length: ts.Expression | undefined) =>
         (
             item: Metadata,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             comments: ICommentTag[],
         ): ts.Expression => {
             const generator: ts.Expression = ts.factory.createCallExpression(
@@ -60,7 +60,11 @@ export namespace RandomJoiner {
 
     export const tuple =
         (decoder: Decoder) =>
-        (items: Metadata[], tags: IMetadataTag[], comments: ICommentTag[]) =>
+        (
+            items: Metadata[],
+            tags: IMetadataCommentTag[],
+            comments: ICommentTag[],
+        ) =>
             ts.factory.createArrayLiteralExpression(
                 items.map((i) => decoder(i.rest ?? i, tags, comments)),
                 true,