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

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

@@ -0,0 +1,99 @@
+import babel from '@babel/core';
+
+import { deepCloneNode } from '../util/syntax-helpers.js';
+
+import { NodeMutator } from './node-mutator.js';
+
+const { types } = babel;
+
+const replacements = new Map([
+  ['charAt', null],
+  ['endsWith', 'startsWith'],
+  ['every', 'some'],
+  ['filter', null],
+  ['reverse', null],
+  ['slice', null],
+  ['sort', null],
+  ['substr', null],
+  ['substring', null],
+  ['toLocaleLowerCase', 'toLocaleUpperCase'],
+  ['toLowerCase', 'toUpperCase'],
+  ['trim', null],
+  ['trimEnd', 'trimStart'],
+  ['min', 'max'],
+  ['setDate', 'setTime'],
+  ['setFullYear', 'setMonth'],
+  ['setHours', 'setMinutes'],
+  ['setSeconds', 'setMilliseconds'],
+  ['setUTCDate', 'setTime'],
+  ['setUTCFullYear', 'setUTCMonth'],
+  ['setUTCHours', 'setUTCMinutes'],
+  ['setUTCSeconds', 'setUTCMilliseconds'],
+]);
+
+const noReverseRemplacements = ['getUTCDate', 'setUTCDate'];
+
+for (const [key, value] of Array.from(replacements)) {
+  if (value && !noReverseRemplacements.includes(key)) {
+    replacements.set(value, key);
+  }
+}
+
+export const methodExpressionMutator: NodeMutator = {
+  name: 'MethodExpression',
+
+  *mutate(path) {
+    if (!(path.isCallExpression() || path.isOptionalCallExpression())) {
+      return;
+    }
+
+    const { callee } = path.node;
+    if (
+      !(
+        types.isMemberExpression(callee) ||
+        types.isOptionalMemberExpression(callee)
+      ) ||
+      !types.isIdentifier(callee.property)
+    ) {
+      return;
+    }
+
+    const newName = replacements.get(callee.property.name);
+    if (newName === undefined) {
+      return;
+    }
+
+    if (newName === null) {
+      // Remove the method expression. I.e. `foo.trim()` => `foo`
+      yield deepCloneNode(callee.object);
+      return;
+    }
+
+    // Replace the method expression. I.e. `foo.toLowerCase()` => `foo.toUpperCase`
+    const nodeArguments = path.node.arguments.map((argumentNode) =>
+      deepCloneNode(argumentNode),
+    );
+
+    const mutatedCallee = types.isMemberExpression(callee)
+      ? types.memberExpression(
+          deepCloneNode(callee.object),
+          types.identifier(newName),
+          false,
+          callee.optional,
+        )
+      : types.optionalMemberExpression(
+          deepCloneNode(callee.object),
+          types.identifier(newName),
+          false,
+          callee.optional,
+        );
+
+    yield types.isCallExpression(path.node)
+      ? types.callExpression(mutatedCallee, nodeArguments)
+      : types.optionalCallExpression(
+          mutatedCallee,
+          nodeArguments,
+          path.node.optional,
+        );
+  },
+};

package/src/mutators/mutate.ts

@@ -0,0 +1,36 @@
+import { arithmeticOperatorMutator } from './arithmetic-operator-mutator.js';
+import { NodeMutator } from './node-mutator.js';
+import { blockStatementMutator } from './block-statement-mutator.js';
+import { conditionalExpressionMutator } from './conditional-expression-mutator.js';
+import { stringLiteralMutator } from './string-literal-mutator.js';
+import { arrayDeclarationMutator } from './array-declaration-mutator.js';
+import { arrowFunctionMutator } from './arrow-function-mutator.js';
+import { booleanLiteralMutator } from './boolean-literal-mutator.js';
+import { equalityOperatorMutator } from './equality-operator-mutator.js';
+import { methodExpressionMutator } from './method-expression-mutator.js';
+import { logicalOperatorMutator } from './logical-operator-mutator.js';
+import { objectLiteralMutator } from './object-literal-mutator.js';
+import { unaryOperatorMutator } from './unary-operator-mutator.js';
+import { updateOperatorMutator } from './update-operator-mutator.js';
+import { regexMutator } from './regex-mutator.js';
+import { optionalChainingMutator } from './optional-chaining-mutator.js';
+import { assignmentOperatorMutator } from './assignment-operator-mutator.js';
+
+export const allMutators: NodeMutator[] = [
+  arithmeticOperatorMutator,
+  arrayDeclarationMutator,
+  arrowFunctionMutator,
+  blockStatementMutator,
+  booleanLiteralMutator,
+  conditionalExpressionMutator,
+  equalityOperatorMutator,
+  logicalOperatorMutator,
+  methodExpressionMutator,
+  objectLiteralMutator,
+  stringLiteralMutator,
+  unaryOperatorMutator,
+  updateOperatorMutator,
+  regexMutator,
+  optionalChainingMutator,
+  assignmentOperatorMutator,
+];

