Simple consequent only tests for IfStatementSimplifyTransformer

src/enums/node/NodeType.ts

@@ -43,6 +43,7 @@ export enum NodeType {
     SwitchStatement = 'SwitchStatement',
     TaggedTemplateExpression = 'TaggedTemplateExpression',
     TemplateLiteral = 'TemplateLiteral',
+    ThrowStatement = 'ThrowStatement',
     TryStatement = 'TryStatement',
     UnaryExpression = 'UnaryExpression',
     UpdateExpression = 'UpdateExpression',

src/node/NodeGuards.ts

@@ -381,6 +381,14 @@ export class NodeGuards {
         return node.type === NodeType.TemplateLiteral;
     }
 
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isThrowStatementNode (node: ESTree.Node): node is ESTree.ThrowStatement {
+        return node.type === NodeType.ThrowStatement;
+    }
+
     /**
      * @param {Node} node
      * @returns {boolean}

test/dev/dev.ts

@@ -7,14 +7,16 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-            function foo () {
+           function foo () {
                 if (true) {
-                    console.log(1);
-                    return 1;
-                } else {
-                    return 2;
+                    console.log(3);
+                    console.log(2);
+            
+                    return 'abc';
                 }
             }
+            
+            console.log(foo());
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,

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

@@ -0,0 +1,119 @@
+import { assert } from 'chai';
+
+import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../src/options/presets/NoCustomNodes';
+
+import { readFileAsString } from '../../../../helpers/readFileAsString';
+
+import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFacade';
+
+describe('IfStatementSimplifyTransformer', () => {
+    describe('Full `IfStatement` simplify cases', () => {
+        describe('Consequent only', () => {
+            describe('No `ReturnStatement`', () => {
+                describe('Variant #1: single statement', () => {
+                    const regExp: RegExp = new RegExp(
+                        '!!\\[] *&& *bar\\(\\);'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/consequent-only-no-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(
+                        '!!\\[] *&& *\\(bar\\(\\) *, *baz\\(\\) *, *bark\\(\\)\\);'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/consequent-only-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('With `ReturnStatement`', () => {
+                describe('Variant #1: single statement', () => {
+                    const regExp: RegExp = new RegExp(
+                        'if *\\(!!\\[]\\) *' +
+                            'return *bar\\(\\);'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/consequent-only-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 *\\(!!\\[]\\) *' +
+                            'return *bar\\(\\) *, *baz\\(\\) *, *bark\\(\\);'
+                    );
+
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/consequent-only-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/consequent-only-no-return-multiple-statements.js

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

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

@@ -0,0 +1,5 @@
+function foo () {
+    if (true) {
+        bar();
+    }
+}

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

@@ -0,0 +1,8 @@
+function foo () {
+    if (true) {
+        bar();
+        baz();
+
+        return bark();
+    }
+}

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

@@ -0,0 +1,5 @@
+function foo () {
+    if (true) {
+        return bar();
+    }
+}

test/index.spec.ts

@@ -90,6 +90,7 @@ import './functional-tests/node-transformers/converting-transformers/split-strin
 import './functional-tests/node-transformers/converting-transformers/template-literal-transformer/TemplateLiteralTransformer.spec';
 import './functional-tests/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.spec';
 import './functional-tests/node-transformers/initializing-transformers/comments-transformer/CommentsTransformer.spec';
+import './functional-tests/node-transformers/minification-transformers/if-statement-simplify-transformer/IfStatementSimplifyTransformer.spec';
 import './functional-tests/node-transformers/minification-transformers/variable-declarations-merge-transformer/VariableDeclarationsMergeTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/labeled-statement-transformer/LabeledStatementTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/literal-transformer/LiteralTransformer.spec';