Improved Identifier scanning, function length calculator + tests

MichaelXF · MichaelXF · commit 484c5dfe9740 · 2023-07-02T22:03:48.000-04:00
diff --git a/src/util/gen.ts b/src/util/gen.ts
@@ -171,7 +171,12 @@ export function BreakStatement(label?: string) {
   };
 }
 
-export function Property(key: Node, value: Node, computed = false) {
+export function Property(
+  key: Node,
+  value: Node,
+  computed = false,
+  kind: "init" | "set" | "get" = "init"
+) {
   if (!key) {
     throw new Error("key is undefined");
   }
@@ -183,7 +188,7 @@ export function Property(key: Node, value: Node, computed = false) {
     key: key,
     computed: computed,
     value: value,
-    kind: "init",
+    kind: kind,
     method: false,
     shorthand: false,
   };
diff --git a/src/util/identifiers.ts b/src/util/identifiers.ts
@@ -30,6 +30,23 @@ export function validateChain(object: Node, parents: Node[]) {
   }
 }
 
+function objectPatternCheck(object: Node, parents: Node[]) {
+  var objectPatternIndex = parents.findIndex((x) => x.type === "ObjectPattern");
+  if (objectPatternIndex == -1) {
+    return true;
+  }
+
+  var property = parents[objectPatternIndex].properties.find(
+    (property) => parents[objectPatternIndex - 2] === property
+  );
+
+  if (property.key === (parents[objectPatternIndex - 3] || object)) {
+    return false;
+  }
+
+  return true;
+}
+
 /**
  * Returns detailed information about the given Identifier node.
  * @param object
@@ -74,7 +91,22 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
   var isVariableDeclaration =
     varIndex != -1 &&
     parents[varIndex].id == (parents[varIndex - 1] || object) &&
-    parents.find((x) => x.type == "VariableDeclaration");
+    parents.find((x) => x.type == "VariableDeclaration") &&
+    objectPatternCheck(object, parents);
+
+  // Assignment pattern check!
+  if (isVariableDeclaration) {
+    var slicedParents = parents.slice(0, varIndex - 1);
+    var i = 0;
+    for (var parent of slicedParents) {
+      var childNode = slicedParents[i - 1] || object;
+      if (parent.type === "AssignmentPattern" && parent.right === childNode) {
+        isVariableDeclaration = false;
+        break;
+      }
+      i++;
+    }
+  }
 
   var forIndex = parents.findIndex((x) => x.type == "ForStatement");
   var isForInitializer =
@@ -87,6 +119,12 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
     functionIndex != -1 &&
     parents[functionIndex].type == "FunctionDeclaration" &&
     parents[functionIndex].id == object;
+
+  var isNamedFunctionExpression =
+    functionIndex != -1 &&
+    parents[functionIndex].type === "FunctionExpression" &&
+    parents[functionIndex].id === object;
+
   var isAFunctionParameter = isFunctionParameter(object, parents);
 
   var isClauseParameter = false;
@@ -112,7 +150,9 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
 
   var isAssignmentLeft =
     assignmentIndex !== -1 &&
-    parents[assignmentIndex].left === (parents[assignmentIndex - 1] || object);
+    parents[assignmentIndex].left ===
+      (parents[assignmentIndex - 1] || object) &&
+    objectPatternCheck(object, parents);
   var isAssignmentValue =
     assignmentIndex !== -1 &&
     parents[assignmentIndex].right === (parents[assignmentIndex - 1] || object);
@@ -272,6 +312,7 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
       isDefined:
         isVariableDeclaration ||
         isFunctionDeclaration ||
+        isNamedFunctionExpression ||
         isAFunctionParameter ||
         isClassDeclaration ||
         isClauseParameter ||
diff --git a/src/util/insert.ts b/src/util/insert.ts
@@ -145,13 +145,13 @@ export function getAllDefiningContexts(o: Node, p: Node[]): Node[] {
     // Get Function
     var fn = getFunction(o, p);
 
-    contexts.push(fn.body);
+    // contexts.push(fn.body);
   }
 
   if (info.isClauseParameter) {
     var catchClause = p.find((x) => x.type === "CatchClause");
     if (catchClause) {
-      contexts.push(catchClause.body);
+      return [catchClause];
     }
   }
 
@@ -376,3 +376,27 @@ export function isForInitialize(
 
   return false;
 }
+
+/**
+ * Computes the `function.length` property given the parameter nodes.
+ *
+ * @param params
+ * @returns
+ */
+export function computeFunctionLength(params: Node[]): number {
+  var count = 0;
+
+  for (var parameterNode of params) {
+    if (
+      parameterNode.type === "Identifier" ||
+      parameterNode.type === "ObjectPattern" ||
+      parameterNode.type === "ArrayPattern"
+    ) {
+      count++;
+    } else {
+      break;
+    }
+  }
+
+  return count;
+}
diff --git a/test/util/identifiers.test.ts b/test/util/identifiers.test.ts
@@ -1,4 +1,7 @@
-import parseJS from "../../src/parser";
+import { ok } from "assert";
+import parseJS, { parseSync } from "../../src/parser";
+import traverse from "../../src/traverse";
+import { Location, Node } from "../../src/util/gen";
 import {
   getFunctionParameters,
   getIdentifierInfo,
@@ -41,6 +44,115 @@ describe("getIdentifierInfo", () => {
       getIdentifierInfo({ type: "Literal", value: true }, []);
     }).toThrow();
   });
