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

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -42,7 +42,9 @@ export namespace JsonStringifyProgrammer {
 
     export const write =
         (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             const config: FeatureProgrammer.IConfig =
                 configure(project)(importer);
 
@@ -186,14 +188,14 @@ export namespace JsonStringifyProgrammer {
             const unions: IUnion[] = [];
 
             // toJSON() METHOD
-            if (meta.resolved !== null)
+            if (meta.escaped !== null)
                 unions.push({
                     type: "resolved",
                     is: () => IsProgrammer.decode_to_json(false)(input),
                     value: () =>
                         decode_to_json(project)(config)(importer)(
                             input,
-                            meta.resolved!.returns,
+                            meta.escaped!.returns,
                             explore,
                         ),
                 });
@@ -931,7 +933,7 @@ export namespace JsonStringifyProgrammer {
         (type) => {
             const collection: MetadataCollection = new MetadataCollection();
             const meta: Metadata = MetadataFactory.analyze(checker)({
-                resolve: true,
+                escape: true,
                 constant: true,
                 absorb: true,
                 validate: (meta) => {

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -24,7 +24,7 @@ export namespace MiscAssertCloneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
+                    `typia.Resolved<${
                         name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -26,7 +26,9 @@ import { wrap_metadata_rest_tuple } from "../internal/wrap_metadata_rest_tuple";
 export namespace MiscCloneProgrammer {
     export const write =
         (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             return FeatureProgrammer.write(project)({
                 ...configure(project)(importer),
                 addition: (collection) => [
@@ -137,19 +139,6 @@ export namespace MiscCloneProgrammer {
             //----
             // LIST UP UNION TYPES
             //----
-            // toJSON() METHOD
-            if (meta.resolved !== null)
-                unions.push({
-                    type: "resolved",
-                    is: () => IsProgrammer.decode_to_json(true)(input),
-                    value: () =>
-                        decode_to_json(project)(config)(importer)(
-                            input,
-                            meta.resolved!.returns,
-                            explore,
-                        ),
-                });
-
             // TUPLES
             for (const tuple of meta.tuples)
                 unions.push({
@@ -195,13 +184,26 @@ export namespace MiscCloneProgrammer {
                 unions.push({
                     type: "set",
                     is: () => ExpressionFactory.isInstanceOf("Set")(input),
-                    value: () => ts.factory.createIdentifier("{}"),
+                    value: () =>
+                        explore_sets(project)(config)(importer)(
+                            input,
+                            meta.sets,
+                            { ...explore, from: "array" },
+                        ),
                 });
             if (meta.maps.length)
                 unions.push({
                     type: "map",
                     is: () => ExpressionFactory.isInstanceOf("Map")(input),
-                    value: () => ts.factory.createIdentifier("{}"),
+                    value: () =>
+                        explore_maps(project)(config)(importer)(
+                            input,
+                            meta.maps,
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                        ),
                 });
             for (const native of meta.natives)
                 unions.push({
@@ -216,7 +218,7 @@ export namespace MiscCloneProgrammer {
                                   undefined,
                                   undefined,
                               )
-                            : ts.factory.createIdentifier("{}"),
+                            : decode_native(native)(input),
                 });
 
             // OBJECTS
@@ -251,26 +253,6 @@ export namespace MiscCloneProgrammer {
             );
         };
 
-    const decode_to_json =
-        (project: IProject) =>
-        (config: FeatureProgrammer.IConfig) =>
-        (importer: FunctionImporter) =>
-        (
-            input: ts.Expression,
-            resolved: Metadata,
-            explore: FeatureProgrammer.IExplore,
-        ): ts.Expression => {
-            return decode(project)(config)(importer)(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(input)("toJSON"),
-                    undefined,
-                    [],
-                ),
-                resolved,
-                explore,
-            );
-        };
-
     const decode_object = (importer: FunctionImporter) =>
         FeatureProgrammer.decode_object({
             trace: false,
@@ -393,9 +375,204 @@ export namespace MiscCloneProgrammer {
             return CloneJoiner.tuple(children, rest);
         };
 
+    /* -----------------------------------------------------------
+        NATIVE CLASSES
+    ----------------------------------------------------------- */
+    const decode_native = (type: string) => (input: ts.Expression) =>
+        type === "Date" ||
+        type === "Uint8Array" ||
+        type === "Uint8ClampedArray" ||
+        type === "Uint16Array" ||
+        type === "Uint32Array" ||
+        type === "BigUint64Array" ||
+        type === "Int8Array" ||
+        type === "Int16Array" ||
+        type === "Int32Array" ||
+        type === "BigInt64Array" ||
+        type === "Float32Array" ||
+        type === "Float64Array"
+            ? decode_native_copyable(type)(input)
+            : type === "ArrayBuffer" || type === "SharedArrayBuffer"
+            ? decode_native_buffer(type)(input)
+            : type === "DataView"
+            ? decode_native_data_view(input)
+            : ts.factory.createCallExpression(
+                  ts.factory.createIdentifier(type),
+                  undefined,
+                  [],
+              );
+
+    const decode_native_copyable = (type: string) => (input: ts.Expression) =>
+        ts.factory.createNewExpression(
+            ts.factory.createIdentifier(type),
+            undefined,
+            [input],
+        );
+
+    const decode_native_buffer =
+        (type: "ArrayBuffer" | "SharedArrayBuffer") => (input: ts.Expression) =>
+            ExpressionFactory.selfCall(
+                ts.factory.createBlock(
+                    [
+                        StatementFactory.constant(
+                            "buffer",
+                            ts.factory.createNewExpression(
+                                ts.factory.createIdentifier(type),
+                                undefined,
+                                [IdentifierFactory.access(input)("byteLength")],
+                            ),
+                        ),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(
+                                    ts.factory.createNewExpression(
+                                        ts.factory.createIdentifier(
+                                            "Uint8Array",
+                                        ),
+                                        undefined,
+                                        [ts.factory.createIdentifier("buffer")],
+                                    ),
+                                )("set"),
+                                undefined,
+                                [
+                                    ts.factory.createNewExpression(
+                                        ts.factory.createIdentifier(
+                                            "Uint8Array",
+                                        ),
+                                        undefined,
+                                        [input],
+                                    ),
+                                ],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createIdentifier("buffer"),
+                        ),
+                    ],
+                    true,
+                ),
+            );
+
+    const decode_native_data_view = (input: ts.Expression) =>
+        ts.factory.createNewExpression(
+            ts.factory.createIdentifier("DataView"),
+            undefined,
+            [IdentifierFactory.access(input)("buffer")],
+        );
+
     /* -----------------------------------------------------------
         EXPLORERS FOR UNION TYPES
     ----------------------------------------------------------- */
+    const explore_sets =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            sets: Metadata[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            ts.factory.createCallExpression(
+                UnionExplorer.set({
+                    checker: IsProgrammer.decode(project)(importer),
+                    decoder: (input, array, explore) =>
+                        ts.factory.createNewExpression(
+                            ts.factory.createIdentifier("Set"),
+                            [TypeFactory.keyword("any")],
+                            [
+                                decode_array(config)(importer)(
+                                    input,
+                                    array,
+                                    explore,
+                                ),
+                            ],
+                        ),
+                    empty: ts.factory.createNewExpression(
+                        ts.factory.createIdentifier("Set"),
+                        [TypeFactory.keyword("any")],
+                        [],
+                    ),
+                    success: ts.factory.createTrue(),
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                })([])(input, sets, explore, [], []),
+                undefined,
+                undefined,
+            );
+
+    const explore_maps =
+        (project: IProject) =>
+        (config: FeatureProgrammer.IConfig) =>
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            maps: Metadata.Entry[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression =>
+            ts.factory.createCallExpression(
+                UnionExplorer.map({
+                    checker: (top, entry, explore) => {
+                        const func = IsProgrammer.decode(project)(importer);
+                        return ts.factory.createLogicalAnd(
+                            func(
+                                ts.factory.createElementAccessExpression(
+                                    top,
+                                    0,
+                                ),
+                                entry[0],
+                                {
+                                    ...explore,
+                                    postfix: `${explore.postfix}[0]`,
+                                },
+                                [],
+                                [],
+                            ),
+                            func(
+                                ts.factory.createElementAccessExpression(
+                                    top,
+                                    1,
+                                ),
+                                entry[1],
+                                {
+                                    ...explore,
+                                    postfix: `${explore.postfix}[1]`,
+                                },
+                                [],
+                                [],
+                            ),
+                        );
+                    },
+                    decoder: (input, array, explore) =>
+                        ts.factory.createNewExpression(
+                            ts.factory.createIdentifier("Map"),
+                            [
+                                TypeFactory.keyword("any"),
+                                TypeFactory.keyword("any"),
+                            ],
+                            [
+                                decode_array(config)(importer)(
+                                    input,
+                                    array,
+                                    explore,
+                                ),
+                            ],
+                        ),
+                    empty: ts.factory.createNewExpression(
+                        ts.factory.createIdentifier("Map"),
+                        [
+                            TypeFactory.keyword("any"),
+                            TypeFactory.keyword("any"),
+                        ],
+                        [],
+                    ),
+                    success: ts.factory.createTrue(),
+                    failure: (input, expected) =>
+                        create_throw_error(importer)(expected)(input),
+                })([])(input, maps, explore, [], []),
+                undefined,
+                undefined,
+            );
+
     const explore_objects =
         (config: FeatureProgrammer.IConfig) =>
         (importer: FunctionImporter) =>
@@ -514,7 +691,7 @@ export namespace MiscCloneProgrammer {
                         ),
                     output: (type, name) =>
                         ts.factory.createTypeReferenceNode(
-                            `typia.Primitive<${
+                            `typia.Resolved<${
                                 name ??
                                 TypeFactory.getFullName(project.checker)(type)
                             }>`,
@@ -523,7 +700,7 @@ export namespace MiscCloneProgrammer {
                 prefix: PREFIX,
                 trace: false,
                 path: false,
-                initializer,
+                initializer: initializer(importer.method),
                 decoder: () => decode(project)(config)(importer),
                 objector: {
                     checker: () => IsProgrammer.decode(project)(importer),
@@ -547,14 +724,25 @@ export namespace MiscCloneProgrammer {
             return config;
         };
 
-    const initializer: FeatureProgrammer.IConfig["initializer"] =
+    const initializer =
+        (method: string): FeatureProgrammer.IConfig["initializer"] =>
         ({ checker }) =>
         (type) => {
             const collection = new MetadataCollection();
             const meta = MetadataFactory.analyze(checker)({
-                resolve: true,
+                escape: false,
                 constant: true,
                 absorb: true,
+                validate: (meta) => {
+                    if (meta.natives.some((n) => n === "WeakSet"))
+                        throw new Error(
+                            `Error on ${method}(): WeakSet is not supported.`,
+                        );
+                    else if (meta.natives.some((n) => n === "WeakMap"))
+                        throw new Error(
+                            `Error on ${method}(): WeakMap is not supported.`,
+                        );
+                },
             })(collection)(type);
             return [collection, meta];
         };

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -25,7 +25,7 @@ export namespace MiscIsCloneProgrammer {
                 ],
                 ts.factory.createUnionTypeNode([
                     ts.factory.createTypeReferenceNode(
-                        `typia.Primitive<${
+                        `typia.Resolved<${
                             name ??
                             TypeFactory.getFullName(project.checker)(type)
                         }>`,

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -15,7 +15,7 @@ import { ArrayUtil } from "../../utils/ArrayUtil";
 export namespace MiscLiteralsProgrammer {
     export const write = (project: IProject) => (type: ts.Type) => {
         const meta: Metadata = MetadataFactory.analyze(project.checker)({
-            resolve: true,
+            escape: true,
             constant: true,
             absorb: true,
             validate: (meta) => {

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -26,7 +26,9 @@ import { wrap_metadata_rest_tuple } from "../internal/wrap_metadata_rest_tuple";
 export namespace MiscPruneProgrammer {
     export const write =
         (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter = new FunctionImporter(
+                modulo.getText(),
+            );
             return FeatureProgrammer.write(project)({
                 ...configure(project)(importer),
                 addition: (collection) => [
@@ -507,7 +509,7 @@ export namespace MiscPruneProgrammer {
         (type) => {
             const collection = new MetadataCollection();
             const meta = MetadataFactory.analyze(checker)({
-                resolve: false,
+                escape: false,
                 constant: true,
                 absorb: true,
             })(collection)(type);

package/src/programmers/misc/MiscValidateCloneProgrammer.ts

@@ -24,7 +24,7 @@ export namespace MiscValidateCloneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Primitive<${
+                    `typia.IValidation<typia.Resolved<${
                         name ?? TypeFactory.getFullName(project.checker)(type)
                     }>>`,
                 ),

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

@@ -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(
@@ -279,35 +283,51 @@ export namespace ProtobufDecodeProgrammer {
             tags: IMetadataTag[],
         ): ts.CaseClause[] => {
             const clauses: ts.CaseClause[] = [];
-            const emplace = (v: ts.Expression | ts.Statement[]) =>
-                clauses.push(
-                    ts.factory.createCaseClause(
-                        ts.factory.createNumericLiteral(index++),
-                        Array.isArray(v)
-                            ? [...v, ts.factory.createBreakStatement()]
-                            : [
-                                  ts.factory.createExpressionStatement(
-                                      ts.factory.createBinaryExpression(
-                                          accessor,
-                                          ts.factory.createToken(
-                                              ts.SyntaxKind.EqualsToken,
+            const emplace =
+                (name: string) => (v: ts.Expression | ts.Statement[]) =>
+                    clauses.push(
+                        ts.factory.createCaseClause(
+                            ts.factory.createNumericLiteral(index++),
+                            Array.isArray(v)
+                                ? [
+                                      ts.factory.createExpressionStatement(
+                                          ts.factory.createIdentifier(
+                                              `// type: ${name}`,
                                           ),
-                                          v,
                                       ),
-                                  ),
-                                  ts.factory.createBreakStatement(),
-                              ],
-                    ),
-                );
+                                      ...v,
+                                      ts.factory.createBreakStatement(),
+                                  ]
+                                : [
+                                      ts.factory.createExpressionStatement(
+                                          ts.factory.createIdentifier(
+                                              `// ${name}`,
+                                          ),
+                                      ),
+                                      ts.factory.createExpressionStatement(
+                                          ts.factory.createBinaryExpression(
+                                              accessor,
+                                              ts.factory.createToken(
+                                                  ts.SyntaxKind.EqualsToken,
+                                              ),
+                                              v,
+                                          ),
+                                      ),
+                                      ts.factory.createBreakStatement(),
+                                  ],
+                        ),
+                    );
 
             const required: boolean = meta.isRequired() && !meta.nullable;
             for (const atomic of ProtobufUtil.getAtomics(meta))
-                emplace(decode_atomic(atomic, tags));
-            if (meta.natives.length) emplace(decode_bytes("bytes"));
+                emplace(atomic)(decode_atomic(atomic, tags));
+            if (meta.natives.length) emplace("bytes")(decode_bytes("bytes"));
             for (const array of meta.arrays)
-                emplace(decode_array(accessor, array, required, tags));
+                emplace(`Array<${array.value.getName()}>`)(
+                    decode_array(accessor, array, required, tags),
+                );
             for (const map of meta.maps)
-                emplace(
+                emplace(`Map<string, ${map.value.getName()}>`)(
                     decode_map(project)(importer)(
                         accessor,
                         map,
@@ -316,7 +336,7 @@ export namespace ProtobufDecodeProgrammer {
                     ),
                 );
             for (const obj of meta.objects)
-                emplace(
+                emplace(obj.name)(
                     ProtobufUtil.isStaticObject(obj)
                         ? decode_regular_object(false)(obj)
                         : decode_dynamic_object(project)(importer)(