Revert "[Remarks] Add a new Remark / RemarkParser abstraction"

This reverts commit 51dc6a8c84cd6a58562e320e1828a0158dbbf750.

Breaks
http://lab.llvm.org:8011/builders/clang-cmake-x86_64-sde-avx512-linux/builds/20034/steps/build%20stage%201/logs/stdio.

llvm-svn: 356492

6 files changed, 317 insertions, 622 deletions

diff --git a/llvm/lib/Remarks/CMakeLists.txt b/llvm/lib/Remarks/CMakeLists.txt
index 2ab7e8476a1..83713d66a60 100644
--- a/llvm/lib/Remarks/CMakeLists.txt
+++ b/llvm/lib/Remarks/CMakeLists.txt
@@ -1,5 +1,3 @@
 add_llvm_library(LLVMRemarks
-  Remark.cpp
   RemarkParser.cpp
-  YAMLRemarkParser.cpp
 )
diff --git a/llvm/lib/Remarks/Remark.cpp b/llvm/lib/Remarks/Remark.cpp
deleted file mode 100644
index b4be19f47a5..00000000000
--- a/llvm/lib/Remarks/Remark.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//===- 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-c/Remarks.h"
-#include "llvm/Support/CBindingWrapping.h"
-#include "llvm/Support/raw_ostream.h"
-
-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();
-}
-
-// 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) {
-  return unwrap(String)->size();
-}
-
-extern "C" LLVMRemarkStringRef
-LLVMRemarkDebugLocGetSourceFilePath(LLVMRemarkDebugLocRef DL) {
-  return wrap(&unwrap(DL)->SourceFilePath);
-}
-
-extern "C" uint32_t LLVMRemarkDebugLocGetSourceLine(LLVMRemarkDebugLocRef DL) {
-  return unwrap(DL)->SourceLine;
-}
-
-extern "C" uint32_t
-LLVMRemarkDebugLocGetSourceColumn(LLVMRemarkDebugLocRef DL) {
-  return unwrap(DL)->SourceColumn;
-}
-
-extern "C" LLVMRemarkStringRef LLVMRemarkArgGetKey(LLVMRemarkArgRef Arg) {
-  return wrap(&unwrap(Arg)->Key);
-}
-
-extern "C" LLVMRemarkStringRef LLVMRemarkArgGetValue(LLVMRemarkArgRef Arg) {
-  return wrap(&unwrap(Arg)->Val);
-}
-
-extern "C" LLVMRemarkDebugLocRef
-LLVMRemarkArgGetDebugLoc(LLVMRemarkArgRef Arg) {
-  if (const Optional<RemarkLocation> &Loc = unwrap(Arg)->Loc)
-    return wrap(&*Loc);
-  return nullptr;
-}
-
-extern "C" LLVMRemarkType LLVMRemarkEntryGetType(LLVMRemarkEntryRef Remark) {
-  // Assume here that the enums can be converted both ways.
-  return static_cast<LLVMRemarkType>(unwrap(Remark)->RemarkType);
-}
-
-extern "C" LLVMRemarkStringRef
-LLVMRemarkEntryGetPassName(LLVMRemarkEntryRef Remark) {
-  return wrap(&unwrap(Remark)->PassName);
-}
-
-extern "C" LLVMRemarkStringRef
-LLVMRemarkEntryGetRemarkName(LLVMRemarkEntryRef Remark) {
-  return wrap(&unwrap(Remark)->RemarkName);
-}
-
-extern "C" LLVMRemarkStringRef
-LLVMRemarkEntryGetFunctionName(LLVMRemarkEntryRef Remark) {
-  return wrap(&unwrap(Remark)->FunctionName);
-}
-
-extern "C" LLVMRemarkDebugLocRef
-LLVMRemarkEntryGetDebugLoc(LLVMRemarkEntryRef Remark) {
-  if (const Optional<RemarkLocation> &Loc = unwrap(Remark)->Loc)
-    return wrap(&*Loc);
-  return nullptr;
-}
-
-extern "C" uint64_t LLVMRemarkEntryGetHotness(LLVMRemarkEntryRef Remark) {
-  if (const Optional<uint64_t> &Hotness = unwrap(Remark)->Hotness)
-    return *Hotness;
-  return 0;
-}
-
-extern "C" uint32_t LLVMRemarkEntryGetNumArgs(LLVMRemarkEntryRef Remark) {
-  return unwrap(Remark)->Args.size();
-}
-
-extern "C" LLVMRemarkArgRef
-LLVMRemarkEntryGetFirstArg(LLVMRemarkEntryRef Remark) {
-  ArrayRef<Argument> Args = unwrap(Remark)->Args;
-  // No arguments to iterate on.
-  if (Args.empty())
-    return NULL;
-  return reinterpret_cast<LLVMRemarkArgRef>(
-      const_cast<Argument *>(Args.begin()));
-}
-
-extern "C" LLVMRemarkArgRef
-LLVMRemarkEntryGetNextArg(LLVMRemarkArgRef ArgIt, LLVMRemarkEntryRef Remark) {
-  // No more arguments to iterate on.
-  if (ArgIt == NULL)
-    return NULL;
-
-  auto It = (ArrayRef<Argument>::const_iterator)ArgIt;
-  auto Next = std::next(It);
-  if (Next == unwrap(Remark)->Args.end())
-    return NULL;
-
-  return reinterpret_cast<LLVMRemarkArgRef>(const_cast<Argument *>(Next));
-}
diff --git a/llvm/lib/Remarks/RemarkParser.cpp b/llvm/lib/Remarks/RemarkParser.cpp
index a303b36c0ad..204b8002884 100644
--- a/llvm/lib/Remarks/RemarkParser.cpp
+++ b/llvm/lib/Remarks/RemarkParser.cpp
@@ -11,104 +11,355 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Remarks/RemarkParser.h"
-#include "YAMLRemarkParser.h"
 #include "llvm-c/Remarks.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/CBindingWrapping.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/YAMLTraits.h"
 
 using namespace llvm;
