Fix typia.functional module for async or implicit return type case.

When user inputs implicit return typed function into the `typia.functional` module, `typia.functional` could not validate exact return type value. Also, if the input parameter function is a typeof async, it could not be validated, either. This PR fixes such bugs.
samchon · Mar 6, 2024 · 823c52a · 823c52a
1 parent b6aa134
commit 823c52a
Show file tree

Hide file tree

Showing 20 changed files with 168 additions and 186 deletions.
diff --git a/benchmark/package.json b/benchmark/package.json
@@ -73,6 +73,6 @@
     "suppress-warnings": "^1.0.2",
     "tstl": "^2.5.13",
     "uuid": "^9.0.1",
-    "typia": "D:\\github\\samchon\\typia\\typia-5.5.0.tgz"
+    "typia": "D:\\github\\samchon\\typia\\typia-5.5.1.tgz"
   }
 }
diff --git a/debug/features/functional.ts b/debug/features/functional.ts
@@ -1,12 +1,13 @@
 import fs from "fs";
 import typia from "typia";
 
+type Something = Promise<number>;
+const plus = async (x: number, y: number): Something => x + y;
+
 try {
   fs.mkdirSync(__dirname + "/../bin");
 } catch {}
-const func = typia.functional.validateFunction(
-  (x: number, y: number): number => x + y,
-);
+const func = typia.functional.isReturn(plus);
 fs.writeFileSync(`${__dirname}/../bin/functional.js`, func.toString(), "utf8");
 
 console.log(func(3, 4));
diff --git a/debug/package.json b/debug/package.json
@@ -15,6 +15,6 @@
     "typescript": "^5.3.2"
   },
   "dependencies": {
-    "typia": "D:\\github\\samchon\\typia\\typia-5.5.0-dev.20240305.tgz"
+    "typia": "D:\\github\\samchon\\typia\\typia-5.5.1-dev.20240307-2.tgz"
   }
 }
diff --git a/errors/package.json b/errors/package.json
@@ -32,6 +32,6 @@
     "typescript": "^5.3.2"
   },
   "dependencies": {
-    "typia": "D:\\github\\samchon\\typia\\typia-5.5.0.tgz"
+    "typia": "D:\\github\\samchon\\typia\\typia-5.5.1.tgz"
   }
 }
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "5.5.0",
+  "version": "5.5.1",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

