Code coverage report for src/node-transformers/node-control-flow-transformers/BlockStatementControlFlowTransformer.ts

# All files / src/node-transformers/node-control-flow-transformers BlockStatementControlFlowTransformer.ts

100% Statements 29/29
100% Branches 14/14
100% Functions 3/3
100% Lines 25/25

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    861x
    1x

    1x

    1x
    1x
    1x
    1x

    1x

    838x

    838x

    2051x
    5060x
    5060x

    5060x

    2554x

    1189x

    1365x
    1365x
    1365x
    3823x

    1365x
    855x

    510x

    510x

    510x

     import { injectable, inject } from 'inversify';
    import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';

    import * as ESTree from 'estree';

    import { TCustomNodeFactory } from '../../types/container/TCustomNodeFactory';

    import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
    import { IOptions } from '../../interfaces/options/IOptions';

    import { CustomNodes } from '../../enums/container/CustomNodes';

    import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
    import { Node } from '../../node/Node';
    import { RandomGeneratorUtils } from '../../utils/RandomGeneratorUtils';
    import { Utils } from '../../utils/Utils';

    @injectable()
    export class BlockStatementControlFlowTransformer extends AbstractNodeTransformer {
        /**
         * @type {TCustomNodeFactory}
         */
        private readonly customNodeFactory: TCustomNodeFactory;

        /**
         * @param customNodeFactory
         * @param options
         */
        constructor (
            @inject(ServiceIdentifiers.Factory__ICustomNode) customNodeFactory: TCustomNodeFactory,
            @inject(ServiceIdentifiers.IOptions) options: IOptions
        ) {
            super(options);

            this.customNodeFactory = customNodeFactory;
        }

        /**
         * @param blockStatementNode
         * @return {boolean}
         */
        private static blockStatementHasProhibitedStatements (blockStatementNode: ESTree.BlockStatement): boolean {
            return blockStatementNode.body.some((statement: ESTree.Statement) => {
                const isBreakOrContinueStatement: boolean = Node.isBreakStatementNode(statement) || Node.isContinueStatementNode(statement);
                const isVariableDeclarationWithLetOrConstKind: boolean = Node.isVariableDeclarationNode(statement) &&
                    (statement.kind === 'const' ||  statement.kind === 'let');

                return Node.isFunctionDeclarationNode(statement) || isBreakOrContinueStatement || isVariableDeclarationWithLetOrConstKind;
            });
        }

        /**
         * @param blockStatementNode
         * @returns {ESTree.Node}
         */
        public transformNode (blockStatementNode: ESTree.BlockStatement): ESTree.Node {
            if (
                RandomGeneratorUtils.getRandomFloat(0, 1) > this.options.controlFlowFlatteningThreshold ||
                BlockStatementControlFlowTransformer.blockStatementHasProhibitedStatements(blockStatementNode)
            ) {
                return blockStatementNode;
            }

            const blockStatementBody: ESTree.Statement[] = blockStatementNode.body;
            const originalKeys: number[] = [...Array(blockStatementBody.length).keys()];
            const shuffledKeys: number[] = Utils.arrayShuffle(originalKeys);
            const originalKeysIndexesInShuffledArray: number[] = originalKeys.map((key: number) => shuffledKeys.indexOf(key));

            if (blockStatementBody.length <= 4) {
                return blockStatementNode;
            }

            const blockStatementControlFlowFlatteningCustomNode: ICustomNode = this.customNodeFactory(
                CustomNodes.BlockStatementControlFlowFlatteningNode
            );

            blockStatementControlFlowFlatteningCustomNode.initialize(
                blockStatementBody,
                shuffledKeys,
                originalKeysIndexesInShuffledArray
            );

            return blockStatementControlFlowFlatteningCustomNode.getNode()[0];
        }
    }