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

package/src/disable-type-checks.ts

@@ -0,0 +1,153 @@
+import type { types } from '@babel/core';
+import { notEmpty } from '@stryker-mutator/util';
+
+import { File } from './file.js';
+
+import { createParser, getFormat, ParserOptions } from './parsers/index.js';
+import { AstFormat, HtmlAst, ScriptAst, SvelteAst } from './syntax/index.js';
+
+const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
+const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
+const startingCommentRegex = /(^\s*\/\*.*?\*\/)/gs;
+
+/**
+ * Disables TypeScript type checking for a single file by inserting `// @ts-nocheck` commands.
+ * It also does this for *.js files, as they can be type checked by typescript as well.
+ * Other file types are silently ignored
+ *
+ * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#-ts-nocheck-in-typescript-files
+ */
+export async function disableTypeChecks(
+  file: File,
+  options: ParserOptions,
+): Promise<File> {
+  const format = getFormat(file.name);
+  if (!format) {
+    // Readme files and stuff don't need disabling.
+    return file;
+  }
+  if (isJSFileWithoutTSDirectives(file, format)) {
+    // Performance optimization. Only parse the file when it has a chance of containing a `// @ts-` directive
+    return {
+      ...file,
+      content: prefixWithNoCheck(file.content),
+    };
+  }
+
+  const parse = createParser(options);
+  const ast = await parse(file.content, file.name);
+  switch (ast.format) {
+    case AstFormat.JS:
+    case AstFormat.TS:
+    case AstFormat.Tsx:
+      return { ...file, content: disableTypeCheckingInBabelAst(ast) };
+    case AstFormat.Html:
+      return { ...file, content: disableTypeCheckingInHtml(ast) };
+    case AstFormat.Svelte:
+      return { ...file, content: disableTypeCheckingInSvelte(ast) };
+  }
+}
+
+function isJSFileWithoutTSDirectives(file: File, format: AstFormat) {
+  return (
+    (format === AstFormat.TS || format === AstFormat.JS) &&
+    !tsDirectiveLikeRegEx.test(file.content)
+  );
+}
+
+function disableTypeCheckingInBabelAst(ast: ScriptAst): string {
+  return prefixWithNoCheck(
+    removeTSDirectives(ast.rawContent, ast.root.comments),
+  );
+}
+
+function prefixWithNoCheck(code: string): string {
+  if (code.startsWith('#')) {
+    // first line has a shebang (#!/usr/bin/env node)
+    const newLineIndex = code.indexOf('\n');
+    if (newLineIndex > 0) {
+      return `${code.substring(0, newLineIndex)}\n// @ts-nocheck\n${code.substring(newLineIndex + 1)}`;
+    } else {
+      return code;
+    }
+  } else {
+    // We should leave comments, like `/** @jest-env jsdom */ at the top of the file, see #2569
+    startingCommentRegex.lastIndex = 0;
+    const commentMatch = startingCommentRegex.exec(code);
+    return `${commentMatch?.[1].concat('\n') ?? ''}// @ts-nocheck\n${code.substring(commentMatch?.[1].length ?? 0)}`;
+  }
+}
+
+function disableTypeCheckingInHtml(ast: HtmlAst): string {
+  const sortedScripts = [...ast.root.scripts].sort(
+    (a, b) => a.root.start! - b.root.start!,
+  );
+  let currentIndex = 0;
+  let html = '';
+  for (const script of sortedScripts) {
+    html += ast.rawContent.substring(currentIndex, script.root.start!);
+    html += '\n';
+    html += prefixWithNoCheck(
+      removeTSDirectives(script.rawContent, script.root.comments),
+    );
+    html += '\n';
+    currentIndex = script.root.end!;
+  }
+  html += ast.rawContent.substring(currentIndex);
+  return html;
+}
+
+function disableTypeCheckingInSvelte(ast: SvelteAst): string {
+  const sortedScripts = [ast.root.moduleScript, ...ast.root.additionalScripts]
+    .filter(notEmpty)
+    .sort((a, b) => a.range.start - b.range.start);
+  let currentIndex = 0;
+  let html = '';
+  for (const script of sortedScripts) {
+    html += ast.rawContent.substring(currentIndex, script.range.start);
+    html += '\n';
+    html += prefixWithNoCheck(
+      removeTSDirectives(script.ast.rawContent, script.ast.root.comments),
+    );
+    html += '\n';
+    currentIndex = script.range.end;
+  }
+  html += ast.rawContent.substring(currentIndex);
+  return html;
+}
+
+function removeTSDirectives(
+  text: string,
+  comments: Array<types.CommentBlock | types.CommentLine> | null | undefined,
+): string {
+  const directiveRanges = comments
+    ?.map(tryParseTSDirective)
+    .filter(notEmpty)
+    .sort((a, b) => a.startPos - b.startPos);
+  if (directiveRanges) {
+    let currentIndex = 0;
+    let pruned = '';
+    for (const directiveRange of directiveRanges) {
+      pruned += text.substring(currentIndex, directiveRange.startPos);
+      currentIndex = directiveRange.endPos;
+    }
+    pruned += text.substring(currentIndex);
+    return pruned;
+  } else {
+    return text;
+  }
+}
+
+function tryParseTSDirective(
+  comment: types.CommentBlock | types.CommentLine,
+): { startPos: number; endPos: number } | undefined {
+  const match = commentDirectiveRegEx.exec(comment.value);
+  if (match) {
+    const directiveStartPos = comment.start! + match[1].length + 2; // +2 to account for the `//` or `/*` start character
+    return {
+      startPos: directiveStartPos,
+      endPos: directiveStartPos + match[2].length + 1,
+    };
+  }
+  return undefined;
+}

