Rewrite Moved Declarations to obfuscate much faster

MichaelXF · MichaelXF · commit 54a69539137f · 2023-07-02T22:08:39.000-04:00
diff --git a/src/transforms/identifier/movedDeclarations.ts b/src/transforms/identifier/movedDeclarations.ts
@@ -1,19 +1,15 @@
 import Transform from "../transform";
-import { isBlock, walk } from "../../traverse";
+import { isBlock } from "../../traverse";
 import {
-  Location,
   ExpressionStatement,
   AssignmentExpression,
   Identifier,
   Node,
   VariableDeclarator,
-  VariableDeclaration,
 } from "../../util/gen";
 import { isForInitialize, prepend } from "../../util/insert";
 import { ok } from "assert";
 import { ObfuscateOrder } from "../../order";
-import { getIdentifierInfo } from "../../util/identifiers";
-import { isLexicalScope, getLexicalScope } from "../../util/scope";
 
 /**
  * Defines all the names at the top of every lexical block.
@@ -24,110 +20,68 @@ export default class MovedDeclarations extends Transform {
   }
 
   match(object, parents) {
-    return isLexicalScope(object);
+    return (
+      object.type === "VariableDeclaration" &&
+      object.kind === "var" &&
+      object.declarations.length === 1 &&
+      object.declarations[0].id.type === "Identifier"
+    );
   }
 
   transform(object: Node, parents: Node[]) {
     return () => {
-      var body = isBlock(object) ? object.body : object.consequent;
-      ok(Array.isArray(body));
-
-      var illegal = new Set<string>();
-      var defined = new Set<string>();
-      var variableDeclarations: {
-        [name: string]: {
-          location: Location;
-          replace: Node;
+      var forInitializeType = isForInitialize(object, parents);
+
+      // Get the block statement or Program node
+      var blockIndex = parents.findIndex((x) => isBlock(x));
+      var block = parents[blockIndex];
+      var body = block.body;
+      var bodyObject = parents[blockIndex - 2] || object;
+
+      // Make sure in the block statement, and not already at the top of it
+      var index = body.indexOf(bodyObject);
+      if (index === -1 || index === 0) return;
+
+      var topVariableDeclaration;
+      if (body[0].type === "VariableDeclaration" && body[0].kind === "var") {
+        topVariableDeclaration = body[0];
+      } else {
+        topVariableDeclaration = {
+          type: "VariableDeclaration",
+          declarations: [],
+          kind: "var",
         };
-      } = Object.create(null);
-
-      walk(object, parents, (o, p) => {
-        if (o.type == "Identifier") {
-          if (o.hidden || getLexicalScope(o, p) !== object) {
-            illegal.add(o.name);
-          } else {
-            var info = getIdentifierInfo(o, p);
-            if (!info.spec.isReferenced) {
-              return;
-            }
 
-            if (info.spec.isDefined) {
-              if (info.isFunctionDeclaration || info.isClassDeclaration) {
-                illegal.add(o.name);
-              } else {
-                if (defined.has(o.name)) {
-                  illegal.add(o.name);
-                } else {
-                  defined.add(o.name);
-                }
-              }
-            }
-          }
-        }
+        prepend(block, topVariableDeclaration);
+      }
 
-        if (o.type == "VariableDeclaration") {
-          return () => {
-            if (
-              o.declarations.length === 1 &&
-              o.declarations[0].id.type === "Identifier"
-            ) {
-              var name = o.declarations[0].id.name;
+      var varName = object.declarations[0].id.name;
+      ok(typeof varName === "string");
 
-              // Check if duplicate
-              if (variableDeclarations[name] || o.kind !== "var") {
-                illegal.add(name);
-                return;
-              }
+      // Add `var x` at the top of the block
+      topVariableDeclaration.declarations.push(
+        VariableDeclarator(Identifier(varName))
+      );
 
-              // Check if already at top
-              if (body[0] === o) {
-                illegal.add(name);
-                return;
-              }
+      var assignmentExpression = AssignmentExpression(
+        "=",
+        Identifier(varName),
+        object.declarations[0].init || Identifier("undefined")
+      );
 
-              var replace: Node = AssignmentExpression(
-                "=",
-                Identifier(name),
-                o.declarations[0].init || Identifier("undefined")
-              );
+      if (forInitializeType) {
+        if (forInitializeType === "initializer") {
+          // Replace `for (var i = 0...)` to `for (i = 0...)`
+          this.replace(object, assignmentExpression);
+        } else if (forInitializeType === "left-hand") {
+          // Replace `for (var k in...)` to `for (k in ...)`
 
-              var forType = isForInitialize(o, p);
-              if (forType === "left-hand") {
-                replace = Identifier(name);
-              } else if (!forType) {
-                replace = ExpressionStatement(replace);
-              }
-              variableDeclarations[name] = {
-                location: [o, p],
-                replace: replace,
-              };
-            }
-          };
+          this.replace(object, Identifier(varName));
         }
-      });
-
-      illegal.forEach((name) => {
-        delete variableDeclarations[name];
-      });
-
-      var movingNames = Object.keys(variableDeclarations);
-
-      if (movingNames.length === 0) {
-        return;
+      } else {
+        // Replace `var x = value` to `x = value`
+        this.replace(object, ExpressionStatement(assignmentExpression));
       }
-
-      var variableDeclaration = VariableDeclaration(
-        movingNames.map((name) => {
-          return VariableDeclarator(name);
-        })
-      );
-
-      prepend(object, variableDeclaration);
-
-      movingNames.forEach((name) => {
-        var { location, replace } = variableDeclarations[name];
-        this.replace(location[0], replace);
-      });
     };
   }
 }
diff --git a/test/transforms/identifier/movedDeclarations.test.ts b/test/transforms/identifier/movedDeclarations.test.ts
@@ -12,7 +12,7 @@ test("Variant #1: Move variable 'y' to top", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y;");
+  expect(output).toContain("var x=10,y;");
   expect(output).toContain("y=15");
 
   var TEST_VARIABLE;
@@ -34,7 +34,7 @@ test("Variant #2: Move variable 'y' and 'z' to top", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y,z");
+  expect(output).toContain("var x=10,y,z;");
   expect(output).toContain("y=15");
   expect(output).toContain("z=5");
 
@@ -44,7 +44,7 @@ test("Variant #2: Move variable 'y' and 'z' to top", async () => {
   expect(TEST_VARIABLE).toStrictEqual(30);
 });
 
-test("Variant #2: Don't move 'y' (destructuring)", async () => {
+test("Variant #3: Don't move 'y' (destructuring)", async () => {
   var code = `
     var x = 10;
     var [y] = [15];
@@ -64,7 +64,7 @@ test("Variant #2: Don't move 'y' (destructuring)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
+test("Variant #4: Move 'y' (nested lexical scope)", async () => {
   var code = `
     var x = 10;
     var y = 15;
@@ -81,15 +81,15 @@ test("Variant #3: Don't move 'y' (nested lexical scope)", async () => {
     movedDeclarations: true,
   });
 
-  expect(output).toContain("var y=15");
+  expect(output).toContain("var x=10,y;");
 
   var TEST_VARIABLE;
   eval(output);
 
   expect(TEST_VARIABLE).toStrictEqual(20);
 });
 
-test("Variant #4: Move 'y' (for statement initializer)", async () => {
+test("Variant #5: Move 'y' (for statement initializer)", async () => {
   var code = `
     var x = 10;
     for ( var y = 0; y < 15; y++ ) {
@@ -111,7 +111,7 @@ test("Variant #4: Move 'y' (for statement initializer)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #5: Move 'y' (for-in left-hand initializer)", async () => {
+test("Variant #6: Move 'y' (for-in left-hand initializer)", async () => {
   var code = `
     var x = 10;
     for ( var y in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15] ) {
@@ -134,7 +134,7 @@ test("Variant #5: Move 'y' (for-in left-hand initializer)", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #6: Don't move const or let variables", async () => {
+test("Variant #7: Don't move const or let variables", async () => {
   var code = `
     var fillerExpr;
 
@@ -158,7 +158,7 @@ test("Variant #6: Don't move const or let variables", async () => {
   expect(TEST_VARIABLE).toStrictEqual(25);
 });
 
-test("Variant #7: Work with 'use strict'", async () => {
+test("Variant #8: Work with 'use strict'", async () => {
   var code = `
   function myFunction(){
     'use strict';
