Add Patches Reporter

This reporter is available as `Patches`. It generates a patch for each mutant.

docs/command-line/generated/mull-runner-cli-options.rst

@@ -16,6 +16,8 @@
 
     :Elements:	Generates mutation-testing-elements compatible JSON file
 
+    :Patches:	Generates a unified patchfile for each mutation
+
 --ide-reporter-show-killed		Makes IDEReporter to also report killed mutations (disabled by default)
 
 --debug		Enables Debug Mode: more logs are printed

include/mull/Reporters/PatchesReporter.h

@@ -0,0 +1,28 @@
+#include "Reporter.h"
+
+#include "mull/Reporters/SourceCodeReader.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mull {
+
+class Result;
+class Diagnostics;
+
+class PatchesReporter : public Reporter {
+public:
+  explicit PatchesReporter(Diagnostics &diagnostics, const std::string &reportDir = "",
+                          const std::string &reportName = "");
+
+  void reportResults(const Result &result) override;
+
+  std::string getPatchesPath();
+
+private:
+  Diagnostics &diagnostics;
+  std::string patchesPath;
+  SourceCodeReader sourceCodeReader;
+};
+
+} // namespace mull

include/mull/Reporters/Reporter.h

@@ -4,7 +4,7 @@ namespace mull {
 
 class Result;
 
-enum class ReporterKind { IDE, SQLite, Elements };
+enum class ReporterKind { IDE, SQLite, Elements, Patches };
 
 class Reporter {
 public:

include/mull/Reporters/SourceCodeReader.h

@@ -13,6 +13,7 @@ class SourceCodeReader {
   SourceCodeReader();
   std::string getContext(const mull::SourceLocation &sourceLocation);
   std::string getSourceLineWithCaret(const SourceLocation &sourceLocation);
+  std::string getSourceLine(const SourceLocation &sourceLocation);
 private:
   SourceManager sourceManager;
 };

lib/CMakeLists.txt

@@ -39,6 +39,7 @@ set(mull_sources
   Reporters/SourceCodeReader.cpp
   Reporters/SourceManager.cpp
   Reporters/SQLiteReporter.cpp
+  Reporters/PatchesReporter.cpp
 
   SourceLocation.cpp
 

lib/Reporters/PatchesReporter.cpp

@@ -0,0 +1,101 @@
+#include "mull/Reporters/PatchesReporter.h"
+
+#include "mull/Bitcode.h"
+#include "mull/Diagnostics/Diagnostics.h"
+#include "mull/ExecutionResult.h"
+#include "mull/Mutant.h"
+#include "mull/Mutators/Mutator.h"
+#include "mull/Mutators/MutatorsFactory.h"
+#include "mull/Result.h"
+#include "mull/SourceLocation.h"
+#include "mull/Reporters/SourceCodeReader.h"
+
+#include <llvm/IR/DebugInfoMetadata.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instruction.h>
+#include <llvm/IR/Module.h>
+#include <llvm/Support/FileSystem.h>
+
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <unistd.h>
+
+using namespace mull;
+using namespace llvm;
+
+
+static std::string getReportName(const std::string &name) {
+  std::string reportName = name;
+  if (reportName.empty()) {
+    time_t t;
+    time(&t);
+    reportName = std::to_string(t);
+  }
+  return reportName + "-patches";
+}
+
+static std::string getReportDir(const std::string &reportDir) {
+  if (reportDir.empty()) {
+    return std::string(".");
+  }
+  return reportDir;
+}
+
+PatchesReporter::PatchesReporter(Diagnostics &diagnostics, const std::string &reportDir,
+                               const std::string &reportName)
+    : diagnostics(diagnostics),
+      patchesPath(getReportDir(reportDir) + "/" + getReportName(reportName)) ,
+      sourceCodeReader() {
+  llvm::sys::fs::create_directories(patchesPath, true);
+}
+
+std::string mull::PatchesReporter::getPatchesPath() {
+  return patchesPath;
+}
+
+void mull::PatchesReporter::reportResults(const Result &result) {
+  MutatorsFactory factory(diagnostics);
+  factory.init();
+  for (auto &mutationResult : result.getMutationResults()) {
+
+    const ExecutionResult mutationExecutionResult = mutationResult->getExecutionResult();
+
+    std::stringstream filename;
+    auto mutant = *mutationResult->getMutant();
+    auto& sourceLocation = mutant.getSourceLocation();
+    auto& sourceEndLocation = mutant.getEndLocation();
+    std::string sourceBasename = sourceLocation.filePath.substr(sourceLocation.directory.size()+1);
+    auto mutator = factory.getMutator(mutant.getMutatorIdentifier());
+    std::string sourceLine = sourceCodeReader.getSourceLine(sourceLocation);
+
+    auto prefix = [&mutationExecutionResult](){
+      switch(mutationExecutionResult.status){
+        case ExecutionStatus::Passed:
+          return "survived-";
+          break;
+        case ExecutionStatus::NotCovered:
+          return "uncovered-";
+          break;
+        default:
+          return "killed-";
+      }
+    };
+
+    filename << patchesPath << "/" << prefix() << "-"
+             << sourceBasename << mutant.getMutatorIdentifier()
+             << "-L" << sourceLocation.line << "-C" << sourceLocation.column
+             << ".patch";
+
+    std::ofstream myfile{filename.str()};
+    myfile << "--- a" << sourceLocation.filePath << " 0" << "\n"
+           << "+++ b" << sourceLocation.filePath << " 0" << "\n"
+           << "@@ -" << sourceLocation.line << ",1 +" << sourceLocation.line << ",1 @@\n"
+           << "-" << sourceLine
+           << "+" << sourceLine.substr(0, sourceLocation.column-1)
+           << mutator->getReplacement() << sourceLine.substr(sourceEndLocation.column-1) ;
+    myfile.close();
+  }
+
+  diagnostics.info(std::string("Patchefiles can be found at '") + patchesPath + "'");
+}

lib/Reporters/SourceCodeReader.cpp

@@ -91,3 +91,13 @@ std::string SourceCodeReader::getSourceLineWithCaret(const SourceLocation &sourc
   ss << line << caret << "\n";
   return ss.str();
 }
+
+std::string SourceCodeReader::getSourceLine(const SourceLocation &sourceLocation) {
+  std::stringstream ss;
+
+  auto line = sourceManager.getLine(sourceLocation);
+  assert(sourceLocation.column < line.size());
+
+  ss << line;
+  return ss.str();
+}

tools/CLIOptions/CLIOptions.cpp

@@ -4,6 +4,7 @@
 #include <mull/Reporters/IDEReporter.h>
 #include <mull/Reporters/MutationTestingElementsReporter.h>
 #include <mull/Reporters/SQLiteReporter.h>
+#include <mull/Reporters/PatchesReporter.h>
 
 using namespace mull;
 using namespace tool;
@@ -44,6 +45,7 @@ static std::vector<ReporterDefinition> reporterOptions({
     { "Elements",
       "Generates mutation-testing-elements compatible JSON file",
       ReporterKind::Elements },
+    { "Patches", "Saves results into Patchfiles", ReporterKind::Patches },
 });
 
 ReportersCLIOptions::ReportersCLIOptions(Diagnostics &diagnostics, list<ReporterKind> &parameter)
@@ -67,6 +69,9 @@ std::vector<std::unique_ptr<Reporter>> ReportersCLIOptions::reporters(ReporterPa
     case ReporterKind::SQLite: {
       reporters.emplace_back(new mull::SQLiteReporter(diagnostics, directory, name));
     } break;
+    case ReporterKind::Patches: {
+      reporters.emplace_back(new mull::PatchesReporter(diagnostics, directory, name));
+    } break;
     case ReporterKind::Elements: {
       if (!params.compilationDatabaseAvailable) {
         diagnostics.warning("Mutation Testing Elements Reporter may not work without compilation "