143 changes: 46 additions & 97 deletions llvm/lib/Remarks/RemarkParser.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,69 +20,7 @@
using namespace llvm;
using namespace llvm::remarks;

static std::unique_ptr<ParserImpl> formatToParserImpl(Format ParserFormat,
StringRef Buf) {
switch (ParserFormat) {
case Format::YAML:
return llvm::make_unique<YAMLParserImpl>(Buf);
case Format::Unknown:
llvm_unreachable("Unhandled llvm::remarks::ParserFormat enum");
return nullptr;
};
}

static std::unique_ptr<ParserImpl>
formatToParserImpl(Format ParserFormat, StringRef Buf,
const ParsedStringTable &StrTab) {
switch (ParserFormat) {
case Format::YAML:
return llvm::make_unique<YAMLParserImpl>(Buf, &StrTab);
case Format::Unknown:
llvm_unreachable("Unhandled llvm::remarks::ParserFormat enum");
return nullptr;
};
}

Parser::Parser(Format ParserFormat, StringRef Buf)
: Impl(formatToParserImpl(ParserFormat, Buf)) {}

Parser::Parser(Format ParserFormat, StringRef Buf,
const ParsedStringTable &StrTab)
: Impl(formatToParserImpl(ParserFormat, Buf, StrTab)) {}

Parser::~Parser() = default;

static Expected<const Remark *> getNextYAML(YAMLParserImpl &Impl) {
YAMLRemarkParser &YAMLParser = Impl.YAMLParser;
// Check for EOF.
if (Impl.YAMLIt == Impl.YAMLParser.Stream.end())
return nullptr;

auto CurrentIt = Impl.YAMLIt;

// 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);
}

// Move on.
++Impl.YAMLIt;

// Return the just-parsed remark.
if (const Optional<YAMLRemarkParser::ParseState> &State = YAMLParser.State)
return &State->TheRemark;
else
return createStringError(std::make_error_code(std::errc::invalid_argument),
"unexpected error while parsing.");
}

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.");
}
char EndOfFileError::ID = 0;

ParsedStringTable::ParsedStringTable(StringRef InBuffer) : Buffer(InBuffer) {
while (!InBuffer.empty()) {
Expand All @@ -109,59 +47,70 @@ Expected<StringRef> ParsedStringTable::operator[](size_t Index) const {
return StringRef(Buffer.data() + Offset, NextOffset - Offset - 1);
}

Expected<std::unique_ptr<Parser>>
llvm::remarks::createRemarkParser(Format ParserFormat, StringRef Buf,
Optional<const ParsedStringTable *> StrTab) {
switch (ParserFormat) {
case Format::YAML:
return llvm::make_unique<YAMLRemarkParser>(Buf, StrTab);
case Format::Unknown:
return createStringError(std::make_error_code(std::errc::invalid_argument),
"Unknown remark parser format.");
}
}

// Wrapper that holds the state needed to interact with the C API.
struct CParser {
std::unique_ptr<Parser> TheParser;
Optional<std::string> Err;

CParser(Format ParserFormat, StringRef Buf,
Optional<const ParsedStringTable *> StrTab = None)
: TheParser(cantFail(createRemarkParser(ParserFormat, Buf, StrTab))) {}

void handleError(Error E) { Err.emplace(toString(std::move(E))); }
bool hasError() const { return Err.hasValue(); }
const char *getMessage() const { return Err ? Err->c_str() : nullptr; };
};

// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(remarks::Parser, LLVMRemarkParserRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(CParser, LLVMRemarkParserRef)

extern "C" LLVMRemarkParserRef LLVMRemarkParserCreateYAML(const void *Buf,
uint64_t Size) {
return wrap(new remarks::Parser(
remarks::Format::YAML, StringRef(static_cast<const char *>(Buf), Size)));
}

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'));
},
[&](const ErrorInfoBase &EIB) { EIB.log(Impl.YAMLParser.ErrorStream); });
Impl.HasErrors = true;
return wrap(new CParser(Format::YAML,
StringRef(static_cast<const char *>(Buf), Size)));
}

extern "C" LLVMRemarkEntryRef
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.");
CParser &TheCParser = *unwrap(Parser);
remarks::Parser &TheParser = *TheCParser.TheParser;

Expected<std::unique_ptr<Remark>> MaybeRemark = TheParser.next();
if (Error E = MaybeRemark.takeError()) {
if (E.isA<EndOfFileError>()) {
consumeError(std::move(E));
return nullptr;
}

// Handle the error. Allow it to be checked through HasError and
// GetErrorMessage.
TheCParser.handleError(std::move(E));
return nullptr;
}

if (*RemarkOrErr == nullptr)
return nullptr;
// Valid remark.
return wrap(*RemarkOrErr);
return wrap(MaybeRemark->release());
}

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)->hasError();
}

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)->getMessage();
}

extern "C" void LLVMRemarkParserDispose(LLVMRemarkParserRef Parser) {
Expand Down
33 changes: 0 additions & 33 deletions llvm/lib/Remarks/RemarkParserImpl.h
View file

This file was deleted.

429 changes: 241 additions & 188 deletions llvm/lib/Remarks/YAMLRemarkParser.cpp
View file

Large diffs are not rendered by default.

130 changes: 43 additions & 87 deletions llvm/lib/Remarks/YAMLRemarkParser.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,6 @@
#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"
Expand All @@ -27,112 +26,69 @@

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 string table used for parsing strings.
Optional<const ParsedStringTable *> StrTab;
/// 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 TheRemark;

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,
Optional<const ParsedStringTable *> StrTab = None)
: SM(), Stream(Buf, SM), ErrorString(), ErrorStream(ErrorString),
TmpArgs(), StrTab(StrTab) {
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) {}
YAMLParseError(StringRef Message, SourceMgr &SM, yaml::Stream &Stream,
yaml::Node &Node);

YAMLParseError(StringRef Message) : Message(Message) {}

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;
std::string Message;
};

/// Regular YAML to Remark parser.
struct YAMLParserImpl : public ParserImpl {
/// The object parsing the YAML.
YAMLRemarkParser YAMLParser;
struct YAMLRemarkParser : public Parser {
/// The string table used for parsing strings.
Optional<const ParsedStringTable *> StrTab;
/// Last error message that can come from the YAML parser diagnostics.
/// We need this for catching errors in the constructor.
std::string LastErrorMessage;
/// Source manager for better error messages.
SourceMgr SM;
/// Stream for yaml parsing.
yaml::Stream Stream;
/// 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,
Optional<const ParsedStringTable *> StrTab = None)
: ParserImpl{Format::YAML}, YAMLParser(Buf, StrTab),
YAMLIt(YAMLParser.Stream.begin()), HasErrors(false) {}
YAMLRemarkParser(StringRef Buf,
Optional<const ParsedStringTable *> StrTab = None);

Expected<std::unique_ptr<Remark>> next() override;

static bool classof(const ParserImpl *PI) {
return PI->ParserFormat == Format::YAML;
static bool classof(const Parser *P) {
return P->ParserFormat == Format::YAML;
}

private:
/// Create a YAMLParseError error from an existing error generated by the YAML
/// parser.
/// If there is no error, this returns Success.
Error error();
/// Create a YAMLParseError error referencing a specific node.
Error error(StringRef Message, yaml::Node &Node);
/// Parse a YAML remark to a remarks::Remark object.
Expected<std::unique_ptr<Remark>> parseRemark(yaml::Document &Remark);
/// Parse the type of a remark to an enum type.
Expected<Type> parseType(yaml::MappingNode &Node);
/// Parse one key to a string.
Expected<StringRef> parseKey(yaml::KeyValueNode &Node);
/// Parse one value to a string.
Expected<StringRef> parseStr(yaml::KeyValueNode &Node);
/// Parse one value to an unsigned.
Expected<unsigned> parseUnsigned(yaml::KeyValueNode &Node);
/// Parse a debug location.
Expected<RemarkLocation> parseDebugLoc(yaml::KeyValueNode &Node);
/// Parse an argument.
Expected<Argument> parseArg(yaml::Node &Node);
};
} // end namespace remarks
} // end namespace llvm
Expand Down
26 changes: 19 additions & 7 deletions llvm/tools/llvm-opt-report/OptReport.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -150,20 +150,32 @@ static bool readLocationInfo(LocationInfoTy &LocationInfo) {
return false;
}

remarks::Parser Parser(remarks::Format::YAML, (*Buf)->getBuffer());
Expected<std::unique_ptr<remarks::Parser>> MaybeParser =
remarks::createRemarkParser(remarks::Format::YAML, (*Buf)->getBuffer());
if (!MaybeParser) {
handleAllErrors(MaybeParser.takeError(), [&](const ErrorInfoBase &PE) {
PE.log(WithColor::error());
});
return false;
}
remarks::Parser &Parser = **MaybeParser;