package/src/file.ts

@@ -0,0 +1,6 @@
+import { FileDescription } from '@stryker-mutator/api/core';
+
+export interface File extends FileDescription {
+  name: string;
+  content: string;
+}

package/src/frameworks/angular-ignorer.ts

@@ -0,0 +1,129 @@
+import { Ignorer, NodePath } from '@stryker-mutator/api/ignore';
+
+const ANGULAR_SIGNAL_IO_FUNCTIONS = Object.freeze(['input', 'model', 'output']);
+
+const ANGULAR_SIGNAL_QUERY_FUNCTIONS = Object.freeze([
+  'contentChild',
+  'contentChildren',
+  'viewChild',
+  'viewChildren',
+]);
+
+const INPUT_MODEL_OUTPUT_CONFIG_MSG =
+  'Angular signal based input, model and output functions configuration object cannot be mutated as that causes issues with the Angular compiler.';
+
+const SIGNAL_QUERY_OPTIONS_MSG =
+  'Angular signal query options object cannot be mutated as that causes issues with the Angular compiler.';
+
+export class AngularIgnorer implements Ignorer {
+  public shouldIgnore(path: NodePath): string | undefined {
+    if (this.isInputModelOrOutputConfigurationObject(path)) {
+      return INPUT_MODEL_OUTPUT_CONFIG_MSG;
+    }
+
+    if (this.isSignalQueryOptionsObject(path)) {
+      return SIGNAL_QUERY_OPTIONS_MSG;
+    }
+
+    return undefined;
+  }
+
+  #isClassFieldLike(path: NodePath): boolean {
+    return (
+      path.isClassProperty() ||
+      path.isClassPrivateProperty() ||
+      path.isClassAccessorProperty()
+    );
+  }
+
+  /**
+   * Determines if the given path is a configuration object for an Angular input, model or output function.
+   * This solves the "Argument needs to be statically analyzable." error
+   */
+  private isInputModelOrOutputConfigurationObject(path: NodePath): boolean {
+    if (
+      !path.isObjectExpression() ||
+      !path.parentPath.isCallExpression() ||
+      !path.parentPath.parentPath.isClassProperty()
+    ) {
+      return false;
+    }
+
+    const callExpression = path.parentPath;
+    const objectExpression = path;
+
+    const isRequiredSignalIOFunction =
+      callExpression.node.callee.type === 'MemberExpression' &&
+      callExpression.node.callee.object.type === 'Identifier' &&
+      ANGULAR_SIGNAL_IO_FUNCTIONS.includes(
+        callExpression.node.callee.object.name,
+      ) &&
+      callExpression.node.callee.property.type === 'Identifier' &&
+      callExpression.node.callee.property.name === 'required';
+
+    const isSignalIOFunction =
+      callExpression.node.callee.type === 'Identifier' &&
+      ANGULAR_SIGNAL_IO_FUNCTIONS.includes(callExpression.node.callee.name);
+
+    const isOutput =
+      callExpression.node.callee.type === 'Identifier' &&
+      callExpression.node.callee.name === 'output';
+
+    if (isRequiredSignalIOFunction || isOutput) {
+      // The { alias: '...' } should be the first argument of the call expression
+      return (
+        callExpression.node.arguments.length >= 1 &&
+        callExpression.node.arguments[0] === objectExpression.node
+      );
+    }
+
+    if (isSignalIOFunction) {
+      // The { alias: '...' } should be the second argument of the call expression
+      return (
+        callExpression.node.arguments.length >= 2 &&
+        callExpression.node.arguments[1] === objectExpression.node
+      );
+    }
+
+    return false;
+  }
+
+  /**
+   * Determines if the given path is a configuration object for an Angular signal query function.
+   * This solves the "Argument needs to be statically analyzable." error
+   */
+  private isSignalQueryOptionsObject(path: NodePath): boolean {
+    if (
+      !path.isObjectExpression() ||
+      !path.parentPath.isCallExpression() ||
+      !this.#isClassFieldLike(path.parentPath.parentPath)
+    ) {
+      return false;
+    }
+
+    const callExpression = path.parentPath;
+    const objectExpression = path;
+
+    const callee = callExpression.node.callee;
+
+    const isQueryFn =
+      callee.type === 'Identifier' &&
+      ANGULAR_SIGNAL_QUERY_FUNCTIONS.includes(callee.name);
+
+    const isRequiredQueryFn =
+      callee.type === 'MemberExpression' &&
+      callee.object.type === 'Identifier' &&
+      ANGULAR_SIGNAL_QUERY_FUNCTIONS.includes(callee.object.name) &&
+      callee.property.type === 'Identifier' &&
+      callee.property.name === 'required';
+
+    if (!isQueryFn && !isRequiredQueryFn) {
+      return false;
+    }
+
+    return (
+      callExpression.node.arguments.length >= 2 &&
+      callExpression.node.arguments[1] === objectExpression.node
+    );
+  }
+}

