@systemfsoftware/stryker-js-typescript-checker 0.1.0

package/src/fs/hybrid-file-system.ts

@@ -0,0 +1,118 @@
+import { readFileSync } from 'fs'
+
+import type { FileSystem, FileSystemEntries } from 'typescript/unstable/fs'
+
+import { toPosixFileName } from '../tsconfig-helpers.js'
+
+import { ScriptFile } from './script-file.js'
+
+/**
+ * A very simple hybrid file system.
+ * * Readonly from disk
+ * * Writes in-memory
+ * * Hard caching
+ * * Ability to mutate one file
+ */
+export class HybridFileSystem implements FileSystem {
+  private readonly files = new Map<string, ScriptFile | undefined>()
+
+  /**
+   * Map of absolute tsconfig file paths to their adjusted JSON content.
+   * This allows the TS7 API to read overridden compiler options.
+   */
+  public tsConfigOverrides = new Map<string, string>()
+
+  public readFile = (fileName: string): string | null | undefined => {
+    const normalized = toPosixFileName(fileName)
+    if (this.fileNameIsBuildInfo(normalized)) {
+      return null
+    }
+    const override = this.tsConfigOverrides.get(normalized)
+    if (override !== undefined) {
+      return override
+    }
+    const file = this.files.get(normalized)
+    if (file) {
+      return file.content
+    }
+    if (file === undefined && this.files.has(normalized)) {
+      // File was previously read and does not exist
+      return null
+    }
+    return undefined
+  }
+
+  public fileExists = (fileName: string): boolean | undefined => {
+    const normalized = toPosixFileName(fileName)
+    if (this.fileNameIsBuildInfo(normalized)) {
+      return false
+    }
+    if (this.tsConfigOverrides.has(normalized)) {
+      return true
+    }
+    if (this.files.has(normalized)) {
+      return this.files.get(normalized) !== undefined
+    }
+    return undefined
+  }
+
+  public directoryExists = (): boolean | undefined => {
+    return undefined
+  }
+
+  public getAccessibleEntries = (): FileSystemEntries | undefined => {
+    return undefined
+  }
+
+  public realpath = (): string | undefined => {
+    return undefined
+  }
+
+  public writeFile(fileName: string, data: string): void {
+    const normalized = toPosixFileName(fileName)
+    const existingFile = this.files.get(normalized)
+    if (existingFile) {
+      existingFile.write(data)
+    } else {
+      this.files.set(normalized, new ScriptFile(data, normalized))
+    }
+  }
+
+  public getFile(fileName: string): ScriptFile | undefined {
+    const normalized = toPosixFileName(fileName)
+    if (!this.files.has(normalized)) {
+      try {
+        const content = readFileSync(normalized, 'utf-8')
+        this.files.set(normalized, new ScriptFile(content, normalized))
+      } catch {
+        this.files.set(normalized, undefined)
+      }
+    }
+    return this.files.get(normalized)
+  }
+
+  public mutateFile(
+    fileName: string,
+    mutant: Parameters<ScriptFile['mutate']>[0],
+  ): void {
+    const file = this.getFile(fileName)
+    if (!file) {
+      throw new Error(`Tried to mutate file "${fileName}" but it could not be found.`)
+    }
+    file.mutate(mutant)
+  }
+
+  public resetFile(fileName: string): void {
+    const file = this.getFile(fileName)
+    file?.resetMutant()
+  }
+
+  public existsInMemory(fileName: string): boolean {
+    const file = this.files.get(toPosixFileName(fileName))
+    return file !== undefined
+  }
+
+  private fileNameIsBuildInfo(fileName: string): boolean {
+    return fileName.endsWith('.tsbuildinfo')
+  }
+}

package/src/fs/index.ts

@@ -0,0 +1,2 @@
+export * from './hybrid-file-system.js'
+export * from './script-file.js'

package/src/fs/script-file.ts