while (true) {
Expected<const remarks::Remark *> RemarkOrErr = Parser.getNext();
if (!RemarkOrErr) {
handleAllErrors(RemarkOrErr.takeError(), [&](const ErrorInfoBase &PE) {
Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
if (!MaybeRemark) {
Error E = MaybeRemark.takeError();
if (E.isA<remarks::EndOfFileError>()) {
// EOF.
consumeError(std::move(E));
break;
}
handleAllErrors(MaybeRemark.takeError(), [&](const ErrorInfoBase &PE) {
PE.log(WithColor::error());
});
return false;
}
if (!*RemarkOrErr) // End of file.
break;

const remarks::Remark &Remark = **RemarkOrErr;
const remarks::Remark &Remark = **MaybeRemark;

bool Transformed = Remark.RemarkType == remarks::Type::Passed;

Expand Down
1 change: 1 addition & 0 deletions llvm/tools/remarks-shlib/Remarks.exports
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@ LLVMRemarkDebugLocGetSourceColumn
LLVMRemarkArgGetKey
LLVMRemarkArgGetValue
LLVMRemarkArgGetDebugLoc
LLVMRemarkEntryDispose
LLVMRemarkEntryGetType
LLVMRemarkEntryGetPassName
LLVMRemarkEntryGetRemarkName
Expand Down
103 changes: 62 additions & 41 deletions llvm/unittests/Remarks/YAMLRemarksParsingTest.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,20 +14,31 @@
using namespace llvm;

template <size_t N> void parseGood(const char (&Buf)[N]) {
remarks::Parser Parser(remarks::Format::YAML, {Buf, N - 1});
Expected<const remarks::Remark *> Remark = Parser.getNext();
Expected<std::unique_ptr<remarks::Parser>> MaybeParser =
remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
EXPECT_TRUE(*MaybeParser != nullptr);

remarks::Parser &Parser = **MaybeParser;
Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
EXPECT_TRUE(*Remark != nullptr); // At least one remark.
Remark = Parser.getNext();
EXPECT_FALSE(errorToBool(Remark.takeError())); // Check for parsing errors.
EXPECT_TRUE(*Remark == nullptr); // Check that there are no more remarks.
Remark = Parser.next();
Error E = Remark.takeError();
EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
}

template <size_t N>
bool parseExpectError(const char (&Buf)[N], const char *Error) {
remarks::Parser Parser(remarks::Format::YAML, {Buf, N - 1});
Expected<const remarks::Remark *> Remark = Parser.getNext();
EXPECT_FALSE(Remark); // Expect an error here.
Expected<std::unique_ptr<remarks::Parser>> MaybeParser =
remarks::createRemarkParser(remarks::Format::YAML, {Buf, N - 1});
EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
EXPECT_TRUE(*MaybeParser != nullptr);

remarks::Parser &Parser = **MaybeParser;
Expected<std::unique_ptr<remarks::Remark>> Remark = Parser.next();
EXPECT_FALSE(Remark); // Check for parsing errors.

std::string ErrorStr;
raw_string_ostream Stream(ErrorStr);
Expand All @@ -42,7 +53,7 @@ TEST(YAMLRemarks, ParsingEmpty) {

TEST(YAMLRemarks, ParsingNotYAML) {
EXPECT_TRUE(
parseExpectError("\x01\x02\x03\x04\x05\x06", "not a valid YAML file."));
parseExpectError("\x01\x02\x03\x04\x05\x06", "Got empty plain scalar"));
}

TEST(YAMLRemarks, ParsingGood) {
Expand Down Expand Up @@ -309,17 +320,6 @@ TEST(YAMLRemarks, ParsingWrongArgs) {
"",
"only one string entry is allowed per argument."));
// No arg value.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
"Name: NoDefinition\n"
"Function: foo\n"
"Args:\n"
" - Callee: ''\n"
" - DebugLoc: { File: a, Line: 1, Column: 2 }\n"
"",
"argument value is missing."));
// No arg value.
EXPECT_TRUE(parseExpectError("\n"
"--- !Missed\n"
"Pass: inline\n"
Expand Down Expand Up @@ -354,12 +354,18 @@ TEST(YAMLRemarks, Contents) {
" - String: ' because its definition is unavailable'\n"
"\n";

remarks::Parser Parser(remarks::Format::YAML, Buf);
Expected<const remarks::Remark *> RemarkOrErr = Parser.getNext();
EXPECT_FALSE(errorToBool(RemarkOrErr.takeError()));
EXPECT_TRUE(*RemarkOrErr != nullptr);
Expected<std::unique_ptr<remarks::Parser>> MaybeParser =
remarks::createRemarkParser(remarks::Format::YAML, Buf);
EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
EXPECT_TRUE(*MaybeParser != nullptr);

remarks::Parser &Parser = **MaybeParser;
Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
EXPECT_FALSE(
errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.

const remarks::Remark &Remark = **RemarkOrErr;
const remarks::Remark &Remark = **MaybeRemark;
EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
Expand Down Expand Up @@ -408,9 +414,10 @@ TEST(YAMLRemarks, Contents) {
++ArgID;
}

RemarkOrErr = Parser.getNext();
EXPECT_FALSE(errorToBool(RemarkOrErr.takeError()));
EXPECT_EQ(*RemarkOrErr, nullptr);
MaybeRemark = Parser.next();
Error E = MaybeRemark.takeError();
EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
}

static inline StringRef checkStr(LLVMRemarkStringRef Str,
Expand Down Expand Up @@ -487,6 +494,8 @@ TEST(YAMLRemarks, ContentsCAPI) {
++ArgID;
} while ((Arg = LLVMRemarkEntryGetNextArg(Arg, Remark)));

LLVMRemarkEntryDispose(Remark);

EXPECT_EQ(LLVMRemarkParserGetNext(Parser), nullptr);

EXPECT_FALSE(LLVMRemarkParserHasError(Parser));
Expand Down Expand Up @@ -516,12 +525,18 @@ TEST(YAMLRemarks, ContentsStrTab) {
115);

remarks::ParsedStringTable StrTab(StrTabBuf);
remarks::Parser Parser(remarks::Format::YAML, Buf, StrTab);
Expected<const remarks::Remark *> RemarkOrErr = Parser.getNext();
EXPECT_FALSE(errorToBool(RemarkOrErr.takeError()));
EXPECT_TRUE(*RemarkOrErr != nullptr);

const remarks::Remark &Remark = **RemarkOrErr;
Expected<std::unique_ptr<remarks::Parser>> MaybeParser =
remarks::createRemarkParser(remarks::Format::YAML, Buf, &StrTab);
EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
EXPECT_TRUE(*MaybeParser != nullptr);

remarks::Parser &Parser = **MaybeParser;
Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
EXPECT_FALSE(
errorToBool(MaybeRemark.takeError())); // Check for parsing errors.
EXPECT_TRUE(*MaybeRemark != nullptr); // At least one remark.

const remarks::Remark &Remark = **MaybeRemark;
EXPECT_EQ(Remark.RemarkType, remarks::Type::Missed);
EXPECT_EQ(checkStr(Remark.PassName, 6), "inline");
EXPECT_EQ(checkStr(Remark.RemarkName, 12), "NoDefinition");
Expand Down Expand Up @@ -570,9 +585,10 @@ TEST(YAMLRemarks, ContentsStrTab) {
++ArgID;
}

RemarkOrErr = Parser.getNext();
EXPECT_FALSE(errorToBool(RemarkOrErr.takeError()));
EXPECT_EQ(*RemarkOrErr, nullptr);
MaybeRemark = Parser.next();
Error E = MaybeRemark.takeError();
EXPECT_TRUE(E.isA<remarks::EndOfFileError>());
EXPECT_TRUE(errorToBool(std::move(E))); // Check for parsing errors.
}

TEST(YAMLRemarks, ParsingBadStringTableIndex) {
Expand All @@ -584,13 +600,18 @@ TEST(YAMLRemarks, ParsingBadStringTableIndex) {
StringRef StrTabBuf = StringRef("inline");

remarks::ParsedStringTable StrTab(StrTabBuf);
remarks::Parser Parser(remarks::Format::YAML, Buf, StrTab);
Expected<const remarks::Remark *> Remark = Parser.getNext();
EXPECT_FALSE(Remark); // Expect an error here.
Expected<std::unique_ptr<remarks::Parser>> MaybeParser =
remarks::createRemarkParser(remarks::Format::YAML, Buf, &StrTab);
EXPECT_FALSE(errorToBool(MaybeParser.takeError()));
EXPECT_TRUE(*MaybeParser != nullptr);

remarks::Parser &Parser = **MaybeParser;
Expected<std::unique_ptr<remarks::Remark>> MaybeRemark = Parser.next();
EXPECT_FALSE(MaybeRemark); // Expect an error here.

std::string ErrorStr;
raw_string_ostream Stream(ErrorStr);
handleAllErrors(Remark.takeError(),
handleAllErrors(MaybeRemark.takeError(),
[&](const ErrorInfoBase &EIB) { EIB.log(Stream); });
EXPECT_TRUE(
StringRef(Stream.str())
Expand Down