diff --git a/packages/typescript-json/package.json b/packages/typescript-json/package.json
@@ -1,6 +1,6 @@
 {
   "name": "typescript-json",
-  "version": "5.5.0",
+  "version": "5.5.1",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -62,7 +62,7 @@
   },
   "homepage": "https://typia.io",
   "dependencies": {
-    "typia": "5.5.0"
+    "typia": "5.5.1"
   },
   "peerDependencies": {
     "typescript": ">=4.8.0 <5.5.0"

diff --git a/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts b/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts
@@ -24,14 +24,7 @@ export namespace FunctionalAssertFunctionProgrammer {
       const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
       const { async, returns } = FunctionAssertReturnProgrammer.returnStatement(
         project,
-      )(modulo)(equals)(
-        expression,
-        declaration.type,
-        declaration.parameters.map((p) =>
-          ts.factory.createIdentifier(p.name.getText()),
-        ),
-        wrapper.name,
-      );
+      )(modulo)(equals)(expression, declaration, wrapper.name);
       return ts.factory.createArrowFunction(
         async
           ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]

diff --git a/src/programmers/functional/FunctionalAssertParametersProgrammer.ts b/src/programmers/functional/FunctionalAssertParametersProgrammer.ts
@@ -6,6 +6,7 @@ import { IProject } from "../../transformers/IProject";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalAssertParametersProgrammer {
   export const write =
@@ -20,13 +21,9 @@ export namespace FunctionalAssertParametersProgrammer {
       const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
         modulo,
       )(declaration.parameters)(init);
-      const async: boolean = (() => {
-        if (declaration.type === undefined) return false;
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-          declaration.type,
-        );
-        return type.isTypeParameter() && type.symbol.name === "Promise";
-      })();
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
       return ts.factory.createArrowFunction(
         async
           ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]

diff --git a/src/programmers/functional/FunctionalAssertReturnProgrammer.ts b/src/programmers/functional/FunctionalAssertReturnProgrammer.ts
@@ -1,11 +1,10 @@
 import ts from "typescript";
 
-import { TypeFactory } from "../../factories/TypeFactory";
-
 import { IProject } from "../../transformers/IProject";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionAssertReturnProgrammer {
   export const write =
@@ -22,14 +21,7 @@ export namespace FunctionAssertReturnProgrammer {
       )(declaration.parameters)(init);
       const { async, returns: statement } = returnStatement(project)(modulo)(
         equals,
-      )(
-        expression,
-        declaration.type,
-        declaration.parameters.map((p) =>
-          ts.factory.createIdentifier(p.name.getText()),
-        ),
-        wrapper.name,
-      );
+      )(expression, declaration, wrapper.name);
       return ts.factory.createArrowFunction(
         async
           ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
@@ -48,25 +40,21 @@ export namespace FunctionAssertReturnProgrammer {
     (equals: boolean) =>
     (
       expression: ts.Expression,
-      typeNode: ts.TypeNode | undefined,
-      argumentExpressions: ts.Expression[],
+      declaration: ts.FunctionDeclaration,
       wrapper: string,
     ): {
       async: boolean;
       returns: ts.ReturnStatement;
     } => {
-      const [type, async]: [ts.Type, boolean] = (() => {
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-          typeNode ?? TypeFactory.keyword("any"),
-        );
-        return type.isTypeParameter() && type.symbol.name === "Promise"
-          ? [type.aliasTypeArguments![0]!, true]
-          : [type, false];
-      })();
+      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
       const caller: ts.CallExpression = ts.factory.createCallExpression(
         expression,
         undefined,
-        argumentExpressions,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
       );
       return {
         async,

diff --git a/src/programmers/functional/FunctionalIsFunctionProgrammer.ts b/src/programmers/functional/FunctionalIsFunctionProgrammer.ts
@@ -25,11 +25,12 @@ export namespace FunctionalIsFunctionProgrammer {
           : undefined,
         undefined,
         declaration.parameters,
-        ts.factory.createUnionTypeNode([
-          declaration.type ??
-            ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-          ts.factory.createTypeReferenceNode("null"),
-        ]),
+        declaration.type
+          ? ts.factory.createUnionTypeNode([
+              declaration.type,
+              ts.factory.createTypeReferenceNode("null"),
+            ])
+          : undefined,
         undefined,
         ts.factory.createBlock(
           [

diff --git a/src/programmers/functional/FunctionalIsParametersProgrammer.ts b/src/programmers/functional/FunctionalIsParametersProgrammer.ts
@@ -5,6 +5,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { IProject } from "../../transformers/IProject";
 
 import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalIsParametersProgrammer {
   export const write =
@@ -15,23 +16,21 @@ export namespace FunctionalIsParametersProgrammer {
       expression: ts.Expression,
       declaration: ts.FunctionDeclaration,
     ): ts.ArrowFunction => {
-      const async: boolean = (() => {
-        if (declaration.type === undefined) return false;
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-          declaration.type,
-        );
-        return type.isTypeParameter() && type.symbol.name === "Promise";
-      })();
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
       return ts.factory.createArrowFunction(
         async
           ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
           : undefined,
         undefined,
         declaration.parameters,
-        ts.factory.createUnionTypeNode([
-          declaration.type ?? TypeFactory.keyword("any"),
-          ts.factory.createTypeReferenceNode("null"),
-        ]),
+        declaration.type
+          ? ts.factory.createUnionTypeNode([
+              declaration.type,
+              ts.factory.createTypeReferenceNode("null"),
+            ])
+          : undefined,
         undefined,
         ts.factory.createBlock(
           [

diff --git a/src/programmers/functional/FunctionalIsReturnProgrammer.ts b/src/programmers/functional/FunctionalIsReturnProgrammer.ts
@@ -1,13 +1,13 @@
 import ts from "typescript";
 
 import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IProject } from "../../transformers/IProject";
 
 import { StringUtil } from "../../utils/StringUtil";
 
 import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalIsReturnProgrammer {
   export const write =
@@ -28,10 +28,12 @@ export namespace FunctionalIsReturnProgrammer {
           : undefined,
         undefined,
         declaration.parameters,
-        ts.factory.createUnionTypeNode([
-          declaration.type ?? TypeFactory.keyword("any"),
-          ts.factory.createTypeReferenceNode("null"),
-        ]),
+        declaration.type
+          ? ts.factory.createUnionTypeNode([
+              declaration.type,
+              ts.factory.createTypeReferenceNode("null"),
+            ])
+          : undefined,
         undefined,
         ts.factory.createBlock(statements, true),
       );
@@ -48,14 +50,9 @@ export namespace FunctionalIsReturnProgrammer {
       async: boolean;
       statements: ts.Statement[];
     } => {
-      const [type, async]: [ts.Type, boolean] = (() => {
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-          declaration.type ?? TypeFactory.keyword("any"),
-        );
-        return type.isTypeParameter() && type.symbol.name === "Promise"
-          ? [type.aliasTypeArguments![0]!, true]
-          : [type, false];
-      })();
+      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
       const caller: ts.CallExpression = ts.factory.createCallExpression(
         expression,
         undefined,

diff --git a/src/programmers/functional/FunctionalValidateParametersProgrammer.ts b/src/programmers/functional/FunctionalValidateParametersProgrammer.ts
@@ -10,6 +10,7 @@ import { StringUtil } from "../../utils/StringUtil";
 
 import { ValidateProgrammer } from "../ValidateProgrammer";
 import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalValidateParametersProgrammer {
   export const write =
@@ -20,13 +21,9 @@ export namespace FunctionalValidateParametersProgrammer {
       expression: ts.Expression,
       declaration: ts.FunctionDeclaration,
     ): ts.ArrowFunction => {
-      const async: boolean = (() => {
-        if (declaration.type === undefined) return false;
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-          declaration.type,
-        );
-        return type.isTypeParameter() && type.symbol.name === "Promise";
-      })();
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
       const caller: ts.CallExpression = ts.factory.createCallExpression(
         expression,
         undefined,

diff --git a/src/programmers/functional/FunctionalValidateReturnProgrammer.ts b/src/programmers/functional/FunctionalValidateReturnProgrammer.ts
@@ -1,14 +1,14 @@
 import ts from "typescript";
 
 import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IProject } from "../../transformers/IProject";
 
 import { StringUtil } from "../../utils/StringUtil";
 
 import { ValidateProgrammer } from "../ValidateProgrammer";
 import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalValidateReturnProgrammer {
   export const write =
@@ -55,14 +55,9 @@ export namespace FunctionalValidateReturnProgrammer {
       async: boolean;
       statements: ts.Statement[];
     } => {
-      const [type, async]: [ts.Type, boolean] = (() => {
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-          declaration.type ?? TypeFactory.keyword("any"),
-        );
-        return type.isTypeParameter() && type.symbol.name === "Promise"
-          ? [type.aliasTypeArguments![0]!, true]
-          : [type, false];
-      })();
+      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
       const caller: ts.CallExpression = ts.factory.createCallExpression(
         expression,
         undefined,

diff --git a/src/programmers/functional/internal/FunctionalGeneralProgrammer.ts b/src/programmers/functional/internal/FunctionalGeneralProgrammer.ts
@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+export namespace FunctionalGeneralProgrammer {
+  export interface IOutput {
+    type: ts.Type;
+    async: boolean;
+  }
+  export const getReturnType =
+    (checker: ts.TypeChecker) =>
+    (declaration: ts.FunctionDeclaration): IOutput => {
+      const signature: ts.Signature | undefined =
+        checker.getSignatureFromDeclaration(declaration);
+      const type: ts.Type =
+        signature?.getReturnType() ??
+        checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
+
+      if (type.symbol?.name === "Promise") {
+        const generic: readonly ts.Type[] = checker.getTypeArguments(
+          type as ts.TypeReference,
+        );
+        return generic.length === 1
+          ? { type: generic[0]!, async: true }
+          : {
+              type: checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+              async: false,
+            };
+      }
+      return { type, async: false };
+    };
+}
diff --git a/test/package.json b/test/package.json
@@ -49,6 +49,6 @@
     "suppress-warnings": "^1.0.2",
     "tstl": "^2.5.13",
     "uuid": "^9.0.1",
-    "typia": "D:\\github\\samchon\\typia\\typia-5.5.0.tgz"
+    "typia": "D:\\github\\samchon\\typia\\typia-5.5.1.tgz"
   }
 }