package/src/mutators/mutator-options.ts

@@ -0,0 +1,4 @@
+export interface MutatorOptions {
+  excludedMutations: string[];
+  noHeader?: boolean;
+}

package/src/mutators/node-mutator.ts

@@ -0,0 +1,6 @@
+import type { types, NodePath } from '@babel/core';
+
+export interface NodeMutator {
+  mutate(path: NodePath): Iterable<types.Node>;
+  readonly name: string;
+}

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

@@ -0,0 +1,15 @@
+import babel from '@babel/core';
+
+import { NodeMutator } from './index.js';
+
+const { types } = babel;
+
+export const objectLiteralMutator: NodeMutator = {
+  name: 'ObjectLiteral',
+
+  *mutate(path) {
+    if (path.isObjectExpression() && path.node.properties.length > 0) {
+      yield types.objectExpression([]);
+    }
+  },
+};

package/src/mutators/optional-chaining-mutator.ts

@@ -0,0 +1,39 @@
+import babel from '@babel/core';
+
+import { NodeMutator } from './index.js';
+
+const { types: t } = babel;
+
+/**
+ * Mutates optional chaining operators
+ * Note that the AST for optional chaining might not be what you expect. Nodes of type `OptionalMemberExpression` can be either optional or not-optional
+ *
+ * For example: In this expression: `foo?.bar.baz` the `.baz` member expression is of type `OptionalMemberExpression`, because it is part of an optional chain, but is is _not_ optional.
+ * Only the `.bar` optional member expression is optional.
+ *
+ * @example
+ * foo?.bar -> foo.bar
+ * foo?.[1] -> foo[1]
+ * foo?.() -> foo()
+ */
+export const optionalChainingMutator: NodeMutator = {
+  name: 'OptionalChaining',
+
+  *mutate(path) {
+    if (path.isOptionalMemberExpression() && path.node.optional) {
+      yield t.optionalMemberExpression(
+        t.cloneNode(path.node.object, true),
+        t.cloneNode(path.node.property, true),
+        path.node.computed,
+        /*optional*/ false,
+      );
+    }
+    if (path.isOptionalCallExpression() && path.node.optional) {
+      yield t.optionalCallExpression(
+        t.cloneNode(path.node.callee, true),
+        path.node.arguments.map((arg) => t.cloneNode(arg, true)),
+        /*optional*/ false,
+      );
+    }
+  },
+};

package/src/mutators/regex-mutator.ts

@@ -0,0 +1,69 @@
+import babel, { NodePath, type types as t } from '@babel/core';
+import * as weaponRegex from 'weapon-regex';
+
+import { NodeMutator } from './index.js';
+
+const { types } = babel;
+
+/**
+ * Checks that a string literal is an obvious regex string literal
+ * @param path The string literal to checks
+ * @example
+ * new RegExp("\\d{4}");
+ */
+function isObviousRegexString(path: NodePath<t.StringLiteral>) {
+  return (
+    path.parentPath.isNewExpression() &&
+    types.isIdentifier(path.parentPath.node.callee) &&
+    path.parentPath.node.callee.name === RegExp.name &&
+    path.parentPath.node.arguments[0] === path.node
+  );
+}
+
+function getFlags(path: NodePath<t.NewExpression>): string | undefined {
+  if (types.isStringLiteral(path.node.arguments[1])) {
+    return path.node.arguments[1].value;
+  }
+  return undefined;
+}
+
+const weaponRegexOptions: weaponRegex.MutationOptions = { mutationLevels: [1] };
+
+export const regexMutator: NodeMutator = {
+  name: 'Regex',
+
+  *mutate(path) {
+    if (path.isRegExpLiteral()) {
+      for (const replacementPattern of mutatePattern(
+        path.node.pattern,
+        path.node.flags,
+      )) {
+        const replacement = types.regExpLiteral(
+          replacementPattern,
+          path.node.flags,
+        );
+        yield replacement;
+      }
+    } else if (path.isStringLiteral() && isObviousRegexString(path)) {
+      const flags = getFlags(path.parentPath as NodePath<t.NewExpression>);
+      for (const replacementPattern of mutatePattern(path.node.value, flags)) {
+        yield types.stringLiteral(replacementPattern);
+      }
+    }
+  },
+};
+
+function mutatePattern(pattern: string, flags: string | undefined): string[] {
+  if (pattern.length) {
+    try {
+      return weaponRegex
+        .mutate(pattern, flags, weaponRegexOptions)
+        .map((mutant) => mutant.pattern);
+    } catch (err: any) {
+      console.error(
+        `[RegexMutator]: The Regex parser of weapon-regex couldn't parse this regex pattern: "${pattern}". Please report this issue at https://github.com/stryker-mutator/weapon-regex/issues. Inner error: ${err.message}`,
+      );
+    }
+  }
+  return [];
+}

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