@@ -0,0 +1,44 @@
+import type { Mutant, Position } from '@stryker-mutator/api/core'
+
+export class ScriptFile {
+  private readonly originalContent: string
+
+  constructor(
+    public content: string,
+    public fileName: string,
+    public modifiedTime = new Date(),
+  ) {
+    this.originalContent = content
+  }
+
+  public write(content: string): void {
+    this.content = content
+    this.touch()
+  }
+
+  public mutate(mutant: Pick<Mutant, 'location' | 'replacement'>): void {
+    const start = this.getOffset(mutant.location.start)
+    const end = this.getOffset(mutant.location.end)
+    this.content = `${this.originalContent.slice(0, start)}${mutant.replacement}${this.originalContent.slice(end)}`
+    this.touch()
+  }
+
+  private getOffset(pos: Position): number {
+    const lines = this.originalContent.split('\n')
+    let offset = 0
+    for (let i = 0; i < pos.line && i < lines.length; i++) {
+      offset += lines[i]!.length + 1 // +1 for the newline character
+    }
+    offset += pos.column
+    return offset
+  }
+
+  public resetMutant(): void {
+    this.content = this.originalContent
+    this.touch()
+  }
+
+  private touch(): void {
+    this.modifiedTime = new Date()
+  }
+}

package/src/grouping/create-groups.ts

@@ -0,0 +1,77 @@
+import type { Mutant } from '@stryker-mutator/api/core'
+
+import { toPosixFileName } from '../tsconfig-helpers.js'
+
+import { TSFileNode } from './ts-file-node.js'
+
+/**
+ * To speed up the type-checking we want to check multiple mutants at once.
+ * When multiple mutants in different files don't have overlap in affected files (or have small overlap), we can type-check them simultaneously.
+ * These mutants who can be tested at the same time are called a group.
+ * Therefore, the return type is an array of arrays, in other words: an array of groups.
+ *
+ * @param mutants All the mutants of the test project.
+ * @param nodes A graph representation of the test project.
+ */
+export function createGroups(
+  mutants: Mutant[],
+  nodes: Map<string, TSFileNode>,
+): string[][] {
+  const groups: string[][] = []
+  const mutantsToGroup = new Set(mutants)
+
+  while (mutantsToGroup.size) {
+    const group: string[] = []
+    const groupNodes = new Set<TSFileNode>()
+    const nodesToIgnore = new Set<TSFileNode>()
+
+    for (const currentMutant of mutantsToGroup) {
+      const currentNode = findNode(currentMutant.fileName, nodes)
+      if (
+        !nodesToIgnore.has(currentNode) &&
+        !parentsHaveOverlapWith(currentNode, groupNodes)
+      ) {
+        group.push(currentMutant.id)
+        groupNodes.add(currentNode)
+        mutantsToGroup.delete(currentMutant)
+        addRangeOfNodesToSet(
+          nodesToIgnore,
+          currentNode.getAllParentReferencesIncludingSelf(),
+        )
+      }
+    }
+    groups.push(group)
+  }
+
+  return groups
+}
+
+function addRangeOfNodesToSet(
+  nodes: Set<TSFileNode>,
+  nodesToAdd: Iterable<TSFileNode>,
+) {
+  for (const parent of nodesToAdd) {
+    nodes.add(parent)
+  }
+}
+
+function findNode(fileName: string, nodes: Map<string, TSFileNode>) {
+  const node = nodes.get(toPosixFileName(fileName))
+  if (node == null) {
+    throw new Error(`Node not in graph: ${fileName}`)
+  }
+  return node
+}
+
+function parentsHaveOverlapWith(
+  currentNode: TSFileNode,
+  groupNodes: Set<TSFileNode>,
+) {
+  for (const parentNode of currentNode.getAllParentReferencesIncludingSelf()) {
+    if (groupNodes.has(parentNode)) {
+      return true
+    }
+  }
+
+  return false
+}

package/src/grouping/ts-file-node.ts