+
+  function findIdentifier(tree: Node, identifierName: string) {
+    var searchLocation: Location;
+
+    traverse(tree, (o, p) => {
+      if (o.type === "Identifier" && o.name === identifierName) {
+        ok(!searchLocation);
+        searchLocation = [o, p];
+      }
+    });
+
+    ok(searchLocation);
+    return searchLocation;
+  }
+
+  test("Variant #4: Variable declaration assignment pattern", async () => {
+    var tree = parseSync(`
+      var [ definedIdentifier = nonDefinedIdentifier ] = [];
+    `);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
+  });
+
+  test("Variant #5: Function parameter assignment pattern", async () => {
+    var tree = parseSync(`
+      function myFunction(definedIdentifier = nonDefinedIdentifier) {
+
+      }
+    `);
+
+    var myFunction = findIdentifier(tree, "myFunction");
+    var myFunctionInfo = getIdentifierInfo(myFunction[0], myFunction[1]);
+
+    expect(myFunctionInfo.isFunctionDeclaration).toStrictEqual(true);
+    expect(myFunctionInfo.spec.isDefined).toStrictEqual(true);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(true);
+  });
+
+  test("Variant #6: Object pattern", async () => {
+    var tree = parseSync(`
+      var { nonDefinedIdentifier: definedIdentifier } = {};
+
+      ( { nonModifiedIdentifier: modifiedIdentifier } = {} );
+    `);
+
+    var definedIdentifier = findIdentifier(tree, "definedIdentifier");
+    var definedInfo = getIdentifierInfo(
+      definedIdentifier[0],
+      definedIdentifier[1]
+    );
+    expect(definedInfo.spec.isDefined).toStrictEqual(true);
+    expect(definedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonDefinedIdentifier = findIdentifier(tree, "nonDefinedIdentifier");
+    var nonDefinedInfo = getIdentifierInfo(
+      nonDefinedIdentifier[0],
+      nonDefinedIdentifier[1]
+    );
+    expect(nonDefinedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonDefinedInfo.spec.isReferenced).toStrictEqual(false);
+
+    var modifiedIdentifier = findIdentifier(tree, "modifiedIdentifier");
+    var modifiedInfo = getIdentifierInfo(
+      modifiedIdentifier[0],
+      modifiedIdentifier[1]
+    );
+    expect(modifiedInfo.spec.isDefined).toStrictEqual(false);
+    expect(modifiedInfo.spec.isModified).toStrictEqual(true);
+    expect(modifiedInfo.spec.isReferenced).toStrictEqual(true);
+
+    var nonModifiedIdentifier = findIdentifier(tree, "nonModifiedIdentifier");
+    var nonModifiedInfo = getIdentifierInfo(
+      nonModifiedIdentifier[0],
+      nonModifiedIdentifier[1]
+    );
+
+    expect(nonModifiedInfo.spec.isDefined).toStrictEqual(false);
+    expect(nonModifiedInfo.spec.isModified).toStrictEqual(false);
+    expect(nonModifiedInfo.spec.isReferenced).toStrictEqual(false);
+  });
 });
 
 describe("validateChain", () => {
diff --git a/test/util/insert.test.ts b/test/util/insert.test.ts
@@ -1,7 +1,8 @@
+import { ok } from "assert";
 import { compileJsSync } from "../../src/compiler";
-import parseJS from "../../src/parser";
-import { isBlock } from "../../src/traverse";
-import { Identifier } from "../../src/util/gen";
+import parseJS, { parseSync } from "../../src/parser";
+import traverse, { isBlock } from "../../src/traverse";
+import { Identifier, Location } from "../../src/util/gen";
 import {
   deleteDeclaration,
   isVarContext,
@@ -10,6 +11,7 @@ import {
   getContexts,
   getLexContext,
   getVarContext,
+  computeFunctionLength,
 } from "../../src/util/insert";
 
 it("isBlock() should be true for block statements and program", async () => {
@@ -86,3 +88,55 @@ it("should throw when missing parameters", () => {
   expect(() => getLexContext(Identifier("test"), [])).toThrow();
   expect(() => getVarContext(Identifier("test"), [])).toThrow();
 });
+
+test("computeFunctionLength", () => {
+  var tree = parseSync(`
+  function zeroParameters(){}; // 0
+  function oneParameter(a){}; // 1
+  function twoParameter(a,b){}; // 2
+  function restParameter1(...a){}; // 0
+  function restParameter2(a,b,...c){}; // 2
+  function defaultValue(a,b,c=1,d){}; // 2
+  function arrayPattern([a],[b = 2],[[c]]){}; // 3
+  function objectPattern({a},{b = 2},{c, d}){}; // 3
+  function mixed(a,{b},[c = 3],d,e=5,f,...g){}; // 4
+  `);
+
+  function getFunction(searchName: string): Location {
+    var searchLocation: Location;
+    traverse(tree, (o, p) => {
+      if (o.type === "FunctionDeclaration" && o.id.name === searchName) {
+        ok(!searchLocation);
+        searchLocation = [o, p];
+      }
+    });
+
+    ok(searchLocation);
+    return searchLocation;
+  }
+
+  expect(
+    computeFunctionLength(getFunction("zeroParameters")[0].params)
+  ).toStrictEqual(0);
+  expect(
+    computeFunctionLength(getFunction("oneParameter")[0].params)
+  ).toStrictEqual(1);
+  expect(
+    computeFunctionLength(getFunction("twoParameter")[0].params)
+  ).toStrictEqual(2);
+  expect(
+    computeFunctionLength(getFunction("restParameter1")[0].params)
+  ).toStrictEqual(0);
+  expect(
+    computeFunctionLength(getFunction("restParameter2")[0].params)
+  ).toStrictEqual(2);
+  expect(
+    computeFunctionLength(getFunction("arrayPattern")[0].params)
+  ).toStrictEqual(3);
+  expect(
+    computeFunctionLength(getFunction("objectPattern")[0].params)
+  ).toStrictEqual(3);
+  expect(computeFunctionLength(getFunction("mixed")[0].params)).toStrictEqual(
+    4
+  );
+});
