@d-es-ign/stryker-js-instrumenter 9.6.0

package/src/mutant-placers/statement-mutant-placer.ts

@@ -0,0 +1,39 @@
+import babel, { type types } from '@babel/core';
+
+import {
+  mutantTestExpression,
+  mutationCoverageSequenceExpression,
+} from '../util/syntax-helpers.js';
+
+import { MutantPlacer } from './mutant-placer.js';
+
+const { types: t } = babel;
+
+/**
+ * Mutant placer that places mutants in statements that allow it.
+ * It uses an `if` statement to do so
+ */
+export const statementMutantPlacer: MutantPlacer<types.Statement> = {
+  name: 'statementMutantPlacer',
+  canPlace(path) {
+    return path.isStatement();
+  },
+  place(path, appliedMutants) {
+    let statement: types.Statement = t.blockStatement([
+      t.expressionStatement(
+        mutationCoverageSequenceExpression(appliedMutants.keys()),
+      ),
+      ...(path.isBlockStatement() ? path.node.body : [path.node]),
+    ]);
+    for (const [mutant, appliedMutant] of appliedMutants) {
+      statement = t.ifStatement(
+        mutantTestExpression(mutant.id),
+        t.blockStatement([appliedMutant]),
+        statement,
+      );
+    }
+    path.replaceWith(
+      path.isBlockStatement() ? t.blockStatement([statement]) : statement,
+    );
+  },
+};

package/src/mutant-placers/switch-case-mutant-placer.ts

@@ -0,0 +1,41 @@
+import babel, { type types } from '@babel/core';
+
+import {
+  mutantTestExpression,
+  mutationCoverageSequenceExpression,
+} from '../util/index.js';
+
+import { MutantPlacer } from './mutant-placer.js';
+
+/**
+ * Places the mutants with consequent of a SwitchCase node. Uses an if-statement to do so.
+ * @example
+ *  case 'foo':
+ *    if (stryMutAct_9fa48(0)) {} else {
+ *      stryCov_9fa48(0);
+ *      console.log('bar');
+ *      break;
+ *   }
+ */
+export const switchCaseMutantPlacer: MutantPlacer<types.SwitchCase> = {
+  name: 'switchCaseMutantPlacer',
+  canPlace(path) {
+    return path.isSwitchCase();
+  },
+  place(path, appliedMutants) {
+    let consequence: types.Statement = babel.types.blockStatement([
+      babel.types.expressionStatement(
+        mutationCoverageSequenceExpression(appliedMutants.keys()),
+      ),
+      ...path.node.consequent,
+    ]);
+    for (const [mutant, appliedMutant] of appliedMutants) {
+      consequence = babel.types.ifStatement(
+        mutantTestExpression(mutant.id),
+        babel.types.blockStatement(appliedMutant.consequent),
+        consequence,
+      );
+    }
+    path.replaceWith(babel.types.switchCase(path.node.test, [consequence]));
+  },
+};

package/src/mutant-placers/throw-placement-error.ts

@@ -0,0 +1,34 @@
+import path from 'path';
+
+import { NodePath } from '@babel/core';
+import { propertyPath } from '@stryker-mutator/util';
+import { StrykerOptions } from '@stryker-mutator/api/core';
+
+import { Mutant } from '../mutant.js';
+
+import { MutantPlacer } from './mutant-placer.js';
+
+export function throwPlacementError(
+  error: Error,
+  nodePath: NodePath,
+  placer: MutantPlacer,
+  mutants: Mutant[],
+  fileName: string,
+): never {
+  const location = `${path.relative(process.cwd(), fileName)}:${nodePath.node.loc?.start.line}:${nodePath.node.loc?.start.column}`;
+  const message = `${placer.name} could not place mutants with type(s): "${new Intl.ListFormat('en').format(mutants.map((mutant) => mutant.mutatorName))}"`;
+  const errorMessage = `${location} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using ${propertyPath<StrykerOptions>()(
+    'mutator',
+    'excludedMutations',
+  )}). Please report this issue at https://github.com/stryker-mutator/stryker-js/issues/new?assignees=&labels=%F0%9F%90%9B+Bug&template=bug_report.md&title=${encodeURIComponent(
+    message,
+  )}. Original error: ${error.stack}`;
+  let builtError = new Error(errorMessage);
+  try {
+    // `buildCodeFrameError` is kind of flaky, see https://github.com/stryker-mutator/stryker-js/issues/2695
+    builtError = nodePath.buildCodeFrameError(errorMessage);
+  } catch {
+    // Idle, regular error will have to suffice
+  }
+  throw builtError;
+}

