typia 7.0.0-dev.20241002-2 → 7.0.0-dev.20241005

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -20,14 +20,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 
 export namespace ProtobufDecodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -47,10 +47,10 @@ export namespace ProtobufDecodeProgrammer {
           .map((object) => [
             `${PREFIX}o${object.index}`,
             StatementFactory.constant({
-              name: props.importer.useLocal(`${PREFIX}o${object.index}`),
+              name: props.functor.useLocal(`${PREFIX}o${object.index}`),
               value: write_object_function({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 object,
               }),
             }),
@@ -88,7 +88,7 @@ export namespace ProtobufDecodeProgrammer {
             StatementFactory.constant({
               name: "reader",
               value: ts.factory.createNewExpression(
-                props.importer.use("Reader"),
+                props.context.importer.internal("ProtobufReader"),
                 undefined,
                 [ts.factory.createIdentifier("input")],
               ),
@@ -107,23 +107,23 @@ export namespace ProtobufDecodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
 
   const write_object_function = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     object: MetadataObject;
   }): ts.ArrowFunction =>
     ts.factory.createArrowFunction(
@@ -170,7 +170,7 @@ export namespace ProtobufDecodeProgrammer {
           ),
           ...write_object_function_body({
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             condition: ts.factory.createLessThan(
               ts.factory.createCallExpression(
                 IdentifierFactory.access(READER(), "index"),
@@ -193,7 +193,7 @@ export namespace ProtobufDecodeProgrammer {
 
   const write_object_function_body = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     condition: ts.Expression;
     tag: string;
     output: string;
@@ -204,7 +204,7 @@ export namespace ProtobufDecodeProgrammer {
       .map((p) => {
         const clause = decode_property({
           context: props.context,
-          importer: props.importer,
+          functor: props.functor,
           index,
           accessor: IdentifierFactory.access(
             ts.factory.createIdentifier(props.output),
@@ -326,7 +326,7 @@ export namespace ProtobufDecodeProgrammer {
     ----------------------------------------------------------- */
   const decode_property = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     index: number;
     accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression;
     metadata: Metadata;
@@ -385,7 +385,7 @@ export namespace ProtobufDecodeProgrammer {
         `Map<string, ${entry.value.getName()}>`,
         decode_map({
           context: props.context,
-          importer: props.importer,
+          functor: props.functor,
           accessor: props.accessor,
           entry,
           required,
@@ -401,7 +401,7 @@ export namespace ProtobufDecodeProgrammer {
             })
           : decode_dynamic_object({
               context: props.context,
-              importer: props.importer,
+              functor: props.functor,
               accessor: props.accessor,
               object,
               required,
@@ -568,7 +568,7 @@ export namespace ProtobufDecodeProgrammer {
 
   const decode_dynamic_object = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression;
     object: MetadataObject;
     required: boolean;
@@ -576,7 +576,7 @@ export namespace ProtobufDecodeProgrammer {
     const top: MetadataProperty = props.object.properties[0]!;
     return decode_entry({
       context: props.context,
-      importer: props.importer,
+      functor: props.functor,
       initializer: () =>
         ts.factory.createBinaryExpression(
           props.accessor,
@@ -611,14 +611,14 @@ export namespace ProtobufDecodeProgrammer {
 
   const decode_map = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression;
     entry: Metadata.Entry;
     required: boolean;
   }): ts.Statement[] =>
     decode_entry({
       context: props.context,
-      importer: props.importer,
+      functor: props.functor,
       initializer: () =>
         ts.factory.createBinaryExpression(
           props.accessor,
@@ -644,7 +644,7 @@ export namespace ProtobufDecodeProgrammer {
 
   const decode_entry = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     initializer: () => ts.Expression;
     setter: () => ts.Expression;
     entry: Metadata.Entry;
@@ -671,7 +671,7 @@ export namespace ProtobufDecodeProgrammer {
       }),
       ...write_object_function_body({
         context: props.context,
-        importer: props.importer,
+        functor: props.functor,
         condition: ts.factory.createLessThan(
           ts.factory.createCallExpression(
             IdentifierFactory.access(READER(), "index"),

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -21,7 +21,7 @@ import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 import { ProtobufWire } from "../helpers/ProtobufWire";
 import { UnionPredicator } from "../helpers/UnionPredicator";
@@ -31,7 +31,7 @@ export namespace ProtobufEncodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -56,10 +56,10 @@ export namespace ProtobufEncodeProgrammer {
     return {
       functions: {
         encoder: StatementFactory.constant({
-          name: props.importer.useLocal("encoder"),
+          name: props.functor.useLocal("encoder"),
           value: write_encoder({
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             collection,
             metadata,
           }),
@@ -88,7 +88,7 @@ export namespace ProtobufEncodeProgrammer {
             callEncoder(
               "sizer",
               ts.factory.createNewExpression(
-                props.importer.use("Sizer"),
+                props.context.importer.internal("ProtobufSizer"),
                 undefined,
                 [],
               ),
@@ -96,7 +96,7 @@ export namespace ProtobufEncodeProgrammer {
             callEncoder(
               "writer",
               ts.factory.createNewExpression(
-                props.importer.use("Writer"),
+                props.context.importer.internal("ProtobufWriter"),
                 undefined,
                 [ts.factory.createIdentifier("sizer")],
               ),
@@ -116,23 +116,23 @@ export namespace ProtobufEncodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
 
   const write_encoder = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     collection: MetadataCollection;
     metadata: Metadata;
   }): ts.ArrowFunction => {
@@ -144,7 +144,7 @@ export namespace ProtobufEncodeProgrammer {
           name: `${PREFIX}o${object.index}`,
           value: write_object_function({
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             input: ts.factory.createIdentifier("input"),
             object,
             explore: {
@@ -158,7 +158,7 @@ export namespace ProtobufEncodeProgrammer {
       );
     const main: ts.Block = decode({
       context: props.context,
-      importer: props.importer,
+      functor: props.functor,
       index: null,
       input: ts.factory.createIdentifier("input"),
       metadata: props.metadata,
@@ -180,7 +180,7 @@ export namespace ProtobufEncodeProgrammer {
       undefined,
       ts.factory.createBlock(
         [
-          ...props.importer.declareUnions(),
+          ...props.functor.declareUnions(),
           ...functors,
           ...IsProgrammer.write_function_statements(props),
           ...main.statements,
@@ -195,7 +195,7 @@ export namespace ProtobufEncodeProgrammer {
 
   const write_object_function = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     object: MetadataObject;
     explore: FeatureProgrammer.IExplore;
@@ -235,7 +235,7 @@ export namespace ProtobufEncodeProgrammer {
     ----------------------------------------------------------- */
   const decode = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     index: number | null;
     input: ts.Expression;
     metadata: Metadata;
@@ -434,7 +434,8 @@ export namespace ProtobufEncodeProgrammer {
     else
       return wrapper(
         iterate({
-          importer: props.importer,
+          context: props.context,
+          functor: props.functor,
           index: props.index,
           unions,
           expected: props.metadata.getName(),
@@ -444,7 +445,8 @@ export namespace ProtobufEncodeProgrammer {
   };
 
   const iterate = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     index: number | null;
     unions: IUnion[];
     expected: string;
@@ -472,7 +474,7 @@ export namespace ProtobufEncodeProgrammer {
 
   const decode_map = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     index: number;
     input: ts.Expression;
     entry: Metadata.Entry;
@@ -530,7 +532,7 @@ export namespace ProtobufEncodeProgrammer {
 
   const decode_object = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     index: number | null;
     input: ts.Expression;
     object: MetadataObject;
@@ -580,7 +582,7 @@ export namespace ProtobufEncodeProgrammer {
           : []),
         ts.factory.createCallExpression(
           ts.factory.createIdentifier(
-            props.importer.useLocal(`${PREFIX}o${props.object.index}`),
+            props.functor.useLocal(`${PREFIX}o${props.object.index}`),
           ),
           [],
           [props.input],
@@ -601,7 +603,7 @@ export namespace ProtobufEncodeProgrammer {
 
   const decode_array = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     index: number;
     input: ts.Expression;
     array: MetadataArray;
@@ -834,7 +836,7 @@ export namespace ProtobufEncodeProgrammer {
     ----------------------------------------------------------- */
   const explore_objects = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     level: number;
     index: number | null;
     input: ts.Expression;
@@ -845,7 +847,7 @@ export namespace ProtobufEncodeProgrammer {
     if (props.objects.length === 1)
       return decode_object({
         context: props.context,
-        importer: props.importer,
+        functor: props.functor,
         index: props.indexes
           ? props.indexes.get(props.objects[0]!)!
           : props.index,
@@ -869,7 +871,7 @@ export namespace ProtobufEncodeProgrammer {
         checker: (v) =>
           IsProgrammer.decode_object({
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             object: v.object,
             input: v.input,
             explore: v.explore,
@@ -878,7 +880,7 @@ export namespace ProtobufEncodeProgrammer {
           ExpressionFactory.selfCall(
             decode_object({
               context: props.context,
-              importer: props.importer,
+              functor: props.functor,
               index: indexes.get(v.object)!,
               input: v.input,
               object: v.object,
@@ -888,7 +890,8 @@ export namespace ProtobufEncodeProgrammer {
         success: (expr) => expr,
         escaper: (v) =>
           create_throw_error({
-            importer: props.importer,
+            context: props.context,
+            functor: props.functor,
             expected: v.expected,
             input: v.input,
           }),
@@ -914,7 +917,7 @@ export namespace ProtobufEncodeProgrammer {
         const pred: ts.Expression = spec.neighbour
           ? IsProgrammer.decode({
               context: props.context,
-              importer: props.importer,
+              functor: props.functor,
               input: accessor,
               metadata: spec.property.value,
               explore: {
@@ -930,7 +933,7 @@ export namespace ProtobufEncodeProgrammer {
             ExpressionFactory.selfCall(
               decode_object({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 index: indexes.get(spec.object)!,
                 input: props.input,
                 object: spec.object,
@@ -944,7 +947,7 @@ export namespace ProtobufEncodeProgrammer {
                   ExpressionFactory.selfCall(
                     explore_objects({
                       context: props.context,
-                      importer: props.importer,
+                      functor: props.functor,
                       level: props.level + 1,
                       index: props.index,
                       input: props.input,
@@ -955,7 +958,8 @@ export namespace ProtobufEncodeProgrammer {
                   ),
                 )
               : create_throw_error({
-                  importer: props.importer,
+                  context: props.context,
+                  functor: props.functor,
                   input: props.input,
                   expected,
                 })
@@ -977,17 +981,22 @@ export namespace ProtobufEncodeProgrammer {
   const PREFIX = "$pe";
 
   const create_throw_error = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     expected: string;
     input: ts.Expression;
   }) =>
     ts.factory.createExpressionStatement(
       ts.factory.createCallExpression(
-        props.importer.use("throws"),
+        props.context.importer.internal("throwTypeGuardError"),
         [],
         [
           ts.factory.createObjectLiteralExpression(
             [
+              ts.factory.createPropertyAssignment(
+                "method",
+                ts.factory.createStringLiteral(props.functor.method),
+              ),
               ts.factory.createPropertyAssignment(
                 "expected",
                 ts.factory.createStringLiteral(props.expected),

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -8,14 +8,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
 
 export namespace ProtobufIsDecodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -93,16 +93,16 @@ export namespace ProtobufIsDecodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/protobuf/ProtobufIsEncodeProgrammer.ts

@@ -9,14 +9,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
 
 export namespace ProtobufIsEncodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -82,16 +82,16 @@ export namespace ProtobufIsEncodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -8,14 +8,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
 
 export namespace ProtobufValidateDecodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -74,16 +74,16 @@ export namespace ProtobufValidateDecodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts

@@ -9,14 +9,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
 
 export namespace ProtobufValidateEncodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -98,16 +98,16 @@ export namespace ProtobufValidateEncodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };