feat(arrow mutations): add arrow mutations and refactor JavaScript mutators (#1898)

* JavaScript mutator code improvements
  - use raw string mutations *internally* whenever possible
  - generate some of the mutations as AST nodes from the Babel types API
  - use some ternaries
  - remove some intermediate const declarations no longer needed
  - remove a couple of internal utility functions no longer needed
* add Arrow Function Mutator for JavaScript (already supported by the existing TypeScript mutator)
* remove `lodash.clonedeep` from dependencies in packages/javascript-mutator/package.json

Author: Chris Brody

packages/javascript-mutator/package.json

@@ -40,7 +40,6 @@
     "@babel/parser": "~7.7.0",
     "@babel/traverse": "~7.7.0",
     "@stryker-mutator/api": "^2.4.0",
-    "lodash.clonedeep": "^4.5.0",
     "tslib": "~1.10.0"
   },
   "peerDependencies": {

packages/javascript-mutator/src/JavaScriptMutator.ts

@@ -5,7 +5,6 @@ import { Mutant, Mutator } from '@stryker-mutator/api/mutant';
 import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
 
 import BabelParser from './helpers/BabelParser';
-import copy from './helpers/copy';
 import { NodeMutator } from './mutators/NodeMutator';
 import { NODE_MUTATORS_TOKEN, PARSER_TOKEN } from './helpers/tokens';
 
@@ -21,35 +20,27 @@ export class JavaScriptMutator implements Mutator {
 
       this.parser.getNodes(ast).forEach(node => {
         this.mutators.forEach(mutator => {
-          const mutatedNodes = mutator.mutate(node, copy);
-
-          if (mutatedNodes.length) {
-            const newMutants = this.generateMutants(mutatedNodes, mutator.name, file.name);
-            mutants.push(...newMutants);
-          }
+          const fileName = file.name;
+          const mutatorName = mutator.name;
+
+          mutator.mutate(node).forEach(([original, mutation]) => {
+            if (original.start !== null && original.end !== null) {
+              const replacement = types.isNode(mutation) ? this.parser.generateCode(mutation) : mutation.raw;
+
+              mutants.push({
+                fileName: fileName,
+                mutatorName: mutatorName,
+                range: [original.start, original.end],
+                replacement
+              });
+
+              this.log.trace(`Generated mutant for mutator ${mutatorName} in file ${fileName} with replacement code "${replacement}"`);
+            }
+          });
         });
       });
     });
 
     return mutants;
   }
-
-  private generateMutants(mutatedNodes: types.Node[], mutatorName: string, fileName: string): Mutant[] {
-    const mutants: Mutant[] = [];
-    mutatedNodes.forEach(node => {
-      const replacement = this.parser.generateCode(node);
-      if (node.start !== null && node.end !== null) {
-        const range: [number, number] = [node.start, node.end];
-        const mutant: Mutant = {
-          fileName,
-          mutatorName,
-          range,
-          replacement
-        };
-        this.log.trace(`Generated mutant for mutator ${mutatorName} in file ${fileName} with replacement code "${replacement}"`);
-        mutants.push(mutant);
-      }
-    });
-    return mutants;
-  }
 }

packages/javascript-mutator/src/helpers/NodeGenerator.ts