package/src/mutant.ts

@@ -0,0 +1,101 @@
+import babel, { type types } from '@babel/core';
+import generate from '@babel/generator';
+import {
+  Mutant as ApiMutant,
+  Location,
+  Position,
+} from '@stryker-mutator/api/core';
+
+import { deepCloneNode, eqNode } from './util/index.js';
+
+const { traverse } = babel;
+
+const generator = generate.default;
+
+export interface Mutable {
+  mutatorName: string;
+  ignoreReason?: string;
+  replacement: types.Node;
+}
+
+export class Mutant implements Mutable {
+  public readonly replacementCode: string;
+  public readonly replacement: types.Node;
+  public readonly mutatorName: string;
+  public readonly ignoreReason: string | undefined;
+
+  constructor(
+    public readonly id: string,
+    public readonly fileName: string,
+    public readonly original: types.Node,
+    specs: Mutable,
+    public readonly offset: Position = { column: 0, line: 0 },
+  ) {
+    this.replacement = specs.replacement;
+    this.mutatorName = specs.mutatorName;
+    this.ignoreReason = specs.ignoreReason;
+    this.replacementCode = generator(this.replacement).code;
+  }
+
+  public toApiMutant(): ApiMutant {
+    return {
+      fileName: this.fileName,
+      id: this.id,
+      location: toApiLocation(this.original.loc!, this.offset),
+      mutatorName: this.mutatorName,
+      replacement: this.replacementCode,
+      statusReason: this.ignoreReason,
+      status: this.ignoreReason ? 'Ignored' : undefined,
+    };
+  }
+
+  /**
+   * Applies the mutant in (a copy of) the AST, without changing provided AST.
+   * Can the tree itself (in which case the replacement is returned),
+   * or can be nested in the given tree.
+   * @param originalTree The original node, which will be treated as readonly
+   */
+  public applied<TNode extends types.Node>(originalTree: TNode): TNode {
+    if (originalTree === this.original) {
+      return this.replacement as TNode;
+    } else {
+      const mutatedAst = deepCloneNode(originalTree);
+      let applied = false;
+      const { original, replacement } = this;
+      traverse(mutatedAst, {
+        noScope: true,
+        enter(path) {
+          if (eqNode(path.node, original)) {
+            path.replaceWith(replacement);
+            path.stop();
+            applied = true;
+          }
+        },
+      });
+      if (!applied) {
+        throw new Error(
+          `Could not apply mutant ${JSON.stringify(this.replacement)}.`,
+        );
+      }
+      return mutatedAst;
+    }
+  }
+}
+
+function toApiLocation(
+  source: types.SourceLocation,
+  offset: Position,
+): Location {
+  const loc = {
+    start: toPosition(source.start, offset),
+    end: toPosition(source.end, offset),
+  };
+  return loc;
+}
+
+function toPosition(source: Position, offset: Position): Position {
+  return {
+    column: source.column + (source.line === 1 ? offset.column : 0), // offset is zero-based
+    line: source.line + offset.line - 1, // Stryker works 0-based internally, offset is zero based as well
+  };
+}

package/src/mutators/arithmetic-operator-mutator.ts

@@ -0,0 +1,51 @@
+import type { types } from '@babel/core';
+
+import { deepCloneNode } from '../util/index.js';
+
+import { NodeMutator } from './node-mutator.js';
+
+const arithmeticOperatorReplacements = Object.freeze({
+  '+': '-',
+  '-': '+',
+  '*': '/',
+  '/': '*',
+  '%': '*',
+} as const);
+
+export const arithmeticOperatorMutator: NodeMutator = {
+  name: 'ArithmeticOperator',
+
+  *mutate(path) {
+    if (
+      path.isBinaryExpression() &&
+      isSupported(path.node.operator, path.node)
+    ) {
+      const mutatedOperator =
+        arithmeticOperatorReplacements[path.node.operator];
+      const replacement = deepCloneNode(path.node);
+      replacement.operator = mutatedOperator;
+      yield replacement;
+    }
+  },
+};
+
+function isSupported(
+  operator: string,
+  node: types.BinaryExpression,
+): operator is keyof typeof arithmeticOperatorReplacements {
+  if (!Object.keys(arithmeticOperatorReplacements).includes(operator)) {
+    return false;
+  }
+
+  const stringTypes = ['StringLiteral', 'TemplateLiteral'];
+  const leftType =
+    node.left.type === 'BinaryExpression'
+      ? node.left.right.type
+      : node.left.type;
+
+  if (stringTypes.includes(node.right.type) || stringTypes.includes(leftType)) {
+    return false;
+  }
+
+  return true;
+}

