feat(getCallExpressionIdentifier): add resolveCallExpression option (#194)

Author: fraxken

workspaces/estree-ast-utils/README.md

@@ -58,7 +58,7 @@ One of the options of the method is `stopOnUnsupportedNode`, if true it will thr
 
 </details>
 
-<details><summary>getCallExpressionIdentifier(node): string | null</summary>
+<details><summary>getCallExpressionIdentifier(node, options): string | null</summary>
 
 Return the identifier name of the CallExpression (or null if there is none).
 
@@ -68,6 +68,17 @@ foobar();
 
 will return `"foobar"`.
 
+One of the options of the method is `resolveCallExpression` (which is true by default).
+
+Sometimes you don't want to resolve/jump early CallExpression like in the following example:
+```js
+require('./file.js')();
+//     ^ Second     ^ First
+```
+
+With **resolveCallExpression** equal to **false** the function return `null`.
+
+
 </details>
 
 <details><summary>getMemberExpressionIdentifier(node): IterableIterator< string ></summary>

workspaces/estree-ast-utils/src/getCallExpressionIdentifier.js

@@ -1,21 +1,29 @@
 // Import Internal Dependencies
 import { getMemberExpressionIdentifier } from "./getMemberExpressionIdentifier.js";
+import { VariableTracer } from "./utils/VariableTracer.js";
 
 /**
  * @param {any} node
+ * @param {object} options
+ * @param {VariableTracer} [options.tracer=null]
+ * @param {boolean} [options.resolveCallExpression=true]
  * @returns {string | null}
  */
-export function getCallExpressionIdentifier(node) {
+export function getCallExpressionIdentifier(node, options = {}) {
   if (node.type !== "CallExpression") {
     return null;
   }
+  const { tracer = null, resolveCallExpression = true } = options;
 
   if (node.callee.type === "Identifier") {
     return node.callee.name;
   }
   if (node.callee.type === "MemberExpression") {
-    return [...getMemberExpressionIdentifier(node.callee)].join(".");
+    return [
+      ...getMemberExpressionIdentifier(node.callee, { tracer })
+    ].join(".");
   }
 
-  return getCallExpressionIdentifier(node.callee);
+  return resolveCallExpression ?
+    getCallExpressionIdentifier(node.callee, { tracer }) : null;
 }

workspaces/estree-ast-utils/src/index.d.ts

@@ -16,7 +16,7 @@ export function getCallExpressionArguments(
 ): string[] | null;
 
 export function getCallExpressionIdentifier(
-  node: any
+  node: any, options?: { tracer?: VariableTracer, resolveCallExpression?: boolean }
 ): string | null;
 
 export function getMemberExpressionIdentifier(

workspaces/estree-ast-utils/test/getCallExpressionIdentifier.spec.js

@@ -13,18 +13,54 @@ test("given a JavaScript eval CallExpression then it must return eval", (tape) =
   tape.end();
 });
 
-test("given a JavaScript Function() CallExpression then it must return Function", (tape) => {
+test("given a Function(`...`)() Double CallExpression then it must return the Function literal identifier", (tape) => {
   const [astNode] = codeToAst("Function(\"return this\")();");
   const nodeIdentifier = getCallExpressionIdentifier(getExpressionFromStatement(astNode));
 
   tape.strictEqual(nodeIdentifier, "Function");
   tape.end();
 });
 
+test(`given a Function("...")() Double CallExpression with resolveCallExpression options disabled
+then it must return null`, (tape) => {
+  const [astNode] = codeToAst("Function(\"return this\")();");
+  const nodeIdentifier = getCallExpressionIdentifier(
+    getExpressionFromStatement(astNode),
+    { resolveCallExpression: false }
+  );
+
+  tape.strictEqual(nodeIdentifier, null);
+  tape.end();
+});
+
 test("given a JavaScript AssignmentExpression then it must return null", (tape) => {
   const [astNode] = codeToAst("foo = 10;");
   const nodeIdentifier = getCallExpressionIdentifier(getExpressionFromStatement(astNode));
 
   tape.strictEqual(nodeIdentifier, null);
   tape.end();
 });
+
+test(`given a require statement immediatly invoked with resolveCallExpression options enabled
+then it must return require literal identifier`, (tape) => {
+  const [astNode] = codeToAst("require('foo')();");
+  const nodeIdentifier = getCallExpressionIdentifier(
+    getExpressionFromStatement(astNode),
+    { resolveCallExpression: true }
+  );
+
+  tape.strictEqual(nodeIdentifier, "require");
+  tape.end();
+});
+
+test(`given a require statement immediatly invoked with resolveCallExpression options disabled
+then it must return null`, (tape) => {
+  const [astNode] = codeToAst("require('foo')();");
+  const nodeIdentifier = getCallExpressionIdentifier(
+    getExpressionFromStatement(astNode),
+    { resolveCallExpression: false }
+  );
+
+  tape.strictEqual(nodeIdentifier, null);
+  tape.end();
+});