@@ -0,0 +1,54 @@
+import type { Mutant } from '@stryker-mutator/api/core'
+
+import { toPosixFileName } from '../tsconfig-helpers.js'
+
+// This class exists so we can have a two-way dependency graph.
+// The two-way dependency graph is used to search for mutants related to typescript errors.
+export class TSFileNode {
+  constructor(
+    public fileName: string,
+    public parents: TSFileNode[],
+    public children: TSFileNode[],
+  ) {}
+
+  public getAllParentReferencesIncludingSelf(
+    allParentReferences: Set<TSFileNode> = new Set<TSFileNode>(),
+  ): Set<TSFileNode> {
+    allParentReferences.add(this)
+    this.parents.forEach((parent) => {
+      if (!allParentReferences.has(parent)) {
+        parent.getAllParentReferencesIncludingSelf(allParentReferences)
+      }
+    })
+    return allParentReferences
+  }
+
+  public getAllChildReferencesIncludingSelf(
+    allChildReferences: Set<TSFileNode> = new Set<TSFileNode>(),
+  ): Set<TSFileNode> {
+    allChildReferences.add(this)
+    this.children.forEach((child) => {
+      if (!allChildReferences.has(child)) {
+        child.getAllChildReferencesIncludingSelf(allChildReferences)
+      }
+    })
+    return allChildReferences
+  }
+
+  public getMutantsWithReferenceToChildrenOrSelf(
+    mutants: Mutant[],
+    nodesChecked: string[] = [],
+  ): Mutant[] {
+    if (nodesChecked.includes(this.fileName)) {
+      return []
+    }
+
+    nodesChecked.push(this.fileName)
+
+    const relatedMutants = mutants.filter(
+      (m) => toPosixFileName(m.fileName) === this.fileName,
+    )
+    const childResult = this.children.flatMap((c) => c.getMutantsWithReferenceToChildrenOrSelf(mutants, nodesChecked))
+    return [...relatedMutants, ...childResult]
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import { readFileSync } from 'fs'
+
+import { declareFactoryPlugin, PluginKind } from '@stryker-mutator/api/plugin'
+
+import { create } from './typescript-checker.js'
+
+export const strykerPlugins = [
+  declareFactoryPlugin(PluginKind.Checker, 'typescript', create),
+]
+
+export const createTypescriptChecker = create
+
+export const strykerValidationSchema: Record<string, unknown> = JSON.parse(
+  readFileSync(
+    new URL('../schema/typescript-checker-options.json', import.meta.url),
+    'utf-8',
+  ),
+)

package/src/plugin-tokens.ts

@@ -0,0 +1,2 @@
+export const fs = 'fs'
+export const tsCompiler = 'tsCompiler'

package/src/tsconfig-helpers.ts

@@ -0,0 +1,168 @@
+import { readFileSync } from 'fs'
+import { createRequire } from 'module'
+import path from 'path'
+
+import semver from 'semver'
+
+// Override some compiler options that have to do with code quality. When mutating, we're not interested in the resulting code quality
+// See https://github.com/stryker-mutator/stryker-js/issues/391 for more info
+const COMPILER_OPTIONS_OVERRIDES: Readonly<Record<string, unknown>> = Object.freeze({
+  allowUnreachableCode: true,
+  noUnusedLocals: false,
+  noUnusedParameters: false,
+})
+
+// When we're running in 'single-project' mode, we can safely disable emit
+const NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT: Readonly<Record<string, unknown>> = Object.freeze({
+  noEmit: true,
+  incremental: false, // incremental and composite off: https://github.com/microsoft/TypeScript/issues/36917
+  tsBuildInfoFile: undefined,
+  composite: false,
+})
+
+// When we're running in 'project references' mode, we need to enable declaration output
+const LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES: Readonly<Record<string, unknown>> = Object.freeze({
+  emitDeclarationOnly: true,
+  noEmit: false,
+  declarationMap: true,
+  declaration: true,
+})
+
+let cachedTSVersion: string | undefined
+
+export function getTSVersion(): string {
+  if (cachedTSVersion === undefined) {
+    const require = createRequire(import.meta.url)
+    const pkg = JSON.parse(
+      readFileSync(require.resolve('typescript/package.json'), 'utf-8'),
+    ) as { version: string }
+    cachedTSVersion = pkg.version
+  }
+  return cachedTSVersion
+}
+
+export function guardTSVersion(version = getTSVersion()): void {
+  if (!semver.satisfies(version, '>=7.0.0', { includePrerelease: true })) {
+    throw new Error(
+      `@systemfsoftware/stryker-js-typescript-checker only supports typescript@7.0.0 or higher. Found typescript@${version}`,
+    )
+  }
+}
+
+/**
+ * Determines whether or not to use `--build` mode based on "references" being there in the config file
+ * @param tsconfigFileName The tsconfig file to parse
+ */
+export interface ParsedConfig {
+  config?: unknown
+  error?: Error
+}
+
+function stripJsonComments(json: string): string {
+  return json
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/\/\/.*$/gm, '')
+}
+
+export function parseConfigFileTextToJson(fileName: string, jsonText: string): ParsedConfig {
+  try {
+    const stripped = stripJsonComments(jsonText)
+    return { config: JSON.parse(stripped) }
+  } catch (error) {
+    return { error: error as Error }
+  }
+}
+
+export function determineBuildModeEnabled(tsconfigFileName: string): boolean {
+  const tsconfigFile = readFileSync(tsconfigFileName, 'utf-8')
+  const parsed = parseConfigFileTextToJson(tsconfigFileName, tsconfigFile)
+  if (parsed.error) {
+    return false
+  }
+  const useProjectReferences = 'references' in (parsed.config as { references?: unknown[] })
+  return useProjectReferences
+}
+
+/**
+ * Overrides some options to speed up compilation and disable some code quality checks we don't want during mutation testing
+ * @param parsedConfig The parsed config file
+ * @param useBuildMode whether or not `--build` mode is used
+ */
+export function overrideOptions(parsedConfig: ParsedConfig, useBuildMode: boolean): string {
+  const config = (parsedConfig.config ?? {}) as { compilerOptions?: Record<string, unknown> }
+  const compilerOptions: Record<string, unknown> = {
+    ...config.compilerOptions,
+    ...COMPILER_OPTIONS_OVERRIDES,
+    ...(useBuildMode ? LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES : NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT),
+    // TypeScript 7 removed some legacy defaults that the upstream fixtures still use.
+    target: 'es2022',
+    moduleResolution: 'bundler',
+  }
+
+  if (
+    !useBuildMode &&
+    compilerOptions['declarationDir'] !== undefined &&
+    compilerOptions['declarationDir'] !== null
+  ) {
+    // because composite and/or declaration was disabled in non-build mode, we have to disable declarationDir as well
+    // otherwise, error TS5069: Option 'declarationDir' cannot be specified without specifying option 'declaration' or option 'composite'.
+    delete compilerOptions['declarationDir']
+  }
+
+  if (useBuildMode) {
+    // Remove the options to place declarations files in different locations to decrease the complexity of searching the source file in the TypescriptCompiler class.
+    delete compilerOptions['inlineSourceMap']
+    delete compilerOptions['inlineSources']
+    delete compilerOptions['mapRoute']
+    delete compilerOptions['sourceRoot']
+    delete compilerOptions['outFile']
+  }
+
+  return JSON.stringify({
+    ...config,
+    compilerOptions,
+  })
+}
+
+interface ProjectReference {
+  path: string
+}
+
+/**
+ * Retrieves the referenced config files based on parsed configuration
+ * @param parsedConfig The parsed config file
+ * @param fromDirName The directory where to resolve from
+ */
+export function retrieveReferencedProjects(parsedConfig: ParsedConfig, fromDirName: string): string[] {
+  const config = parsedConfig.config as { references?: ProjectReference[] } | undefined
+  if (Array.isArray(config?.references)) {
+    return config!.references.map((reference) => {
+      let resolved = path.resolve(fromDirName, reference.path)
+      if (!path.basename(resolved).endsWith('.json')) {
+        resolved = path.join(resolved, 'tsconfig.json')
+      }
+      return toPosixFileName(resolved)
+    })
+  }
+  return []
+}
+
+/**
+ * Replaces backslashes with forward slashes (used by typescript)
+ * @param fileName The file name that may contain backslashes `\`
+ * @returns posix and ts complaint file name (with `/`)
+ */
+export function toPosixFileName(fileName: string): string {
+  return fileName.replace(/\\/g, '/')
+}
+
+/**
+ * Find source file in declaration file
+ * @param content The content of the declaration file
+ * @returns URL of the source file or undefined if not found
+ */
+const findSourceMapRegex = /\/\/# sourceMappingURL=(.+)$/m
+export function getSourceMappingURL(content: string): string | undefined {
+  findSourceMapRegex.lastIndex = 0
+  return findSourceMapRegex.exec(content)?.[1]
+}

package/src/typescript-checker-options-with-stryker-options.ts

@@ -0,0 +1,9 @@
+import type { StrykerOptions } from '@stryker-mutator/api/core'
+
+export interface TypescriptCheckerPluginOptions {
+  typescriptChecker: {
+    prioritizePerformanceOverAccuracy?: boolean
+  }
+}
+
+export interface TypescriptCheckerOptionsWithStrykerOptions extends TypescriptCheckerPluginOptions, StrykerOptions {}