src-transpiler/expandType: Implement JSDocFunctionType (#213)

* src-transpiler/expandType: Implement `JSDocFunctionType`

* Add unit test

Author: kungfooman

src-transpiler/expandType.js

@@ -61,18 +61,22 @@ export const requiredTypeofs = {};
  * This function handles various TypeScript AST node types and converts them into a string
  * or an object representing the type.
  *
- * @param {ts.TypeNode|ts.Identifier|ts.QualifiedName} node - The TypeScript AST node to convert.
+ * @param {ts.TypeNode|ts.Identifier|ts.QualifiedName|undefined} node - The TypeScript AST node to convert.
  * @returns {string | number | boolean | {type: string, [key: string]: any} | undefined} The source string/number,
  * or an object with type information based on the node, or `undefined` if the node kind is not handled.
  */
 function toSourceTS(node) {
+  if (!node) {
+    return 'undefined';
+  }
   const {typeArguments, typeName} = node;
   const kind_ = ts.SyntaxKind[node.kind];
   const {
     AnyKeyword,          // parseType('any'                            ).kind                 === ts.SyntaxKind.AnyKeyword && toSourceTS(parseType('any')) === 'any'
     ArrayType,           // parseType('number[]'                       ).kind                 === ts.SyntaxKind.ArrayType // todo toSourceTS(parseType('number[]')) === {type: 'array etc.
     BooleanKeyword,      // parseType("boolean"                        ).kind                 === ts.SyntaxKind.BooleanKeyword
     FunctionType,        // parseType("() => void"                     ).kind                 === ts.SyntaxKind.FunctionType
+    JSDocFunctionType,   // parseType("function (number, number): number").kind               === ts.SyntaxKind.JSDocFunctionType
     Identifier,          // parseType("{a: 1, b: 2}"                   ).members[0].name.kind === ts.SyntaxKind.Identifier
     IntersectionType,    // parseType("1 & 2"                          ).kind                 === ts.SyntaxKind.IntersectionType
     JSDocAllType,        // parseType("*"                              ).kind                 === ts.SyntaxKind.JSDocAllType
@@ -144,12 +148,20 @@ function toSourceTS(node) {
       const ret = toSourceTS(node.type);
       return {type: 'new', parameters, ret};
     }
-    case FunctionType:
+    case FunctionType: {
       if (!ts.isFunctionTypeNode(node)) {
         throw Error("Impossible");
       }
       const parameters = node.parameters.map(toSourceTS);
       return {type: 'function', parameters};
+    }
+    case JSDocFunctionType: {
+      if (!ts.isJSDocFunctionType(node)) {
+        throw Error("Impossible");
+      }
+      const parameters = node.parameters.map(toSourceTS);
+      return {type: 'function', parameters};
+    }
     case IndexedAccessType:
       if (!ts.isIndexedAccessTypeNode(node)) {
         throw Error("Impossible");

test/typechecking.json

@@ -35,6 +35,10 @@
     "input": "./test/typechecking/JSDoc-FunctionExpression-ExpressionStatement-input.mjs",
     "output": "./test/typechecking/JSDoc-FunctionExpression-ExpressionStatement-output.mjs"
   },
+  {
+    "input": "./test/typechecking/JSDocFunctionType-input.mjs",
+    "output": "./test/typechecking/JSDocFunctionType-output.mjs"
+  },
   {
     "input": "./test/typechecking/ParenthesizedExpression-multiline-input.mjs",
     "output": "./test/typechecking/ParenthesizedExpression-multiline-output.mjs"

test/typechecking/JSDocFunctionType-input.mjs

@@ -0,0 +1,8 @@
+/**
+ * @param {function (number, number): number} cb
+ */
+function op(cb, a, b) {
+  return cb(a, b);
+}
+const ret = op((a, b) => a + b, 10, 20);
+console.log("ret", ret);

test/typechecking/JSDocFunctionType-output.mjs

@@ -0,0 +1,26 @@
+/**
+ * @param {function (number, number): number} cb
+ */
+function op(cb, a, b) {
+  if (!inspectType(cb, {
+    "type": "function",
+    "parameters": [
+      {
+        "type": "number",
+        "name": "undefined"
+      },
+      {
+        "type": "number",
+        "name": "undefined"
+      }
+    ],
+    "optional": false
+  }, 'op', 'cb')) {
+    youCanAddABreakpointHere();
+  }
+  return cb(a, b);
+}
+const ret = op((a, b) => {
+  return a + b;
+}, 10, 20);
+console.log("ret", ret);