@@ -0,0 +1,49 @@
+import babel, { type NodePath } from '@babel/core';
+
+import { NodeMutator } from './node-mutator.js';
+
+const { types } = babel;
+
+export const stringLiteralMutator: NodeMutator = {
+  name: 'StringLiteral',
+
+  *mutate(path) {
+    if (path.isTemplateLiteral()) {
+      const replacement =
+        path.node.quasis.length === 1 &&
+        path.node.quasis[0].value.raw.length === 0
+          ? 'Stryker was here!'
+          : '';
+      yield types.templateLiteral(
+        [types.templateElement({ raw: replacement })],
+        [],
+      );
+    }
+    if (path.isStringLiteral() && isValidParent(path)) {
+      yield types.stringLiteral(
+        path.node.value.length === 0 ? 'Stryker was here!' : '',
+      );
+    }
+  },
+};
+
+function isValidParent(child: NodePath<babel.types.StringLiteral>): boolean {
+  const { parent } = child;
+  return !(
+    types.isImportDeclaration(parent) ||
+    types.isExportDeclaration(parent) ||
+    types.isImportOrExportDeclaration(parent) ||
+    types.isTSExternalModuleReference(parent) ||
+    types.isJSXAttribute(parent) ||
+    types.isExpressionStatement(parent) ||
+    types.isTSLiteralType(parent) ||
+    types.isObjectMethod(parent) ||
+    (types.isObjectProperty(parent) && parent.key === child.node) ||
+    (types.isClassProperty(parent) && parent.key === child.node) ||
+    (types.isCallExpression(parent) &&
+      types.isIdentifier(parent.callee, { name: 'require' })) ||
+    (types.isCallExpression(parent) &&
+      types.isIdentifier(parent.callee, { name: 'Symbol' })) ||
+    (types.isCallExpression(parent) && types.isImport(parent.callee))
+  );
+}

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

@@ -0,0 +1,39 @@
+import babel from '@babel/core';
+
+import { deepCloneNode } from '../util/index.js';
+
+import { NodeMutator } from './index.js';
+
+const { types } = babel;
+
+enum UnaryOperator {
+  '+' = '-',
+  '-' = '+',
+  '~' = '',
+}
+
+export const unaryOperatorMutator: NodeMutator = {
+  name: 'UnaryOperator',
+
+  *mutate(path) {
+    if (
+      path.isUnaryExpression() &&
+      isSupported(path.node.operator) &&
+      path.node.prefix
+    ) {
+      const mutatedOperator = UnaryOperator[path.node.operator];
+      const replacement = mutatedOperator.length
+        ? types.unaryExpression(
+            mutatedOperator as '-' | '+',
+            deepCloneNode(path.node.argument),
+          )
+        : deepCloneNode(path.node.argument);
+
+      yield replacement;
+    }
+  },
+};
+
+function isSupported(operator: string): operator is keyof typeof UnaryOperator {
+  return Object.keys(UnaryOperator).includes(operator);
+}

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

@@ -0,0 +1,26 @@
+import babel from '@babel/core';
+
+import { deepCloneNode } from '../util/index.js';
+
+import { NodeMutator } from './index.js';
+
+const { types } = babel;
+
+enum UpdateOperators {
+  '++' = '--',
+  '--' = '++',
+}
+
+export const updateOperatorMutator: NodeMutator = {
+  name: 'UpdateOperator',
+
+  *mutate(path) {
+    if (path.isUpdateExpression()) {
+      yield types.updateExpression(
+        UpdateOperators[path.node.operator],
+        deepCloneNode(path.node.argument),
+        path.node.prefix,
+      );
+    }
+  },
+};

package/src/parsers/create-parser.ts

