[Remark] Overload `<<` for Remark, RemarkType and RemarkLocation.

[zjaffal]

Summary

Represent different remark concepts as strings by overloading the <<
operator.

[JDevlieghere]

llvm/include/llvm/Remarks/Remark.h

38

Doesn't look like you need the grouping here. Similar comment below.

73–90

Given that there are all string literals, this function should return a StringRef and avoid the std::string allocation.

[bulbazord]

llvm/include/llvm/Remarks/Remark.h

73–90

+1

llvm/lib/Remarks/Remark.cpp

30–31

No need for the additional allocation, you can send StringRefs to raw_ostreams.

35

42–43

[zjaffal]

1. Change std::string references to StringRef

[thegameg]

llvm/lib/Remarks/Remark.cpp

30

I suggest Line and Column, the difference is not that big.

39

Name and Type? Remove Remark from the keys.

llvm/include/llvm/Remarks/Remark.h

 
 #ifndef LLVM_REMARKS_REMARK_H
 #define LLVM_REMARKS_REMARK_H
 
 #include "llvm-c/Remarks.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CBindingWrapping.h"
+#include "llvm/Support/raw_ostream.h"
 #include <optional>
 #include <string>
 
 namespace llvm {
 namespace remarks {
 
 /// The current version of the remark entry.
 constexpr uint64_t CurrentRemarkVersion = 0;
 
 /// The debug location used to track a remark back to the source file.
 struct RemarkLocation {
   /// Absolute path of the source file corresponding to this remark.
   StringRef SourceFilePath;
   unsigned SourceLine = 0;
   unsigned SourceColumn = 0;
+
+  /// Implement operator<< on RemarkLocation.
+  void print(raw_ostream &OS) const;
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(RemarkLocation, LLVMRemarkDebugLocRef)
 
 /// A key-value pair with a debug location that is used to display the remarks
 /// at the right place in the source.
 struct Argument {
   StringRef Key;
   // FIXME: We might want to be able to store other types than strings here.
   StringRef Val;
   // If set, the debug location corresponding to the value.
   std::optional<RemarkLocation> Loc;
+
+  /// Implement operator<< on Argument.
+  void print(raw_ostream &OS) const;
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Argument, LLVMRemarkArgRef)
 
 /// The type of the remark.
 enum class Type {
   Unknown,
   Passed,
   Missed,
   Analysis,
   AnalysisFPCommute,
   AnalysisAliasing,
   Failure,
   First = Unknown,
   Last = Failure
 };
 
+inline StringRef typeToStr(Type Ty) {
+  switch (Ty) {
+  case Type::Unknown:
+    return "Unknown";
+  case Type::Missed:
+    return "Missed";
+  case Type::Passed:
+    return "Passed";
+  case Type::Analysis:
+    return "Analysis";
+  case Type::AnalysisFPCommute:
+    return "AnalysisFPCommute";
+  case Type::AnalysisAliasing:
+    return "AnalysisAliasing";
+  default:
+    return "Failure";
+  }
+}
+
 /// A remark type used for both emission and parsing.
 struct Remark {
   /// The type of the remark.
   Type RemarkType = Type::Unknown;
 
   /// Name of the pass that triggers the emission of this remark.
   StringRef PassName;
 
struct Remark {
   Remark &operator=(Remark &&) = default;
 
   /// Return a message composed from the arguments as a string.
   std::string getArgsAsMsg() const;
 
   /// Clone this remark to explicitly ask for a copy.
   Remark clone() const { return *this; }
 
+  /// Implement operator<< on Remark.
+  void print(raw_ostream &OS) const;
+
 private:
   /// In order to avoid unwanted copies, "delete" the copy constructor.
   /// If a copy is needed, it should be done through `Remark::clone()`.
   Remark(const Remark &) = default;
   Remark& operator=(const Remark &) = default;
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).

 
 inline bool operator<(const Remark &LHS, const Remark &RHS) {
   return std::make_tuple(LHS.RemarkType, LHS.PassName, LHS.RemarkName,
                          LHS.FunctionName, LHS.Loc, LHS.Hotness, LHS.Args) <
          std::make_tuple(RHS.RemarkType, RHS.PassName, RHS.RemarkName,
                          RHS.FunctionName, RHS.Loc, RHS.Hotness, RHS.Args);
 }
 
+inline raw_ostream &operator<<(raw_ostream &OS, const RemarkLocation &RLoc) {
+  RLoc.print(OS);
+  return OS;
+}
+
+inline raw_ostream &operator<<(raw_ostream &OS, const Argument &Arg) {
+  Arg.print(OS);
+  return OS;
+}
+
+inline raw_ostream &operator<<(raw_ostream &OS, const Remark &Remark) {
+  Remark.print(OS);
+  return OS;
+}
+
 } // end namespace remarks
 } // end namespace llvm
 
 #endif /* LLVM_REMARKS_REMARK_H */

llvm/lib/Remarks/Remark.cpp

 //===- Remark.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation of the Remark type and the C API.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Remarks/Remark.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 using namespace llvm;
 using namespace llvm::remarks;
 
 std::string Remark::getArgsAsMsg() const {
   std::string Str;
   raw_string_ostream OS(Str);
   for (const Argument &Arg : Args)
     OS << Arg.Val;
   return OS.str();
 }
 
+void RemarkLocation::print(raw_ostream &OS) const {
+  OS << "{ "
+     << "File: " << SourceFilePath << ", Line: " << SourceLine
+     << " Column:" << SourceColumn << " }\n";
+}
+
+void Argument::print(raw_ostream &OS) const {
+  OS << Key << ": " << Val << "\n";
+}
+
+void Remark::print(raw_ostream &OS) const {
+  OS << "Name: ";
+  OS << RemarkName << "\n";
+  OS << "Type: " << typeToStr(RemarkType) << "\n";
+  OS << "FunctionName: " << FunctionName << "\n";
+  OS << "PassName: " << PassName << "\n";
+  if (Loc)
+    OS << "Loc: " << Loc.value();
+  if (Hotness)
+    OS << "Hotness: " << Hotness;
+  if (!Args.empty()) {
+    OS << "Args:\n";
+    for (auto Arg : Args)
+      OS << "\t" << Arg;
+  }
+}
+
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(StringRef, LLVMRemarkStringRef)
 
 extern "C" const char *LLVMRemarkStringGetData(LLVMRemarkStringRef String) {
   return unwrap(String)->data();
 }
 
 extern "C" uint32_t LLVMRemarkStringGetLen(LLVMRemarkStringRef String) {