[clang-tidy] Add line/column to export-fixes yaml

[rpbeltran]

Summary

This change adds line and column numbers to the YAML output from
export-fixes. Currently, line and column numbers are only given in human
readable formats while YAML output only gives a file name and offset.

This is unfortunate for tools that want to parse clang tidy output in a
machine readble format but do not have access to the original files or
do not want to use offsets.

For efficiency, line and column information is only to be produced if
export-fixes is enabled.

[rpbeltran]

Added missing arg in call to runClangTidy

[rpbeltran]

Added lines/numbers to notes as well and fixed problems with draft

clang-tools-extra/clang-tidy/ClangTidy.h

 
 /// Run a set of clang-tidy checks on a set of files.
 ///
 /// \param EnableCheckProfile If provided, it enables check profile collection
 /// in MatchFinder, and will contain the result of the profile.
 /// \param StoreCheckProfile If provided, and EnableCheckProfile is true,
 /// the profile will not be output to stderr, but will instead be stored
 /// as a JSON file in the specified directory.
+/// \param WillExportFixes If true, add line and column information to messages
+/// for fixes later being exported to yaml.
 std::vector<ClangTidyError>
 runClangTidy(clang::tidy::ClangTidyContext &Context,
              const tooling::CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
              bool ApplyAnyFix, bool EnableCheckProfile = false,
+             bool WillExportFixes = false,
              llvm::StringRef StoreCheckProfile = StringRef());
 
 /// Controls what kind of fixes clang-tidy is allowed to apply.
 enum FixBehaviour {
   /// Don't try to apply any fix.
   FB_NoFix,
   /// Only apply fixes added to warnings.
   FB_Fix,

clang-tools-extra/clang-tidy/ClangTidy.cpp

getCheckOptions(const ClangTidyOptions &Options,
   return Factory.getCheckOptions();
 }
 
 std::vector<ClangTidyError>
 runClangTidy(clang::tidy::ClangTidyContext &Context,
              const CompilationDatabase &Compilations,
              ArrayRef<std::string> InputFiles,
              llvm::IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> BaseFS,
-             bool ApplyAnyFix, bool EnableCheckProfile,
+             bool ApplyAnyFix, bool EnableCheckProfile, bool willExport,
              llvm::StringRef StoreCheckProfile) {
   ClangTool Tool(Compilations, InputFiles,
                  std::make_shared<PCHContainerOperations>(), BaseFS);
 
   // Add extra arguments passed by the clang-tidy command-line.
   ArgumentsAdjuster PerFileExtraArgumentsInserter =
       [&Context](const CommandLineArguments &Args, StringRef Filename) {
         ClangTidyOptions Opts = Context.getOptionsForFile(Filename);
private:
       ClangTidyASTConsumerFactory *Factory;
     };
 
     ClangTidyASTConsumerFactory ConsumerFactory;
   };
 
   ActionFactory Factory(Context, std::move(BaseFS));
   Tool.run(&Factory);
+
+  if (willExport) {
+    // Only compute line and column information if needed for yaml export
+    DiagConsumer.addLineAndColToDiagnostics();
+  }
   return DiagConsumer.take();
 }
 
 void handleErrors(llvm::ArrayRef<ClangTidyError> Errors,
                   ClangTidyContext &Context, FixBehaviour Fix,
                   unsigned &WarningsAsErrorsCount,
                   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) {
   ErrorReporter Reporter(Context, Fix, std::move(BaseFS));

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

public:
   // more generic and should be pulled out into a more useful Diagnostics
   // library.
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                         const Diagnostic &Info) override;
 
   // Retrieve the diagnostics that were captured.
   std::vector<ClangTidyError> take();
 
+  // Add Line and Column data to errors so that it is available when exporting yaml.
+  void addLineAndColToDiagnostics();
+
 private:
   void finalizeLastError();
   void removeIncompatibleErrors();
   void removeDuplicatedDiagnosticsOfAliasCheckers();
 
   /// Returns the \c HeaderFilter constructed for the options set in the
   /// context.
   llvm::Regex *getHeaderFilter();

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

 #include "GlobList.h"
 #include "NoLintDirectiveHandler.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/Attr.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileEntry.h"
 #include "clang/Basic/FileManager.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"

 struct EqualClangTidyError {
   bool operator()(const ClangTidyError &LHS, const ClangTidyError &RHS) const {
     LessClangTidyError Less;
     return !Less(LHS, RHS) && !Less(RHS, LHS);
   }
 };
 } // end anonymous namespace
 
