typia 5.0.0-dev.20230827 → 5.0.0-dev.20230828

package/src/programmers/internal/application_schema.ts

@@ -9,10 +9,10 @@ import { application_alias } from "./application_alias";
 import { application_array } from "./application_array";
 import { application_boolean } from "./application_boolean";
 import { application_constant } from "./application_constant";
+import { application_escaped } from "./application_escaped";
 import { application_native } from "./application_native";
 import { application_number } from "./application_number";
 import { application_object } from "./application_object";
-import { application_resolved } from "./application_resolved";
 import { application_string } from "./application_string";
 import { application_templates } from "./application_templates";
 import { application_tuple } from "./application_tuple";
@@ -61,7 +61,7 @@ export const application_schema =
         // toJSON() METHOD
         if (meta.escaped !== null)
             union.push(
-                ...application_resolved(options)(blockNever)(components)(
+                ...application_escaped(options)(blockNever)(components)(
                     meta.escaped,
                 )(attribute),
             );
@@ -70,7 +70,7 @@ export const application_schema =
         if (meta.templates.length && AtomicPredicator.template(meta))
             insert(application_templates(meta)(attribute));
         for (const constant of meta.constants)
-            if (constant.type === "bigint") throw new Error(NO_BIGINT);
+            if (constant.type === "bigint") throw new TypeError(NO_BIGINT);
             else if (
                 (constant.type === "string" && meta.templates.length) ||
                 AtomicPredicator.constant(meta)(constant.type) === false
@@ -78,7 +78,7 @@ export const application_schema =
                 continue;
             else insert(application_constant(constant)(attribute));
         for (const a of meta.atomics)
-            if (a.type === "bigint") throw new Error(NO_BIGINT);
+            if (a.type === "bigint") throw new TypeError(NO_BIGINT);
             else if (a.type === "boolean")
                 insert(application_boolean(attribute));
             else if (a.type === "number")
@@ -103,7 +103,7 @@ export const application_schema =
             if (AtomicPredicator.native(native)) {
                 const type: string = native.toLowerCase();
                 if (meta.atomics.some((a) => a.type === type)) continue;
-                else if (type === "bigint") throw new Error(NO_BIGINT);
+                else if (type === "bigint") throw new TypeError(NO_BIGINT);
                 else if (type === "boolean")
                     insert(application_boolean(attribute));
                 else if (type === "number")

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -3,6 +3,8 @@ import { IJsonComponents } from "../../schemas/json/IJsonComponents";
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
+import { TransformerError } from "../../transformers/TransformerError";
+
 import { application_schema } from "../internal/application_schema";
 
 export namespace JsonApplicationProgrammer {
@@ -35,9 +37,10 @@ export namespace JsonApplicationProgrammer {
                 schemas: metadatas.map((meta, i) => {
                     const schema: IJsonSchema | null = generator(meta)({});
                     if (schema === null)
-                        throw new Error(
-                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                        );
+                        throw new TransformerError({
+                            code: "typia.json.application",
+                            message: `invalid type on argument - (${meta.getName()}, ${i})`,
+                        });
                     return schema;
                 }),
                 components,

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonAssertParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -63,4 +67,5 @@ export namespace JsonAssertParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonIsParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonIsParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -69,4 +73,5 @@ export namespace JsonIsParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -2,8 +2,8 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { MetadataCollection } from "../../factories/MetadataCollection";
-import { MetadataFactory } from "../../factories/MetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 import { ValueFactory } from "../../factories/ValueFactory";
@@ -315,12 +315,7 @@ export namespace JsonStringifyProgrammer {
                     });
 
             // TUPLES
-            for (const tuple of meta.tuples) {
-                for (const child of tuple.type.elements)
-                    if (StringifyPredicator.undefindable(meta))
-                        throw new Error(
-                            `Error on typia.json.stringify(): tuple cannot contain undefined value - (${child.getName()}).`,
-                        );
+            for (const tuple of meta.tuples)
                 unions.push({
                     type: "tuple",
                     is: () =>
@@ -340,15 +335,9 @@ export namespace JsonStringifyProgrammer {
                             explore,
                         ),
                 });
-            }
 
             // ARRAYS
             if (meta.arrays.length) {
-                for (const child of meta.arrays)
-                    if (StringifyPredicator.undefindable(child.type.value))
-                        throw new Error(
-                            `Error on typia.json.stringify(): array cannot contain undefined value (${child.type.value.getName()}).`,
-                        );
                 const value: () => ts.Expression =
                     meta.arrays.length === 1
                         ? () =>
@@ -935,25 +924,11 @@ export namespace JsonStringifyProgrammer {
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
-        (type) => {
-            const collection: MetadataCollection = new MetadataCollection();
-            const meta: Metadata = MetadataFactory.analyze(checker)({
-                escape: true,
-                constant: true,
-                absorb: true,
-                validate: (meta) => {
-                    if (meta.atomics.find((a) => a.type === "bigint"))
-                        throw new Error(NO_BIGINT);
-                    else if (
-                        meta.arrays.some(
-                            (array) => array.type.value.isRequired() === false,
-                        )
-                    )
-                        throw new Error(NO_UNDEFINED_IN_ARRAY);
-                },
-            })(collection)(type);
-            return [collection, meta];
-        };
+        (importer) =>
+        (type) =>
+            JsonMetadataFactory.analyze(`typia.json.${importer.method}`)(
+                checker,
+            )(type);
 
     const create_throw_error =
         (importer: FunctionImporter) =>
@@ -987,8 +962,3 @@ interface IUnion {
     is: () => ts.Expression;
     value: () => ts.Expression;
 }
-
-const NO_BIGINT =
-    "Error on typia.json.stringify(): does not allow bigint type.";
-const NO_UNDEFINED_IN_ARRAY =
-    "Error on typia.json.stringify(): does not allow undefined type in array.";

package/src/programmers/json/JsonValidateParseProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { JsonMetadataFactory } from "../../factories/JsonMetadataFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -12,8 +13,11 @@ export namespace JsonValidateParseProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+        (type: ts.Type, name?: string): ts.ArrowFunction => {
+            JsonMetadataFactory.analyze(`typia.json.${modulo.getText()}`)(
+                project.checker,
+            )(type);
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
@@ -60,4 +64,5 @@ export namespace JsonValidateParseProgrammer {
                     ),
                 ]),
             );
+        };
 }

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -13,7 +13,7 @@ export namespace JsonValidateStringifyProgrammer {
     export const write =
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -13,6 +13,7 @@ import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -696,7 +697,7 @@ export namespace MiscCloneProgrammer {
                 prefix: PREFIX,
                 trace: false,
                 path: false,
-                initializer: initializer(importer.method),
+                initializer,
                 decoder: () => decode(project)(config)(importer),
                 objector: {
                     checker: () => IsProgrammer.decode(project)(importer),
@@ -720,27 +721,29 @@ export namespace MiscCloneProgrammer {
             return config;
         };
 
-    const initializer =
-        (method: string): FeatureProgrammer.IConfig["initializer"] =>
+    const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
+        (importer) =>
         (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const result = MetadataFactory.analyze(checker)({
                 escape: false,
                 constant: true,
                 absorb: true,
                 validate: (meta) => {
+                    const output: string[] = [];
                     if (meta.natives.some((n) => n === "WeakSet"))
-                        throw new Error(
-                            `Error on ${method}(): WeakSet is not supported.`,
-                        );
+                        output.push("unable to clone WeakSet");
                     else if (meta.natives.some((n) => n === "WeakMap"))
-                        throw new Error(
-                            `Error on ${method}(): WeakMap is not supported.`,
-                        );
+                        output.push("unable to clone WeakMap");
+                    return output;
                 },
             })(collection)(type);
-            return [collection, meta];
+            if (result.success === false)
+                throw TransformerError.from(`typia.misc.${importer.method}`)(
+                    result.errors,
+                );
+            return [collection, result.data];
         };
 
     const create_throw_error =

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -7,6 +7,7 @@ import { MetadataFactory } from "../../factories/MetadataFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { Atomic } from "../../typings/Atomic";
 
@@ -14,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)({
+        const result = MetadataFactory.analyze(project.checker)({
             escape: true,
             constant: true,
             absorb: true,
@@ -24,11 +25,15 @@ export namespace MiscLiteralsProgrammer {
                         .map((c) => c.values.length)
                         .reduce((a, b) => a + b, 0) +
                     meta.atomics.filter((a) => a.type === "boolean").length;
-                if (0 === length) throw new Error(ErrorMessages.NO);
-                else if (meta.size() !== length)
-                    throw new Error(ErrorMessages.ONLY);
+                if (0 === length) return [ErrorMessages.NO];
+                else if (meta.size() !== length) return [ErrorMessages.ONLY];
+                return [];
             },
         })(new MetadataCollection())(type);
+        if (result.success === false)
+            throw TransformerError.from(`typia.misc.literals`)(result.errors);
+
+        const meta: Metadata = result.data;
         const values: Set<Atomic.Type | null> = new Set([
             ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
             ...(meta.atomics.filter((a) => a.type === "boolean").length
@@ -59,6 +64,6 @@ export namespace MiscLiteralsProgrammer {
 }
 
 enum ErrorMessages {
-    NO = "Error on typia.literals(): no literal type found.",
-    ONLY = "Error on typia.literals(): only literal type allowed.",
+    NO = "no constant literal type found.",
+    ONLY = "only constant literal types are allowed.",
 }

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -13,6 +13,7 @@ import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { IProject } from "../../transformers/IProject";
+import { TransformerError } from "../../transformers/TransformerError";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -506,14 +507,19 @@ export namespace MiscPruneProgrammer {
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
         ({ checker }) =>
+        (importer) =>
         (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const result = MetadataFactory.analyze(checker)({
                 escape: false,
                 constant: true,
                 absorb: true,
             })(collection)(type);
-            return [collection, meta];
+            if (result.success === false)
+                throw TransformerError.from(`typia.misc.${importer.method}`)(
+                    result.errors,
+                );
+            return [collection, result.data];
         };
 
     const create_throw_error =

package/src/schemas/metadata/Metadata.ts

@@ -236,7 +236,7 @@ export class Metadata {
             arrays: meta.arrays.map((ref) => {
                 const type = dict.arrays.get(ref.name);
                 if (type === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find array "${ref.name}".`,
                     );
                 return MetadataArray.create({
@@ -247,7 +247,7 @@ export class Metadata {
             tuples: meta.tuples.map((t) => {
                 const type = dict.tuples.get(t.name);
                 if (type === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find tuple "${t.name}".`,
                     );
                 return MetadataTuple.create({
@@ -258,7 +258,7 @@ export class Metadata {
             objects: meta.objects.map((name) => {
                 const found = dict.objects.get(name);
                 if (found === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find object "${name}".`,
                     );
                 return found;
@@ -266,7 +266,7 @@ export class Metadata {
             aliases: meta.aliases.map((alias) => {
                 const found = dict.aliases.get(alias);
                 if (found === undefined)
-                    throw new Error(
+                    throw new RangeError(
                         `Error on Metadata.from(): failed to find alias "${alias}".`,
                     );
                 return found;

package/src/transform.ts

@@ -1,11 +1,13 @@
 import ts from "typescript";
 
 import { FileTransformer } from "./transformers/FileTransformer";
+import { IProject } from "./transformers/IProject";
 import { ITransformOptions } from "./transformers/ITransformOptions";
 
 export const transform = (
     program: ts.Program,
-    options?: ITransformOptions,
+    options: ITransformOptions | undefined,
+    extras: IProject["extras"],
 ): ts.TransformerFactory<ts.SourceFile> => {
     const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
     const strict: boolean =
@@ -13,15 +15,21 @@ export const transform = (
             ? !!compilerOptions.strictNullChecks
             : !!compilerOptions.strict;
     if (strict === false)
-        throw new Error(
-            `Error on "tsconfig.json": typia requires \`compilerOptions.strictNullChecks\` to be true.`,
-        );
+        extras.addDiagnostic({
+            category: ts.DiagnosticCategory.Error,
+            code: "(typia)" as any,
+            file: undefined,
+            start: undefined,
+            length: undefined,
+            messageText: "strict mode is required.",
+        });
     return FileTransformer.transform({
         program,
         compilerOptions,
         checker: program.getTypeChecker(),
         printer: ts.createPrinter(),
-        options: options || {},
+        options: options ?? {},
+        extras,
     });
 };
 export default transform;

package/src/transformers/CallExpressionTransformer.ts

@@ -64,7 +64,7 @@ import { ProtobufValidateEncodeTransformer } from "./features/protobuf/ProtobufV
 export namespace CallExpressionTransformer {
     export const transform =
         (project: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
+        (expression: ts.CallExpression): ts.Expression | null => {
             //----
             // VALIDATIONS
             //----
@@ -95,7 +95,10 @@ export namespace CallExpressionTransformer {
             if (functor === undefined) return expression;
 
             // RETURNS WITH TRANSFORMATION
-            return functor()(project)(expression.expression)(expression);
+            const result: ts.Expression | null = functor()(project)(
+                expression.expression,
+            )(expression);
+            return result ?? expression;
         };
 
     const isTarget = (location: string): boolean => {
@@ -126,7 +129,7 @@ type Task = (
     project: IProject,
 ) => (
     modulo: ts.LeftHandSideExpression,
-) => (expression: ts.CallExpression) => ts.Expression;
+) => (expression: ts.CallExpression) => ts.Expression | null;
 
 const FUNCTORS: Record<string, Record<string, () => Task>> = {
     module: {

package/src/transformers/FileTransformer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { NodeTransformer } from "./NodeTransformer";
+import { TransformerError } from "./TransformerError";
 
 export namespace FileTransformer {
     export const transform =
@@ -19,29 +20,40 @@ export namespace FileTransformer {
     const iterate_node =
         (project: IProject) =>
         (context: ts.TransformationContext) =>
-        (node: ts.Node): ts.Node =>
-            ts.visitEachChild(
-                try_transform_node(project)(node),
+        (node: ts.Node): ts.Node => {
+            const changed: ts.Node | null = try_transform_node(project)(node);
+            return ts.visitEachChild(
+                changed ?? node,
                 (child) => iterate_node(project)(context)(child),
                 context,
             );
+        };
 
     const try_transform_node =
         (project: IProject) =>
-        (node: ts.Node): ts.Node => {
+        (node: ts.Node): ts.Node | null => {
             try {
                 return NodeTransformer.transform(project)(node);
             } catch (exp) {
-                if (!(exp instanceof Error)) throw exp;
-
-                const file: ts.SourceFile | undefined = node.getSourceFile();
-                if (file === undefined) throw exp;
+                // ONLY ACCEPT TRANSFORMER-ERROR
+                if (!isTransformerError(exp)) throw exp;
 
-                const { line, character } = file.getLineAndCharacterOfPosition(
-                    node.pos,
-                );
-                console.error(`${file.fileName}:${line}:${character}:`, exp);
-                throw exp;
+                // REPORT DIAGNOSTIC
+                const diagnostic = ts.createDiagnosticForNode(node, {
+                    key: exp.code,
+                    category: ts.DiagnosticCategory.Error,
+                    message: exp.message,
+                    code: `(${exp.code})` as any,
+                });
+                project.extras.addDiagnostic(diagnostic);
+                return null;
             }
         };
 }
+
+const isTransformerError = (error: any): error is TransformerError =>
+    typeof error === "object" &&
+    error !== null &&
+    error.constructor.name === "TransformerError" &&
+    typeof error.code === "string" &&
+    typeof error.message === "string";

package/src/transformers/IProject.ts

@@ -9,4 +9,7 @@ export interface IProject {
     printer: ts.Printer;
     options: ITransformOptions;
     context: ts.TransformationContext;
+    extras: {
+        addDiagnostic: (diag: ts.Diagnostic) => number;
+    };
 }

package/src/transformers/NodeTransformer.ts

@@ -6,7 +6,7 @@ import { IProject } from "./IProject";
 export namespace NodeTransformer {
     export const transform =
         (project: IProject) =>
-        (expression: ts.Node): ts.Node =>
+        (expression: ts.Node): ts.Node | null =>
             ts.isCallExpression(expression)
                 ? CallExpressionTransformer.transform(project)(expression)
                 : expression;

package/src/transformers/TransformerError.ts

@@ -0,0 +1,55 @@
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+import { Escaper } from "../utils/Escaper";
+
+export class TransformerError extends Error {
+    public readonly code: string;
+
+    public constructor(props: TransformerError.IProps) {
+        super(props.message);
+        this.code = props.code;
+
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+        else (this as any).__proto__ = proto;
+    }
+}
+export namespace TransformerError {
+    export interface IProps {
+        code: string;
+        message: string;
+    }
+
+    export const from =
+        (method: string) =>
+        (errors: MetadataFactory.IError[]): TransformerError => {
+            const body: string = errors
+                .map((e) => {
+                    const subject: string =
+                        e.explore.object === null
+                            ? ""
+                            : join(e.explore.object)(e.explore.property);
+                    const type: string = `${
+                        subject.length ? `${subject}: ` : ""
+                    }${e.name}`;
+                    return `- ${type}\n${e.messages
+                        .map((msg) => `  - ${msg}`)
+                        .join("\n")}`;
+                })
+                .join("\n\n");
+            return new TransformerError({
+                code: method,
+                message: `unsupported type detected\n\n${body}`,
+            });
+        };
+
+    const join = (object: MetadataObject) => (key: string | object | null) => {
+        if (key === null) return object.name;
+        else if (typeof key === "object") return `${object.name}[key]`;
+        else if (Escaper.variable(key)) return `${object.name}.${key}`;
+        return `${object.name}[${JSON.stringify(key)}]`;
+    };
+}

package/src/transformers/features/CreateRandomTransformer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
 import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
 
 export namespace CreateRandomTransformer {
     export const transform =
@@ -10,13 +11,21 @@ export namespace CreateRandomTransformer {
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "generic argument is not specified.",
+                });
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
             const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "typia.createRandom",
+                    message: "non-specified generic argument.",
+                });
 
             // DO TRANSFORM
             return RandomProgrammer.write({
@@ -32,8 +41,3 @@ export namespace CreateRandomTransformer {
             );
         };
 }
-
-const NOT_SPECIFIED =
-    "Error on typia.createRandom(): generic argument is not specified.";
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.createRandom(): non-specified generic argument.";