package/src/mutators/array-declaration-mutator.ts

@@ -0,0 +1,36 @@
+import babel, { type NodePath } from '@babel/core';
+
+import { deepCloneNode } from '../util/index.js';
+
+import { NodeMutator } from './node-mutator.js';
+
+const { types } = babel;
+
+export const arrayDeclarationMutator: NodeMutator = {
+  name: 'ArrayDeclaration',
+
+  *mutate(path: NodePath): Iterable<babel.types.Node> {
+    if (path.isArrayExpression()) {
+      const replacement = path.node.elements.length
+        ? types.arrayExpression()
+        : types.arrayExpression([types.stringLiteral('Stryker was here')]);
+      yield replacement;
+    }
+    if (
+      (path.isCallExpression() || path.isNewExpression()) &&
+      types.isIdentifier(path.node.callee) &&
+      path.node.callee.name === 'Array'
+    ) {
+      const mutatedCallArgs = path.node.arguments.length
+        ? []
+        : [types.arrayExpression()];
+      const replacement = types.isNewExpression(path.node)
+        ? types.newExpression(deepCloneNode(path.node.callee), mutatedCallArgs)
+        : types.callExpression(
+            deepCloneNode(path.node.callee),
+            mutatedCallArgs,
+          );
+      yield replacement;
+    }
+  },
+};

package/src/mutators/arrow-function-mutator.ts

@@ -0,0 +1,22 @@
+import babel from '@babel/core';
+
+const { types } = babel;
+
+import { NodeMutator } from './index.js';
+
+export const arrowFunctionMutator: NodeMutator = {
+  name: 'ArrowFunction',
+
+  *mutate(path) {
+    if (
+      path.isArrowFunctionExpression() &&
+      !types.isBlockStatement(path.node.body) &&
+      !(
+        types.isIdentifier(path.node.body) &&
+        path.node.body.name === 'undefined'
+      )
+    ) {
+      yield types.arrowFunctionExpression([], types.identifier('undefined'));
+    }
+  },
+};

package/src/mutators/assignment-operator-mutator.ts

@@ -0,0 +1,59 @@
+import type { types as t } from '@babel/core';
+
+import { deepCloneNode } from '../util/index.js';
+
+import { NodeMutator } from './index.js';
+
+const assignmentOperatorReplacements = Object.freeze({
+  '+=': '-=',
+  '-=': '+=',
+  '*=': '/=',
+  '/=': '*=',
+  '%=': '*=',
+  '<<=': '>>=',
+  '>>=': '<<=',
+  '&=': '|=',
+  '|=': '&=',
+  '&&=': '||=',
+  '||=': '&&=',
+  '??=': '&&=',
+} as const);
+
+const stringTypes = Object.freeze(['StringLiteral', 'TemplateLiteral']);
+const stringAssignmentTypes = Object.freeze(['&&=', '||=', '??=']);
+
+export const assignmentOperatorMutator: NodeMutator = {
+  name: 'AssignmentOperator',
+
+  *mutate(path) {
+    if (
+      path.isAssignmentExpression() &&
+      isSupportedAssignmentOperator(path.node.operator) &&
+      isSupported(path.node)
+    ) {
+      const mutatedOperator =
+        assignmentOperatorReplacements[path.node.operator];
+      const replacement = deepCloneNode(path.node);
+      replacement.operator = mutatedOperator;
+      yield replacement;
+    }
+  },
+};
+
+function isSupportedAssignmentOperator(
+  operator: string,
+): operator is keyof typeof assignmentOperatorReplacements {
+  return Object.keys(assignmentOperatorReplacements).includes(operator);
+}
+
+function isSupported(node: t.AssignmentExpression): boolean {
+  // Excludes assignment operators that apply to strings.
+  if (
+    stringTypes.includes(node.right.type) &&
+    !stringAssignmentTypes.includes(node.operator)
+  ) {
+    return false;
+  }
+
+  return true;
+}