-using namespace llvm::remarks;
 
-Parser::Parser(StringRef Buf) : Impl(llvm::make_unique<YAMLParserImpl>(Buf)) {}
+namespace {
+struct YAMLRemarkParser {
+  /// Source manager for better error messages.
+  SourceMgr SM;
+  /// Stream for yaml parsing.
+  yaml::Stream Stream;
+  /// Storage for the error stream.
+  std::string ErrorString;
+  /// The error stream.
+  raw_string_ostream ErrorStream;
+  /// Iterator in the YAML stream.
+  yaml::document_iterator DI;
+  /// The parsed remark (if any).
+  Optional<LLVMRemarkEntry> LastRemark;
+  /// Temporary parsing buffer for the arguments.
+  SmallVector<LLVMRemarkArg, 8> TmpArgs;
+  /// The state used by the parser to parse a remark entry. Invalidated with
+  /// every call to `parseYAMLElement`.
+  struct ParseState {
+    /// Temporary parsing buffer for the arguments.
+    SmallVectorImpl<LLVMRemarkArg> *Args;
+    StringRef Type;
+    StringRef Pass;
+    StringRef Name;
+    StringRef Function;
+    /// Optional.
+    Optional<StringRef> File;
+    Optional<unsigned> Line;
+    Optional<unsigned> Column;
+    Optional<unsigned> Hotness;
 
-Parser::~Parser() = default;
+    ParseState(SmallVectorImpl<LLVMRemarkArg> &Args) : Args(&Args) {}
+    /// Use Args only as a **temporary** buffer.
+    ~ParseState() { Args->clear(); }
+  };
 
-static Expected<const Remark *> getNextYAML(YAMLParserImpl &Impl) {
-  YAMLRemarkParser &YAMLParser = Impl.YAMLParser;
-  // Check for EOF.
-  if (Impl.YAMLIt == Impl.YAMLParser.Stream.end())
-    return nullptr;
+  ParseState State;
 
-  auto CurrentIt = Impl.YAMLIt;
+  /// Set to `true` if we had any errors during parsing.
+  bool HadAnyErrors = false;
 
-  // Try to parse an entry.
-  if (Error E = YAMLParser.parseYAMLElement(*CurrentIt)) {
-    // Set the iterator to the end, in case the user calls getNext again.
-    Impl.YAMLIt = Impl.YAMLParser.Stream.end();
-    return std::move(E);
+  YAMLRemarkParser(StringRef Buf)
+      : SM(), Stream(Buf, SM), ErrorString(), ErrorStream(ErrorString),
+        DI(Stream.begin()), LastRemark(), TmpArgs(), State(TmpArgs) {
+    SM.setDiagHandler(YAMLRemarkParser::HandleDiagnostic, this);
   }
 
-  // Move on.
-  ++Impl.YAMLIt;
+  /// Parse a YAML element.
+  Error parseYAMLElement(yaml::Document &Remark);
 
-  // Return the just-parsed remark.
-  if (const Optional<YAMLRemarkParser::ParseState> &State = YAMLParser.State)
-    return &State->Remark;
-  else
-    return createStringError(std::make_error_code(std::errc::invalid_argument),
-                             "unexpected error while parsing.");
+private:
+  /// Parse one key to a string.
+  /// otherwise.
+  Error parseKey(StringRef &Result, yaml::KeyValueNode &Node);
+  /// Parse one value to a string.
+  Error parseValue(StringRef &Result, yaml::KeyValueNode &Node);
+  /// Parse one value to an unsigned.
+  Error parseValue(Optional<unsigned> &Result, yaml::KeyValueNode &Node);
+  /// Parse a debug location.
+  Error parseDebugLoc(Optional<StringRef> &File, Optional<unsigned> &Line,
+                      Optional<unsigned> &Column, yaml::KeyValueNode &Node);
+  /// Parse an argument.
+  Error parseArg(SmallVectorImpl<LLVMRemarkArg> &TmpArgs, yaml::Node &Node);
+
+  /// Handle a diagnostic from the YAML stream. Records the error in the
+  /// YAMLRemarkParser class.
+  static void HandleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {
+    assert(Ctx && "Expected non-null Ctx in diagnostic handler.");
+    auto *Parser = static_cast<YAMLRemarkParser *>(Ctx);
+    Diag.print(/*ProgName=*/nullptr, Parser->ErrorStream, /*ShowColors*/ false,
+               /*ShowKindLabels*/ true);
+  }
+};
+
+class ParseError : public ErrorInfo<ParseError> {
+public:
+  static char ID;
+
+  ParseError(StringRef Message, yaml::Node &Node)
+      : Message(Message), Node(Node) {}
+
+  void log(raw_ostream &OS) const override { OS << Message; }
+  std::error_code convertToErrorCode() const override {
+    return inconvertibleErrorCode();
+  }
+
+  StringRef getMessage() const { return Message; }
+  yaml::Node &getNode() const { return Node; }
+
+private:
+  StringRef Message; // No need to hold a full copy of the buffer.
+  yaml::Node &Node;
+};
+
+char ParseError::ID = 0;
+
+static LLVMRemarkStringRef toRemarkStr(StringRef Str) {
+  return {Str.data(), static_cast<uint32_t>(Str.size())};
+}
+
+Error YAMLRemarkParser::parseKey(StringRef &Result, yaml::KeyValueNode &Node) {
+  auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey());
+  if (!Key)
+    return make_error<ParseError>("key is not a string.", Node);
+
+  Result = Key->getRawValue();
+  return Error::success();
 }
 
-Expected<const Remark *> Parser::getNext() const {
-  if (auto *Impl = dyn_cast<YAMLParserImpl>(this->Impl.get()))
-    return getNextYAML(*Impl);
-  llvm_unreachable("Get next called with an unknown parsing implementation.");
+Error YAMLRemarkParser::parseValue(StringRef &Result,
+                                   yaml::KeyValueNode &Node) {
+  auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
+  if (!Value)
+    return make_error<ParseError>("expected a value of scalar type.", Node);
+  Result = Value->getRawValue();
+
+  if (Result.front() == '\'')
+    Result = Result.drop_front();
+
+  if (Result.back() == '\'')
+    Result = Result.drop_back();
+
+  return Error::success();
 }
 
-// Create wrappers for C Binding types (see CBindingWrapping.h).
-DEFINE_SIMPLE_CONVERSION_FUNCTIONS(remarks::Parser, LLVMRemarkParserRef)
+Error YAMLRemarkParser::parseValue(Optional<unsigned> &Result,
+                                   yaml::KeyValueNode &Node) {
+  SmallVector<char, 4> Tmp;
+  auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
+  if (!Value)
+    return make_error<ParseError>("expected a value of scalar type.", Node);
+  unsigned UnsignedValue = 0;
+  if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
+    return make_error<ParseError>("expected a value of integer type.", *Value);
+  Result = UnsignedValue;
+  return Error::success();
+}
 
-extern "C" LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
-                                                          uint64_t Size) {
-  return wrap(
-      new remarks::Parser(StringRef(static_cast<const char *>(Buf), Size)));
+Error YAMLRemarkParser::parseDebugLoc(Optional<StringRef> &File,
+                                      Optional<unsigned> &Line,
+                                      Optional<unsigned> &Column,
+                                      yaml::KeyValueNode &Node) {
+  auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
+  if (!DebugLoc)
+    return make_error<ParseError>("expected a value of mapping type.", Node);
+
+  for (yaml::KeyValueNode &DLNode : *DebugLoc) {
+    StringRef KeyName;
+    if (Error E = parseKey(KeyName, DLNode))
+      return E;
+    if (KeyName == "File") {
+      File = StringRef(); // Set the optional to contain a default constructed
+                          // value, to be passed to the parsing function.
+      if (Error E = parseValue(*File, DLNode))
+        return E;
+    } else if (KeyName == "Column") {
+      if (Error E = parseValue(Column, DLNode))
+        return E;
+    } else if (KeyName == "Line") {
+      if (Error E = parseValue(Line, DLNode))
+        return E;
+    } else {
+      return make_error<ParseError>("unknown entry in DebugLoc map.", DLNode);
+    }
+  }
+
+  // If any of the debug loc fields is missing, return an error.
+  if (!File || !Line || !Column)
+    return make_error<ParseError>("DebugLoc node incomplete.", Node);
+
+  return Error::success();
+}
+
+Error YAMLRemarkParser::parseArg(SmallVectorImpl<LLVMRemarkArg> &Args,
+                                 yaml::Node &Node) {
+  auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
+  if (!ArgMap)
+    return make_error<ParseError>("expected a value of mapping type.", Node);
+
+  StringRef ValueStr;
+  StringRef KeyStr;
+  Optional<StringRef> File;
+  Optional<unsigned> Line;
+  Optional<unsigned> Column;
+
+  for (yaml::KeyValueNode &ArgEntry : *ArgMap) {
+    StringRef KeyName;
+    if (Error E = parseKey(KeyName, ArgEntry))
+      return E;
+
+    // Try to parse debug locs.
+    if (KeyName == "DebugLoc") {
+      // Can't have multiple DebugLoc entries per argument.
+      if (File || Line || Column)
+        return make_error<ParseError>(
+            "only one DebugLoc entry is allowed per argument.", ArgEntry);
+
+      if (Error E = parseDebugLoc(File, Line, Column, ArgEntry))
+        return E;
+      continue;
+    }
+
+    // If we already have a string, error out.
+    if (!ValueStr.empty())
+      return make_error<ParseError>(
+          "only one string entry is allowed per argument.", ArgEntry);
+
+    // Try to parse a string.
+    if (Error E = parseValue(ValueStr, ArgEntry))
+      return E;
+
+    // Keep the key from the string.
+    KeyStr = KeyName;
+  }
+
+  if (KeyStr.empty())
+    return make_error<ParseError>("argument key is missing.", *ArgMap);
+  if (ValueStr.empty())
+    return make_error<ParseError>("argument value is missing.", *ArgMap);
+
+  Args.push_back(LLVMRemarkArg{
+      toRemarkStr(KeyStr), toRemarkStr(ValueStr),
+      LLVMRemarkDebugLoc{toRemarkStr(File.getValueOr(StringRef())),
+                         Line.getValueOr(0), Column.getValueOr(0)}});
+
+  return Error::success();
+}
+
+Error YAMLRemarkParser::parseYAMLElement(yaml::Document &Remark) {
+  // Parsing a new remark, clear the previous one.
+  LastRemark = None;
+  State = ParseState(TmpArgs);
+
+  auto *Root = dyn_cast<yaml::MappingNode>(Remark.getRoot());
+  if (!Root)
+    return make_error<ParseError>("document root is not of mapping type.",
+                                  *Remark.getRoot());
+
+  State.Type = Root->getRawTag();
+
+  for (yaml::KeyValueNode &RemarkField : *Root) {
+    StringRef KeyName;
+    if (Error E = parseKey(KeyName, RemarkField))
+      return E;
+
+    if (KeyName == "Pass") {
+      if (Error E = parseValue(State.Pass, RemarkField))
+        return E;
+    } else if (KeyName == "Name") {
+      if (Error E = parseValue(State.Name, RemarkField))
+        return E;
+    } else if (KeyName == "Function") {
+      if (Error E = parseValue(State.Function, RemarkField))
+        return E;
+    } else if (KeyName == "Hotness") {
+      if (Error E = parseValue(State.Hotness, RemarkField))
+        return E;
+    } else if (KeyName == "DebugLoc") {
+      if (Error E =
+              parseDebugLoc(State.File, State.Line, State.Column, RemarkField))
+        return E;
+    } else if (KeyName == "Args") {
+      auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());
+      if (!Args)
+        return make_error<ParseError>("wrong value type for key.", RemarkField);
+
+      for (yaml::Node &Arg : *Args)
+        if (Error E = parseArg(*State.Args, Arg))
+          return E;
+    } else {
+      return make_error<ParseError>("unknown key.", RemarkField);
+    }
+  }
+
+  // If the YAML parsing failed, don't even continue parsing. We might
+  // encounter malformed YAML.
+  if (Stream.failed())
+    return make_error<ParseError>("YAML parsing failed.", *Remark.getRoot());
+
+  // Check if any of the mandatory fields are missing.
+  if (State.Type.empty() || State.Pass.empty() || State.Name.empty() ||
+      State.Function.empty())
+    return make_error<ParseError>("Type, Pass, Name or Function missing.",
+                                  *Remark.getRoot());
+
+  LastRemark = LLVMRemarkEntry{
+      toRemarkStr(State.Type),
+      toRemarkStr(State.Pass),
+      toRemarkStr(State.Name),
+      toRemarkStr(State.Function),
+      LLVMRemarkDebugLoc{toRemarkStr(State.File.getValueOr(StringRef())),
+                         State.Line.getValueOr(0), State.Column.getValueOr(0)},
+      State.Hotness.getValueOr(0),
+      static_cast<uint32_t>(State.Args->size()),
+      State.Args->data()};
+
+  return Error::success();
 }
+} // namespace
+
+// Create wrappers for C Binding types (see CBindingWrapping.h).
+DEFINE_SIMPLE_CONVERSION_FUNCTIONS(YAMLRemarkParser, LLVMRemarkParserRef)
 
-static void handleYAMLError(remarks::YAMLParserImpl &Impl, Error E) {
-  handleAllErrors(
-      std::move(E),
-      [&](const YAMLParseError &PE) {
-        Impl.YAMLParser.Stream.printError(&PE.getNode(),
-                                          Twine(PE.getMessage()) + Twine('\n'));
-        Impl.HasErrors = true;
-      },
-      [&](const StringError &PE) { PE.log(Impl.YAMLParser.ErrorStream); });
+extern "C" LLVMRemarkParserRef LLVMRemarkParserCreate(const void *Buf,
+                                                      uint64_t Size) {
+  return wrap(
+      new YAMLRemarkParser(StringRef(static_cast<const char *>(Buf), Size)));
 }
 
-extern "C" LLVMRemarkEntryRef
+extern "C" LLVMRemarkEntry *
 LLVMRemarkParserGetNext(LLVMRemarkParserRef Parser) {
-  remarks::Parser &TheParser = *unwrap(Parser);
-
-  Expected<const remarks::Remark *> RemarkOrErr = TheParser.getNext();
-  if (!RemarkOrErr) {
-    // Error during parsing.
-    if (auto *Impl = dyn_cast<remarks::YAMLParserImpl>(TheParser.Impl.get()))
-      handleYAMLError(*Impl, RemarkOrErr.takeError());
-    else
-      llvm_unreachable("unkown parser implementation.");
+  YAMLRemarkParser &TheParser = *unwrap(Parser);
+  // Check for EOF.
+  if (TheParser.HadAnyErrors || TheParser.DI == TheParser.Stream.end())
     return nullptr;
-  }
 
-  if (*RemarkOrErr == nullptr)
+  // Try to parse an entry.
+  if (Error E = TheParser.parseYAMLElement(*TheParser.DI)) {
+    handleAllErrors(std::move(E), [&](const ParseError &PE) {
+      TheParser.Stream.printError(&PE.getNode(),
+                                  Twine(PE.getMessage()) + Twine('\n'));
+      TheParser.HadAnyErrors = true;
+    });
     return nullptr;
-  // Valid remark.
-  return wrap(*RemarkOrErr);
+  }
+
+  // Move on.
+  ++TheParser.DI;
+
+  // Return the just-parsed remark.
+  if (Optional<LLVMRemarkEntry> &Entry = TheParser.LastRemark)
+    return &*Entry;
+  return nullptr;
 }
 
 extern "C" LLVMBool LLVMRemarkParserHasError(LLVMRemarkParserRef Parser) {
-  if (auto *Impl =
-          dyn_cast<remarks::YAMLParserImpl>(unwrap(Parser)->Impl.get()))
-    return Impl->HasErrors;
-  llvm_unreachable("unkown parser implementation.");
+  return unwrap(Parser)->HadAnyErrors;
 }
 
 extern "C" const char *
 LLVMRemarkParserGetErrorMessage(LLVMRemarkParserRef Parser) {
-  if (auto *Impl =
-          dyn_cast<remarks::YAMLParserImpl>(unwrap(Parser)->Impl.get()))
-    return Impl->YAMLParser.ErrorStream.str().c_str();
-  llvm_unreachable("unkown parser implementation.");
+  return unwrap(Parser)->ErrorStream.str().c_str();
 }
 
 extern "C" void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser) {
diff --git a/llvm/lib/Remarks/RemarkParserImpl.h b/llvm/lib/Remarks/RemarkParserImpl.h
deleted file mode 100644
index f812f495a17..00000000000
--- a/llvm/lib/Remarks/RemarkParserImpl.h
+++ /dev/null
@@ -1,29 +0,0 @@
-//===-- RemarkParserImpl.h - Implementation details -------------*- C++/-*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides implementation details for the remark parser.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_REMARKS_REMARK_PARSER_IMPL_H
-#define LLVM_REMARKS_REMARK_PARSER_IMPL_H
-
-namespace llvm {
-namespace remarks {
-/// This is used as a base for any parser implementation.
-struct ParserImpl {
-  enum class Kind { YAML };
-
-  // The parser kind. This is used as a tag to safely cast between
-  // implementations.
-  enum Kind Kind;
-};
-} // end namespace remarks
-} // end namespace llvm
-
-#endif /* LLVM_REMARKS_REMARK_PARSER_IMPL_H */
diff --git a/llvm/lib/Remarks/YAMLRemarkParser.cpp b/llvm/lib/Remarks/YAMLRemarkParser.cpp
deleted file mode 100644
index 3091c80629d..00000000000
--- a/llvm/lib/Remarks/YAMLRemarkParser.cpp
+++ /dev/null
@@ -1,261 +0,0 @@
-//===- YAMLRemarkParser.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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides utility methods used by clients that want to use the
-// parser for remark diagnostics in LLVM.
-//
-//===----------------------------------------------------------------------===//
-
-#include "YAMLRemarkParser.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Remarks/RemarkParser.h"
-
-using namespace llvm;
-using namespace llvm::remarks;
-
-char YAMLParseError::ID = 0;
-
-Error YAMLRemarkParser::parseKey(StringRef &Result, yaml::KeyValueNode &Node) {
-  if (auto *Key = dyn_cast<yaml::ScalarNode>(Node.getKey())) {
-    Result = Key->getRawValue();
-    return Error::success();
-  }
-
-  return make_error<YAMLParseError>("key is not a string.", Node);
-}
-
-template <typename T>
-Error YAMLRemarkParser::parseStr(T &Result, yaml::KeyValueNode &Node) {
-  auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
-  if (!Value)
-    return make_error<YAMLParseError>("expected a value of scalar type.", Node);
-  StringRef Tmp = Value->getRawValue();
-
-  if (Tmp.front() == '\'')
-    Tmp = Tmp.drop_front();
-
-  if (Tmp.back() == '\'')
-    Tmp = Tmp.drop_back();
-
-  Result = Tmp;
-
-  return Error::success();
-}
-
-template <typename T>
-Error YAMLRemarkParser::parseUnsigned(T &Result, yaml::KeyValueNode &Node) {
-  SmallVector<char, 4> Tmp;
-  auto *Value = dyn_cast<yaml::ScalarNode>(Node.getValue());
-  if (!Value)
-    return make_error<YAMLParseError>("expected a value of scalar type.", Node);
-  unsigned UnsignedValue = 0;
-  if (Value->getValue(Tmp).getAsInteger(10, UnsignedValue))
-    return make_error<YAMLParseError>("expected a value of integer type.",
-                                      *Value);
-  Result = UnsignedValue;
-  return Error::success();
-}
-
-Error YAMLRemarkParser::parseType(Type &Result, yaml::MappingNode &Node) {
-  auto Type = StringSwitch<remarks::Type>(Node.getRawTag())
-                  .Case("!Passed", Type::Passed)
-                  .Case("!Missed", Type::Missed)
-                  .Case("!Analysis", Type::Analysis)
-                  .Case("!AnalysisFPCommute", Type::AnalysisFPCommute)
-                  .Case("!AnalysisAliasing", Type::AnalysisAliasing)
-                  .Case("!Failure", Type::Failure)
-                  .Default(Type::Unknown);
-  if (Type == Type::Unknown)
-    return make_error<YAMLParseError>("expected a remark tag.", Node);
-  Result = Type;
-  return Error::success();
-}
-
-Error YAMLRemarkParser::parseDebugLoc(Optional<RemarkLocation> &Result,
-                                      yaml::KeyValueNode &Node) {
-  auto *DebugLoc = dyn_cast<yaml::MappingNode>(Node.getValue());
-  if (!DebugLoc)
-    return make_error<YAMLParseError>("expected a value of mapping type.",
-                                      Node);
-
-  Optional<StringRef> File;
-  Optional<unsigned> Line;
-  Optional<unsigned> Column;
-
-  for (yaml::KeyValueNode &DLNode : *DebugLoc) {
-    StringRef KeyName;
-    if (Error E = parseKey(KeyName, DLNode))
-      return E;
-    if (KeyName == "File") {
-      if (Error E = parseStr(File, DLNode))
-        return E;
-    } else if (KeyName == "Column") {
-      if (Error E = parseUnsigned(Column, DLNode))
-        return E;
-    } else if (KeyName == "Line") {
-      if (Error E = parseUnsigned(Line, DLNode))
-        return E;
-    } else {
-      return make_error<YAMLParseError>("unknown entry in DebugLoc map.",
-                                        DLNode);
-    }
-  }
-
-  // If any of the debug loc fields is missing, return an error.
-  if (!File || !Line || !Column)
-    return make_error<YAMLParseError>("DebugLoc node incomplete.", Node);
-
-  Result = RemarkLocation{*File, *Line, *Column};
-
-  return Error::success();
-}
-
-Error YAMLRemarkParser::parseRemarkField(yaml::KeyValueNode &RemarkField) {
-
-  StringRef KeyName;
-  if (Error E = parseKey(KeyName, RemarkField))
-    return E;
-
-  if (KeyName == "Pass") {
-    if (Error E = parseStr(State->Remark.PassName, RemarkField))
-      return E;
-  } else if (KeyName == "Name") {
-    if (Error E = parseStr(State->Remark.RemarkName, RemarkField))
-      return E;
-  } else if (KeyName == "Function") {
-    if (Error E = parseStr(State->Remark.FunctionName, RemarkField))
-      return E;
-  } else if (KeyName == "Hotness") {
-    State->Remark.Hotness = 0;
-    if (Error E = parseUnsigned(*State->Remark.Hotness, RemarkField))
-      return E;
-  } else if (KeyName == "DebugLoc") {
-    if (Error E = parseDebugLoc(State->Remark.Loc, RemarkField))
-      return E;
-  } else if (KeyName == "Args") {
-    auto *Args = dyn_cast<yaml::SequenceNode>(RemarkField.getValue());
-    if (!Args)
-      return make_error<YAMLParseError>("wrong value type for key.",
-                                        RemarkField);
-
-    for (yaml::Node &Arg : *Args)
-      if (Error E = parseArg(State->Args, Arg))
-        return E;
-
-    State->Remark.Args = State->Args;
-  } else {
-    return make_error<YAMLParseError>("unknown key.", RemarkField);
-  }
-
-  return Error::success();
-}
-
-Error YAMLRemarkParser::parseArg(SmallVectorImpl<Argument> &Args,
-                                 yaml::Node &Node) {
-  auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
-  if (!ArgMap)
-    return make_error<YAMLParseError>("expected a value of mapping type.",
-                                      Node);
-
-  StringRef KeyStr;
-  StringRef ValueStr;
-  Optional<RemarkLocation> Loc;
-
-  for (yaml::KeyValueNode &ArgEntry : *ArgMap)
-    if (Error E = parseArgEntry(ArgEntry, KeyStr, ValueStr, Loc))
-      return E;
-
-  if (KeyStr.empty())
-    return make_error<YAMLParseError>("argument key is missing.", *ArgMap);
-  if (ValueStr.empty())
-    return make_error<YAMLParseError>("argument value is missing.", *ArgMap);
-
-  Args.push_back(Argument{KeyStr, ValueStr, Loc});
-
-  return Error::success();
-}
-
-Error YAMLRemarkParser::parseArgEntry(yaml::KeyValueNode &ArgEntry,
-                                      StringRef &KeyStr, StringRef &ValueStr,
-                                      Optional<RemarkLocation> &Loc) {
-  StringRef KeyName;
-  if (Error E = parseKey(KeyName, ArgEntry))
-    return E;
-
-  // Try to parse debug locs.
-  if (KeyName == "DebugLoc") {
-    // Can't have multiple DebugLoc entries per argument.
-    if (Loc)
-      return make_error<YAMLParseError>(
-          "only one DebugLoc entry is allowed per argument.", ArgEntry);
-
-    if (Error E = parseDebugLoc(Loc, ArgEntry))
-      return E;
-    return Error::success();
-  }
-
-  // If we already have a string, error out.
-  if (!ValueStr.empty())
-    return make_error<YAMLParseError>(
-        "only one string entry is allowed per argument.", ArgEntry);
-
-  // Try to parse a string.
-  if (Error E = parseStr(ValueStr, ArgEntry))
-    return E;
-
-  // Keep the key from the string.
-  KeyStr = KeyName;
-  return Error::success();
-}
-
-Error YAMLRemarkParser::parseYAMLElement(yaml::Document &Remark) {
-  // Parsing a new remark, clear the previous one by re-constructing the state
-  // in-place in the Optional.
-  State.emplace(TmpArgs);
-
-  yaml::Node *YAMLRoot = Remark.getRoot();
-  if (!YAMLRoot)
-    return createStringError(std::make_error_code(std::errc::invalid_argument),
-                             "not a valid YAML file.");
-
-  auto *Root = dyn_cast<yaml::MappingNode>(YAMLRoot);
-  if (!Root)
-    return make_error<YAMLParseError>("document root is not of mapping type.",
-                                      *YAMLRoot);
-
-  if (Error E = parseType(State->Remark.RemarkType, *Root))
-    return E;
-
-  for (yaml::KeyValueNode &RemarkField : *Root)
-    if (Error E = parseRemarkField(RemarkField))
-      return E;
-
-  // If the YAML parsing failed, don't even continue parsing. We might
-  // encounter malformed YAML.
-  if (Stream.failed())
-    return make_error<YAMLParseError>("YAML parsing failed.",
-                                      *Remark.getRoot());
-
-  // Check if any of the mandatory fields are missing.
-  if (State->Remark.RemarkType == Type::Unknown ||
-      State->Remark.PassName.empty() || State->Remark.RemarkName.empty() ||
-      State->Remark.FunctionName.empty())
-    return make_error<YAMLParseError>("Type, Pass, Name or Function missing.",
-                                      *Remark.getRoot());
-
-  return Error::success();
-}
-
-/// Handle a diagnostic from the YAML stream. Records the error in the
-/// YAMLRemarkParser class.
-void YAMLRemarkParser::HandleDiagnostic(const SMDiagnostic &Diag, void *Ctx) {
-  assert(Ctx && "Expected non-null Ctx in diagnostic handler.");
-  auto *Parser = static_cast<YAMLRemarkParser *>(Ctx);
-  Diag.print(/*ProgName=*/nullptr, Parser->ErrorStream, /*ShowColors*/ false,
-             /*ShowKindLabels*/ true);
-}
diff --git a/llvm/lib/Remarks/YAMLRemarkParser.h b/llvm/lib/Remarks/YAMLRemarkParser.h
deleted file mode 100644
index 1eb5706bfd4..00000000000
--- a/llvm/lib/Remarks/YAMLRemarkParser.h
+++ /dev/null
@@ -1,136 +0,0 @@
-//===-- YAMLRemarkParser.h - Parser for YAML remarks ------------*- C++/-*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the impementation of the YAML remark parser.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_REMARKS_YAML_REMARK_PARSER_H
-#define LLVM_REMARKS_YAML_REMARK_PARSER_H
-
-#include "RemarkParserImpl.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Remarks/Remark.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/YAMLParser.h"
-#include "llvm/Support/YAMLTraits.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string>
-
-namespace llvm {
-namespace remarks {
-/// Parses and holds the state of the latest parsed remark.
-struct YAMLRemarkParser {
-  /// Source manager for better error messages.
-  SourceMgr SM;
-  /// Stream for yaml parsing.
-  yaml::Stream Stream;
-  /// Storage for the error stream.
-  std::string ErrorString;
-  /// The error stream.
-  raw_string_ostream ErrorStream;
-  /// Temporary parsing buffer for the arguments.
-  SmallVector<Argument, 8> TmpArgs;
-
-  /// The state used by the parser to parse a remark entry. Invalidated with
-  /// every call to `parseYAMLElement`.
-  struct ParseState {
-    /// Temporary parsing buffer for the arguments.
-    /// The parser itself is owning this buffer in order to reduce the number of
-    /// allocations.
-    SmallVectorImpl<Argument> &Args;
-    Remark Remark;
-
-    ParseState(SmallVectorImpl<Argument> &Args) : Args(Args) {}
-    /// Use Args only as a **temporary** buffer.
-    ~ParseState() { Args.clear(); }
-  };
-
-  /// The current state of the parser. If the parsing didn't start yet, it will
-  /// not be containing any value.
-  Optional<ParseState> State;
-
-  YAMLRemarkParser(StringRef Buf)
-      : SM(), Stream(Buf, SM), ErrorString(), ErrorStream(ErrorString),
-        TmpArgs() {
-    SM.setDiagHandler(YAMLRemarkParser::HandleDiagnostic, this);
-  }
-
-  /// Parse a YAML element.
-  Error parseYAMLElement(yaml::Document &Remark);
-
-private:
-  /// Parse one key to a string.
-  /// otherwise.
-  Error parseKey(StringRef &Result, yaml::KeyValueNode &Node);
-  /// Parse one value to a string.
-  template <typename T> Error parseStr(T &Result, yaml::KeyValueNode &Node);
-  /// Parse one value to an unsigned.
-  template <typename T>
-  Error parseUnsigned(T &Result, yaml::KeyValueNode &Node);
-  /// Parse the type of a remark to an enum type.
-  Error parseType(Type &Result, yaml::MappingNode &Node);
-  /// Parse a debug location.
-  Error parseDebugLoc(Optional<RemarkLocation> &Result,
-                      yaml::KeyValueNode &Node);
-  /// Parse a remark field and update the parsing state.
-  Error parseRemarkField(yaml::KeyValueNode &RemarkField);
-  /// Parse an argument.
-  Error parseArg(SmallVectorImpl<Argument> &TmpArgs, yaml::Node &Node);
-  /// Parse an entry from the contents of an argument.
-  Error parseArgEntry(yaml::KeyValueNode &ArgEntry, StringRef &KeyStr,
-                      StringRef &ValueStr, Optional<RemarkLocation> &Loc);
-
-  /// Handle a diagnostic from the YAML stream. Records the error in the
-  /// YAMLRemarkParser class.
-  static void HandleDiagnostic(const SMDiagnostic &Diag, void *Ctx);
-};
-
-class YAMLParseError : public ErrorInfo<YAMLParseError> {
-public:
-  static char ID;
-
-  YAMLParseError(StringRef Message, yaml::Node &Node)
-      : Message(Message), Node(Node) {}
-
-  void log(raw_ostream &OS) const override { OS << Message; }
-  std::error_code convertToErrorCode() const override {
-    return inconvertibleErrorCode();
-  }
-
-  StringRef getMessage() const { return Message; }
-  yaml::Node &getNode() const { return Node; }
-
-private:
-  StringRef Message; // No need to hold a full copy of the buffer.
-  yaml::Node &Node;
-};
-
-/// Regular YAML to Remark parser.
-struct YAMLParserImpl : public ParserImpl {
-  /// The object parsing the YAML.
-  YAMLRemarkParser YAMLParser;
-  /// Iterator in the YAML stream.
-  yaml::document_iterator YAMLIt;
-  /// Set to `true` if we had any errors during parsing.
-  bool HasErrors = false;
-
-  YAMLParserImpl(StringRef Buf)
-      : ParserImpl{ParserImpl::Kind::YAML}, YAMLParser(Buf),
-        YAMLIt(YAMLParser.Stream.begin()), HasErrors(false) {}
-
-  static bool classof(const ParserImpl *PI) {
-    return PI->Kind == ParserImpl::Kind::YAML;
-  }
-};
-} // end namespace remarks
-} // end namespace llvm
-
-#endif /* LLVM_REMARKS_YAML_REMARK_PARSER_H */