typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -41,7 +41,7 @@ export namespace NotationGeneralProgrammer {
           ...IsProgrammer.write_function_statements(project)(importer)(
             collection,
           ),
-          ...importer.declare(),
+          ...importer.declare(modulo),
         ],
       })(importer);
     };
@@ -82,7 +82,6 @@ export namespace NotationGeneralProgrammer {
         );
 
   const write_tuple_functions =
-    (rename: (str: string) => string) =>
     (project: IProject) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
@@ -101,7 +100,7 @@ export namespace NotationGeneralProgrammer {
               )(ts.factory.createIdentifier("input")),
               TypeFactory.keyword("any"),
               undefined,
-              decode_tuple_inline(rename)(project)(config)(importer)(
+              decode_tuple_inline(project)(config)(importer)(
                 ts.factory.createIdentifier("input"),
                 tuple,
                 {
@@ -119,7 +118,6 @@ export namespace NotationGeneralProgrammer {
         DECODERS
     ----------------------------------------------------------- */
   const decode =
-    (rename: (str: string) => string) =>
     (project: IProject) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
@@ -137,11 +135,9 @@ export namespace NotationGeneralProgrammer {
             !!t.type.elements.length && t.type.elements.every((e) => e.any),
         )
       )
-        return ts.factory.createCallExpression(
-          importer.use(rename.name),
-          undefined,
-          [input],
-        );
+        return ts.factory.createCallExpression(importer.use("any"), undefined, [
+          input,
+        ]);
 
       interface IUnion {
         type: string;
@@ -180,11 +176,7 @@ export namespace NotationGeneralProgrammer {
               explore,
             ),
           value: () =>
-            decode_tuple(rename)(project)(config)(importer)(
-              input,
-              tuple,
-              explore,
-            ),
+            decode_tuple(project)(config)(importer)(input, tuple, explore),
         });
 
       // ARRAYS
@@ -309,7 +301,6 @@ export namespace NotationGeneralProgrammer {
       );
 
   const decode_tuple =
-    (rename: (str: string) => string) =>
     (project: IProject) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
@@ -329,14 +320,13 @@ export namespace NotationGeneralProgrammer {
               source: "function",
             })(input),
           )
