typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/programmers/PruneProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
@@ -27,19 +27,15 @@ export namespace PruneProgrammer {
             write(project)(modulo)(type, name);
 
     export const write =
-        (project: IProject) => (modulo: ts.LeftHandSideExpression) => {
-            const importer: FunctionImporter = new FunctionImporter();
-            return FeatureProgrammer.analyze(project)({
-                ...configure(project)(importer),
+        (p: IProject) => (modulo: ts.LeftHandSideExpression) => {
+            const importer: FunctionImporter = new FunctionImporter(p.tsc);
+            return FeatureProgrammer.analyze(p)({
+                ...configure(p)(importer),
                 addition: (collection) => {
                     const isFunctors =
-                        IsProgrammer.write_functors(project)(importer)(
-                            collection,
-                        );
+                        IsProgrammer.write_functors(p)(importer)(collection);
                     const isUnioners =
-                        IsProgrammer.write_unioners(project)(importer)(
-                            collection,
-                        );
+                        IsProgrammer.write_unioners(p)(importer)(collection);
 
                     return [
                         ...importer.declare(modulo),
@@ -58,14 +54,15 @@ export namespace PruneProgrammer {
         DECODERS
     ----------------------------------------------------------- */
     const decode =
-        (project: IProject) =>
+        (p: IProject) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
             meta: Metadata,
             explore: FeatureProgrammer.IExplore,
         ): ts.ConciseBody => {
-            if (filter(meta) === false) return ts.factory.createBlock([]);
+            const tsc: typeof ts = p.tsc;
+            if (filter(meta) === false) return tsc.factory.createBlock([]);
 
             interface IUnion {
                 type: string;
@@ -84,7 +81,7 @@ export namespace PruneProgrammer {
                 unions.push({
                     type: "tuple",
                     is: () =>
-                        IsProgrammer.decode(project, importer)(
+                        IsProgrammer.decode(p)(importer)(
                             input,
                             (() => {
                                 const partial = Metadata.initialize();
@@ -96,16 +93,16 @@ export namespace PruneProgrammer {
                             [],
                         ),
                     value: () =>
-                        decode_tuple(project)(importer)(input, tuple, explore),
+                        decode_tuple(p)(importer)(input, tuple, explore),
                 });
 
             // ARRAYS
             if (meta.arrays.filter(filter).length)
                 unions.push({
                     type: "array",
-                    is: () => ExpressionFactory.isArray(input),
+                    is: () => ExpressionFactory.isArray(tsc)(input),
                     value: () =>
-                        explore_arrays(project)(importer)(
+                        explore_arrays(p)(importer)(
                             input,
                             meta.arrays,
                             {
@@ -122,20 +119,21 @@ export namespace PruneProgrammer {
                 for (const native of meta.natives)
                     unions.push({
                         type: "native",
-                        is: () => ExpressionFactory.isInstanceOf(native)(input),
-                        value: () => ts.factory.createReturnStatement(),
+                        is: () =>
+                            ExpressionFactory.isInstanceOf(tsc)(native)(input),
+                        value: () => tsc.factory.createReturnStatement(),
                     });
             if (meta.sets.length)
                 unions.push({
                     type: "set",
-                    is: () => ExpressionFactory.isInstanceOf("Set")(input),
-                    value: () => ts.factory.createReturnStatement(),
+                    is: () => ExpressionFactory.isInstanceOf(tsc)("Set")(input),
+                    value: () => tsc.factory.createReturnStatement(),
                 });
             if (meta.maps.length)
                 unions.push({
                     type: "map",
-                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
-                    value: () => ts.factory.createReturnStatement(),
+                    is: () => ExpressionFactory.isInstanceOf(tsc)("Map")(input),
+                    value: () => tsc.factory.createReturnStatement(),
                 });
 
             // OBJECTS
@@ -143,12 +141,12 @@ export namespace PruneProgrammer {
                 unions.push({
                     type: "object",
                     is: () =>
-                        ExpressionFactory.isObject({
+                        ExpressionFactory.isObject(tsc)({
                             checkNull: true,
                             checkArray: false,
                         })(input),
                     value: () =>
-                        explore_objects(importer)(input, meta, {
+                        explore_objects(tsc)(importer)(input, meta, {
                             ...explore,
                             from: "object",
                         }),
@@ -160,18 +158,18 @@ export namespace PruneProgrammer {
             const converter = (
                 v: ts.Expression | ts.Block | ts.ReturnStatement,
             ) =>
-                ts.isReturnStatement(v) || ts.isBlock(v)
+                tsc.isReturnStatement(v) || tsc.isBlock(v)
                     ? v
-                    : ts.factory.createExpressionStatement(v);
+                    : tsc.factory.createExpressionStatement(v);
 
             const statements: ts.Statement[] = unions.map((u) =>
-                ts.factory.createIfStatement(u.is(), converter(u.value())),
+                tsc.factory.createIfStatement(u.is(), converter(u.value())),
             );
-            return ts.factory.createBlock(statements, true);
+            return tsc.factory.createBlock(statements, true);
         };
 
     const decode_tuple =
-        (project: IProject) =>
+        (p: IProject) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -182,8 +180,11 @@ export namespace PruneProgrammer {
                 .map((elem, index) => [elem, index] as const)
                 .filter(([elem]) => filter(elem) && elem.rest === null)
                 .map(([elem, index]) =>
-                    decode(project)(importer)(
-                        ts.factory.createElementAccessExpression(input, index),
+                    decode(p)(importer)(
+                        p.tsc.factory.createElementAccessExpression(
+                            input,
+                            index,
+                        ),
                         elem,
                         {
                             ...explore,
@@ -198,11 +199,11 @@ export namespace PruneProgrammer {
                 const rest: Metadata | null = last.rest;
                 if (rest === null || filter(rest) === false) return null;
 
-                return decode(project)(importer)(
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(input)("slice"),
+                return decode(p)(importer)(
+                    p.tsc.factory.createCallExpression(
+                        IdentifierFactory.access(p.tsc)(input)("slice"),
                         undefined,
-                        [ts.factory.createNumericLiteral(tuple.length - 1)],
+                        [p.tsc.factory.createNumericLiteral(tuple.length - 1)],
                     ),
                     (() => {
                         const wrapper: Metadata = Metadata.initialize();
@@ -215,33 +216,33 @@ export namespace PruneProgrammer {
                     },
                 );
             })();
-            return PruneJoiner.tuple(children, rest);
+            return PruneJoiner.tuple(p.tsc)(children, rest);
         };
 
-    const decode_array = (project: IProject) => (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_array(configure(project)(importer))(importer)(
-            PruneJoiner.array,
+    const decode_array = (p: IProject) => (importer: FunctionImporter) =>
+        FeatureProgrammer.decode_array(p.tsc)(configure(p)(importer))(importer)(
+            PruneJoiner.array(p.tsc),
         );
 
-    const decode_object = (importer: FunctionImporter) =>
-        FeatureProgrammer.decode_object({
+    const decode_object = (tsc: typeof ts) => (importer: FunctionImporter) =>
+        FeatureProgrammer.decode_object(tsc)({
             trace: false,
             path: false,
             functors: FUNCTORS,
         })(importer);
 
-    const explore_arrays =
-        (project: IProject) => (importer: FunctionImporter) =>
-            UnionExplorer.array({
-                checker: IsProgrammer.decode(project, importer),
-                decoder: decode_array(project)(importer),
-                empty: ts.factory.createReturnStatement(),
-                success: ts.factory.createTrue(),
-                failure: (input, expected) =>
-                    create_throw_error(importer)(expected)(input),
-            });
+    const explore_arrays = (p: IProject) => (importer: FunctionImporter) =>
+        UnionExplorer.array(p.tsc)({
+            checker: IsProgrammer.decode(p)(importer),
+            decoder: decode_array(p)(importer),
+            empty: p.tsc.factory.createReturnStatement(),
+            success: p.tsc.factory.createTrue(),
+            failure: (input, expected) =>
+                create_throw_error(p.tsc)(importer)(expected)(input),
+        });
 
     const explore_objects =
+        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (
             input: ts.Expression,
@@ -249,14 +250,14 @@ export namespace PruneProgrammer {
             explore: FeatureProgrammer.IExplore,
         ) => {
             if (meta.objects.length === 1)
-                return decode_object(importer)(
+                return decode_object(tsc)(importer)(
                     input,
                     meta.objects[0]!,
                     explore,
                 );
 
-            return ts.factory.createCallExpression(
-                ts.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
+            return tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
                 undefined,
                 [input],
             );
@@ -275,44 +276,43 @@ export namespace PruneProgrammer {
     const UNIONERS = "$pu";
 
     const configure =
-        (project: IProject) =>
+        (p: IProject) =>
         (importer: FunctionImporter): FeatureProgrammer.IConfig => ({
             types: {
                 input: (type, name) =>
-                    ts.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(project.checker)(type),
+                    p.tsc.factory.createTypeReferenceNode(
+                        name ?? TypeFactory.getFullName(p)(type),
                     ),
-                output: () => TypeFactory.keyword("void"),
+                output: () => TypeFactory.keyword(p.tsc)("void"),
             },
             functors: FUNCTORS,
             unioners: UNIONERS,
             trace: false,
             path: false,
             initializer,
-            decoder: decode(project)(importer),
-            objector: objector(project)(importer),
+            decoder: decode(p)(importer),
+            objector: objector(p)(importer),
         });
 
     const objector =
-        (project: IProject) =>
+        (p: IProject) =>
         (importer: FunctionImporter): FeatureProgrammer.IConfig.IObjector => ({
-            checker: IsProgrammer.decode(project, importer),
-            decoder: decode_object(importer),
-            joiner: PruneJoiner.object,
-            unionizer: decode_union_object(
-                IsProgrammer.decode_object(importer),
-            )(decode_object(importer))((exp) => exp)((value, expected) =>
-                create_throw_error(importer)(expected)(value),
+            checker: IsProgrammer.decode(p)(importer),
+            decoder: decode_object(p.tsc)(importer),
+            joiner: PruneJoiner.object(p.tsc),
+            unionizer: decode_union_object(p.tsc)(
+                IsProgrammer.decode_object(p.tsc)(importer),
+            )(decode_object(p.tsc)(importer))((exp) => exp)((value, expected) =>
+                create_throw_error(p.tsc)(importer)(expected)(value),
             ),
             failure: (input, expected) =>
-                create_throw_error(importer)(expected)(input),
+                create_throw_error(p.tsc)(importer)(expected)(input),
         });
 
     const initializer: FeatureProgrammer.IConfig["initializer"] =
-        ({ checker }) =>
-        (type) => {
+        (p) => (type) => {
             const collection = new MetadataCollection();
-            const meta = MetadataFactory.analyze(checker)({
+            const meta = MetadataFactory.analyze(p)({
                 resolve: false,
                 constant: true,
             })(collection)(type);
@@ -320,21 +320,22 @@ export namespace PruneProgrammer {
         };
 
     const create_throw_error =
+        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (expected: string) =>
         (value: ts.Expression) =>
-            ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
+            tsc.factory.createExpressionStatement(
+                tsc.factory.createCallExpression(
                     importer.use("throws"),
                     [],
                     [
-                        ts.factory.createObjectLiteralExpression(
+                        tsc.factory.createObjectLiteralExpression(
                             [
-                                ts.factory.createPropertyAssignment(
+                                tsc.factory.createPropertyAssignment(
                                     "expected",
-                                    ts.factory.createStringLiteral(expected),
+                                    tsc.factory.createStringLiteral(expected),
                                 ),
-                                ts.factory.createPropertyAssignment(
+                                tsc.factory.createPropertyAssignment(
                                     "value",
                                     value,
                                 ),