@@ -0,0 +1,78 @@
+import path from 'path';
+
+import { AstByFormat, AstFormat } from '../syntax/index.js';
+
+import { createParser as createJSParser } from './js-parser.js';
+import { parseTS, parseTsx } from './ts-parser.js';
+import { parse as htmlParse } from './html-parser.js';
+import { parse as svelteParse } from './svelte-parser.js';
+import { ParserOptions } from './parser-options.js';
+
+export function createParser(
+  parserOptions: ParserOptions,
+): <T extends AstFormat = AstFormat>(
+  code: string,
+  fileName: string,
+  formatOverride?: T,
+) => Promise<AstByFormat[T]> {
+  const jsParse = createJSParser(parserOptions);
+  return async function parse<T extends AstFormat = AstFormat>(
+    code: string,
+    fileName: string,
+    formatOverride?: T,
+  ): Promise<AstByFormat[T]> {
+    const format = getFormat(fileName, formatOverride);
+    if (!format) {
+      const ext = path.extname(fileName).toLowerCase();
+      throw new Error(
+        `Unable to parse ${fileName}. No parser registered for ${ext}!`,
+      );
+    }
+    switch (format) {
+      case AstFormat.JS:
+        return jsParse(code, fileName) as Promise<AstByFormat[T]>;
+      case AstFormat.Tsx:
+        return parseTsx(code, fileName) as Promise<AstByFormat[T]>;
+      case AstFormat.TS:
+        return parseTS(code, fileName) as Promise<AstByFormat[T]>;
+      case AstFormat.Html:
+        return htmlParse(code, fileName, { parse }) as Promise<AstByFormat[T]>;
+      case AstFormat.Svelte:
+        return svelteParse(code, fileName, { parse }) as Promise<
+          AstByFormat[T]
+        >;
+    }
+  };
+}
+
+export function getFormat(
+  fileName: string,
+  override?: AstFormat,
+): AstFormat | undefined {
+  if (override) {
+    return override;
+  } else {
+    const ext = path.extname(fileName).toLowerCase();
+    switch (ext) {
+      case '.js':
+      case '.jsx':
+      case '.mjs':
+      case '.cjs':
+        return AstFormat.JS;
+      case '.mts':
+      case '.cts':
+      case '.ts':
+        return AstFormat.TS;
+      case '.tsx':
+        return AstFormat.Tsx;
+      case '.vue':
+      case '.html':
+      case '.htm':
+        return AstFormat.Html;
+      case '.svelte':
+        return AstFormat.Svelte;
+      default:
+        return;
+    }
+  }
+}

package/src/parsers/html-parser.ts

@@ -0,0 +1,138 @@
+import {
+  HtmlAst,
+  AstFormat,
+  HtmlRootNode,
+  ScriptFormat,
+  AstByFormat,
+  ScriptAst,
+} from '../syntax/index.js';
+import type { Ast as NGAst } from 'angular-html-parser';
+import { ParserContext } from './parser-context.js';
+import { ParseError } from './parse-error.js';
+
+const TSX_SCRIPT_TYPES = Object.freeze(['tsx', 'text/tsx']);
+const TS_SCRIPT_TYPES = Object.freeze(['ts', 'text/typescript', 'typescript']);
+const JS_SCRIPT_TYPES = Object.freeze([
+  'js',
+  'text/javascript',
+  'javascript',
+  'module',
+]);
+
+/*
+The parser implementation in this file is heavily based on prettier's html parser
+https://github.com/prettier/prettier/blob/5a7162d0636a82c5862b9101b845af40918d22d1/src/language-html/parser-html.js
+*/
+export async function parse(
+  text: string,
+  originFileName: string,
+  context: ParserContext,
+): Promise<HtmlAst> {
+  const root = await ngHtmlParser(text, originFileName, context);
+
+  return {
+    originFileName,
+    rawContent: text,
+    format: AstFormat.Html,
+    root,
+  };
+}
+
+async function ngHtmlParser(
+  text: string,
+  fileName: string,
+  parserContext: ParserContext,
+): Promise<HtmlRootNode> {
+  const ngParser = await import('angular-html-parser');
+
+  const { rootNodes, errors } = ngParser.parse(text, {
+    canSelfClose: true,
+    allowHtmComponentClosingTags: true,
+    isTagNameCaseSensitive: true,
+  });
+
+  if (errors.length !== 0) {
+    throw new ParseError(
+      errors[0].msg,
+      fileName,
+      toSourceLocation(errors[0].span.start),
+    );
+  }
+  const scriptsAsPromised: Array<Promise<ScriptAst>> = [];
+  ngParser.visitAll(
+    new (class extends ngParser.RecursiveVisitor {
+      public override visitElement(el: NGAst.Element, context: unknown): void {
+        const scriptFormat = getScriptType(el);
+        if (scriptFormat) {
+          scriptsAsPromised.push(parseScript(el, scriptFormat));
+        }
+        super.visitElement(el, context);
+      }
+    })(),
+    rootNodes,
+  );
+  const scripts = await Promise.all(scriptsAsPromised);
+  const root: HtmlRootNode = {
+    scripts,
+  };
+
+  return root;
+
+  async function parseScript<T extends ScriptFormat>(
+    el: NGAst.Element,
+    scriptFormat: T,
+  ): Promise<AstByFormat[T]> {
+    const content = text.substring(
+      el.startSourceSpan.end.offset,
+      el.endSourceSpan!.start.offset,
+    );
+    const ast = await parserContext.parse(content, fileName, scriptFormat);
+    if (ast) {
+      const offset = el.startSourceSpan.end;
+      ast.root.start! += offset.offset;
+      ast.root.end! += offset.offset;
+      return {
+        ...ast,
+        offset: {
+          column: offset.offset,
+          line: offset.line,
+        },
+      };
+    }
+    return ast;
+  }
+}
+
+function toSourceLocation({ line, col }: { line: number; col: number }): {
+  line: number;
+  column: number;
+} {
+  // Offset line with 1, since ngHtmlParser is 0-based
+  return { line: line + 1, column: col };
+}
+
+function getScriptType(element: NGAst.Element): ScriptFormat | undefined {
+  if (element.name === 'script') {
+    const containsSrc = element.attrs.some((attr) => attr.name === 'src');
+    if (!containsSrc) {
+      const type =
+        element.attrs.find((attr) => attr.name === 'type') ??
+        element.attrs.find((attr) => attr.name === 'lang');
+      if (type) {
+        const typeToLower = type.value.toLowerCase();
+        if (TSX_SCRIPT_TYPES.includes(typeToLower)) {
+          return AstFormat.Tsx;
+        }
+        if (TS_SCRIPT_TYPES.includes(typeToLower)) {
+          return AstFormat.TS;
+        }
+        if (JS_SCRIPT_TYPES.includes(typeToLower)) {
+          return AstFormat.JS;
+        }
+      } else {
+        return AstFormat.JS;
+      }
+    }
+  }
+  return undefined;
+}