package/src/mutators/block-statement-mutator.ts

@@ -0,0 +1,89 @@
+import babel, { type NodePath } from '@babel/core';
+
+import { NodeMutator } from './node-mutator.js';
+
+const { types } = babel;
+
+export const blockStatementMutator: NodeMutator = {
+  name: 'BlockStatement',
+
+  *mutate(path) {
+    if (path.isBlockStatement() && isValid(path)) {
+      yield types.blockStatement([]);
+    }
+  },
+};
+
+function isValid(path: NodePath<babel.types.BlockStatement>) {
+  return !isEmpty(path) && !isInvalidConstructorBody(path);
+}
+
+function isEmpty(path: NodePath<babel.types.BlockStatement>) {
+  return !path.node.body.length;
+}
+
+/**
+ * Checks to see if a statement is an invalid constructor body
+ * @example
+ * // Invalid!
+ * class Foo extends Bar {
+ *   constructor(public baz: string) {
+ *     super(42);
+ *   }
+ * }
+ * @example
+ * // Invalid!
+ * class Foo extends Bar {
+ *   public baz = 'string';
+ *   constructor() {
+ *     super(42);
+ *   }
+ * }
+ * @see https://github.com/stryker-mutator/stryker-js/issues/2314
+ * @see https://github.com/stryker-mutator/stryker-js/issues/2474
+ */
+function isInvalidConstructorBody(
+  blockStatement: NodePath<babel.types.BlockStatement>,
+): boolean {
+  return Boolean(
+    blockStatement.parentPath.isClassMethod() &&
+    blockStatement.parentPath.node.kind === 'constructor' &&
+    (containsTSParameterProperties(blockStatement.parentPath) ||
+      containsInitializedClassProperties(blockStatement.parentPath)) &&
+    hasSuperExpression(blockStatement),
+  );
+}
+
+function containsTSParameterProperties(
+  constructor: NodePath<babel.types.ClassMethod>,
+): boolean {
+  return constructor.node.params.some((param) =>
+    types.isTSParameterProperty(param),
+  );
+}
+
+function containsInitializedClassProperties(
+  constructor: NodePath<babel.types.ClassMethod>,
+): boolean {
+  return (
+    constructor.parentPath.isClassBody() &&
+    constructor.parentPath.node.body.some(
+      (classMember) => types.isClassProperty(classMember) && classMember.value,
+    )
+  );
+}
+
+function hasSuperExpression(
+  constructor: NodePath<babel.types.BlockStatement>,
+): boolean {
+  let hasSuper = false;
+  constructor.traverse({
+    Super(path) {
+      if (path.parentPath.isCallExpression()) {
+        path.stop();
+        hasSuper = true;
+      }
+    },
+  });
+  return hasSuper;
+}

package/src/mutators/boolean-literal-mutator.ts

@@ -0,0 +1,24 @@
+import babel from '@babel/core';
+
+import { deepCloneNode } from '../util/index.js';
+
+const { types } = babel;
+
+import { NodeMutator } from './index.js';
+
+export const booleanLiteralMutator: NodeMutator = {
+  name: 'BooleanLiteral',
+
+  *mutate(path) {
+    if (path.isBooleanLiteral()) {
+      yield types.booleanLiteral(!path.node.value);
+    }
+    if (
+      path.isUnaryExpression() &&
+      path.node.operator === '!' &&
+      path.node.prefix
+    ) {
+      yield deepCloneNode(path.node.argument);
+    }
+  },
+};

package/src/mutators/conditional-expression-mutator.ts

