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

package/src/mutants/incremental-differ.ts

@@ -0,0 +1,771 @@
+import path from 'path';
+
+import { diff_match_patch as DiffMatchPatch } from 'diff-match-patch';
+import chalk from 'chalk';
+import {
+  schema,
+  Mutant,
+  Position,
+  Location,
+  StrykerOptions,
+  FileDescriptions,
+  MutateDescription,
+} from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { TestResult, TestStatus } from '@stryker-mutator/api/test-runner';
+import {
+  I,
+  normalizeFileName,
+  normalizeLineEndings,
+  notEmpty,
+} from '@stryker-mutator/util';
+import { TestDefinition } from 'mutation-testing-report-schema';
+import { commonTokens } from '@stryker-mutator/api/plugin';
+
+import {
+  DiffChange,
+  DiffStatisticsCollector,
+} from './diff-statistics-collector.js';
+import { TestCoverage } from './test-coverage.js';
+
+/**
+ * The 'diff match patch' high-performant 'diffing' of files.
+ * @see https://github.com/google/diff-match-patch
+ */
+const diffMatchPatch = new DiffMatchPatch();
+
+/**
+ * This class is responsible for calculating the diff between a run and a previous run based on the incremental report.
+ *
+ * Since the ids of tests and mutants can differ across reports (they are only unique within 1 report), this class
+ * identifies mutants and tests by attributes that make them unique:
+ * - Mutant: file name, mutator name, location and replacement
+ * - Test: test name, test file name (if present) and location (if present).
+ *
+ * We're storing these identifiers in local variables (maps and sets) as strings.
+ * We should move to 'records' for these when they come available: https://github.com/tc39/proposal-record-tuple
+ *
+ * A mutant result from the previous run is reused if the following conditions were met:
+ * - The location of the mutant refers to a piece of code that didn't change
+ * - If mutant was killed:
+ *   - The culprit test wasn't changed
+ * - If the mutant survived:
+ *   - No test was added
+ *
+ * It uses google's "diff-match-patch" project to calculate the new locations for tests and mutants, see link.
+ * @link https://github.com/google/diff-match-patch
+ */
+export class IncrementalDiffer {
+  public mutantStatisticsCollector: DiffStatisticsCollector | undefined;
+  public testStatisticsCollector: DiffStatisticsCollector | undefined;
+  private readonly mutateDescriptionByRelativeFileName: Map<
+    string,
+    MutateDescription
+  >;
+
+  public static inject = [
+    commonTokens.logger,
+    commonTokens.options,
+    commonTokens.fileDescriptions,
+  ] as const;
+  constructor(
+    private readonly logger: Logger,
+    private readonly options: StrykerOptions,
+    fileDescriptions: FileDescriptions,
+  ) {
+    this.mutateDescriptionByRelativeFileName = new Map(
+      Object.entries(fileDescriptions).map(([name, description]) => [
+        toRelativeNormalizedFileName(name),
+        description.mutate,
+      ]),
+    );
+  }
+
+  private isInMutatedScope(
+    relativeFileName: string,
+    mutant: schema.MutantResult,
+  ): boolean {
+    const mutate =
+      this.mutateDescriptionByRelativeFileName.get(relativeFileName);
+    return (
+      mutate === true ||
+      (Array.isArray(mutate) &&
+        mutate.some((range) => locationIncluded(range, mutant.location)))
+    );
+  }
+
+  public diff(
+    currentMutants: readonly Mutant[],
+    testCoverage: I<TestCoverage>,
+    incrementalReport: schema.MutationTestResult,
+    currentRelativeFiles: Map<string, string>,
+  ): readonly Mutant[] {
+    const { files, testFiles } = incrementalReport;
+    const mutantStatisticsCollector = new DiffStatisticsCollector();
+    const testStatisticsCollector = new DiffStatisticsCollector();
+
+    // Expose the collectors for unit testing purposes
+    this.mutantStatisticsCollector = mutantStatisticsCollector;
+    this.testStatisticsCollector = testStatisticsCollector;
+
+    // Collect what we can reuse, while correcting for diff in the locations
+    const reusableMutantsByKey = collectReusableMutantsByKey(this.logger);
+    const { byId: oldTestsById, byKey: oldTestInfoByKey } =
+      collectReusableTestInfo(this.logger);
+
+    // Collect some helper maps and sets
+    const {
+      oldCoverageByMutantKey: oldCoverageTestKeysByMutantKey,
+      oldKilledByMutantKey: oldKilledTestKeysByMutantKey,
+    } = collectOldKilledAndCoverageMatrix();
+    const oldTestKeys = new Set(
+      [...oldTestsById.values()].map(({ key }) => key),
+    );
+    const newTestKeys = new Set(
+      [...testCoverage.testsById].map(([, test]) =>
+        testToIdentifyingKey(test, toRelativeNormalizedFileName(test.fileName)),
+      ),
+    );
+
+    // Create a dictionary to more easily get test information
+    const testInfoByKey = collectCurrentTestInfo();
+
+    // Mark which tests are added
+    for (const [key, { relativeFileName }] of testInfoByKey) {
+      if (!oldTestKeys.has(key)) {
+        testStatisticsCollector.count(relativeFileName, 'added');
+      }
+    }
+
+    // Make sure that tests that didn't run this time around aren't forgotten
+    for (const [
+      testKey,
+      {
+        test: { name, location },
+        relativeFileName,
+      },
+    ] of oldTestInfoByKey) {
+      if (!testInfoByKey.has(testKey)) {
+        const test: TestResult = {
+          status: TestStatus.Success,
+          id: testKey,
+          name,
+          startPosition: location?.start,
+          timeSpentMs: 0,
+          fileName: path.resolve(relativeFileName),
+        };
+        testInfoByKey.set(testKey, {
+          test,
+          relativeFileName: relativeFileName,
+        });
+        testCoverage.addTest(test);
+      }
+    }
+
+    // Done with preparations, time to map over the mutants
+    let reusedMutantCount = 0;
+    const currentMutantKeys = new Set<string>();
+    const mutants = currentMutants.map((mutant) => {
+      const relativeFileName = toRelativeNormalizedFileName(mutant.fileName);
+      const mutantKey = mutantToIdentifyingKey(mutant, relativeFileName);
+      currentMutantKeys.add(mutantKey);
+      if (!mutant.status && !this.options.force) {
+        const oldMutant = reusableMutantsByKey.get(mutantKey);
+        if (oldMutant) {
+          const coveringTests = testCoverage.forMutant(mutant.id);
+          const killedByTestKeys = oldKilledTestKeysByMutantKey.get(mutantKey);
+          if (
+            mutantCanBeReused(
+              mutant,
+              oldMutant,
+              mutantKey,
+              coveringTests,
+              killedByTestKeys,
+            )
+          ) {
+            reusedMutantCount++;
+            const { status, statusReason, testsCompleted } = oldMutant;
+            const executedTests = (oldMutant as { executedTests?: unknown })
+              .executedTests;
+            return {
+              ...mutant,
+              status,
+              statusReason,
+              testsCompleted,
+              executedTests,
+              coveredBy: [...(coveringTests ?? [])].map(({ id }) => id),
+              killedBy: testKeysToId(killedByTestKeys),
+            };
+          }
+        } else {
+          mutantStatisticsCollector.count(relativeFileName, 'added');
+        }
+      }
+      return mutant;
+    });
+
+    // Make sure that old mutants that didn't run this time around aren't forgotten
+
+    for (const [mutantKey, oldResult] of reusableMutantsByKey) {
+      // Do an additional check to see if the mutant is in mutated range.
+      //
+      // For example:
+      // ```diff
+      // - return a || b;
+      // + return a && b;
+      // ```
+      // The conditional expression mutator here decides to _not_ mutate b to `false` the second time around. (even though the text of "b" itself didn't change)
+      // Not doing this additional check would result in a sticky mutant that is never removed
+      if (
+        !currentMutantKeys.has(mutantKey) &&
+        !this.isInMutatedScope(oldResult.relativeFileName, oldResult)
+      ) {
+        const coverage = oldCoverageTestKeysByMutantKey.get(mutantKey) ?? [];
+        const killed = oldKilledTestKeysByMutantKey.get(mutantKey) ?? [];
+        const coveredBy = testKeysToId(coverage);
+        const killedBy = testKeysToId(killed);
+        const reusedMutant = {
+          ...oldResult,
+          id: mutantKey,
+          fileName: path.resolve(oldResult.relativeFileName),
+          replacement: oldResult.replacement ?? oldResult.mutatorName,
+          coveredBy,
+          killedBy,
+        };
+        mutants.push(reusedMutant);
+        testCoverage.addCoverage(reusedMutant.id, coveredBy);
+      }
+    }
+
+    if (this.logger.isInfoEnabled()) {
+      const testInfo = testCoverage.hasCoverage
+        ? `\n\tTests:\t\t${testStatisticsCollector.createTotalsReport()}`
+        : '';
+      this.logger.info(
+        `Incremental report:\n\tMutants:\t${mutantStatisticsCollector.createTotalsReport()}` +
+          testInfo +
+          `\n\tResult:\t\t${chalk.yellowBright(reusedMutantCount)} of ${currentMutants.length} mutant result(s) are reused.`,
+      );
+    }
+    if (this.logger.isDebugEnabled()) {
+      const lineSeparator = '\n\t\t';
+      const noChanges = 'No changes';
+      const detailedMutantSummary = `${lineSeparator}${mutantStatisticsCollector.createDetailedReport().join(lineSeparator) || noChanges}`;
+      const detailedTestsSummary = `${lineSeparator}${testStatisticsCollector.createDetailedReport().join(lineSeparator) || noChanges}`;
+      this.logger.debug(
+        `Detailed incremental report:\n\tMutants: ${detailedMutantSummary}\n\tTests: ${detailedTestsSummary}`,
+      );
+    }
+    return mutants;
+
+    function testKeysToId(testKeys: Iterable<string> | undefined) {
+      return [...(testKeys ?? [])]
+        .map((id) => testInfoByKey.get(id))
+        .filter(notEmpty)
+        .map(({ test: { id } }) => id);
+    }
+
+    function collectReusableMutantsByKey(log: Logger) {
+      return new Map(
+        Object.entries(files).flatMap(([fileName, oldFile]) => {
+          const relativeFileName = toRelativeNormalizedFileName(fileName);
+          const currentFileSource = currentRelativeFiles.get(relativeFileName);
+          if (currentFileSource) {
+            log.trace('Diffing %s', relativeFileName);
+            const { results, removeCount } = performFileDiff(
+              oldFile.source,
+              currentFileSource,
+              oldFile.mutants,
+            );
+            mutantStatisticsCollector.count(
+              relativeFileName,
+              'removed',
+              removeCount,
+            );
+            return results.map((m) => [
+              mutantToIdentifyingKey(m, relativeFileName),
+              {
+                ...m,
+                relativeFileName,
+              },
+            ]);
+          }
+          mutantStatisticsCollector.count(
+            relativeFileName,
+            'removed',
+            oldFile.mutants.length,
+          );
+          // File has since been deleted, these mutants are not reused
+          return [];
+        }),
+      );
+    }
+
+    function collectReusableTestInfo(log: Logger) {
+      const byId = new Map<
+        string,
+        { relativeFileName: string; test: TestDefinition; key: string }
+      >();
+      const byKey = new Map<string, TestInfo>();
+
+      Object.entries(testFiles ?? {}).forEach(([fileName, oldTestFile]) => {
+        const relativeFileName = toRelativeNormalizedFileName(fileName);
+        const currentFileSource = currentRelativeFiles.get(relativeFileName);
+        if (currentFileSource === undefined && fileName !== '') {
+          // An empty file name means the test runner cannot report test file locations.
+          // If the current file is undefined while the test runner can report test file locations, it means it has been deleted
+          log.debug('Test file removed: %s', relativeFileName);
+          testStatisticsCollector.count(
+            relativeFileName,
+            'removed',
+            oldTestFile.tests.length,
+          );
+        } else if (
+          currentFileSource !== undefined &&
+          oldTestFile.source !== undefined
+        ) {
+          log.trace('Diffing %s', relativeFileName);
+          const locatedTests = closeLocations(oldTestFile);
+          const { results, removeCount } = performFileDiff(
+            oldTestFile.source,
+            currentFileSource,
+            locatedTests,
+          );
+          testStatisticsCollector.count(
+            relativeFileName,
+            'removed',
+            removeCount,
+          );
+          results.forEach((test) => {
+            const key = testToIdentifyingKey(test, relativeFileName);
+            const testInfo = { key, test, relativeFileName };
+            byId.set(test.id, testInfo);
+            byKey.set(key, testInfo);
+          });
+        } else {
+          // No sources to compare, we should do our best with the info we do have
+          oldTestFile.tests.map((test) => {
+            const key = testToIdentifyingKey(test, relativeFileName);
+            const testInfo = { key, test, relativeFileName };
+            byId.set(test.id, testInfo);
+            byKey.set(key, testInfo);
+          });
+        }
+      });
+      return { byId, byKey };
+    }
+
+    function collectOldKilledAndCoverageMatrix() {
+      const oldCoverageByMutantKey = new Map<string, Set<string>>();
+      const oldKilledByMutantKey = new Map<string, Set<string>>();
+
+      for (const [key, mutant] of reusableMutantsByKey) {
+        const killedRow = new Set(
+          mutant.killedBy
+            ?.map((testId) => oldTestsById.get(testId)?.key)
+            .filter(notEmpty),
+        );
+        const coverageRow = new Set(
+          mutant.coveredBy
+            ?.map((testId) => oldTestsById.get(testId)?.key)
+            .filter(notEmpty),
+        );
+        killedRow.forEach((killed) => coverageRow.add(killed));
+        oldCoverageByMutantKey.set(key, coverageRow);
+        oldKilledByMutantKey.set(key, killedRow);
+      }
+      return { oldCoverageByMutantKey, oldKilledByMutantKey };
+    }
+
+    function collectCurrentTestInfo() {
+      const byTestKey = new Map<
+        string,
+        { relativeFileName: string; test: TestResult }
+      >();
+      for (const testResult of testCoverage.testsById.values()) {
+        const relativeFileName = toRelativeNormalizedFileName(
+          testResult.fileName,
+        );
+        const key = testToIdentifyingKey(testResult, relativeFileName);
+        const info = { relativeFileName, test: testResult, key: key };
+        byTestKey.set(key, info);
+      }
+
+      return byTestKey;
+    }
+
+    function mutantCanBeReused(
+      mutant: Mutant,
+      oldMutant: schema.MutantResult,
+      mutantKey: string,
+      coveringTests: ReadonlySet<TestResult> | undefined,
+      oldKillingTests: Set<string> | undefined,
+    ): boolean {
+      if (!testCoverage.hasCoverage) {
+        // This is the best we can do when the test runner didn't report coverage.
+        // We assume that all mutant test results can be reused,
+        // End users can use --force to force retesting of certain mutants
+        return true;
+      }
+      if (oldMutant.status === 'Ignored') {
+        // Was previously ignored, but not anymore, we need to run it now
+        return false;
+      }
+
+      const testsDiff = diffTestCoverage(
+        mutant.id,
+        oldCoverageTestKeysByMutantKey.get(mutantKey),
+        coveringTests,
+      );
+      if (oldMutant.status === 'Killed') {
+        if (oldKillingTests) {
+          for (const killingTest of oldKillingTests) {
+            if (testsDiff.get(killingTest) === 'same') {
+              return true;
+            }
+          }
+        }
+        // Killing tests has changed or no longer exists
+        return false;
+      }
+      for (const action of testsDiff.values()) {
+        if (action === 'added') {
+          // A non-killed mutant got a new test, we need to run it
+          return false;
+        }
+      }
+      // A non-killed mutant did not get new tests, no need to rerun it
+      return true;
+    }
+
+    /**
+     * Determines if there is a diff between old test coverage and new test coverage.
+     */
+    function diffTestCoverage(
+      mutantId: string,
+      oldCoveringTestKeys: Set<string> | undefined,
+      newCoveringTests: ReadonlySet<TestResult> | undefined,
+    ): Map<string, DiffAction> {
+      const result = new Map<string, DiffAction>();
+      if (newCoveringTests) {
+        for (const newTest of newCoveringTests) {
+          const key = testToIdentifyingKey(
+            newTest,
+            toRelativeNormalizedFileName(newTest.fileName),
+          );
+          result.set(key, oldCoveringTestKeys?.has(key) ? 'same' : 'added');
+        }
+      }
+      if (oldCoveringTestKeys) {
+        const isStatic = testCoverage.hasStaticCoverage(mutantId);
+        for (const oldTestKey of oldCoveringTestKeys) {
+          if (!result.has(oldTestKey)) {
+            // Static mutants might not have covering tests, but the test might still exist
+            if (isStatic && newTestKeys.has(oldTestKey)) {
+              result.set(oldTestKey, 'same');
+            } else {
+              result.set(oldTestKey, 'removed');
+            }
+          }
+        }
+      }
+      return result;
+    }
+  }
+}
+
+/**
+ * Finds the diff of mutants and tests. Removes mutants / tests that no longer exist (changed or removed). Updates locations of mutants or tests that do still exist.
+ * @param oldCode The old code to use for the diff
+ * @param newCode The new (current) code to use for the diff
+ * @param items The mutants or tests to be looked . These will be treated as immutable.
+ * @returns A list of items with updated locations, without items that are changed.
+ */
+function performFileDiff<T extends { location: Location }>(
+  oldCode: string,
+  newCode: string,
+  items: T[],
+): { results: T[]; removeCount: number } {
+  const oldSourceNormalized = normalizeLineEndings(oldCode);
+  const currentSrcNormalized = normalizeLineEndings(newCode);
+  const diffChanges = diffMatchPatch.diff_main(
+    oldSourceNormalized,
+    currentSrcNormalized,
+  );
+
+  const toDo = new Set(
+    items.map((m) => ({ ...m, location: deepClone(m.location) })),
+  );
+  const [added, removed] = [1, -1];
+  const done: T[] = [];
+  const currentPosition: Position = { column: 0, line: 0 };
+  let removeCount = 0;
+  for (const [change, text] of diffChanges) {
+    if (toDo.size === 0) {
+      // There are more changes, but nothing left to update.
+      break;
+    }
+    const offset = calculateOffset(text);
+    if (change === added) {
+      for (const test of toDo) {
+        const { location } = test;
+        if (
+          gte(currentPosition, location.start) &&
+          gte(location.end, currentPosition)
+        ) {
+          // This item cannot be reused, code was added here
+          removeCount++;
+          toDo.delete(test);
+        } else {
+          locationAdd(
+            location,
+            offset,
+            currentPosition.line === location.start.line,
+          );
+        }
+      }
+      positionMove(currentPosition, offset);
+    } else if (change === removed) {
+      for (const item of toDo) {
+        const {
+          location: { start },
+        } = item;
+        const endOffset = positionMove({ ...currentPosition }, offset);
+        if (gte(endOffset, start)) {
+          // This item cannot be reused, the code it covers has changed
+          removeCount++;
+          toDo.delete(item);
+        } else {
+          locationAdd(
+            item.location,
+            negate(offset),
+            currentPosition.line === start.line,
+          );
+        }
+      }
+    } else {
+      positionMove(currentPosition, offset);
+      toDo.forEach((item) => {
+        const { end } = item.location;
+        if (gte(currentPosition, end)) {
+          // We're done with this item, it can be reused
+          toDo.delete(item);
+          done.push(item);
+        }
+      });
+    }
+  }
+  done.push(...toDo);
+  return { results: done, removeCount };
+}
+
+/**
+ * A greater-than-equals implementation for positions
+ */
+function gte(a: Position, b: Position) {
+  return a.line > b.line || (a.line === b.line && a.column >= b.column);
+}
+
+function locationIncluded(haystack: Location, needle: Location) {
+  const startIncluded = gte(needle.start, haystack.start);
+  const endIncluded = gte(haystack.end, needle.end);
+  return startIncluded && endIncluded;
+}
+
+function deepClone(loc: Location): Location {
+  return { start: { ...loc.start }, end: { ...loc.end } };
+}
+
+/**
+ * Reduces a mutant to a string that identifies the mutant across reports.
+ * Consists of the relative file name, mutator name, replacement, and location
+ */
+function mutantToIdentifyingKey(
+  {
+    mutatorName,
+    replacement,
+    location: { start, end },
+  }: Pick<Mutant, 'location' | 'mutatorName'> & { replacement?: string },
+  relativeFileName: string,
+) {
+  return `${relativeFileName}@${start.line}:${start.column}-${end.line}:${end.column}\n${mutatorName}: ${replacement}`;
+}
+
+function testToIdentifyingKey(
+  {
+    name,
+    location,
+    startPosition,
+  }: Pick<schema.TestDefinition, 'location' | 'name'> &
+    Pick<TestResult, 'startPosition'>,
+  relativeFileName: string | undefined,
+) {
+  startPosition = startPosition ?? location?.start ?? { line: 0, column: 0 };
+  return `${relativeFileName}@${startPosition.line}:${startPosition.column}\n${name}`;
+}
+
+export function toRelativeNormalizedFileName(
+  fileName: string | undefined,
+): string {
+  return normalizeFileName(path.relative(process.cwd(), fileName ?? ''));
+}
+
+function calculateOffset(text: string): Position {
+  const pos: Position = { line: 0, column: 0 };
+  for (const char of text) {
+    if (char === '\n') {
+      pos.line++;
+      pos.column = 0;
+    } else {
+      pos.column++;
+    }
+  }
+  return pos;
+}
+
+function positionMove(pos: Position, diff: Position): Position {
+  pos.line += diff.line;
+  if (diff.line === 0) {
+    pos.column += diff.column;
+  } else {
+    pos.column = diff.column;
+  }
+  return pos;
+}
+
+function locationAdd(
+  { start, end }: Location,
+  { line, column }: Position,
+  currentLine: boolean,
+) {
+  start.line += line;
+  if (currentLine) {
+    start.column += column;
+  }
+  end.line += line;
+  if (line === 0 && currentLine) {
+    end.column += column;
+  }
+}
+
+function negate({ line, column }: Position): Position {
+  return { line: -1 * line, column: -1 * column };
+}
+
+interface TestInfo {
+  relativeFileName: string;
+  test: TestDefinition;
+  key: string;
+}
+
+type DiffAction = DiffChange | 'same';
+
+/**
+ * Sets the end position of each test to the start position of the next test.
+ * This is an educated guess and necessary.
+ * If a test has no location, it is assumed it spans the entire file (line 0 to Infinity)
+ *
+ * Knowing the end location of tests is necessary in order to know if the test was changed.
+ */
+function closeLocations(testFile: schema.TestFile): LocatedTest[] {
+  const locatedTests: LocatedTest[] = [];
+  const openEndedTests: OpenEndedTest[] = [];
+
+  testFile.tests.forEach((test) => {
+    if (testHasLocation(test)) {
+      if (isClosed(test)) {
+        locatedTests.push(test);
+      } else {
+        openEndedTests.push(test);
+      }
+    } else {
+      locatedTests.push({
+        ...test,
+        location: {
+          start: { line: 0, column: 0 },
+          end: { line: Number.POSITIVE_INFINITY, column: 0 },
+        },
+      });
+    }
+  });
+
+  if (openEndedTests.length) {
+    // Sort the opened tests in order to close their locations
+    openEndedTests.sort(
+      (a, b) => a.location.start.line - b.location.start.line,
+    );
+    const openEndedTestSet = new Set(openEndedTests);
+    const startPositions = uniqueStartPositions(openEndedTests);
+
+    let currentPositionIndex = 0;
+    openEndedTestSet.forEach((test) => {
+      if (
+        eqPosition(test.location.start, startPositions[currentPositionIndex])
+      ) {
+        currentPositionIndex++;
+      }
+      if (startPositions[currentPositionIndex]) {
+        locatedTests.push({
+          ...test,
+          location: {
+            start: test.location.start,
+            end: startPositions[currentPositionIndex],
+          },
+        });
+        openEndedTestSet.delete(test);
+      }
+    });
+
+    // Don't forget about the last tests
+    openEndedTestSet.forEach((lastTest) => {
+      locatedTests.push({
+        ...lastTest,
+        location: {
+          start: lastTest.location.start,
+          end: { line: Number.POSITIVE_INFINITY, column: 0 },
+        },
+      });
+    });
+  }
+
+  return locatedTests;
+}
+
+/**
+ * Determines the unique start positions of a sorted list of tests in order
+ */
+function uniqueStartPositions(sortedTests: OpenEndedTest[]) {
+  let current: Position | undefined;
+  const startPositions = sortedTests.reduce<Position[]>(
+    (collector, { location: { start } }) => {
+      if (
+        !current ||
+        current.line !== start.line ||
+        current.column !== start.column
+      ) {
+        current = start;
+        collector.push(current);
+      }
+      return collector;
+    },
+    [],
+  );
+  return startPositions;
+}
+
+function testHasLocation(test: schema.TestDefinition): test is OpenEndedTest {
+  return !!test.location?.start;
+}
+
+function isClosed(test: Required<schema.TestDefinition>): test is LocatedTest {
+  return !!test.location.end;
+}
+
+function eqPosition(start: Position, end?: Position): boolean {
+  return start.column === end?.column && start.line === end.line;
+}
+
+type LocatedTest = schema.TestDefinition & { location: Location };
+type OpenEndedTest = schema.TestDefinition & {
+  location: schema.OpenEndLocation;
+};