package/src/frameworks/index.ts

@@ -0,0 +1,9 @@
+import { PluginKind, declareClassPlugin } from '@stryker-mutator/api/plugin';
+
+import { AngularIgnorer } from './angular-ignorer.js';
+
+export const strykerPlugins = [
+  declareClassPlugin(PluginKind.Ignore, 'angular', AngularIgnorer),
+];
+
+export const frameworkPluginsFileUrl = import.meta.url;

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './frameworks/index.js';
+export * from './create-instrumenter.js';
+export * from './instrumenter.js';
+export * from './instrument-result.js';
+export * from './instrumenter-options.js';
+export * from './disable-type-checks.js';
+export type { ParserOptions } from './parsers/index.js';
+export * from './file.js';

package/src/instrument-result.ts

@@ -0,0 +1,8 @@
+import { Mutant } from '@stryker-mutator/api/core';
+
+import { File } from './file.js';
+
+export interface InstrumentResult {
+  files: readonly File[];
+  mutants: readonly Mutant[];
+}

package/src/instrumenter-options.ts

@@ -0,0 +1,5 @@
+import { ParserOptions } from './parsers/index.js';
+import { TransformerOptions } from './transformers/index.js';
+
+export interface InstrumenterOptions
+  extends ParserOptions, TransformerOptions {}