@@ -1,16 +1,10 @@
 import * as types from '@babel/types';
 
 export class NodeGenerator {
-  public static createBooleanLiteralNode(originalNode: types.Node, value: boolean): types.BooleanLiteral {
+  public static createMutatedCloneWithProperties(originalNode: types.Node, props: { [key: string]: any }): types.Node {
     return {
-      end: originalNode.end,
-      innerComments: originalNode.innerComments,
-      leadingComments: originalNode.leadingComments,
-      loc: originalNode.loc,
-      start: originalNode.start,
-      trailingComments: originalNode.trailingComments,
-      type: 'BooleanLiteral',
-      value
+      ...originalNode,
+      ...props
     };
   }
 }

packages/javascript-mutator/src/helpers/copy.ts

@@ -1,5 +1,7 @@
 import * as types from '@babel/types';
 
+import { NodeGenerator } from '../helpers/NodeGenerator';
+
 import { NodeMutator } from './NodeMutator';
 
 export default class ArithmeticOperatorMutator implements NodeMutator {
@@ -13,19 +15,18 @@ export default class ArithmeticOperatorMutator implements NodeMutator {
 
   public name = 'ArithmeticOperator';
 
-  public mutate(node: types.Node, clone: <T extends types.Node>(node: T, deep?: boolean) => T): types.Node[] {
+  public mutate(node: types.Node): Array<[types.Node, types.Node | { raw: string }]> {
     if (types.isBinaryExpression(node)) {
       let mutatedOperators = this.operators[node.operator];
       if (mutatedOperators) {
         if (typeof mutatedOperators === 'string') {
           mutatedOperators = [mutatedOperators];
         }
 
-        return mutatedOperators.map<types.Node>(mutatedOperator => {
-          const mutatedNode = clone(node);
-          mutatedNode.operator = mutatedOperator as any;
-          return mutatedNode;
-        });
+        return mutatedOperators.map(mutatedOperator => [
+          node,
+          NodeGenerator.createMutatedCloneWithProperties(node, { operator: mutatedOperator as any })
+        ]);
       }
     }
 

packages/javascript-mutator/src/mutators/ArithmeticOperatorMutator.ts

@@ -8,19 +8,20 @@ import { NodeMutator } from './NodeMutator';
 export default class ArrayDeclarationMutator implements NodeMutator {
   public name = 'ArrayDeclaration';
 
-  public mutate(node: types.Node, copy: <T extends types.Node>(obj: T, deep?: boolean) => T): types.Node[] {
-    const nodes: types.Node[] = [];
-
+  public mutate(node: types.Node): Array<[types.Node, types.Node | { raw: string }]> {
     if (types.isArrayExpression(node)) {
-      const mutatedNode = copy(node);
-      mutatedNode.elements = node.elements.length ? [] : [types.stringLiteral('Stryker was here')];
-      nodes.push(mutatedNode);
+      return [
+        // replace [...]
+        node.elements.length
+          ? [node, { raw: '[]' }] // raw string here
+          : [node, { raw: '["Stryker was here"]' }]
+      ];
     } else if ((types.isCallExpression(node) || types.isNewExpression(node)) && types.isIdentifier(node.callee) && node.callee.name === 'Array') {
-      const mutatedNode = copy(node);
-      mutatedNode.arguments = node.arguments.length ? [] : [types.arrayExpression()];
-      nodes.push(mutatedNode);
+      const newPrefix = types.isNewExpression(node) ? 'new ' : '';
+      const mutatedCallArgs = node.arguments && node.arguments.length ? '' : '[]';
+      return [[node, { raw: `${newPrefix}Array(${mutatedCallArgs})` }]];
+    } else {
+      return [];
     }
-
-    return nodes;
   }
 }

packages/javascript-mutator/src/mutators/ArrayDeclarationMutator.ts

@@ -0,0 +1,16 @@
+import * as types from '@babel/types';
+
+import { NodeMutator } from './NodeMutator';
+
+/**
+ * Represents a mutator which can remove the content of a Object.
+ */
+export default class ArrowFunctionMutator implements NodeMutator {
+  public name = 'ArrowFunction';
+
+  public mutate(node: types.Node): Array<[types.Node, types.Node | { raw: string }]> {
+    return types.isArrowFunctionExpression(node) && !types.isBlockStatement(node.body)
+      ? [[node, { raw: '() => undefined' }]] // raw string replacement
+      : [];
+  }
+}

packages/javascript-mutator/src/mutators/ArrowFunctionMutator.ts

@@ -1,5 +1,7 @@
 import * as types from '@babel/types';
 
+import { NodeGenerator } from '../helpers/NodeGenerator';
+
 import { NodeMutator } from './NodeMutator';
 
 /**
@@ -8,15 +10,11 @@ import { NodeMutator } from './NodeMutator';
 export default class BlockStatementMutator implements NodeMutator {
   public name = 'BlockStatement';
 
-  public mutate(node: types.Node, copy: <T extends types.Node>(obj: T, deep?: boolean) => T): types.Node[] {
-    const nodes: types.Node[] = [];
-
-    if (types.isBlockStatement(node) && node.body.length > 0) {
-      const mutatedNode = copy(node);
-      mutatedNode.body = [];
-      nodes.push(mutatedNode);
-    }
-
-    return nodes;
+  public mutate(node: types.Node): Array<[types.Node, types.Node | { raw: string }]> {
+    return types.isBlockStatement(node) && node.body.length > 0
+      ? [
+          [node, NodeGenerator.createMutatedCloneWithProperties(node, { body: [] })] // `{}`
+        ]
+      : [];
   }
 }

packages/javascript-mutator/src/mutators/BlockStatementMutator.ts

@@ -1,26 +1,22 @@
 import * as types from '@babel/types';
 
+import { NodeGenerator } from '../helpers/NodeGenerator';
+
 import { NodeMutator } from './NodeMutator';
 
 export default class BooleanLiteralMutator implements NodeMutator {
   public name = 'BooleanLiteral';
 
   private readonly unaryBooleanPrefix = '!';
 
-  public mutate(node: types.Node, copy: <T extends types.Node>(obj: T, deep?: boolean) => T): types.Node[] {
-    const nodes: types.Node[] = [];
-
+  public mutate(node: types.Node): Array<[types.Node, types.Node | { raw: string }]> {
     // true -> false or false -> true
     if (types.isBooleanLiteral(node)) {
-      const mutatedNode = copy(node);
-      mutatedNode.value = !mutatedNode.value;
-      nodes.push(mutatedNode);
+      return [[node, NodeGenerator.createMutatedCloneWithProperties(node, { value: !node.value })]];
     } else if (types.isUnaryExpression(node) && node.operator === this.unaryBooleanPrefix && node.prefix) {
-      const mutatedNode = copy(node.argument);
-      mutatedNode.start = node.start;
-      nodes.push(mutatedNode);
+      return [[node, node.argument]];
     }
 
-    return nodes;
+    return [];
   }
 }

packages/javascript-mutator/src/mutators/BooleanLiteralMutator.ts

@@ -29,29 +29,33 @@ export default class ConditionalExpressionMutator implements NodeMutator {
     return this.validOperators.includes(operator);
   }
 
-  public mutate(node: types.Node, copy: <T extends types.Node>(obj: T, deep?: boolean) => T): types.Node[] {
+  public mutate(node: types.Node): Array<[types.Node, types.Node | { raw: string }]> {
     if ((types.isBinaryExpression(node) || types.isLogicalExpression(node)) && this.hasValidParent(node) && this.isValidOperator(node.operator)) {
-      return [NodeGenerator.createBooleanLiteralNode(node, false), NodeGenerator.createBooleanLiteralNode(node, true)];
+      return [
+        // raw string mutations
+        [node, { raw: 'true' }],
+        [node, { raw: 'false' }]
+      ];
     } else if (types.isDoWhileStatement(node) || types.isWhileStatement(node)) {
-      return [NodeGenerator.createBooleanLiteralNode(node.test, false)];
+      return [[node.test, { raw: 'false' }]];
     } else if (types.isForStatement(node)) {
       if (!node.test) {
-        const mutatedNode = copy(node);
-        mutatedNode.test = NodeGenerator.createBooleanLiteralNode(node, false);
-        return [mutatedNode];
+        return [[node, NodeGenerator.createMutatedCloneWithProperties(node, { test: types.booleanLiteral(false) })]];
       } else {
-        return [NodeGenerator.createBooleanLiteralNode(node.test, false)];
+        return [[node.test, { raw: 'false' }]];
       }
     } else if (types.isIfStatement(node)) {
-      return [NodeGenerator.createBooleanLiteralNode(node.test, false), NodeGenerator.createBooleanLiteralNode(node.test, true)];
+      return [
+        // raw string mutations in the `if` condition
+        [node.test, { raw: 'true' }],
+        [node.test, { raw: 'false' }]
+      ];
     } else if (
       types.isSwitchCase(node) &&
       // if not a fallthrough case
       node.consequent.length > 0
     ) {
-      const mutatedNode = copy(node);
-      mutatedNode.consequent = [];
-      return [mutatedNode];
+      return [[node, NodeGenerator.createMutatedCloneWithProperties(node, { consequent: [] })]];
     }
 
     return [];