typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

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,
           ),

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -45,25 +45,25 @@ export namespace ProtobufEncodeProgrammer {
     });
 
     const callEncoder = (writer: string, factory: ts.NewExpression) =>
-      StatementFactory.constant(
-        writer,
-        ts.factory.createCallExpression(
+      StatementFactory.constant({
+        name: writer,
+        value: ts.factory.createCallExpression(
           ts.factory.createIdentifier("encoder"),
           undefined,
           [factory, ts.factory.createIdentifier("input")],
         ),
-      );
+      });
     return {
       functions: {
-        encoder: StatementFactory.constant(
-          props.importer.useLocal("encoder"),
-          write_encoder({
+        encoder: StatementFactory.constant({
+          name: props.importer.useLocal("encoder"),
+          value: write_encoder({
             context: props.context,
             importer: props.importer,
             collection,
             metadata,
           }),
-        ),
+        }),
       },
       statements: [],
       arrow: ts.factory.createArrowFunction(
@@ -74,7 +74,10 @@ export namespace ProtobufEncodeProgrammer {
             "input",
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           ),
         ],
@@ -100,7 +103,7 @@ export namespace ProtobufEncodeProgrammer {
             ),
             ts.factory.createReturnStatement(
               ts.factory.createCallExpression(
-                IdentifierFactory.access(WRITER())("buffer"),
+                IdentifierFactory.access(WRITER(), "buffer"),
                 undefined,
                 undefined,
               ),
@@ -137,9 +140,9 @@ export namespace ProtobufEncodeProgrammer {
       .objects()
       .filter((obj) => ProtobufUtil.isStaticObject(obj))
       .map((object) =>
-        StatementFactory.constant(
-          `${PREFIX}o${object.index}`,
-          write_object_function({
+        StatementFactory.constant({
+          name: `${PREFIX}o${object.index}`,
+          value: write_object_function({
             context: props.context,
             importer: props.importer,
             input: ts.factory.createIdentifier("input"),
@@ -151,7 +154,7 @@ export namespace ProtobufEncodeProgrammer {
               postfix: "",
             },
           }),
-        ),
+        }),
       );
     const main: ts.Block = decode({
       context: props.context,
@@ -203,7 +206,7 @@ export namespace ProtobufEncodeProgrammer {
         const block = decode({
           ...props,
           index,
-          input: IdentifierFactory.access(props.input)(p.key.getSoleLiteral()!),
+          input: IdentifierFactory.access(props.input, p.key.getSoleLiteral()!),
           metadata: p.value,
         });
         index += ProtobufUtil.size(p.value);
@@ -360,7 +363,7 @@ export namespace ProtobufEncodeProgrammer {
     if (props.metadata.natives.length)
       unions.push({
         type: "bytes",
-        is: () => ExpressionFactory.isInstanceOf("Uint8Array")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Uint8Array", props.input),
         value: (index) =>
           decode_bytes({
             method: "bytes",
@@ -390,7 +393,7 @@ export namespace ProtobufEncodeProgrammer {
     if (props.metadata.maps.length)
       unions.push({
         type: "map",
-        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Map", props.input),
         value: (index) =>
           decode_map({
             ...props,
@@ -411,7 +414,8 @@ export namespace ProtobufEncodeProgrammer {
           ExpressionFactory.isObject({
             checkNull: true,
             checkArray: false,
-          })(props.input),
+            input: props.input,
+          }),
         value: (index) =>
           explore_objects({
             ...props,
@@ -483,7 +487,7 @@ export namespace ProtobufEncodeProgrammer {
       ),
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          IdentifierFactory.access(WRITER())("fork"),
+          IdentifierFactory.access(WRITER(), "fork"),
           undefined,
           undefined,
         ),
@@ -502,7 +506,7 @@ export namespace ProtobufEncodeProgrammer {
       }).statements,
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          IdentifierFactory.access(WRITER())("ldelim"),
+          IdentifierFactory.access(WRITER(), "ldelim"),
           undefined,
           undefined,
         ),
@@ -512,7 +516,10 @@ export namespace ProtobufEncodeProgrammer {
       [
         ts.factory.createForOfStatement(
           undefined,
-          StatementFactory.entry("key")("value"),
+          StatementFactory.entry({
+            key: "key",
+            value: "value",
+          }),
           props.input,
           ts.factory.createBlock(each),
         ),
@@ -565,7 +572,7 @@ export namespace ProtobufEncodeProgrammer {
                 index: props.index,
               }),
               ts.factory.createCallExpression(
-                IdentifierFactory.access(WRITER())("fork"),
+                IdentifierFactory.access(WRITER(), "fork"),
                 undefined,
                 undefined,
               ),
@@ -581,7 +588,7 @@ export namespace ProtobufEncodeProgrammer {
         ...(props.index !== null
           ? [
               ts.factory.createCallExpression(
-                IdentifierFactory.access(WRITER())("ldelim"),
+                IdentifierFactory.access(WRITER(), "ldelim"),
                 undefined,
                 undefined,
               ),
@@ -622,7 +629,7 @@ export namespace ProtobufEncodeProgrammer {
           ts.factory.createIfStatement(
             ts.factory.createStrictInequality(
               ExpressionFactory.number(0),
-              IdentifierFactory.access(props.input)("length"),
+              IdentifierFactory.access(props.input, "length"),
             ),
             block,
           ),
@@ -643,7 +650,7 @@ export namespace ProtobufEncodeProgrammer {
           ),
           ts.factory.createExpressionStatement(
             ts.factory.createCallExpression(
-              IdentifierFactory.access(WRITER())("fork"),
+              IdentifierFactory.access(WRITER(), "fork"),
               undefined,
               undefined,
             ),
@@ -651,7 +658,7 @@ export namespace ProtobufEncodeProgrammer {
           forLoop(null),
           ts.factory.createExpressionStatement(
             ts.factory.createCallExpression(
-              IdentifierFactory.access(WRITER())("ldelim"),
+              IdentifierFactory.access(WRITER(), "ldelim"),
               undefined,
               undefined,
             ),
@@ -674,7 +681,7 @@ export namespace ProtobufEncodeProgrammer {
             ]
           : []),
         ts.factory.createCallExpression(
-          IdentifierFactory.access(WRITER())("bool"),
+          IdentifierFactory.access(WRITER(), "bool"),
           undefined,
           [props.input],
         ),
@@ -699,7 +706,7 @@ export namespace ProtobufEncodeProgrammer {
               ts.factory.createStringLiteral("number"),
               ts.factory.createTypeOfExpression(props.input),
             ),
-            NumericRangeFactory.number(props.type)(props.input),
+            NumericRangeFactory.number(props.type, props.input),
           ),
     value: (index) =>
       ts.factory.createBlock(
@@ -713,7 +720,7 @@ export namespace ProtobufEncodeProgrammer {
               ]
             : []),
           ts.factory.createCallExpression(
-            IdentifierFactory.access(WRITER())(props.type),
+            IdentifierFactory.access(WRITER(), props.type),
             undefined,
             [props.input],
           ),
@@ -739,7 +746,7 @@ export namespace ProtobufEncodeProgrammer {
               ts.factory.createStringLiteral("bigint"),
               ts.factory.createTypeOfExpression(props.input),
             ),
-            NumericRangeFactory.bigint(props.type)(props.input),
+            NumericRangeFactory.bigint(props.type, props.input),
           ),
     value: (index) =>
       ts.factory.createBlock(
@@ -753,7 +760,7 @@ export namespace ProtobufEncodeProgrammer {
               ]
             : []),
           ts.factory.createCallExpression(
-            IdentifierFactory.access(WRITER())(props.type),
+            IdentifierFactory.access(WRITER(), props.type),
             undefined,
             [props.input],
           ),
@@ -774,7 +781,7 @@ export namespace ProtobufEncodeProgrammer {
           index: props.index,
         }),
         ts.factory.createCallExpression(
-          IdentifierFactory.access(WRITER())(props.method),
+          IdentifierFactory.access(WRITER(), props.method),
           undefined,
           [props.input],
         ),
@@ -787,7 +794,7 @@ export namespace ProtobufEncodeProgrammer {
     index: number;
   }): ts.CallExpression =>
     ts.factory.createCallExpression(
-      IdentifierFactory.access(WRITER())("uint32"),
+      IdentifierFactory.access(WRITER(), "uint32"),
       undefined,
       [ExpressionFactory.number((props.index << 3) | props.wire)],
     );
@@ -858,33 +865,37 @@ export namespace ProtobufEncodeProgrammer {
       new Map(props.objects.map((t, i) => [t, props.index! + i]));
 
     if (specList.length === 0) {
-      const condition: ts.Expression = decode_union_object(
-        (input, object, explore) =>
+      const condition: ts.Expression = decode_union_object({
+        checker: (v) =>
           IsProgrammer.decode_object({
             context: props.context,
             importer: props.importer,
-            object,
-            input,
-            explore,
+            object: v.object,
+            input: v.input,
+            explore: v.explore,
           }),
-      )((input, object, explore) =>
-        ExpressionFactory.selfCall(
-          decode_object({
-            context: props.context,
+        decoder: (v) =>
+          ExpressionFactory.selfCall(
+            decode_object({
+              context: props.context,
+              importer: props.importer,
+              index: indexes.get(v.object)!,
+              input: v.input,
+              object: v.object,
+              explore: v.explore,
+            }),
+          ),
+        success: (expr) => expr,
+        escaper: (v) =>
+          create_throw_error({
             importer: props.importer,
-            index: indexes.get(object)!,
-            input,
-            object,
-            explore,
+            expected: v.expected,
+            input: v.input,
           }),
-        ),
-      )((expr) => expr)((input, expected) =>
-        create_throw_error({
-          importer: props.importer,
-          expected,
-          input,
-        }),
-      )(props.input, props.objects, props.explore);
+        input: props.input,
+        objects: props.objects,
+        explore: props.explore,
+      });
       return StatementFactory.block(condition);
     }
     const remained: MetadataObject[] = props.objects.filter(
@@ -896,7 +907,8 @@ export namespace ProtobufEncodeProgrammer {
       .filter((spec) => spec.property.key.getSoleLiteral() !== null)
       .map((spec, i, array) => {
         const key: string = spec.property.key.getSoleLiteral()!;
-        const accessor: ts.Expression = IdentifierFactory.access(props.input)(
+        const accessor: ts.Expression = IdentifierFactory.access(
+          props.input,
           key,
         );
         const pred: ts.Expression = spec.neighbour

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -43,8 +43,14 @@ export namespace ProtobufIsDecodeProgrammer {
       statements: [
         ...is.statements,
         ...decode.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -57,14 +63,14 @@ export namespace ProtobufIsDecodeProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "value",
-              ts.factory.createCallExpression(
+            StatementFactory.constant({
+              name: "value",
+              value: ts.factory.createCallExpression(
                 ts.factory.createIdentifier("__decode"),
                 undefined,
                 [ts.factory.createIdentifier("input")],
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createPrefixUnaryExpression(
                 ts.SyntaxKind.ExclamationToken,

package/src/programmers/protobuf/ProtobufIsEncodeProgrammer.ts

@@ -44,8 +44,14 @@ export namespace ProtobufIsEncodeProgrammer {
       statements: [
         ...is.statements,
         ...encode.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__encode", encode.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__encode",
+          value: encode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -41,8 +41,14 @@ export namespace ProtobufValidateDecodeProgrammer {
       },
       statements: [
         ...validate.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts

@@ -43,8 +43,14 @@ export namespace ProtobufValidateEncodeProgrammer {
       statements: [
         ...validate.statements,
         ...encode.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__encode", encode.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__encode",
+          value: encode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -56,9 +62,9 @@ export namespace ProtobufValidateEncodeProgrammer {
         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 ProtobufValidateEncodeProgrammer {
                 ),
                 TypeFactory.keyword("any"),
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createIdentifier("result.success"),
               ts.factory.createExpressionStatement(