package/src/instrumenter-tokens.ts

@@ -0,0 +1,5 @@
+export const instrumenterTokens = Object.freeze({
+  createParser: 'instrumenterCreateParser',
+  print: 'instrumenterPrint',
+  transform: 'instrumenterTransform',
+} as const);

package/src/instrumenter.ts

@@ -0,0 +1,100 @@
+import path from 'path';
+
+import { tokens, commonTokens } from '@stryker-mutator/api/plugin';
+import { Logger } from '@stryker-mutator/api/logging';
+import { MutateDescription } from '@stryker-mutator/api/core';
+
+import { createParser } from './parsers/index.js';
+import { transform, MutantCollector } from './transformers/index.js';
+import { print } from './printers/index.js';
+import { InstrumentResult } from './instrument-result.js';
+import { InstrumenterOptions } from './instrumenter-options.js';
+import { instrumenterTokens } from './instrumenter-tokens.js';
+import { File } from './file.js';
+
+/**
+ * The instrumenter is responsible for
+ * * Generating mutants based on source files
+ * * Instrumenting the source code with the mutants placed in `mutant switches`.
+ * * Adding mutant coverage expressions in the source code.
+ * @see https://github.com/stryker-mutator/stryker-js/issues/1514
+ */
+export class Instrumenter {
+  public static inject = tokens(
+    commonTokens.logger,
+    instrumenterTokens.createParser,
+    instrumenterTokens.print,
+    instrumenterTokens.transform,
+  );
+
+  constructor(
+    private readonly logger: Logger,
+    private readonly _createParser = createParser,
+    private readonly _print = print,
+    private readonly _transform = transform,
+  ) {}
+
+  public async instrument(
+    files: readonly File[],
+    options: InstrumenterOptions,
+  ): Promise<InstrumentResult> {
+    this.logger.debug(
+      'Instrumenting %d source files with mutants',
+      files.length,
+    );
+    const mutantCollector = new MutantCollector();
+    const outFiles: File[] = [];
+    let mutantCount = 0;
+    const parse = this._createParser(options);
+    for (const { name, mutate, content } of files) {
+      const ast = await parse(content, name);
+      this._transform(ast, mutantCollector, {
+        options,
+        mutateDescription: toBabelLineNumber(mutate),
+        logger: this.logger,
+      });
+      const mutatedContent = this._print(ast);
+      outFiles.push({
+        name,
+        mutate,
+        content: mutatedContent,
+      });
+      if (this.logger.isDebugEnabled()) {
+        const nrOfMutantsInFile = mutantCollector.mutants.length - mutantCount;
+        mutantCount = mutantCollector.mutants.length;
+        this.logger.debug(
+          `Instrumented ${path.relative(process.cwd(), name)} (${nrOfMutantsInFile} mutant(s))`,
+        );
+      }
+    }
+    const mutants = mutantCollector.mutants.map((mutant) =>
+      mutant.toApiMutant(),
+    );
+    this.logger.info(
+      'Instrumented %d source file(s) with %d mutant(s)',
+      files.length,
+      mutants.length,
+    );
+    return {
+      files: outFiles,
+      mutants,
+    };
+  }
+}
+
+function toBabelLineNumber(range: MutateDescription): MutateDescription {
+  if (typeof range === 'boolean') {
+    return range;
+  } else {
+    return range.map(({ start, end }) => ({
+      start: {
+        column: start.column,
+        line: start.line + 1,
+      },
+      end: {
+        column: end.column,
+        line: end.line + 1,
+      },
+    }));
+  }
+}

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

