Fix: Primitive type inferred based on parameter default value (#149)

* Fix: Primitive type inferred based on parameter default value

* Fix default: in param

Author: ShukantPal

common/changes/@webdoc/parser/fix-inferred-param-types_2022-02-19-18-05.json

@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@webdoc/parser",
+      "comment": "Fix parameter type annotation parsing when parameter is assigned a default value (https://github.com/webdoc-labs/webdoc/issues/144)",
+      "type": "none"
+    }
+  ],
+  "packageName": "@webdoc/parser",
+  "email": "[email protected]"
+}

common/changes/@webdoc/parser/fix-inferred-param-types_2022-02-19-18-06.json

@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@webdoc/parser",
+      "comment": "Add primitive type inference for untyped parameters with a default value (https://github.com/webdoc-labs/webdoc/issues/138)",
+      "type": "none"
+    }
+  ],
+  "packageName": "@webdoc/parser",
+  "email": "[email protected]"
+}

packages/webdoc-parser/src/symbols-babel/extract-metadata.js

@@ -3,6 +3,7 @@
 // This file has helper functions for extracting metadata from AST nodes.
 
 import {
+  type BabelNodeExpression,
   type BabelNodeFlow,
   type BabelNodeMemberExpression,
   type BabelNodeQualifiedName,
@@ -24,23 +25,27 @@ import {
   isAnyTypeAnnotation,
   isArrayTypeAnnotation,
   isAssignmentPattern,
+  isBooleanLiteral,
   isBooleanLiteralTypeAnnotation,
   isBooleanTypeAnnotation,
   isClassDeclaration,
   isClassExpression,
   isClassImplements,
+  isExpression,
   isFlowType,
   isFunctionTypeAnnotation,
   isFunctionTypeParam,
   isGenericTypeAnnotation,
   isIdentifier,
   isIntersectionTypeAnnotation,
+  isLiteral,
   isMemberExpression,
   isMixedTypeAnnotation,
   isNullLiteralTypeAnnotation,
   isNullableTypeAnnotation,
   isNumberLiteralTypeAnnotation,
   isNumberTypeAnnotation,
+  isNumericLiteral,
   isObjectExpression,
   isObjectTypeAnnotation,
   isObjectTypeIndexer,
@@ -95,6 +100,7 @@ import {
   isTypeAnnotation,
   isTypeParameterInstantiation,
   isTypeofTypeAnnotation,
+  isUnaryExpression,
   isUnionTypeAnnotation,
   isVoidTypeAnnotation,
 } from "@babel/types";
@@ -217,13 +223,17 @@ export function extractParams(
       };
     } else if (isAssignmentPattern(paramNode)) {
       const extraRaw = paramNode.right.extra && paramNode.right.extra.raw;
+      const [defaultValue, dataType] = extractAssignedValue(paramNode.right);
 
-      paramTypeAnnotation = paramNode.left.typeAnnotation;
       param = {
         identifier: paramNode.left.name,
         optional: paramNode.optional || false,
-        default: paramNode.right.raw || extraRaw,
+        default: paramNode.right.raw || extraRaw || defaultValue,
+        dataType,
       };
+
+      // This will override the inferred data type.
+      paramTypeAnnotation = paramNode.left.typeAnnotation;
     } else if (isObjectExpression(paramNode)) {
       // TODO: Find a way to document {x, y, z} parameters
       // e.g. function ({x, y, z}), you would need to give the object pattern an anonymous like
@@ -264,6 +274,53 @@ export function extractReturns(
   return [];
 }
 
+// Used to get default value
+// TODO: Resolve a lot more expressions
+export function extractRawExpression(expression: BabelNodeExpression): string | void {
+  if (isLiteral(expression)) {
+    if (isStringLiteral(expression)) {
+      return `"${expression.value}"`;
+    } else {
+      return `${expression.value}`;
+    }
+  }
+  if (isUnaryExpression(expression)) {
+    return `-${extractRawExpression(expression.argument) || ""}`;
+  }
+}
+
+export function extractAssignedValue(node: BabelNodeExpression): [?string, ?DataType] {
+  let defaultValue: ?string;
+  let dataType: ?DataType;
+
+  if (isLiteral(node)) {
+    if (isStringLiteral(node)) {
+      // Quotes for strings
+      defaultValue = `"${node.value}"`;
+
+      dataType = createSimpleKeywordType("string");
+    } else {
+      defaultValue = `${node.value}`;
+
+      if (isNumericLiteral(node)) {
+        dataType = createSimpleKeywordType("number");
+      } else if (isBooleanLiteral(node)) {
+        dataType = createSimpleKeywordType("boolean");
+      }
+    }
+  } else if (isExpression(node)) {
+    defaultValue = extractRawExpression(node);
+
+    if (typeof defaultValue === "string") {
+      if (!isNaN(parseFloat(defaultValue))) {
+        dataType = createSimpleKeywordType("number");
+      }
+    }
+  }
+
+  return [defaultValue, dataType];
+}
+
 // Failsafe
 export function extractTypeFailsafe(
   node: BabelNodeTypeAnnotation | BabelNodeTSTypeAnnotation | any,

packages/webdoc-parser/src/symbols-babel/extract-symbol.js

@@ -5,7 +5,6 @@
 
 import {
   type ArrowFunctionExpression,
-  type BabelNodeExpression,
   type FunctionExpression,
   type MemberExpression,
   type Node,
@@ -14,26 +13,22 @@ import {
   isArrowFunctionExpression,
   isAssignmentExpression,
   isAssignmentPattern,
-  isBooleanLiteral,
   isCallExpression,
   isClassDeclaration,
   isClassExpression,
   isClassMethod,
   isClassProperty,
-  isExpression,
   isExpressionStatement,
   isFunctionDeclaration,
   isFunctionExpression,
   isIdentifier,
   isInterfaceDeclaration,
   isLiteral,
   isMemberExpression,
-  isNumericLiteral,
   isObjectExpression,
   isObjectMethod,
   isObjectProperty,
   isReturnStatement,
-  isStringLiteral,
   isTSAsExpression,
   isTSDeclareFunction,
   isTSDeclareMethod,
@@ -45,21 +40,19 @@ import {
   isTSPropertySignature,
   isTSTypeElement,
   isThisExpression,
-  isUnaryExpression,
   isVariableDeclarator,
 } from "@babel/types";
 
 import {OBLIGATE_LEAF, PASS_THROUGH, type Symbol, VIRTUAL, isVirtual} from "../types/Symbol";
 import {PARAMETER, queryType} from "../types/VariableRegistry";
 import {
+  extractAssignedValue,
   extractExtends,
   extractImplements,
   extractParams,
   extractReturns,
   extractType,
 } from "./extract-metadata";
-import type {DataType} from "@webdoc/types";
-import {createSimpleKeywordType} from "@webdoc/model";
 
 // + Extract the symbol name, type from the Node
 // + Set the appopriate flags
@@ -121,7 +114,7 @@ export default function extractSymbol(
     nodeSymbol.meta.scope = node.static ? "static" : "instance";
     nodeSymbol.meta.type = "PropertyDoc";
 
-    const [defaultValue, dataType] = resolveDefaultValue(node.value);
+    const [defaultValue, dataType] = extractAssignedValue(node.value);
 
     if (typeof defaultValue === "string") {
       nodeSymbol.meta.defaultValue = defaultValue;
@@ -243,7 +236,7 @@ export default function extractSymbol(
 
       // Resolve property default
       if (!isInit && init) {
-        const [defaultValue, dataType] = resolveDefaultValue(init);
+        const [defaultValue, dataType] = extractAssignedValue(init);
 
         nodeSymbol.meta.defaultValue = defaultValue;
         nodeSymbol.meta.dataType = dataType;
@@ -429,53 +422,6 @@ function resolveRootObject(expression: MemberExpression): string {
   return isThisExpression(expression) ? "this" : expression.name;
 }
 
-// Used to get default value
-// TODO: Resolve a lot more expressions
-function resolveExpression(expression: BabelNodeExpression): string | void {
-  if (isLiteral(expression)) {
-    if (isStringLiteral(expression)) {
-      return `"${expression.value}"`;
-    } else {
-      return `${expression.value}`;
-    }
-  }
-  if (isUnaryExpression(expression)) {
-    return `-${resolveExpression(expression.argument) || ""}`;
-  }
-}
-
-function resolveDefaultValue(node: BabelNodeExpression): [?string, ?DataType] {
-  let defaultValue: ?string;
-  let dataType: ?DataType;
-
-  if (isLiteral(node)) {
-    if (isStringLiteral(node)) {
-      // Quotes for strings
-      defaultValue = `"${node.value}"`;
-
-      dataType = createSimpleKeywordType("string");
-    } else {
-      defaultValue = `${node.value}`;
-
-      if (isNumericLiteral(node)) {
-        dataType = createSimpleKeywordType("number");
-      } else if (isBooleanLiteral(node)) {
-        dataType = createSimpleKeywordType("boolean");
-      }
-    }
-  } else if (isExpression(node)) {
-    defaultValue = resolveExpression(node);
-
-    if (typeof defaultValue === "string") {
-      if (!isNaN(parseFloat(defaultValue))) {
-        dataType = createSimpleKeywordType("number");
-      }
-    }
-  }
-
-  return [defaultValue, dataType];
-}
-
 // Whether the member expression assigns to this, e.g.
 // this.member.inside.deep -> true
 // top.inside -> false

packages/webdoc-parser/test/lang-ts.js

@@ -203,4 +203,13 @@ describe("@webdoc/parser.LanguageIntegration{@lang ts}", function() {
 
     expect(symbolTree.members[0].meta.params[0].dataType[0]).to.equal("object | string");
   });
+
+  it("should infer primitive parameter types", function() {
+    const symbolTree = buildSymbolTree(`
+      function mark(what = 'test') {
+      }
+    `);
+
+    expect(symbolTree.members[0].meta.params[0].dataType[0]).to.equal("string");
+  });
 });