+FullSourceLoc getLocation(SourceManager & SourceMgr, StringRef FilePath, unsigned Offset) {
+  if (FilePath.empty())
+    return FullSourceLoc(SourceLocation(), SourceMgr);
+
+  auto File = SourceMgr.getFileManager().getFile(FilePath);
+  if (!File)
+    return FullSourceLoc(SourceLocation(), SourceMgr);
+
+  const FileEntry* TheFileEntry = *File;
+  if (TheFileEntry == nullptr) {
+    return FullSourceLoc(SourceLocation(), SourceMgr);
+  }
+
+  FileID ID = SourceMgr.getOrCreateFileID(TheFileEntry, SrcMgr::C_User);
+
+  SourceLocation StartLocation = SourceMgr.getLocForStartOfFile(ID);
+  return FullSourceLoc(StartLocation.getLocWithOffset(Offset), SourceMgr);
+}
+
+void ClangTidyDiagnosticConsumer::addLineAndColToDiagnostics() {
+  for (ClangTidyError CTE : Errors) {
+    tooling::DiagnosticMessage &Message = CTE.Message;
+
+    SourceManager & SM = Context.DiagEngine->getSourceManager();
+
+    FullSourceLoc Loc = getLocation(SM, Message.FilePath, Message.FileOffset);
+    CTE.Message.LineNumber = Loc.getLineNumber();
+    CTE.Message.ColumnNumber = Loc.getColumnNumber();
+  }
+}
+
 std::vector<ClangTidyError> ClangTidyDiagnosticConsumer::take() {
   finalizeLastError();
 
   llvm::stable_sort(Errors, LessClangTidyError());
   Errors.erase(std::unique(Errors.begin(), Errors.end(), EqualClangTidyError()),
                Errors.end());
   if (RemoveIncompatibleErrors)
     removeIncompatibleErrors();

clang/include/clang/Tooling/Core/Diagnostic.h

 #ifndef LLVM_CLANG_TOOLING_CORE_DIAGNOSTIC_H
 #define LLVM_CLANG_TOOLING_CORE_DIAGNOSTIC_H
 
 #include "Replacement.h"
 #include "clang/Basic/Diagnostic.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include <optional>
 #include <string>
 
 namespace clang {
 namespace tooling {
 
 /// Represents a range within a specific source file.
 struct FileByteRange {
   FileByteRange() = default;
struct DiagnosticMessage {
   ///
   DiagnosticMessage(llvm::StringRef Message, const SourceManager &Sources,
                     SourceLocation Loc);
 
   std::string Message;
   std::string FilePath;
   unsigned FileOffset;
 
+  /// Diagnostics normally do not store Line and Col numbers but should if
+  /// exporting to yaml.
+  std::optional<unsigned> LineNumber;
+  std::optional<unsigned> ColumnNumber;
+
   /// Fixes for this diagnostic, grouped by file path.
   llvm::StringMap<Replacements> Fix;
 
   /// Extra source ranges associated with the note, in addition to the location
   /// of the Message itself.
   llvm::SmallVector<FileByteRange, 1> Ranges;
 };
 

clang/include/clang/Tooling/DiagnosticsYaml.h

template <> struct MappingTraits<clang::tooling::FileByteRange> {
   }
 };
 
 template <> struct MappingTraits<clang::tooling::DiagnosticMessage> {
   static void mapping(IO &Io, clang::tooling::DiagnosticMessage &M) {
     Io.mapRequired("Message", M.Message);
     Io.mapOptional("FilePath", M.FilePath);
     Io.mapOptional("FileOffset", M.FileOffset);
+    Io.mapOptional("LineNumber", M.LineNumber);
+    Io.mapOptional("ColumnNumber", M.ColumnNumber);
     std::vector<clang::tooling::Replacement> Fixes;
     for (auto &Replacements : M.Fix) {
       llvm::append_range(Fixes, Replacements.second);
     }
     Io.mapRequired("Replacements", Fixes);
     for (auto &Fix : Fixes) {
       llvm::Error Err = M.Fix[Fix.getFilePath()].add(Fix);
       if (Err) {