typia 7.0.0-dev.20241001 → 7.0.0-dev.20241002

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -70,7 +70,10 @@ export namespace NotationGeneralProgrammer {
             rename: props.rename,
             type:
               props.name ??
-              TypeFactory.getFullName(props.context.checker)(props.type),
+              TypeFactory.getFullName({
+                checker: props.context.checker,
+                type: props.type,
+              }),
           }),
         ),
         undefined,
@@ -104,9 +107,9 @@ export namespace NotationGeneralProgrammer {
       .arrays()
       .filter((a) => a.recursive)
       .map((type, i) =>
-        StatementFactory.constant(
-          `${props.config.prefix}a${i}`,
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: `${props.config.prefix}a${i}`,
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             FeatureProgrammer.parameterDeclarations({
@@ -131,7 +134,7 @@ export namespace NotationGeneralProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   const write_tuple_functions = (props: {
@@ -144,9 +147,9 @@ export namespace NotationGeneralProgrammer {
       .tuples()
       .filter((t) => t.recursive)
       .map((tuple, i) =>
-        StatementFactory.constant(
-          `${props.config.prefix}t${i}`,
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: `${props.config.prefix}t${i}`,
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             FeatureProgrammer.parameterDeclarations({
@@ -168,7 +171,7 @@ export namespace NotationGeneralProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -258,7 +261,7 @@ export namespace NotationGeneralProgrammer {
     if (props.metadata.sets.length)
       unions.push({
         type: "set",
-        is: () => ExpressionFactory.isInstanceOf("Set")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Set", props.input),
         value: () =>
           explore_sets({
             ...props,
@@ -272,7 +275,7 @@ export namespace NotationGeneralProgrammer {
     if (props.metadata.maps.length)
       unions.push({
         type: "map",
-        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Map", props.input),
         value: () =>
           explore_maps({
             ...props,
@@ -287,11 +290,11 @@ export namespace NotationGeneralProgrammer {
       if (native === "WeakSet" || native === "WeakMap") continue;
       unions.push({
         type: "native",
-        is: () => ExpressionFactory.isInstanceOf(native)(props.input),
+        is: () => ExpressionFactory.isInstanceOf(native, props.input),
         value: () =>
           native === "Boolean" || native === "Number" || native === "String"
             ? ts.factory.createCallExpression(
-                IdentifierFactory.access(props.input)("valueOf"),
+                IdentifierFactory.access(props.input, "valueOf"),
                 undefined,
                 undefined,
               )
@@ -310,7 +313,8 @@ export namespace NotationGeneralProgrammer {
           ExpressionFactory.isObject({
             checkNull: true,
             checkArray: false,
-          })(props.input),
+            input: props.input,
+          }),
         value: () =>
           explore_objects({
             ...props,
@@ -475,7 +479,7 @@ export namespace NotationGeneralProgrammer {
       return decode({
         ...props,
         input: ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("slice"),
+          IdentifierFactory.access(props.input, "slice"),
           undefined,
           [ExpressionFactory.number(props.tuple.elements.length - 1)],
         ),
@@ -781,14 +785,19 @@ export namespace NotationGeneralProgrammer {
       types: {
         input: (type, name) =>
           ts.factory.createTypeReferenceNode(
-            name ?? TypeFactory.getFullName(props.context.checker)(type),
+            name ??
+              TypeFactory.getFullName({ checker: props.context.checker, type }),
           ),
         output: (type, name) =>
           ts.factory.createTypeReferenceNode(
             returnType({
               rename: props.rename,
               type:
-                name ?? TypeFactory.getFullName(props.context.checker)(type),
+                name ??
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type,
+                }),
             }),
           ),
       },

package/src/programmers/notations/NotationIsGeneralProgrammer.ts

@@ -43,8 +43,14 @@ export namespace NotationIsGeneralProgrammer {
       statements: [
         ...is.statements,
         ...notation.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__notation", notation.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__notation",
+          value: notation.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/notations/NotationValidateGeneralProgrammer.ts

@@ -43,8 +43,14 @@ export namespace NotationValidateGeneralProgrammer {
       statements: [
         ...validate.statements,
         ...notation.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__notation", notation.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__notation",
+          value: notation.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -56,9 +62,9 @@ export namespace NotationValidateGeneralProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "result",
-              ts.factory.createAsExpression(
+            StatementFactory.constant({
+              name: "result",
+              value: ts.factory.createAsExpression(
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier("__validate"),
                   undefined,
@@ -66,7 +72,7 @@ export namespace NotationValidateGeneralProgrammer {
                 ),
                 TypeFactory.keyword("any"),
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createIdentifier("result.success"),
               ts.factory.createExpressionStatement(

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -44,8 +44,14 @@ export namespace ProtobufAssertDecodeProgrammer {
       statements: [
         ...assert.statements,
         ...decode.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts

@@ -46,8 +46,14 @@ export namespace ProtobufAssertEncodeProgrammer {
       statements: [
         ...assert.statements,
         ...encode.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__encode", encode.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__encode",
+          value: encode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -46,14 +46,14 @@ export namespace ProtobufDecodeProgrammer {
           .filter((object) => ProtobufUtil.isStaticObject(object))
           .map((object) => [
             `${PREFIX}o${object.index}`,
-            StatementFactory.constant(
-              props.importer.useLocal(`${PREFIX}o${object.index}`),
-              write_object_function({
+            StatementFactory.constant({
+              name: props.importer.useLocal(`${PREFIX}o${object.index}`),
+              value: write_object_function({
                 context: props.context,
                 importer: props.importer,
                 object,
               }),
-            ),
+            }),
           ]),
       ),
       statements: [],
@@ -75,21 +75,24 @@ export namespace ProtobufDecodeProgrammer {
           [
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           ],
         ),
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "reader",
-              ts.factory.createNewExpression(
+            StatementFactory.constant({
+              name: "reader",
+              value: ts.factory.createNewExpression(
                 props.importer.use("Reader"),
                 undefined,
                 [ts.factory.createIdentifier("input")],
               ),
-            ),
+            }),
             ts.factory.createReturnStatement(
               decode_regular_object({
                 top: true,
@@ -149,14 +152,14 @@ export namespace ProtobufDecodeProgrammer {
                 ),
                 undefined,
                 ts.factory.createCallExpression(
-                  IdentifierFactory.access(READER())("size"),
+                  IdentifierFactory.access(READER(), "size"),
                   undefined,
                   undefined,
                 ),
                 undefined,
                 ts.factory.createAdd(
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(READER())("index"),
+                    IdentifierFactory.access(READER(), "index"),
                     undefined,
                     undefined,
                   ),
@@ -170,7 +173,7 @@ export namespace ProtobufDecodeProgrammer {
             importer: props.importer,
             condition: ts.factory.createLessThan(
               ts.factory.createCallExpression(
-                IdentifierFactory.access(READER())("index"),
+                IdentifierFactory.access(READER(), "index"),
                 undefined,
                 undefined,
               ),
@@ -205,7 +208,8 @@ export namespace ProtobufDecodeProgrammer {
           index,
           accessor: IdentifierFactory.access(
             ts.factory.createIdentifier(props.output),
-          )(p.key.getSoleLiteral()!),
+            p.key.getSoleLiteral()!,
+          ),
           metadata: p.value,
         });
         index += ProtobufUtil.size(p.value);
@@ -213,9 +217,9 @@ export namespace ProtobufDecodeProgrammer {
       })
       .flat();
     return [
-      StatementFactory.constant(
-        props.output,
-        ts.factory.createAsExpression(
+      StatementFactory.constant({
+        name: props.output,
+        value: ts.factory.createAsExpression(
           ts.factory.createObjectLiteralExpression(
             props.properties
               .filter(
@@ -235,18 +239,18 @@ export namespace ProtobufDecodeProgrammer {
           ),
           TypeFactory.keyword("any"),
         ),
-      ),
+      }),
       ts.factory.createWhileStatement(
         props.condition,
         ts.factory.createBlock([
-          StatementFactory.constant(
-            props.tag,
-            ts.factory.createCallExpression(
-              IdentifierFactory.access(READER())("uint32"),
+          StatementFactory.constant({
+            name: props.tag,
+            value: ts.factory.createCallExpression(
+              IdentifierFactory.access(READER(), "uint32"),
               undefined,
               undefined,
             ),
-          ),
+          }),
           ts.factory.createSwitchStatement(
             ts.factory.createUnsignedRightShift(
               ts.factory.createIdentifier(props.tag),
@@ -257,7 +261,7 @@ export namespace ProtobufDecodeProgrammer {
               ts.factory.createDefaultClause([
                 ts.factory.createExpressionStatement(
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(READER())("skipType"),
+                    IdentifierFactory.access(READER(), "skipType"),
                     undefined,
                     [
                       ts.factory.createBitwiseAnd(
@@ -413,9 +417,7 @@ export namespace ProtobufDecodeProgrammer {
     if (props.type === "string") return decode_bytes("string");
 
     const call: ts.CallExpression = ts.factory.createCallExpression(
-      IdentifierFactory.access(ts.factory.createIdentifier("reader"))(
-        props.type,
-      ),
+      IdentifierFactory.access(READER(), props.type),
       undefined,
       undefined,
     );
@@ -435,7 +437,7 @@ export namespace ProtobufDecodeProgrammer {
 
   const decode_bytes = (method: "bytes" | "string"): ts.Expression =>
     ts.factory.createCallExpression(
-      IdentifierFactory.access(ts.factory.createIdentifier("reader"))(method),
+      IdentifierFactory.access(READER(), method),
       undefined,
       undefined,
     );
@@ -486,25 +488,25 @@ export namespace ProtobufDecodeProgrammer {
           ),
           ts.factory.createBlock(
             [
-              StatementFactory.constant(
-                "piece",
-                ts.factory.createAdd(
+              StatementFactory.constant({
+                name: "piece",
+                value: ts.factory.createAdd(
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(READER())("uint32"),
+                    IdentifierFactory.access(READER(), "uint32"),
                     undefined,
                     undefined,
                   ),
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(READER())("index"),
+                    IdentifierFactory.access(READER(), "index"),
                     undefined,
                     undefined,
                   ),
                 ),
-              ),
+              }),
               ts.factory.createWhileStatement(
                 ts.factory.createLessThan(
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(READER())("index"),
+                    IdentifierFactory.access(READER(), "index"),
                     undefined,
                     undefined,
                   ),
@@ -512,7 +514,7 @@ export namespace ProtobufDecodeProgrammer {
                 ),
                 ts.factory.createExpressionStatement(
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(props.accessor)("push"),
+                    IdentifierFactory.access(props.accessor, "push"),
                     undefined,
                     [decoder()],
                   ),
@@ -523,7 +525,7 @@ export namespace ProtobufDecodeProgrammer {
           ),
           ts.factory.createExpressionStatement(
             ts.factory.createCallExpression(
-              IdentifierFactory.access(props.accessor)("push"),
+              IdentifierFactory.access(props.accessor, "push"),
               undefined,
               [decoder()],
             ),
@@ -533,7 +535,7 @@ export namespace ProtobufDecodeProgrammer {
     } else
       statements.push(
         ts.factory.createCallExpression(
-          IdentifierFactory.access(props.accessor)("push"),
+          IdentifierFactory.access(props.accessor, "push"),
           undefined,
           [decoder()],
         ),
@@ -556,7 +558,7 @@ export namespace ProtobufDecodeProgrammer {
           ? []
           : [
               ts.factory.createCallExpression(
-                IdentifierFactory.access(READER())("uint32"),
+                IdentifierFactory.access(READER(), "uint32"),
                 undefined,
                 undefined,
               ),
@@ -629,7 +631,7 @@ export namespace ProtobufDecodeProgrammer {
         ),
       setter: () =>
         ts.factory.createCallExpression(
-          IdentifierFactory.access(props.accessor)("set"),
+          IdentifierFactory.access(props.accessor, "set"),
           undefined,
           [
             ts.factory.createIdentifier("entry.key"),
@@ -652,27 +654,27 @@ export namespace ProtobufDecodeProgrammer {
       ...(props.required
         ? []
         : [ts.factory.createExpressionStatement(props.initializer())]),
-      StatementFactory.constant(
-        "piece",
-        ts.factory.createAdd(
+      StatementFactory.constant({
+        name: "piece",
+        value: ts.factory.createAdd(
           ts.factory.createCallExpression(
-            IdentifierFactory.access(READER())("uint32"),
+            IdentifierFactory.access(READER(), "uint32"),
             undefined,
             undefined,
           ),
           ts.factory.createCallExpression(
-            IdentifierFactory.access(READER())("index"),
+            IdentifierFactory.access(READER(), "index"),
             undefined,
             undefined,
           ),
         ),
-      ),
+      }),
       ...write_object_function_body({
         context: props.context,
         importer: props.importer,
         condition: ts.factory.createLessThan(
           ts.factory.createCallExpression(
-            IdentifierFactory.access(READER())("index"),
+            IdentifierFactory.access(READER(), "index"),
             undefined,
             undefined,
           ),