typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

package/src/programmers/TypiaProgrammer.ts

@@ -20,7 +20,7 @@ export namespace TypiaProgrammer {
         props.output = path.resolve(props.output);
 
         if ((await is_directory(props.input)) === false)
-            throw new Error(
+            throw new URIError(
                 "Error on TypiaGenerator.generate(): input path is not a directory.",
             );
         else if (fs.existsSync(props.output) === false)
@@ -28,7 +28,7 @@ export namespace TypiaProgrammer {
         else if ((await is_directory(props.output)) === false) {
             const parent: string = path.join(props.output, "..");
             if ((await is_directory(parent)) === false)
-                throw new Error(
+                throw new URIError(
                     "Error on TypiaGenerator.generate(): output path is not a directory.",
                 );
             await fs.promises.mkdir(props.output);
@@ -56,6 +56,7 @@ export namespace TypiaProgrammer {
         );
 
         // DO TRANSFORM
+        const diagnostics: ts.Diagnostic[] = [];
         const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
             program
                 .getSourceFiles()
@@ -73,11 +74,35 @@ export namespace TypiaProgrammer {
                             p.transform === "typia/lib/transform" ||
                             p.transform === "../src/transform.ts",
                     ) ?? {},
+                    {
+                        addDiagnostic: (diag) => diagnostics.push(diag),
+                    },
                 ),
             ],
             program.getCompilerOptions(),
         );
 
+        // TRACE ERRORS
+        for (const diag of diagnostics) {
+            const file: string = diag.file
+                ? path.relative(diag.file.fileName, process.cwd())
+                : "(unknown file)";
+            const category: string =
+                diag.category === ts.DiagnosticCategory.Warning
+                    ? "warning"
+                    : diag.category === ts.DiagnosticCategory.Error
+                    ? "error"
+                    : diag.category === ts.DiagnosticCategory.Suggestion
+                    ? "suggestion"
+                    : diag.category === ts.DiagnosticCategory.Message
+                    ? "message"
+                    : "unkown";
+            console.error(
+                `${file}:${diag.start}:${diag.length} - ${category} TS(${diag.code}): ${diag.messageText}`,
+            );
+        }
+        if (diagnostics.length) process.exit(-1);
+
         // ARCHIVE TRANSFORMED FILES
         const printer: ts.Printer = ts.createPrinter({
             newLine: ts.NewLineKind.LineFeed,

package/src/programmers/ValidateProgrammer.ts

@@ -34,29 +34,68 @@ export namespace ValidateProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
-                    atomist: (explore) => (tuple) => (input) =>
+                    atomist: (explore) => (entry) => (input) =>
                         [
-                            ...(tuple.expression ? [tuple.expression] : []),
-                            ...tuple.tags.map((tag) =>
-                                ts.factory.createLogicalOr(
-                                    tag.expression,
-                                    create_report_call(
-                                        explore.from === "top"
-                                            ? ts.factory.createTrue()
-                                            : ts.factory.createIdentifier(
-                                                  "_exceptionable",
+                            ...(entry.expression ? [entry.expression] : []),
+                            ...(entry.conditions.length === 0
+                                ? []
+                                : entry.conditions.length === 1
+                                ? entry.conditions[0]!.map((cond) =>
+                                      ts.factory.createLogicalOr(
+                                          cond.expression,
+                                          create_report_call(
+                                              explore.from === "top"
+                                                  ? ts.factory.createTrue()
+                                                  : ts.factory.createIdentifier(
+                                                        "_exceptionable",
+                                                    ),
+                                          )(
+                                              ts.factory.createIdentifier(
+                                                  explore.postfix
+                                                      ? `_path + ${explore.postfix}`
+                                                      : "_path",
                                               ),
-                                    )(
-                                        ts.factory.createIdentifier(
-                                            explore.postfix
-                                                ? `_path + ${explore.postfix}`
-                                                : "_path",
-                                        ),
-                                        tag.expected,
-                                        input,
-                                    ),
-                                ),
-                            ),
+                                              cond.expected,
+                                              input,
+                                          ),
+                                      ),
+                                  )
+                                : [
+                                      ts.factory.createLogicalOr(
+                                          entry.conditions
+                                              .map((set) =>
+                                                  set
+                                                      .map((s) => s.expression)
+                                                      .reduce((a, b) =>
+                                                          ts.factory.createLogicalAnd(
+                                                              a,
+                                                              b,
+                                                          ),
+                                                      ),
+                                              )
+                                              .reduce((a, b) =>
+                                                  ts.factory.createLogicalOr(
+                                                      a,
+                                                      b,
+                                                  ),
+                                              ),
+                                          create_report_call(
+                                              explore.from === "top"
+                                                  ? ts.factory.createTrue()
+                                                  : ts.factory.createIdentifier(
+                                                        "_exceptionable",
+                                                    ),
+                                          )(
+                                              ts.factory.createIdentifier(
+                                                  explore.postfix
+                                                      ? `_path + ${explore.postfix}`
+                                                      : "_path",
+                                              ),
+                                              entry.expected,
+                                              input,
+                                          ),
+                                      ),
+                                  ]),
                         ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
                     combiner: combine(equals)(importer),
                     joiner: joiner(equals)(importer),

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/ICheckEntry.ts

@@ -1,11 +1,12 @@
 import ts from "typescript";
 
 export interface ICheckEntry {
+    expected: string;
     expression: ts.Expression | null;
-    tags: ICheckEntry.ITag[];
+    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 { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
-import { Atomic } from "../../typings/Atomic";
+import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
 export namespace ProtobufUtil {
-    export const getAtomics = (meta: Metadata) => {
-        const set: Set<Atomic.Literal> = new Set();
+    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 => meta.arrays.length > 1;
 
-        for (const a of meta.atomics) set.add(a.type);
-        for (const constant of meta.constants) set.add(constant.type);
+    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(
-            (x, y) => ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!,
-        );
+        return [...set].sort(compare);
     };
 
-    export const isStaticObject = (obj: MetadataObject): boolean =>
-        obj.properties.length >= 1 &&
-        obj.properties.every((p) => p.key.isSoleLiteral());
+    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<Atomic.Literal, number>([
-    ["boolean", 0],
-    ["bigint", 1],
-    ["number", 2],
-    ["string", 3],
-]);
+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 { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 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: IMetadataCommentTag[],
-        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: IMetadataCommentTag[],
-            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,17 +46,11 @@ export namespace RandomJoiner {
             );
         };
 
-    export const tuple =
-        (decoder: Decoder) =>
-        (
-            items: Metadata[],
-            tags: IMetadataCommentTag[],
-            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) =>
@@ -92,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,
@@ -150,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(

package/src/programmers/helpers/RandomRanger.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 export namespace RandomRanger {
     export interface IDefaults {
@@ -13,15 +13,12 @@ export namespace RandomRanger {
         (coalesce: (method: string) => ts.Expression) =>
         (defs: IDefaults) =>
         (acc: length.IAccessors) =>
-        (tags: IMetadataCommentTag[]): ts.Expression | undefined => {
+        (tags: IMetadataTypeTag[]): ts.Expression | undefined => {
             const props = {
-                fixed: getter(tags)(acc.fixed),
                 minimum: getter(tags)(acc.minimum),
                 maximum: getter(tags)(acc.maximum),
             };
-            if (props.fixed !== undefined)
-                return ts.factory.createNumericLiteral(props.fixed);
-            else if (props.minimum === undefined && props.maximum === undefined)
+            if (props.minimum === undefined && props.maximum === undefined)
                 return undefined;
 
             props.minimum ??= defs.minimum;
@@ -40,16 +37,15 @@ export namespace RandomRanger {
         };
     export namespace length {
         export interface IAccessors {
-            minimum: IMetadataCommentTag["kind"];
-            maximum: IMetadataCommentTag["kind"];
-            fixed: IMetadataCommentTag["kind"];
+            minimum: string;
+            maximum: string;
         }
     }
 
     export const number =
         (config: number.IConfig) =>
         (defs: IDefaults) =>
-        (tags: IMetadataCommentTag[]): ts.Expression => {
+        (tags: IMetadataTypeTag[]): ts.Expression => {
             const range = {
                 minimum: {
                     value:
@@ -63,30 +59,14 @@ export namespace RandomRanger {
                         getter(tags)("exclusiveMaximum"),
                     exclusive: getter(tags)("exclusiveMaximum") !== undefined,
                 },
-                step: getter(tags)("step"),
+                stepper: undefined,
                 multiply: getter(tags)("multipleOf"),
             };
-            if (Object.values(range).every((v) => v !== undefined))
-                return config.setter([]);
 
             //----
             // MULTIPLIERS
             //----
-            // STEP
-            if (range.step !== undefined) {
-                const { intercept, minimum, maximum } = stepper(defs.gap)(
-                    range,
-                )(range.step);
-                return ts.factory.createAdd(
-                    config.transform(intercept),
-                    ts.factory.createMultiply(
-                        config.transform(range.step),
-                        config.setter([minimum, maximum]),
-                    ),
-                );
-            }
-            // MULTIPLE-OF
-            else if (range.multiply !== undefined) {
+            if (range.multiply !== undefined) {
                 const { minimum, maximum } = multiplier(defs.gap)(range)(
                     range.multiply,
                 );
@@ -151,30 +131,15 @@ export namespace RandomRanger {
 }
 
 const getter =
-    (tags: IMetadataCommentTag[]) =>
-    (kind: IMetadataCommentTag["kind"]): number | undefined =>
-        tags.find((t) => t.kind === kind)?.value as number | undefined;
-
-const stepper = (gap: number) => (range: IRange) => (s: number) => {
-    const intercept: number = range.minimum.value!;
-    const minimum: number = range.minimum.exclusive ? 1 : 0;
-    if (range.maximum.value === undefined)
-        return {
-            intercept,
-            minimum,
-            maximum: gap,
-        };
-
-    const y: number = Math.floor(range.maximum.value - intercept) / s;
-    return {
-        intercept,
-        minimum,
-        maximum:
-            range.maximum.exclusive && intercept + y * s === range.maximum.value
-                ? y - 1
-                : y,
+    (tags: IMetadataTypeTag[]) =>
+    (kind: string): number | undefined => {
+        const value: bigint | number | undefined = tags.find(
+            (t) =>
+                t.kind === kind &&
+                (typeof t.value === "number" || typeof t.value === "bigint"),
+        )?.value;
+        return value !== undefined ? Number(value) : undefined;
     };
-};
 
 const multiplier = (gap: number) => (range: IRange) => (m: number) => {
     const minimum: number =