@@ -0,0 +1,92 @@
+import babel, { type NodePath } from '@babel/core';
+
+import { deepCloneNode } from '../util/index.js';
+
+import { NodeMutator } from './node-mutator.js';
+
+const booleanOperators = Object.freeze([
+  '!=',
+  '!==',
+  '&&',
+  '<',
+  '<=',
+  '==',
+  '===',
+  '>',
+  '>=',
+  '||',
+]);
+
+const { types } = babel;
+
+export const conditionalExpressionMutator: NodeMutator = {
+  name: 'ConditionalExpression',
+
+  *mutate(path) {
+    if (isTestOfLoop(path)) {
+      yield types.booleanLiteral(false);
+    } else if (isTestOfCondition(path)) {
+      yield types.booleanLiteral(true);
+      yield types.booleanLiteral(false);
+    } else if (isBooleanExpression(path)) {
+      if (path.parent?.type === 'LogicalExpression') {
+        // For (x || y), do not generate the (true || y) mutation as it
+        // has the same behavior as the (true) mutator, handled in the
+        // isTestOfCondition branch above
+        if (path.parent.operator === '||') {
+          yield types.booleanLiteral(false);
+          return;
+        }
+        // For (x && y), do not generate the (false && y) mutation as it
+        // has the same behavior as the (false) mutator, handled in the
+        // isTestOfCondition branch above
+        if (path.parent.operator === '&&') {
+          yield types.booleanLiteral(true);
+          return;
+        }
+      }
+      yield types.booleanLiteral(true);
+      yield types.booleanLiteral(false);
+    } else if (path.isForStatement() && !path.node.test) {
+      const replacement = deepCloneNode(path.node);
+      replacement.test = types.booleanLiteral(false);
+      yield replacement;
+    } else if (path.isSwitchCase() && path.node.consequent.length > 0) {
+      // if not a fallthrough case
+      const replacement = deepCloneNode(path.node);
+      replacement.consequent = [];
+      yield replacement;
+    }
+  },
+};
+
+function isTestOfLoop(path: NodePath): boolean {
+  const { parentPath } = path;
+  if (!parentPath) {
+    return false;
+  }
+  return (
+    (parentPath.isForStatement() ||
+      parentPath.isWhileStatement() ||
+      parentPath.isDoWhileStatement()) &&
+    parentPath.node.test === path.node
+  );
+}
+
+function isTestOfCondition(path: NodePath): boolean {
+  const { parentPath } = path;
+  if (!parentPath) {
+    return false;
+  }
+  return (
+    parentPath.isIfStatement() /*|| parentPath.isConditionalExpression()*/ &&
+    parentPath.node.test === path.node
+  );
+}
+
+function isBooleanExpression(path: NodePath) {
+  return (
+    (path.isBinaryExpression() || path.isLogicalExpression()) &&
+    booleanOperators.includes(path.node.operator)
+  );
+}

package/src/mutators/equality-operator-mutator.ts

@@ -0,0 +1,35 @@
+import babel from '@babel/core';
+
+import { NodeMutator } from './node-mutator.js';
+
+const { types: t } = babel;
+
+const operators = {
+  '<': ['<=', '>='],
+  '<=': ['<', '>'],
+  '>': ['>=', '<='],
+  '>=': ['>', '<'],
+  '==': ['!='],
+  '!=': ['=='],
+  '===': ['!=='],
+  '!==': ['==='],
+} as const;
+
+function isEqualityOperator(
+  operator: string,
+): operator is keyof typeof operators {
+  return Object.keys(operators).includes(operator);
+}
+export const equalityOperatorMutator: NodeMutator = {
+  name: 'EqualityOperator',
+
+  *mutate(path) {
+    if (path.isBinaryExpression() && isEqualityOperator(path.node.operator)) {
+      for (const mutableOperator of operators[path.node.operator]) {
+        const replacement = t.cloneNode(path.node, true);
+        replacement.operator = mutableOperator;
+        yield replacement;
+      }
+    }
+  },
+};

package/src/mutators/index.ts

@@ -0,0 +1,3 @@
+export * from './node-mutator.js';
+export * from './mutator-options.js';
+export * from './mutate.js';

package/src/mutators/logical-operator-mutator.ts

@@ -0,0 +1,29 @@
+import { deepCloneNode } from '../util/index.js';
+
+import { NodeMutator } from './index.js';
+
+const logicalOperatorReplacements = Object.freeze({
+  '&&': '||',
+  '||': '&&',
+  '??': '&&',
+} as const);
+
+export const logicalOperatorMutator: NodeMutator = {
+  name: 'LogicalOperator',
+
+  *mutate(path) {
+    if (path.isLogicalExpression() && isSupported(path.node.operator)) {
+      const mutatedOperator = logicalOperatorReplacements[path.node.operator];
+
+      const replacement = deepCloneNode(path.node);
+      replacement.operator = mutatedOperator;
+      yield replacement;
+    }
+  },
+};
+
+function isSupported(
+  operator: string,
+): operator is keyof typeof logicalOperatorReplacements {
+  return Object.keys(logicalOperatorReplacements).includes(operator);
+}