[opt-remark] Teach opt-remarks how to emit notes.

I did this by adding a kind to Arguments and making it so we have a kind that
emits as a separate NOTE when we emit diagnostics, but is emitted as a normal
argument when emitting to the bitstream.

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -536,6 +536,7 @@ ERROR(non_borrowed_indirect_addressof,none,
 
 REMARK(opt_remark_passed, none, "%0", (StringRef))
 REMARK(opt_remark_missed, none, "%0", (StringRef))
+NOTE(opt_remark_note, none, "%0", (StringRef))
 
 // Float-point to integer conversions
 ERROR(float_to_int_overflow, none,

include/swift/SIL/OptimizationRemark.h

@@ -32,16 +32,63 @@ class SILFunction;
 
 namespace OptRemark {
 
+struct ArgumentKeyKind {
+  enum InnerTy {
+    // Just assume this is a normal msg that we are emitting.
+    Default,
+
+    // Assume this is a note that should be emitted as a separate
+    // diagnostic when emitting diagnostics. Do nothing special
+    // along the backend path.
+    Note,
+  };
+
+  InnerTy innerValue;
+
+  ArgumentKeyKind(InnerTy value) : innerValue(value) {}
+  ArgumentKeyKind(const ArgumentKeyKind &kind) : innerValue(kind.innerValue) {}
+
+  operator InnerTy() const { return innerValue; }
+
+  /// Return true if this argument is meant to be a separate diagnostic when we
+  /// emit diagnostics but when we emit to the remark streamer (due to not
+  /// having support for this), we just emit the remark inline.
+  ///
+  /// TODO: Unfortunate that this needs to be done.
+  bool isSeparateDiagnostic() const {
+    switch (innerValue) {
+    case InnerTy::Default:
+      return false;
+    case InnerTy::Note:
+      return true;
+    }
+
+    llvm_unreachable("Covered switch isn't covered?!");
+  }
+};
+
+struct ArgumentKey {
+  ArgumentKeyKind kind;
+  std::string data;
+
+  ArgumentKey(ArgumentKeyKind kind, StringRef data) : kind(kind), data(data) {}
+  ArgumentKey(ArgumentKeyKind::InnerTy kind, StringRef data)
+      : kind(kind), data(data) {}
+  ArgumentKey(ArgumentKey kind, StringRef data) : kind(kind.kind), data(data) {}
+};
+
 /// Used in the streaming interface as the general argument type.  It
 /// internally converts everything into a key-value pair.
 struct Argument {
-  std::string key;
+  ArgumentKey key;
   std::string val;
   /// If set, the debug location corresponding to the value.
   SourceLoc loc;
 
-  explicit Argument(StringRef Str = "") : key("String"), val(Str) {}
-  Argument(StringRef key, StringRef val) : key(key), val(val) {}
+  explicit Argument(StringRef Str = "")
+      : key(ArgumentKeyKind::Default, "String"), val(Str) {}
+  Argument(StringRef key, StringRef val)
+      : key(ArgumentKeyKind::Default, key), val(val) {}
 
   Argument(StringRef key, int n);
   Argument(StringRef key, long n);
@@ -50,7 +97,9 @@ struct Argument {
   Argument(StringRef key, unsigned long n);
   Argument(StringRef key, unsigned long long n);
 
-  Argument(StringRef key, SILFunction *f);
+  Argument(StringRef key, SILFunction *f)
+      : Argument(ArgumentKey(ArgumentKeyKind::Default, key), f) {}
+  Argument(ArgumentKey key, SILFunction *f);
   Argument(StringRef key, SILType ty);
   Argument(StringRef key, CanType ty);
 };

include/swift/SIL/SILRemarkStreamer.h

@@ -111,7 +111,7 @@ llvm::remarks::Remark SILRemarkStreamer::toLLVMRemark(
 
   for (const OptRemark::Argument &arg : optRemark.getArgs()) {
     llvmRemark.Args.emplace_back();
-    llvmRemark.Args.back().Key = arg.key;
+    llvmRemark.Args.back().Key = arg.key.data;
     llvmRemark.Args.back().Val = arg.val;
     llvmRemark.Args.back().Loc =
         toRemarkLocation(arg.loc, getASTContext().SourceMgr);

lib/SIL/Utils/OptimizationRemark.cpp

@@ -28,23 +28,25 @@
 using namespace swift;
 using namespace OptRemark;
 
-Argument::Argument(StringRef key, int n) : key(key), val(llvm::itostr(n)) {}
+Argument::Argument(StringRef key, int n)
+    : key(ArgumentKeyKind::Default, key), val(llvm::itostr(n)) {}
 
-Argument::Argument(StringRef key, long n) : key(key), val(llvm::itostr(n)) {}
+Argument::Argument(StringRef key, long n)
+    : key(ArgumentKeyKind::Default, key), val(llvm::itostr(n)) {}
 
 Argument::Argument(StringRef key, long long n)
-    : key(key), val(llvm::itostr(n)) {}
+    : key(ArgumentKeyKind::Default, key), val(llvm::itostr(n)) {}
 
 Argument::Argument(StringRef key, unsigned n)
-    : key(key), val(llvm::utostr(n)) {}
+    : key(ArgumentKeyKind::Default, key), val(llvm::utostr(n)) {}
 
 Argument::Argument(StringRef key, unsigned long n)
-    : key(key), val(llvm::utostr(n)) {}
+    : key(ArgumentKeyKind::Default, key), val(llvm::utostr(n)) {}
 
 Argument::Argument(StringRef key, unsigned long long n)
-    : key(key), val(llvm::utostr(n)) {}
+    : key(ArgumentKeyKind::Default, key), val(llvm::utostr(n)) {}
 
-Argument::Argument(StringRef key, SILFunction *f) : key(key) {
+Argument::Argument(ArgumentKey key, SILFunction *f) : key(key) {
   auto options = Demangle::DemangleOptions::SimplifiedUIDemangleOptions();
   // Enable module names so that we have a way of filtering out
   // stdlib-related remarks.
@@ -58,12 +60,14 @@ Argument::Argument(StringRef key, SILFunction *f) : key(key) {
     loc = f->getLocation().getSourceLoc();
 }
 
-Argument::Argument(StringRef key, SILType ty) : key(key) {
+Argument::Argument(StringRef key, SILType ty)
+    : key(ArgumentKeyKind::Default, key) {
   llvm::raw_string_ostream stream(val);
   ty.print(stream);
 }
 
-Argument::Argument(StringRef key, CanType ty) : key(key) {
+Argument::Argument(StringRef key, CanType ty)
+    : key(ArgumentKeyKind::Default, key) {
   llvm::raw_string_ostream stream(val);
   ty.print(stream);
 }
@@ -72,8 +76,15 @@ template <typename DerivedT>
 std::string Remark<DerivedT>::getMsg() const {
   std::string str;
   llvm::raw_string_ostream stream(str);
-  for (const Argument &arg : args)
+  // Go through our args and if we are not emitting for diagnostics *OR* we are
+  // emitting for diagnostics and this argument is not intended to be emitted as
+  // a diagnostic separate from our main remark, emit the arg value here.
+  for (const Argument &arg : args) {
+    if (arg.key.kind.isSeparateDiagnostic())
+      continue;
     stream << arg.val;
+  }
+
   return stream.str();
 }
 
@@ -194,9 +205,27 @@ static void emitRemark(SILModule &module, const Remark<RemarkT> &remark,
     return;
   if (auto *remarkStreamer = module.getSILRemarkStreamer())
     remarkStreamer->emit(remark);
-  if (diagEnabled)
-    module.getASTContext().Diags.diagnose(remark.getLocation(), id,
-                                          remark.getMsg());
+
+  // If diagnostics are enabled, first emit the main diagnostic and then loop
+  // through our arguments and allow the arguments to add additional diagnostics
+  // if they want.
+  if (diagEnabled) {
+    auto &Diags = module.getASTContext().Diags;
+    Diags.diagnose(remark.getLocation(), id,
+                   remark.getMsg());
+    for (auto &arg : remark.getArgs()) {
+      switch (arg.key.kind) {
+      case ArgumentKeyKind::Default:
+        continue;
+      case ArgumentKeyKind::Note:
+        Diags.diagnose(arg.loc, diag::opt_remark_note,
+                       arg.key.data);
+        continue;
+      }
+
+      llvm_unreachable("Unhandled case?!");
+    }
+  }
 }
 
 void Emitter::emit(const RemarkPassed &remark) {