@@ -0,0 +1,210 @@
+import babel, { type NodePath } from '@babel/core';
+
+import {
+  mutantTestExpression,
+  mutationCoverageSequenceExpression,
+} from '../util/syntax-helpers.js';
+
+import { MutantPlacer } from './mutant-placer.js';
+
+const { types } = babel;
+
+/**
+ * Will set the identifier of anonymous function expressions if is located in a variable declaration.
+ * Will treat input as readonly. Returns undefined if not needed.
+ * @example
+ * const a = function() { }
+ * becomes
+ * const a = function a() {}
+ */
+function classOrFunctionExpressionNamedIfNeeded(
+  path: NodePath<babel.types.Expression>,
+): babel.types.Expression | undefined {
+  if (
+    (path.isFunctionExpression() || path.isClassExpression()) &&
+    !path.node.id
+  ) {
+    if (
+      path.parentPath.isVariableDeclarator() &&
+      types.isIdentifier(path.parentPath.node.id)
+    ) {
+      path.node.id = path.parentPath.node.id;
+      return path.node;
+    } else if (
+      path.parentPath.isObjectProperty() &&
+      types.isIdentifier(path.parentPath.node.key) &&
+      path.getStatementParent()?.isVariableDeclaration()
+    ) {
+      path.node.id = path.parentPath.node.key;
+      return path.node;
+    }
+  }
+  return;
+}
+
+/**
+ * Will set the identifier of anonymous arrow function expressions if is located in a variable declaration.
+ * Will treat input as readonly. Returns undefined if not needed.
+ * @example
+ * const a = () => { }
+ * becomes
+ * const a = (() => { const a = () => {}; return a; })()
+ */
+function arrowFunctionExpressionNamedIfNeeded(
+  path: NodePath<babel.types.Expression>,
+): babel.types.Expression | undefined {
+  if (
+    path.isArrowFunctionExpression() &&
+    path.parentPath.isVariableDeclarator() &&
+    types.isIdentifier(path.parentPath.node.id)
+  ) {
+    return types.callExpression(
+      types.arrowFunctionExpression(
+        [],
+        types.blockStatement([
+          types.variableDeclaration('const', [
+            types.variableDeclarator(path.parentPath.node.id, path.node),
+          ]),
+          types.returnStatement(path.parentPath.node.id),
+        ]),
+      ),
+      [],
+    );
+  }
+  return;
+}
+
+function nameIfAnonymous(
+  path: NodePath<babel.types.Expression>,
+): babel.types.Expression {
+  return (
+    classOrFunctionExpressionNamedIfNeeded(path) ??
+    arrowFunctionExpressionNamedIfNeeded(path) ??
+    path.node
+  );
+}
+
+function isMemberOrCallOrNonNullExpression(path: NodePath) {
+  return isCallExpression(path) || isMemberOrNonNullExpression(path);
+}
+
+function isMemberOrNonNullExpression(
+  path: NodePath,
+): path is NodePath<
+  | babel.types.MemberExpression
+  | babel.types.OptionalMemberExpression
+  | babel.types.TSNonNullExpression
+> {
+  return isMemberExpression(path) || path.isTSNonNullExpression();
+}
+function isMemberExpression(
+  path: NodePath,
+): path is NodePath<
+  babel.types.MemberExpression | babel.types.OptionalMemberExpression
+> {
+  return path.isMemberExpression() || path.isOptionalMemberExpression();
+}
+
+function isCallExpression(
+  path: NodePath,
+): path is NodePath<
+  babel.types.CallExpression | babel.types.OptionalCallExpression
+> {
+  return path.isCallExpression() || path.isOptionalCallExpression();
+}
+
+function isValidExpression(path: NodePath<babel.types.Expression>) {
+  const parent = path.parentPath;
+  return (
+    !isObjectPropertyKey() &&
+    !isPartOfChain() &&
+    !parent.isTaggedTemplateExpression() &&
+    !isPartOfDeleteExpression() &&
+    !isPartOfAssignmentExpression()
+  );
+
+  /**
+   * Determines if the expression is property of an object.
+   * @example
+   * const a = {
+   *  'foo': 'bar' // 'foo' here is an object property
+   * };
+   */
+  function isObjectPropertyKey() {
+    return parent.isObjectProperty() && parent.node.key === path.node;
+  }
+
+  /**
+   * Determines if the expression is part of a call/member chain.
+   * @example
+   * // bar is part of chain, foo is NOT part of the chain:
+   * foo.bar.baz();
+   * foo.bar?.baz()
+   * foo.bar;
+   * foo.bar!;
+   * foo.bar();
+   * foo?.bar();
+   * baz[foo.bar()]
+   * bar?.baz[0]
+   */
+  function isPartOfChain() {
+    return (
+      isMemberOrCallOrNonNullExpression(path) &&
+      ((isMemberExpression(parent) &&
+        !(parent.node.computed && parent.node.property === path.node)) ||
+        parent.isTSNonNullExpression() ||
+        (isCallExpression(parent) && parent.node.callee === path.node))
+    );
+  }
+
+  /**
+   * Determines if the expression is part of a delete expression.
+   * @returns true if the expression is part of a delete expression
+   * @example
+   * delete foo.bar;
+   */
+  function isPartOfDeleteExpression() {
+    return parent.isUnaryExpression() && parent.node.operator === 'delete';
+  }
+
+  /**
+   * Determines if the expression is part of an assignment expression.
+   * @returns true if the expression is part of an assignment expression
+   * @example
+   * foo.bar = 42;
+   * initialNodes.filter((n) => n.id === 'tiptilt')[0].className = tiptiltState;
+   */
+  function isPartOfAssignmentExpression() {
+    return parent.isAssignmentExpression() && parent.node.left === path.node;
+  }
+}
+
+/**
+ * Places the mutants with a conditional expression: `global.activeMutant === 1? mutatedCode : originalCode`;
+ */
+export const expressionMutantPlacer = {
+  name: 'expressionMutantPlacer',
+  canPlace(path) {
+    return path.isExpression() && isValidExpression(path);
+  },
+  place(path, appliedMutants) {
+    // Make sure anonymous functions and classes keep their 'name' property
+    let expression = nameIfAnonymous(path);
+
+    // Add the mutation coverage expression
+    expression = mutationCoverageSequenceExpression(
+      appliedMutants.keys(),
+      expression,
+    );
+
+    // Now apply the mutants
+    for (const [mutant, appliedMutant] of appliedMutants) {
+      expression = types.conditionalExpression(
+        mutantTestExpression(mutant.id),
+        appliedMutant,
+        expression,
+      );
+    }
+    path.replaceWith(expression);
+  },
+} satisfies MutantPlacer<babel.types.Expression>;

package/src/mutant-placers/index.ts

@@ -0,0 +1,12 @@
+import { expressionMutantPlacer } from './expression-mutant-placer.js';
+import { MutantPlacer } from './mutant-placer.js';
+import { statementMutantPlacer } from './statement-mutant-placer.js';
+import { switchCaseMutantPlacer } from './switch-case-mutant-placer.js';
+
+export * from './mutant-placer.js';
+export * from './throw-placement-error.js';
+export const allMutantPlacers: readonly MutantPlacer[] = Object.freeze([
+  expressionMutantPlacer,
+  statementMutantPlacer,
+  switchCaseMutantPlacer,
+]);

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

@@ -0,0 +1,9 @@
+import { NodePath, types } from '@babel/core';
+
+import { Mutant } from '../mutant.js';
+
+export interface MutantPlacer<TNode extends types.Node = types.Node> {
+  name: string;
+  canPlace(path: NodePath): boolean;
+  place(path: NodePath<TNode>, appliedMutants: Map<Mutant, TNode>): void;
+}