[clang-tidy] Add an option to export suggested fixes into a file.

[bkramer]

Summary

Allows gathering fixes and applying them with clang-apply fixes.

[alexfh]

NIce! But please add error handling for YAML serialization and a bit more description of the new option.

clang-tidy/ClangTidy.cpp

374

"return YAML.error();" seems like a good idea in case the file is not writable or any other error occurs.

clang-tidy/tool/ClangTidyMain.cpp

82

I'd say a few more words about why we need this and how can one use this file.

[bkramer]

clang-tidy/ClangTidy.cpp

374

yaml::Output has no way to retrieve errors :(

Closed by commit rL217139 (authored by d0k).

[alexfh]

clang-tidy/ClangTidy.cpp

374

Oh, didn't know that. In this case, you could use raw_fd_ostream::has_error() after manually closing it. It doesn't provide much detail about what was wrong, but it's better than nothing. WDYT?

[bkramer]

clang-tidy/ClangTidy.cpp

374

raw_ostream will report a fatal error on close anyways when anything went wrong (and we didn't clear the error). The only thing we could do is provide a nicer message, not sure if that's worth the additional code.

clang-tidy/ClangTidy.h

 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
 //
 /// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
 /// Errors containing fixes are automatically applied.
 void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix);
 
+/// \brief Serializes replacements into YAML and writes them to the specified
+/// output stream.
+void exportReplacements(const std::vector<ClangTidyError> &Errors,
+                        raw_ostream &OS);
+
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H

clang-tidy/ClangTidy.cpp

 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
 #include "clang/Tooling/Refactoring.h"
+#include "clang/Tooling/ReplacementsYaml.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include <algorithm>
 #include <utility>
 
 using namespace clang::ast_matchers;

 
 void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix) {
   ErrorReporter Reporter(Fix);
   for (const ClangTidyError &Error : Errors)
     Reporter.reportDiagnostic(Error);
   Reporter.Finish();
 }
 
+void exportReplacements(const std::vector<ClangTidyError> &Errors,
+                        raw_ostream &OS) {
+  tooling::TranslationUnitReplacements TUR;
+  for (const ClangTidyError &Error : Errors)
+    TUR.Replacements.insert(TUR.Replacements.end(), Error.Fix.begin(),
+                            Error.Fix.end());
+
+  yaml::Output YAML(OS);
+  YAML << TUR;
+}
+
 } // namespace tidy
 } // namespace clang

clang-tidy/tool/ClangTidyMain.cpp

ListChecks("list-checks",
            cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool>
 AnalyzeTemporaryDtors("analyze-temporary-dtors",
                       cl::desc("Enable temporary destructor-aware analysis in\n"
                                "clang-analyzer- checks."),
                       cl::init(false), cl::cat(ClangTidyCategory));
 
+static cl::opt<std::string>
+    ExportFixes("export-fixes", cl::desc("File to store suggested fixes in."),
+                cl::value_desc("filename"), cl::cat(ClangTidyCategory));
+
 static void printStats(const clang::tidy::ClangTidyStats &Stats) {
   if (Stats.errorsIgnored()) {
     llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings (";
     StringRef Separator = "";
     if (Stats.ErrorsIgnoredNonUserCode) {
       llvm::errs() << Stats.ErrorsIgnoredNonUserCode << " in non-user code";
       Separator = ", ";
     }
int main(int argc, const char **argv) {
   auto OptionsProvider =
       new clang::tidy::DefaultOptionsProvider(GlobalOptions, Options);
   std::vector<clang::tidy::ClangTidyError> Errors;
   clang::tidy::ClangTidyStats Stats = clang::tidy::runClangTidy(
       OptionsProvider, OptionsParser.getCompilations(),
       OptionsParser.getSourcePathList(), &Errors);
   clang::tidy::handleErrors(Errors, Fix);
 
+  if (!ExportFixes.empty()) {
+    std::error_code EC;
+    llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
+    if (EC) {
+      llvm::errs() << "Error opening output file: " << EC.message() << '\n';
+      return 1;
+    }
+    clang::tidy::exportReplacements(Errors, OS);
+  }
+
   printStats(Stats);
   return 0;
 }
 
 namespace clang {
 namespace tidy {
 
 // This anchor is used to force the linker to link the LLVMModule.

test/clang-tidy/fix.cpp

 // RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
-// RUN: clang-tidy %t.cpp -checks='-*,google-explicit-constructor,llvm-namespace-comment' -fix -- > %t.msg 2>&1
+// RUN: clang-tidy %t.cpp -checks='-*,google-explicit-constructor,llvm-namespace-comment' -fix -export-fixes=%t.yaml -- > %t.msg 2>&1
 // RUN: FileCheck -input-file=%t.cpp %s
 // RUN: FileCheck -input-file=%t.msg -check-prefix=CHECK-MESSAGES %s
+// RUN: FileCheck -input-file=%t.yaml -check-prefix=CHECK-YAML %s
 
 namespace i {
 }
 // CHECK: } // namespace i
 // CHECK-MESSAGES: note: FIX-IT applied suggested code changes
+// CHECK-YAML: ReplacementText: ' // namespace i'
 
 class A { A(int i); };
 // CHECK: class A { explicit A(int i); };
 // CHECK-MESSAGES: note: FIX-IT applied suggested code changes
 // CHECK-MESSAGES: clang-tidy applied 2 of 2 suggested fixes.
+// CHECK-YAML: ReplacementText: 'explicit '