Prevented transformation of object keys in sequence expression that has `super` call

CHANGELOG.md

@@ -3,6 +3,7 @@ Change Log
 v0.25.0
 ---
 * Fixed conflicts between generated names and names from untouched identifiers from source code. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/550. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/549
+* Prevented transformation of object keys in sequence expression that has `super` call
 
 
 v0.24.6

src/node-transformers/converting-transformers/ObjectExpressionKeysTransformer.ts

@@ -58,9 +58,13 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
         hostStatement: ESTree.Statement
     ): boolean {
         return ObjectExpressionKeysTransformer.isReferencedIdentifierName(
-            objectExpressionNode,
-            hostStatement
-        );
+                objectExpressionNode,
+                hostStatement
+            )
+            || ObjectExpressionKeysTransformer.isProhibitedSequenceExpression(
+                objectExpressionNode,
+                hostStatement
+            );
     }
 
     /**
@@ -110,6 +114,23 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
         return isReferencedIdentifierName;
     }
 
+    /**
+     * @param {ObjectExpression} objectExpressionNode
+     * @param {Node} hostNode
+     * @returns {boolean}
+     */
+    private static isProhibitedSequenceExpression (
+        objectExpressionNode: ESTree.ObjectExpression,
+        hostNode: ESTree.Node,
+    ): boolean {
+        return NodeGuards.isExpressionStatementNode(hostNode)
+            && NodeGuards.isSequenceExpressionNode(hostNode.expression)
+            && hostNode.expression.expressions.some((expressionNode: ESTree.Expression) =>
+                NodeGuards.isCallExpressionNode(expressionNode)
+                && NodeGuards.isSuperNode(expressionNode.callee)
+            );
+    }
+
     /**
      * @param {TransformationStage} transformationStage
      * @returns {IVisitor | null}

src/node/NodeGuards.ts

@@ -311,52 +311,26 @@ export class NodeGuards {
 
     /**
      * @param {Node} node
-     * @param {Node} parentNode
-     * @returns {boolean}
-     */
-    public static parentNodeIsPropertyNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
-        return NodeGuards.isPropertyNode(parentNode)
-            && !parentNode.computed
-            && parentNode.key === node;
-    }
-
-    /**
-     * @param {Node} node
-     * @param {Node} parentNode
      * @returns {boolean}
      */
-    public static parentNodeIsMemberExpressionNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
-        return (
-            NodeGuards.isMemberExpressionNode(parentNode)
-            && !parentNode.computed
-            && parentNode.property === node
-        );
-    }
-
-    /**
-     * @param {Node} node
-     * @param {Node} parentNode
-     * @returns {boolean}
-     */
-    public static parentNodeIsMethodDefinitionNode (node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier {
-        return NodeGuards.isMethodDefinitionNode(parentNode)
-            && !parentNode.computed;
+    public static isRestElementNode (node: ESTree.Node): node is ESTree.RestElement {
+        return node.type === NodeType.RestElement;
     }
 
     /**
      * @param {Node} node
      * @returns {boolean}
      */
-    public static isRestElementNode (node: ESTree.Node): node is ESTree.RestElement {
-        return node.type === NodeType.RestElement;
+    public static isReturnStatementNode (node: ESTree.Node): node is ESTree.ReturnStatement {
+        return node.type === NodeType.ReturnStatement;
     }
 
     /**
      * @param {Node} node
      * @returns {boolean}
      */
-    public static isReturnStatementNode (node: ESTree.Node): node is ESTree.ReturnStatement {
-        return node.type === NodeType.ReturnStatement;
+    public static isSequenceExpressionNode (node: ESTree.Node): node is ESTree.SequenceExpression {
+        return node.type === NodeType.SequenceExpression;
     }
 
     /**

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/ObjectExpressionKeysTransformer.spec.ts

@@ -1724,5 +1724,31 @@ describe('ObjectExpressionKeysTransformer', () => {
                 assert.match(obfuscatedCode,  regExp);
             });
         });
+
+        describe('Variant #9: sequence expression super call expression', () => {
+            const match: string = `` +
+                `super\\(\\), *` +
+                `this\\['state'] *= *{ *'foo': *0x1 *};` +
+            ``;
+            const regExp: RegExp = new RegExp(match);
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/sequence-expression-super-call-expression.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        transformObjectKeys: true
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('shouldn\'t ignore sequence expression object expression if this sequence expression contains super call expression', () => {
+                assert.match(obfuscatedCode,  regExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/sequence-expression-super-call-expression.js

@@ -0,0 +1,6 @@
+class Foo extends Bar {
+    constructor() {
+        super(),
+        this.state = {foo: 1};
+    }
+}