Now collected block statement can contain nested block statements

dist/index.js

@@ -5341,12 +5341,12 @@ var DeadCodeInjectionTransformer = DeadCodeInjectionTransformer_1 = function (_A
                     return DeadCodeInjectionTransformer_1.collectBlockStatementNodes(node, _this3.collectedBlockStatements);
                 }
             });
+            if (this.collectedBlockStatements.length < 10) {
+                return;
+            }
             estraverse.replace(programNode, {
                 leave: function leave(node, parentNode) {
-                    if (!Node_1.Node.isBlockStatementNode(node) || !_this3.collectedBlockStatements.length) {
-                        return node;
-                    }
-                    if (RandomGeneratorUtils_1.RandomGeneratorUtils.getMathRandom() > _this3.options.deadCodeInjectionThreshold) {
+                    if (!Node_1.Node.isBlockStatementNode(node) || RandomGeneratorUtils_1.RandomGeneratorUtils.getMathRandom() > _this3.options.deadCodeInjectionThreshold) {
                         return node;
                     }
                     var randomIndex = RandomGeneratorUtils_1.RandomGeneratorUtils.getRandomInteger(0, _this3.collectedBlockStatements.length - 1);
@@ -5360,11 +5360,11 @@ var DeadCodeInjectionTransformer = DeadCodeInjectionTransformer_1 = function (_A
         }
     }], [{
         key: "collectBlockStatementNodes",
-        value: function collectBlockStatementNodes(node, collectedBlockStatements) {
-            if (!Node_1.Node.isBlockStatementNode(node) || !DeadCodeInjectionTransformer_1.isValidBlockStatementNode(node)) {
+        value: function collectBlockStatementNodes(targetNode, collectedBlockStatements) {
+            if (!Node_1.Node.isBlockStatementNode(targetNode) || !DeadCodeInjectionTransformer_1.isValidBlockStatementNode(targetNode)) {
                 return;
             }
-            var clonedBlockStatementNode = NodeUtils_1.NodeUtils.clone(node);
+            var clonedBlockStatementNode = NodeUtils_1.NodeUtils.clone(targetNode);
             estraverse.replace(clonedBlockStatementNode, {
                 enter: function enter(node, parentNode) {
                     if (Node_1.Node.isIdentifierNode(node)) {
@@ -5375,6 +5375,23 @@ var DeadCodeInjectionTransformer = DeadCodeInjectionTransformer_1 = function (_A
             });
             collectedBlockStatements.push(clonedBlockStatementNode);
         }
+    }, {
+        key: "isValidBlockStatementNode",
+        value: function isValidBlockStatementNode(blockStatementNode) {
+            var blockStatementsCount = 0,
+                isValidBlockStatementNode = true;
+            estraverse.traverse(blockStatementNode, {
+                enter: function enter(node, parentNode) {
+                    if (blockStatementNode !== node && Node_1.Node.isBlockStatementNode(node)) {
+                        blockStatementsCount++;
+                    }
+                    if (blockStatementsCount > DeadCodeInjectionTransformer_1.maxNestedBlockStatementsCount || Node_1.Node.isBreakStatementNode(node) || Node_1.Node.isContinueStatementNode(node)) {
+                        isValidBlockStatementNode = false;
+                    }
+                }
+            });
+            return isValidBlockStatementNode;
+        }
     }, {
         key: "replaceBlockStatementNodes",
         value: function replaceBlockStatementNodes(blockStatementNode, randomBlockStatementNode) {
@@ -5410,23 +5427,11 @@ var DeadCodeInjectionTransformer = DeadCodeInjectionTransformer_1 = function (_A
             newBlockStatementNode = NodeUtils_1.NodeUtils.parentize(newBlockStatementNode);
             return newBlockStatementNode;
         }
-    }, {
-        key: "isValidBlockStatementNode",
-        value: function isValidBlockStatementNode(blockStatementNode) {
-            var isValidBlockStatementNode = true;
-            estraverse.traverse(blockStatementNode, {
-                enter: function enter(node, parentNode) {
-                    if (node !== blockStatementNode && Node_1.Node.isBlockStatementNode(node) || Node_1.Node.isBreakStatementNode(node) || Node_1.Node.isContinueStatementNode(node)) {
-                        isValidBlockStatementNode = false;
-                    }
-                }
-            });
-            return isValidBlockStatementNode;
-        }
     }]);
 
     return DeadCodeInjectionTransformer;
 }(AbstractNodeTransformer_1.AbstractNodeTransformer);
+DeadCodeInjectionTransformer.maxNestedBlockStatementsCount = 4;
 DeadCodeInjectionTransformer = DeadCodeInjectionTransformer_1 = tslib_1.__decorate([inversify_1.injectable(), tslib_1.__param(0, inversify_1.inject(ServiceIdentifiers_1.ServiceIdentifiers.IOptions)), tslib_1.__metadata("design:paramtypes", [Object])], DeadCodeInjectionTransformer);
 exports.DeadCodeInjectionTransformer = DeadCodeInjectionTransformer;
 var DeadCodeInjectionTransformer_1;

src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.ts

@@ -15,6 +15,11 @@ import { RandomGeneratorUtils } from '../../utils/RandomGeneratorUtils';
 
 @injectable()
 export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
+    /**
+     * @type {number}
+     */
+    private static maxNestedBlockStatementsCount: number = 4;
+
     /**
      * @type {ESTree.BlockStatement[]}
      */
@@ -53,6 +58,33 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
         collectedBlockStatements.push(clonedBlockStatementNode);
     }
 
+    /**
+     * @param blockStatementNode
+     * @return {boolean}
+     */
+    private static isValidBlockStatementNode (blockStatementNode: ESTree.BlockStatement): boolean {
+        let blockStatementsCount: number = 0,
+            isValidBlockStatementNode: boolean = true;
+
+        estraverse.traverse(blockStatementNode, {
+            enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
+                if (blockStatementNode !== node && Node.isBlockStatementNode(node)) {
+                    blockStatementsCount++;
+                }
+
+                if (
+                    blockStatementsCount > DeadCodeInjectionTransformer.maxNestedBlockStatementsCount ||
+                    Node.isBreakStatementNode(node) ||
+                    Node.isContinueStatementNode(node)
+                ) {
+                    isValidBlockStatementNode = false;
+                }
+            }
+        });
+
+        return isValidBlockStatementNode;
+    }
+
     /**
      * @param blockStatementNode
      * @param randomBlockStatementNode
@@ -112,28 +144,6 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
         return newBlockStatementNode;
     }
 
-    /**
-     * @param blockStatementNode
-     * @return {boolean}
-     */
-    private static isValidBlockStatementNode (blockStatementNode: ESTree.BlockStatement): boolean {
-        let isValidBlockStatementNode: boolean = true;
-
-        estraverse.traverse(blockStatementNode, {
-            enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (
-                    (node !== blockStatementNode && Node.isBlockStatementNode(node)) ||
-                    Node.isBreakStatementNode(node) ||
-                    Node.isContinueStatementNode(node)
-                ) {
-                    isValidBlockStatementNode = false;
-                }
-            }
-        });
-
-        return isValidBlockStatementNode;
-    }
-
     /**
      * @return {IVisitor}
      */
@@ -167,13 +177,16 @@ export class DeadCodeInjectionTransformer extends AbstractNodeTransformer {
                 DeadCodeInjectionTransformer.collectBlockStatementNodes(node, this.collectedBlockStatements)
         });
 
+        if (this.collectedBlockStatements.length < 10) {
+            return;
+        }
+
         estraverse.replace(programNode, {
             leave: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                if (!Node.isBlockStatementNode(node) || !this.collectedBlockStatements.length) {
-                    return node;
-                }
-
-                if (RandomGeneratorUtils.getMathRandom() > this.options.deadCodeInjectionThreshold) {
+                if (
+                    !Node.isBlockStatementNode(node) ||
+                    RandomGeneratorUtils.getMathRandom() > this.options.deadCodeInjectionThreshold
+                ) {
                     return node;
                 }
 

test/dev/dev.ts

@@ -14,22 +14,8 @@ import { NO_CUSTOM_NODES_PRESET } from '../../src/options/presets/NoCustomNodes'
                         console.log('efg');
                         console.log('hij');
                     };
-                    
-                    var bar = function () {
-                        console.log('klm');
-                        console.log('nop');
-                        console.log('qrs');
-                    };
-                
-                    var baz = function () {
-                        console.log('tuv');
-                        console.log('wxy');
-                        console.log('z');
-                    };
-                
+
                     foo();
-                    bar();
-                    baz();
                 }
             })();
         `,