package/src/parsers/index.ts

@@ -0,0 +1,5 @@
+import { ParserOptions } from './parser-options.js';
+import { createParser, getFormat } from './create-parser.js';
+
+export type { ParserOptions };
+export { createParser, getFormat };

package/src/parsers/js-parser.ts

@@ -0,0 +1,58 @@
+import { ParserPlugin } from '@babel/parser';
+import babel from '@babel/core';
+
+import { AstFormat, JSAst } from '../syntax/index.js';
+
+import { ParserOptions } from './parser-options.js';
+
+const { types, parseAsync } = babel;
+
+const defaultPlugins: ParserPlugin[] = [
+  'doExpressions',
+  'objectRestSpread',
+  'classProperties',
+  'exportDefaultFrom',
+  'exportNamespaceFrom',
+  'asyncGenerators',
+  'functionBind',
+  'functionSent',
+  'dynamicImport',
+  'numericSeparator',
+  'importMeta',
+  'optionalCatchBinding',
+  'optionalChaining',
+  'classPrivateProperties',
+  ['pipelineOperator', { proposal: 'minimal' }],
+  'nullishCoalescingOperator',
+  'bigInt',
+  'throwExpressions',
+  'logicalAssignment',
+  'classPrivateMethods',
+  'v8intrinsic',
+  'partialApplication',
+  ['decorators', { decoratorsBeforeExport: false }],
+  'jsx',
+];
+
+export function createParser({ plugins: pluginsOverride }: ParserOptions) {
+  return async function parse(text: string, fileName: string): Promise<JSAst> {
+    const ast = await parseAsync(text, {
+      parserOpts: {
+        plugins: [...(pluginsOverride ?? defaultPlugins)] as ParserPlugin[],
+      },
+      filename: fileName,
+      sourceType: 'module',
+    });
+    if (types.isProgram(ast)) {
+      throw new Error(
+        `Expected ${fileName} to contain a babel.types.file, but was a program`,
+      );
+    }
+    return {
+      originFileName: fileName,
+      rawContent: text,
+      format: AstFormat.JS,
+      root: ast!,
+    };
+  };
+}

package/src/parsers/parse-error.ts

@@ -0,0 +1,9 @@
+import { Position } from '@stryker-mutator/api/core';
+
+export class ParseError extends Error {
+  constructor(message: string, fileName: string, location: Position) {
+    super(
+      `Parse error in ${fileName} (${location.line}:${location.column}) ${message}`,
+    );
+  }
+}