Added more tests for partial if statement branches

src/node-transformers/minification-transformers/IfStatementSimplifyTransformer.ts

@@ -163,6 +163,38 @@ export class IfStatementSimplifyTransformer extends AbstractNodeTransformer {
         consequentSimplifyData: IIfStatementSimplifyData,
         alternateSimplifyData: IIfStatementSimplifyData
     ): ESTree.Node {
+        /**
+         * Converts:
+         * if (true) {
+         *     const foo = 1;
+         *     console.log(1);
+         *     return 1;
+         * }
+         *
+         * to:
+         * if (true) {
+         *     const foo = 1;
+         *     return console.log(1), 1;
+         * }
+         */
+        if (consequentSimplifyData.leadingStatements.length || alternateSimplifyData.leadingStatements.length) {
+            return NodeFactory.ifStatementNode(
+                ifStatementNode.test,
+                consequentSimplifyData.leadingStatements.length
+                    ? NodeFactory.blockStatementNode([
+                        ...consequentSimplifyData.leadingStatements,
+                        consequentSimplifyData.statement
+                    ])
+                    : consequentSimplifyData.statement,
+                alternateSimplifyData.leadingStatements.length
+                    ? NodeFactory.blockStatementNode([
+                        ...alternateSimplifyData.leadingStatements,
+                        alternateSimplifyData.statement
+                    ])
+                    : alternateSimplifyData.statement
+            );
+        }
+
         /**
          * Converts:
          * if (true) {

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/IfStatementSimplifyTransformer.spec.ts

@@ -436,5 +436,292 @@ describe('IfStatementSimplifyTransformer', () => {
                 });
             });
         });
+
+        describe('Consequent and alternate', () => {
+            describe('No `ReturnStatement`', () => {
+                describe('Variant #1: single statement', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\); *' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *hawk\\(\\); *' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-no-return-single-statement.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should not simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+
+                describe('Variant #2: multiple statements', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\), *' +
+                                '_0x([a-f0-9]){4,6} *= *hawk\\(\\); *' +
+                            'eagle\\(\\), *pork\\(\\);' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *cow\\(\\); *' +
+                            'lion\\(\\), *pig\\(\\);' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-no-return-multiple-statements.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+
+                describe('Variant #3: mixed statements #1', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\), *' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *hawk\\(\\); *' +
+                            'eagle\\(\\), *dog\\(\\);' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-no-return-mixed-statements-1.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+
+                describe('Variant #4: mixed statements #2', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\), *' +
+                                '_0x([a-f0-9]){4,6} *= *hawk\\(\\); *' +
+                            'eagle\\(\\), *pork\\(\\);' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *cow\\(\\); *' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-no-return-mixed-statements-2.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+            });
+
+            describe('With consequent `ReturnStatement`', () => {
+                describe('Variant #1: single statement', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'return *bar\\(\\); *' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *bark\\(\\); *' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-consequent-return-single-statement.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+
+                describe('Variant #2: multiple statements', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\), *' +
+                                '_0x([a-f0-9]){4,6} *= *hawk\\(\\); *' +
+                            'return *eagle\\(\\), *cat\\(\\);' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *pig\\(\\); *' +
+                            'lion\\(\\), *dog\\(\\);' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-consequent-return-multiple-statements.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+            });
+
+            describe('With alternate `ReturnStatement`', () => {
+                describe('Variant #1: single statement', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\); *' +
+                        '} *else *{ *' +
+                            'return *bark\\(\\); *' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-alternate-return-single-statement.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+
+                describe('Variant #2: multiple statements', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\); *' +
+                            'bark\\(\\), *hawk\\(\\);' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *pork\\(\\), *' +
+                                '_0x([a-f0-9]){4,6} *= *dog\\(\\); *' +
+                            'return *pig\\(\\), *lion\\(\\);' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-alternate-return-multiple-statements.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+            });
+
+            describe('With consequent and alternate `ReturnStatement`', () => {
+                describe('Variant #1: multiple statements', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *baz\\(\\), *' +
+                                '_0x([a-f0-9]){4,6} *= *eagle\\(\\); *' +
+                            'return *hawk\\(\\), *lion\\(\\);' +
+                        '} *else *{ *' +
+                            'const *_0x([a-f0-9]){4,6} *= *dog\\(\\), *' +
+                                '_0x([a-f0-9]){4,6} *= *hamster\\(\\); *' +
+                            'return *parrot\\(\\), *bull\\(\\);' +
+                        '}'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/partial-consequent-and-alternate-return-multiple-statements.js');
+
+                        obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                minify: true
+                            }
+                        ).getObfuscatedCode();
+                    });
+
+                    it('should simplify if statement', () => {
+                        assert.match(obfuscatedCode, regExp);
+                    });
+                });
+            });
+        });
     });
 });

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-alternate-return-multiple-statements.js

@@ -0,0 +1,15 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+
+        bark();
+        hawk();
+    } else {
+        const eagle = pork();
+        const cat = dog()
+
+        pig();
+
+        return lion();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-alternate-return-single-statement.js

@@ -0,0 +1,7 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+    } else {
+        return bark();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-consequent-return-multiple-statements.js

@@ -0,0 +1,15 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+        const bark = hawk();
+
+        eagle();
+
+        return cat();
+    } else {
+        const pork = pig();
+
+        lion();
+        dog();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-consequent-return-single-statement.js

@@ -0,0 +1,7 @@
+function foo () {
+    if (true) {
+        return bar();
+    } else {
+        const baz = bark();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-no-return-mixed-statements-1.js

@@ -0,0 +1,10 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+    } else {
+        const bark = hawk();
+
+        eagle();
+        dog();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-no-return-mixed-statements-2.js

@@ -0,0 +1,11 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+        const bark = hawk();
+
+        eagle()
+        pork();
+    } else {
+        const horse = cow();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-no-return-multiple-statements.js

@@ -0,0 +1,14 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+        const bark = hawk();
+
+        eagle()
+        pork();
+    } else {
+        const horse = cow();
+
+        lion();
+        pig();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-no-return-single-statement.js

@@ -0,0 +1,7 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+    } else {
+        const bark = hawk();
+    }
+}

test/functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/fixtures/partial-consequent-and-alternate-return-multiple-statements.js

@@ -0,0 +1,17 @@
+function foo () {
+    if (true) {
+        const bar = baz();
+        const bark = eagle();
+
+        hawk();
+
+        return lion();
+    } else {
+        const cat = dog();
+        const elephant = hamster();
+
+        parrot();
+
+        return bull();
+    }
+}