-        : decode_tuple_inline(rename)(project)(config)(importer)(
+        : decode_tuple_inline(project)(config)(importer)(
             input,
             tuple.type,
             explore,
           );
 
   const decode_tuple_inline =
-    (rename: (str: string) => string) =>
     (project: IProject) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
@@ -348,7 +338,7 @@ export namespace NotationGeneralProgrammer {
       const children: ts.Expression[] = tuple.elements
         .filter((m) => m.rest === null)
         .map((elem, index) =>
-          decode(rename)(project)(config)(importer)(
+          decode(project)(config)(importer)(
             ts.factory.createElementAccessExpression(input, index),
             elem,
             {
@@ -367,7 +357,7 @@ export namespace NotationGeneralProgrammer {
         const rest: Metadata | null = last.rest;
         if (rest === null) return null;
 
-        return decode(rename)(project)(config)(importer)(
+        return decode(project)(config)(importer)(
           ts.factory.createCallExpression(
             IdentifierFactory.access(input)("slice"),
             undefined,
@@ -593,7 +583,7 @@ export namespace NotationGeneralProgrammer {
         trace: false,
         path: false,
         initializer,
-        decoder: () => decode(rename)(project)(config)(importer),
+        decoder: () => decode(project)(config)(importer),
         objector: {
           checker: () => IsProgrammer.decode(project)(importer),
           decoder: () => decode_object(importer),
@@ -608,8 +598,7 @@ export namespace NotationGeneralProgrammer {
         },
         generator: {
           arrays: () => write_array_functions(config)(importer),
-          tuples: () =>
-            write_tuple_functions(rename)(project)(config)(importer),
+          tuples: () => write_tuple_functions(project)(config)(importer),
         },
       };
       return config;
@@ -639,7 +628,7 @@ export namespace NotationGeneralProgrammer {
     (value: ts.Expression) =>
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          importer.use("throws", true),
+          importer.use("throws"),
           [],
           [
             ts.factory.createObjectLiteralExpression(

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -13,7 +13,7 @@ export namespace ProtobufAssertDecodeProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string) =>
+    (type: ts.Type, name?: string, init?: ts.Expression) =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
@@ -22,11 +22,20 @@ export namespace ProtobufAssertDecodeProgrammer {
             "input",
             ts.factory.createTypeReferenceNode("Uint8Array"),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock([
@@ -65,7 +74,10 @@ export namespace ProtobufAssertDecodeProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("output")],
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               TypeFactory.keyword("any"),
             ),

package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts

@@ -13,11 +13,14 @@ export namespace ProtobufAssertEncodeProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter(init),
+        ],
         ts.factory.createTypeReferenceNode("Uint8Array"),
         undefined,
         ts.factory.createBlock([
@@ -51,7 +54,10 @@ export namespace ProtobufAssertEncodeProgrammer {
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier("assert"),
                   undefined,
-                  [ts.factory.createIdentifier("input")],
+                  [
+                    ts.factory.createIdentifier("input"),
+                    AssertProgrammer.Guardian.identifier(),
+                  ],
                 ),
               ],
             ),

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -44,11 +44,9 @@ export namespace ProtobufDecodeProgrammer {
         );
       const reader = StatementFactory.constant(
         "reader",
-        ts.factory.createNewExpression(
-          importer.use("ProtobufReader"),
-          undefined,
-          [ts.factory.createIdentifier("input")],
-        ),
+        ts.factory.createNewExpression(importer.use("Reader"), undefined, [
+          ts.factory.createIdentifier("input"),
+        ]),
       );
 
       return ts.factory.createArrowFunction(
@@ -60,15 +58,23 @@ export namespace ProtobufDecodeProgrammer {
             ts.factory.createTypeReferenceNode("Uint8Array"),
           ),
         ],
-        ts.factory.createTypeReferenceNode(
-          `typia.Resolved<${
-            name ?? TypeFactory.getFullName(project.checker)(type)
-          }>`,
+        ts.factory.createImportTypeNode(
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral("typia"),
+          ),
+          undefined,
+          ts.factory.createIdentifier("Resolved"),
+          [
+            ts.factory.createTypeReferenceNode(
+              name ?? TypeFactory.getFullName(project.checker)(type),
+            ),
+          ],
+          false,
         ),
         undefined,
         ts.factory.createBlock(
           [
-            ...importer.declare(),
+            ...importer.declare(modulo),
             ...functors,
             reader,
             ts.factory.createReturnStatement(
@@ -233,33 +239,38 @@ export namespace ProtobufDecodeProgrammer {
       value.nullable
         ? ts.factory.createNull()
         : value.isRequired() === false
-        ? ts.factory.createIdentifier("undefined")
-        : value.arrays.length
-        ? ts.factory.createArrayLiteralExpression()
-        : value.maps.length
-        ? ts.factory.createNewExpression(
-            ts.factory.createIdentifier("Map"),
-            undefined,
-            [],
-          )
-        : value.natives.length
-        ? ts.factory.createNewExpression(
-            ts.factory.createIdentifier("Uint8Array"),
-            undefined,
-            [],
-          )
-        : value.atomics.some((a) => a.type === "string") ||
-          value.constants.some(
-            (c) => c.type === "string" && c.values.some((v) => v === ""),
-          ) ||
-          value.templates.some(
-            (tpl) => tpl.length === 1 && tpl[0]!.getName() === "string",
-          )
-        ? ts.factory.createStringLiteral("")
-        : value.objects.length &&
-          value.objects.some((obj) => !ProtobufUtil.isStaticObject(obj))
-        ? ts.factory.createObjectLiteralExpression()
-        : ts.factory.createIdentifier("undefined"),
+          ? ts.factory.createIdentifier("undefined")
+          : value.arrays.length
+            ? ts.factory.createArrayLiteralExpression()
+            : value.maps.length
+              ? ts.factory.createNewExpression(
+                  ts.factory.createIdentifier("Map"),
+                  undefined,
+                  [],
+                )
+              : value.natives.length
+                ? ts.factory.createNewExpression(
+                    ts.factory.createIdentifier("Uint8Array"),
+                    undefined,
+                    [],
+                  )
+                : value.atomics.some((a) => a.type === "string") ||
+                    value.constants.some(
+                      (c) =>
+                        c.type === "string" &&
+                        c.values.some((v) => v.value === ""),
+                    ) ||
+                    value.templates.some(
+                      (tpl) =>
+                        tpl.length === 1 && tpl[0]!.getName() === "string",
+                    )
+                  ? ts.factory.createStringLiteral("")
+                  : value.objects.length &&
+                      value.objects.some(
+                        (obj) => !ProtobufUtil.isStaticObject(obj),
+                      )
+                    ? ts.factory.createObjectLiteralExpression()
+                    : ts.factory.createIdentifier("undefined"),
       TypeFactory.keyword("any"),
     );
 
@@ -376,10 +387,10 @@ export namespace ProtobufDecodeProgrammer {
     const decoder = atomics.length
       ? () => decode_atomic(array.type.value)(atomics[0]!)
       : array.type.value.natives.length
-      ? () => decode_bytes("bytes")
-      : array.type.value.objects.length
-      ? () => decode_regular_object(false)(array.type.value.objects[0]!)
-      : null;
+        ? () => decode_bytes("bytes")
+        : array.type.value.objects.length
+          ? () => decode_regular_object(false)(array.type.value.objects[0]!)
+          : null;
     if (decoder === null) throw new Error("Never reach here.");
     else if (atomics.length && atomics[0] !== "string") {
       statements.push(

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -54,18 +54,12 @@ export namespace ProtobufEncodeProgrammer {
           write_encoder(project)(importer)(collection)(meta),
         ),
         callEncoder("sizer")(
-          ts.factory.createNewExpression(
-            importer.use("ProtobufSizer"),
-            undefined,
-            [],
-          ),
+          ts.factory.createNewExpression(importer.use("Sizer"), undefined, []),
         ),
         callEncoder("writer")(
-          ts.factory.createNewExpression(
-            importer.use("ProtobufWriter"),
-            undefined,
-            [ts.factory.createIdentifier("sizer")],
-          ),
+          ts.factory.createNewExpression(importer.use("Writer"), undefined, [
+            ts.factory.createIdentifier("sizer"),
+          ]),
         ),
         ts.factory.createReturnStatement(
           ts.factory.createCallExpression(
@@ -89,7 +83,10 @@ export namespace ProtobufEncodeProgrammer {
         ],
         ts.factory.createTypeReferenceNode("Uint8Array"),
         undefined,
-        ts.factory.createBlock([...importer.declare(false), ...block], true),
+        ts.factory.createBlock(
+          [...importer.declare(modulo, false), ...block],
+          true,
+        ),
       );
     };
 
@@ -203,52 +200,52 @@ export namespace ProtobufEncodeProgrammer {
         meta.isRequired() && meta.nullable === false
           ? (block) => block
           : meta.isRequired() === false && meta.nullable === true
-          ? (block) =>
-              ts.factory.createBlock(
-                [
-                  ts.factory.createIfStatement(
-                    ts.factory.createLogicalAnd(
-                      ts.factory.createStrictInequality(
-                        ts.factory.createIdentifier("undefined"),
-                        input,
+            ? (block) =>
+                ts.factory.createBlock(
+                  [
+                    ts.factory.createIfStatement(
+                      ts.factory.createLogicalAnd(
+                        ts.factory.createStrictInequality(
+                          ts.factory.createIdentifier("undefined"),
+                          input,
+                        ),
+                        ts.factory.createStrictInequality(
+                          ts.factory.createNull(),
+                          input,
+                        ),
                       ),
-                      ts.factory.createStrictInequality(
-                        ts.factory.createNull(),
-                        input,
-                      ),
-                    ),
-                    block,
-                  ),
-                ],
-                true,
-              )
-          : meta.isRequired() === false
-          ? (block) =>
-              ts.factory.createBlock(
-                [
-                  ts.factory.createIfStatement(
-                    ts.factory.createStrictInequality(
-                      ts.factory.createIdentifier("undefined"),
-                      input,
-                    ),
-                    block,
-                  ),
-                ],
-                true,
-              )
-          : (block) =>
-              ts.factory.createBlock(
-                [
-                  ts.factory.createIfStatement(
-                    ts.factory.createStrictInequality(
-                      ts.factory.createNull(),
-                      input,
+                      block,
                     ),
-                    block,
-                  ),
-                ],
-                true,
-              );
+                  ],
+                  true,
+                )
+            : meta.isRequired() === false
+              ? (block) =>
+                  ts.factory.createBlock(
+                    [
+                      ts.factory.createIfStatement(
+                        ts.factory.createStrictInequality(
+                          ts.factory.createIdentifier("undefined"),
+                          input,
+                        ),
+                        block,
+                      ),
+                    ],
+                    true,
+                  )
+              : (block) =>
+                  ts.factory.createBlock(
+                    [
+                      ts.factory.createIfStatement(
+                        ts.factory.createStrictInequality(
+                          ts.factory.createNull(),
+                          input,
+                        ),
+                        block,
+                      ),
+                    ],
+                    true,
+                  );
 
       // STARTS FROM ATOMIC TYPES
       const unions: IUnion[] = [];
@@ -687,8 +684,8 @@ export namespace ProtobufEncodeProgrammer {
     type === "double"
       ? ProtobufWire.I64
       : type === "float"
-      ? ProtobufWire.I32
-      : ProtobufWire.VARIANT;
+        ? ProtobufWire.I32
+        : ProtobufWire.VARIANT;
 
   /* -----------------------------------------------------------
         EXPLORERS
@@ -795,7 +792,7 @@ export namespace ProtobufEncodeProgrammer {
     (value: ts.Expression) =>
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          importer.use("throws", true),
+          importer.use("throws"),
           [],
           [
             ts.factory.createObjectLiteralExpression(

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -24,10 +24,18 @@ export namespace ProtobufIsDecodeProgrammer {
           ),
         ],
         ts.factory.createUnionTypeNode([
-          ts.factory.createTypeReferenceNode(
-            `typia.Resolved<${
-              name ?? TypeFactory.getFullName(project.checker)(type)
-            }>`,
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(project.checker)(type),
+              ),
+            ],
+            false,
           ),
           ts.factory.createLiteralTypeNode(ts.factory.createNull()),
         ]),

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -91,8 +91,8 @@ export namespace ProtobufMessageProgrammer {
               prop.value.arrays.length || type.startsWith("map<")
                 ? ""
                 : !prop.value.isRequired() || prop.value.nullable
-                ? "optional "
-                : "required "
+                  ? "optional "
+                  : "required "
             }${type} ${key} = ${++ptr.value};`;
       })
       .join("\n");
@@ -157,4 +157,4 @@ interface IPointer<T> {
   value: T;
 }
 
-const TAB = " ".repeat(4);
+const TAB = " ".repeat(2);