[Error] Add source location to cantFail

[hintonda]

Summary

Add llvm_cantFail macro, a drop in replacement for llvm::cantFail,
that adds source location, similar to assert, for !NDEBUG builds.

Refactor to extract error handling code and place it and new annotated
versions of cantFail that are called by the new macro in a detail
namespace, and change all instances in llvm to use the new macro.

[hintonda]

• Replace macro magic with matching 3-parameter template functions.

[lhames]

Hi Don,

This is a great idea!

I think it would actually be reasonable to have 'cantFail' be the macro though, and move the existing functions (which become an implementation detail) into a detail namespace: We want cantFail to be succinct as part of its value is clarifying flow when we know (from the surrounding context) that errors will not be generated.

[hintonda]

• Replace macro magic with matching 3-parameter template functions.
• Refactor cantFail move into detail namespace. Change macro name to

[hintonda]

• Add back original llvm::cantFail signatures so they'll still be

[hintonda]

Append "_annotated" suffix to detail functions.
Add "llvm_" prefix to macros.
Revert changes to all non-llvm project files.
Update calls in llvm to use new macro.

[hintonda]

@lhames, I think I've applied all your verbal changes, but please let me
know if I missed anything.

Essentially, previous behavior is maintained, but users can opt-in to the
new behavior, adding file and line numbers, by switching to the new macro.
I also updated all of llvm, but excluded other projects for the time being.
Most of them use llvm::cantFail, and could be updated as needed via a
script, e.g., something like this would do it:

find clang -type f \( -name "*.cpp" -o -name "*.h" \) -exec grep -l "cantFail" \{\} \; | xargs sed -i.bak 's/llvm::cantFail/llvm_cantFail/'

clang-tools-extra/clangd/index/Serialization.cpp

void finalize(llvm::raw_ostream &OS) {
 
     std::string RawTable;
     for (llvm::StringRef S : Sorted) {
       RawTable.append(S);
       RawTable.push_back(0);
     }
     if (llvm::zlib::isAvailable()) {
       llvm::SmallString<1> Compressed;
-      llvm::cantFail(llvm::zlib::compress(RawTable, Compressed));
+      cantFail(llvm::zlib::compress(RawTable, Compressed));
       write32(RawTable.size(), OS);
       OS << Compressed;
     } else {
       write32(0, OS); // No compression.
       OS << RawTable;
     }
   }
   // Get the ID of an string, which must be interned. Table must be finalized.

clang-tools-extra/clangd/refactor/tweaks/ExpandMacro.cpp

if (!Replacement.empty()) {
     Replacement.pop_back();
   }
 
   CharSourceRange MacroRange =
       CharSourceRange::getCharRange(Expansion.Spelled.front().location(),
                                     Expansion.Spelled.back().endLocation());
 
   tooling::Replacements Reps;
-  llvm::cantFail(Reps.add(tooling::Replacement(SM, MacroRange, Replacement)));
+  cantFail(Reps.add(tooling::Replacement(SM, MacroRange, Replacement)));
   return Effect::mainFileEdit(SM, std::move(Reps));
 }
 
 std::string ExpandMacro::title() const {
   return llvm::formatv("Expand macro '{0}'", MacroName);
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

if (!IndexSymbols.empty()) {
     assert(!Opts.Index && "both Index and IndexSymbols given!");
     OverrideIndex = memIndex(std::move(IndexSymbols));
     Opts.Index = OverrideIndex.get();
   }
 
   auto File = testPath("foo.cpp");
   runAddDocument(Server, File, TestCode);
   auto CompletionList =
-      llvm::cantFail(runCodeComplete(Server, File, Point, Opts));
+      cantFail(runCodeComplete(Server, File, Point, Opts));
   return CompletionList;
 }
 
 CodeCompleteResult completions(ClangdServer &Server, llvm::StringRef Text,
                                std::vector<Symbol> IndexSymbols = {},
                                clangd::CodeCompleteOptions Opts = {},
                                PathRef FilePath = "foo.cpp") {
   std::unique_ptr<SymbolIndex> OverrideIndex;
   if (!IndexSymbols.empty()) {
     assert(!Opts.Index && "both Index and IndexSymbols given!");
     OverrideIndex = memIndex(std::move(IndexSymbols));
     Opts.Index = OverrideIndex.get();
   }
 
   auto File = testPath(FilePath);
   Annotations Test(Text);
   runAddDocument(Server, File, Test.code());
   auto CompletionList =
-      llvm::cantFail(runCodeComplete(Server, File, Test.point(), Opts));
+      cantFail(runCodeComplete(Server, File, Test.point(), Opts));
   return CompletionList;
 }
 
 // Builds a server and runs code completion.
 // If IndexSymbols is non-empty, an index will be built and passed to opts.
 CodeCompleteResult completions(llvm::StringRef Text,
                                std::vector<Symbol> IndexSymbols = {},
                                clangd::CodeCompleteOptions Opts = {},
SignatureHelp signatures(llvm::StringRef Text, Position Point,
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.StaticIndex = Index.get();
 
   ClangdServer Server(CDB, FS, DiagConsumer, Opts);
   auto File = testPath("foo.cpp");
   runAddDocument(Server, File, Text);
-  return llvm::cantFail(runSignatureHelp(Server, File, Point));
+  return cantFail(runSignatureHelp(Server, File, Point));
 }
 
 SignatureHelp signatures(llvm::StringRef Text,
                          std::vector<Symbol> IndexSymbols = {}) {
   Annotations Test(Text);
   return signatures(Test.code(), Test.point(), std::move(IndexSymbols));
 }
 
void test() {
       f.foo(^);
     }
   )cpp");
   auto File = testPath("test.cpp");
   Server.addDocument(File, FileContent.code());
   // Wait for the dynamic index being built.
   ASSERT_TRUE(Server.blockUntilIdleForTest());
   EXPECT_THAT(
-      llvm::cantFail(runSignatureHelp(Server, File, FileContent.point()))
+      cantFail(runSignatureHelp(Server, File, FileContent.point()))
           .signatures,
       ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Member doc"))));
 }
 
 TEST(CompletionTest, CompletionFunctionArgsDisabled) {
   CodeCompleteOptions Opts;
   Opts.EnableSnippets = true;
   Opts.EnableFunctionArgSnippets = false;

clang-tools-extra/clangd/unittests/FormatTests.cpp

 
 namespace clang {
 namespace clangd {
 namespace {
 
 std::string afterTyped(llvm::StringRef CodeWithCursor,
                            llvm::StringRef Typed) {
   Annotations Code(CodeWithCursor);
-  unsigned Cursor = llvm::cantFail(positionToOffset(Code.code(), Code.point()));
+  unsigned Cursor = cantFail(positionToOffset(Code.code(), Code.point()));
   auto Changes =
       formatIncremental(Code.code(), Cursor, Typed,
                         format::getGoogleStyle(format::FormatStyle::LK_Cpp));
   tooling::Replacements Merged;
   for (const auto& R : Changes)
     if (llvm::Error E = Merged.add(R))
       ADD_FAILURE() << llvm::toString(std::move(E));
   auto NewCode = tooling::applyAllReplacements(Code.code(), Merged);

clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp

const std::string FileContent = R"cpp(
     void foo() {};
   )cpp";
   FS.Files[CppPath] = FileContent;
   auto Options = ClangdServer::optsForTest();
   Options.BuildDynamicSymbolIndex = true;
   ClangdServer Server(CDB, FS, DiagConsumer, Options);
   runAddDocument(Server, CppPath, FileContent);
   EXPECT_EQ(HeaderPath,
-            *llvm::cantFail(runSwitchHeaderSource(Server, CppPath)));
+            *cantFail(runSwitchHeaderSource(Server, CppPath)));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/RenameTests.cpp

TEST(RenameTest, SingleFile) {
   for (const auto T : Tests) {
     Annotations Code(T);
     auto TU = TestTU::withCode(Code.code());
     auto AST = TU.build();
     llvm::StringRef NewName = "abcde";
     auto RenameResult =
         renameWithinFile(AST, testPath(TU.Filename), Code.point(), NewName);
     ASSERT_TRUE(bool(RenameResult)) << RenameResult.takeError();
-    auto ApplyResult = llvm::cantFail(
+    auto ApplyResult = cantFail(
         tooling::applyAllReplacements(Code.code(), *RenameResult));
     EXPECT_EQ(expectedResult(Code, NewName), ApplyResult);
   }
 }
 
 TEST(RenameTest, Renameable) {
   struct Case {
     const char *Code;
if (!WantRename) {
       EXPECT_FALSE(Results)
           << "expected renameWithinFile returned an error: " << T.code();
       auto ActualMessage = llvm::toString(Results.takeError());
       EXPECT_THAT(ActualMessage, testing::HasSubstr(Case.ErrorMessage));
     } else {
       EXPECT_TRUE(bool(Results)) << "renameWithinFile returned an error: "
                                  << llvm::toString(Results.takeError());
       auto ApplyResult =
-          llvm::cantFail(tooling::applyAllReplacements(T.code(), *Results));
+          cantFail(tooling::applyAllReplacements(T.code(), *Results));
       EXPECT_EQ(expectedResult(T, NewName), ApplyResult);
     }
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp

assert(std::is_sorted(
       Tokens.begin(), Tokens.end(),
       [](const HighlightingToken &L, const HighlightingToken &R) {
         return L.R.start < R.R.start;
       }));
 
   std::string Result;
   unsigned NextChar = 0;
   for (auto &T : Tokens) {
-    unsigned StartOffset = llvm::cantFail(positionToOffset(Input, T.R.start));
-    unsigned EndOffset = llvm::cantFail(positionToOffset(Input, T.R.end));
+    unsigned StartOffset = cantFail(positionToOffset(Input, T.R.start));
+    unsigned EndOffset = cantFail(positionToOffset(Input, T.R.end));
     assert(StartOffset <= EndOffset);
     assert(NextChar <= StartOffset);
 
     Result += Input.substr(NextChar, StartOffset - NextChar);
     Result += llvm::formatv("${0}[[{1}]]", T.Kind,
                             Input.substr(StartOffset, EndOffset - StartOffset));
     NextChar = EndOffset;
   }

clang-tools-extra/clangd/unittests/SemanticSelectionTests.cpp

const char *Tests[] = {
         }]]
       )cpp",
 
   };
 
   for (const char *Test : Tests) {
     auto T = Annotations(Test);
     auto AST = TestTU::withCode(T.code()).build();
-    EXPECT_THAT(llvm::cantFail(getSemanticRanges(AST, T.point())),
+    EXPECT_THAT(cantFail(getSemanticRanges(AST, T.point())),
                 ElementsAreArray(T.ranges()))
         << Test;
   }
 }
 
 TEST(SemanticSelection, RunViaClangDServer) {
   MockFSProvider FS;
   IgnoreDiagnostics DiagConsumer;

clang-tools-extra/clangd/unittests/SourceCodeTests.cpp

)cpp");
   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 1)), Failed());
   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 100)),
                        Failed());
   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(4, 1)), Failed());
   // Line number is too large.
   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(5, 0)), Failed());
   // Check all positions mentioned in the test return valid results.
   for (auto P : Source.points()) {
-    size_t Offset = llvm::cantFail(positionToOffset(Source.code(), P));
+    size_t Offset = cantFail(positionToOffset(Source.code(), P));
     EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, P),
                          HasValue(StartOfFile.getLocWithOffset(Offset)));
   }
 }
 
 TEST(SourceCodeTests, GetBeginningOfIdentifier) {
   std::string Preamble = R"cpp(
 struct Bar { int func(); };

clang-tools-extra/clangd/unittests/TweakTesting.cpp

return TweakIsAvailable(llvm::StringRef(TweakID), Context, Header, ExtraArgs,
                           ExtraFiles, Index.get());
 }
 
 std::vector<std::string> TweakTest::expandCases(llvm::StringRef MarkedCode) {
   Annotations Test(MarkedCode);
   llvm::StringRef Code = Test.code();
   std::vector<std::string> Cases;
   for (const auto& Point : Test.points()) {
-    size_t Offset = llvm::cantFail(positionToOffset(Code, Point));
+    size_t Offset = cantFail(positionToOffset(Code, Point));
     Cases.push_back((Code.substr(0, Offset) + "^" + Code.substr(Offset)).str());
   }
   for (const auto& Range : Test.ranges()) {
-    size_t Begin = llvm::cantFail(positionToOffset(Code, Range.start));
-    size_t End = llvm::cantFail(positionToOffset(Code, Range.end));
+    size_t Begin = cantFail(positionToOffset(Code, Range.start));
+    size_t End = cantFail(positionToOffset(Code, Range.end));
     Cases.push_back((Code.substr(0, Begin) + "[[" +
                      Code.substr(Begin, End - Begin) + "]]" + Code.substr(End))
                         .str());
   }
   assert(!Cases.empty() && "No markings in MarkedCode?");
   return Cases;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/XRefsTests.cpp

std::vector<llvm::StringRef> ExpectedDecls;
           {},
       },
   };
   for (const Case &C : Cases) {
     Annotations File(C.AnnotatedCode);
     auto AST = TestTU::withCode(File.code()).build();
     ASSERT_TRUE(AST.getDiagnostics().empty())
         << AST.getDiagnostics().begin()->Message;
-    SourceLocation SL = llvm::cantFail(
+    SourceLocation SL = cantFail(
         sourceLocationInMainFile(AST.getSourceManager(), File.point()));
 
     const FunctionDecl *FD =
         llvm::dyn_cast<FunctionDecl>(&findDecl(AST, [SL](const NamedDecl &ND) {
           return ND.getLocation() == SL && llvm::isa<FunctionDecl>(ND);
         }));
     ASSERT_NE(FD, nullptr);
 

clang/lib/AST/ExternalASTMerger.cpp

bool ExternalASTMerger::FindExternalVisibleDeclsByName(const DeclContext *DC,
   if (Candidates.empty())
     return false;
 
   Decls.reserve(Candidates.size());
   for (const Candidate &C : Candidates) {
     Decl *LookupRes = C.first.get();
     ASTImporter *Importer = C.second;
     auto NDOrErr = Importer->Import(LookupRes);
-    NamedDecl *ND = cast<NamedDecl>(llvm::cantFail(std::move(NDOrErr)));
+    NamedDecl *ND = cast<NamedDecl>(cantFail(std::move(NDOrErr)));
     assert(ND);
     // If we don't import specialization, they are not available via lookup
     // because the lookup result is imported TemplateDecl and it does not
     // reference its specializations until they are imported explicitly.
     bool IsSpecImportFailed =
         importSpecializationsIfNeeded(LookupRes, Importer);
     assert(!IsSpecImportFailed);
     (void)IsSpecImportFailed;

clang/lib/Tooling/Core/Replacement.cpp

calculateRangesAfterReplacements(const Replacements &Replaces,
   //     (unimportant) replacement text of length "length".
   //   - Merge with \p Replaces.
   //   - The new ranges will be the affected ranges of the merged replacements.
   auto MergedRanges = combineAndSortRanges(Ranges);
   if (Replaces.empty())
     return MergedRanges;
   tooling::Replacements FakeReplaces;
   for (const auto &R : MergedRanges) {
-    llvm::cantFail(
+    cantFail(
         FakeReplaces.add(Replacement(Replaces.begin()->getFilePath(),
                                      R.getOffset(), R.getLength(),
                                      std::string(R.getLength(), ' '))),
         "Replacements must not conflict since ranges have been merged.");
   }
   return FakeReplaces.merge(Replaces).getAffectedRanges();
 }
 

clang/lib/Tooling/Tooling.cpp

llvm::Expected<std::string> getAbsolutePath(llvm::vfs::FileSystem &FS,
   SmallString<1024> AbsolutePath = RelativePath;
   if (auto EC = FS.makeAbsolute(AbsolutePath))
     return llvm::errorCodeToError(EC);
   llvm::sys::path::native(AbsolutePath);
   return AbsolutePath.str();
 }
 
 std::string getAbsolutePath(StringRef File) {
-  return llvm::cantFail(getAbsolutePath(*llvm::vfs::getRealFileSystem(), File));
+  return cantFail(getAbsolutePath(*llvm::vfs::getRealFileSystem(), File));
 }
 
 void addTargetAndModeForProgramName(std::vector<std::string> &CommandLine,
                                     StringRef InvokedAs) {
   if (!CommandLine.empty() && !InvokedAs.empty()) {
     bool AlreadyHasTarget = false;
     bool AlreadyHasMode = false;
     // Skip CommandLine[0].

clang/tools/clang-refactor/ClangRefactor.cpp

public:
   ClangRefactorConsumer(AtomicChanges &Changes) : SourceChanges(&Changes) {}
 
   void handleError(llvm::Error Err) override {
     Optional<PartialDiagnosticAt> Diag = DiagnosticError::take(Err);
     if (!Diag) {
       llvm::errs() << llvm::toString(std::move(Err)) << "\n";
       return;
     }
-    llvm::cantFail(std::move(Err)); // This is a success.
+    cantFail(std::move(Err)); // This is a success.
     DiagnosticBuilder DB(
         getDiags().Report(Diag->first, Diag->second.getDiagID()));
     Diag->second.Emit(DB);
   }
 
   void handle(AtomicChanges Changes) override {
     SourceChanges->insert(SourceChanges->begin(), Changes.begin(),
                           Changes.end());

clang/unittests/Basic/DiagnosticTest.cpp

TEST(DiagnosticTest, diagnosticError) {
   PartialDiagnostic::StorageAllocator Alloc;
   llvm::Expected<std::pair<int, int>> Value = DiagnosticError::create(
       SourceLocation(), PartialDiagnostic(diag::err_cannot_open_file, Alloc)
                             << "file"
                             << "error");
   ASSERT_TRUE(!Value);
   llvm::Error Err = Value.takeError();
   Optional<PartialDiagnosticAt> ErrDiag = DiagnosticError::take(Err);
-  llvm::cantFail(std::move(Err));
+  cantFail(std::move(Err));
   ASSERT_FALSE(!ErrDiag);
   EXPECT_EQ(ErrDiag->first, SourceLocation());
   EXPECT_EQ(ErrDiag->second.getDiagID(), diag::err_cannot_open_file);
 
   Value = std::make_pair(20, 1);
   ASSERT_FALSE(!Value);
   EXPECT_EQ(*Value, std::make_pair(20, 1));
   EXPECT_EQ(Value->first, 20);
 }
 }

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Errno.h"
 
 #include <stdio.h>
 
 using namespace lldb_private;
 using namespace lldb;
 using namespace lldb_private::python;
-using llvm::cantFail;
 using llvm::Error;
 using llvm::Expected;
 using llvm::Twine;
 
 template <> Expected<bool> python::As<bool>(Expected<PythonObject> &&obj) {
   if (!obj)
     return obj.takeError();
   return obj.get().IsTrue();

lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp

static bool IsMainFile(llvm::StringRef main, llvm::StringRef other) {
 
   llvm::SmallString<64> normalized(other);
   llvm::sys::path::native(normalized);
   return main.equals_lower(normalized);
 }
 
 static void ParseCompile3(const CVSymbol &sym, CompilandIndexItem &cci) {
   cci.m_compile_opts.emplace();
-  llvm::cantFail(
+  cantFail(
       SymbolDeserializer::deserializeAs<Compile3Sym>(sym, *cci.m_compile_opts));
 }
 
 static void ParseObjname(const CVSymbol &sym, CompilandIndexItem &cci) {
   cci.m_obj_name.emplace();
-  llvm::cantFail(
+  cantFail(
       SymbolDeserializer::deserializeAs<ObjNameSym>(sym, *cci.m_obj_name));
 }
 
 static void ParseBuildInfo(PdbIndex &index, const CVSymbol &sym,
                            CompilandIndexItem &cci) {
   BuildInfoSym bis(SymbolRecordKind::BuildInfoSym);
-  llvm::cantFail(SymbolDeserializer::deserializeAs<BuildInfoSym>(sym, bis));
+  cantFail(SymbolDeserializer::deserializeAs<BuildInfoSym>(sym, bis));
 
   // S_BUILDINFO just points to an LF_BUILDINFO in the IPI stream.  Let's do
   // a little extra work to pull out the LF_BUILDINFO.
   LazyRandomTypeCollection &types = index.ipi().typeCollection();
   llvm::Optional<CVType> cvt = types.tryGetType(bis.BuildId);
 
   if (!cvt || cvt->kind() != LF_BUILDINFO)
     return;
 
   BuildInfoRecord bir;
-  llvm::cantFail(TypeDeserializer::deserializeAs<BuildInfoRecord>(*cvt, bir));
+  cantFail(TypeDeserializer::deserializeAs<BuildInfoRecord>(*cvt, bir));
   cci.m_build_info.assign(bir.ArgIndices.begin(), bir.ArgIndices.end());
 }
 
 static void ParseExtendedInfo(PdbIndex &index, CompilandIndexItem &item) {
   const CVSymbolArray &syms = item.m_debug_stream.getSymbolArray();
 
   // This is a private function, it shouldn't be called if the information
   // has already been parsed.
if (item.m_build_info.size() < 3)
     return {""};
 
   LazyRandomTypeCollection &types = m_index.ipi().typeCollection();
 
   StringIdRecord working_dir;
   StringIdRecord file_name;
   CVType dir_cvt = types.getType(item.m_build_info[0]);
   CVType file_cvt = types.getType(item.m_build_info[2]);
-  llvm::cantFail(
+  cantFail(
       TypeDeserializer::deserializeAs<StringIdRecord>(dir_cvt, working_dir));
-  llvm::cantFail(
+  cantFail(
       TypeDeserializer::deserializeAs<StringIdRecord>(file_cvt, file_name));
 
   llvm::sys::path::Style style = working_dir.String.startswith("/")
                                      ? llvm::sys::path::Style::posix
                                      : llvm::sys::path::Style::windows;
   if (llvm::sys::path::is_absolute(file_name.String, style))
     return file_name.String;
 
   llvm::SmallString<64> absolute_path = working_dir.String;
   llvm::sys::path::append(absolute_path, file_name.String);
   return absolute_path;
 }

lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp

if (ti.isSimple()) {
     SimpleTypeKind stk = ti.getSimpleKind();
     return {GetTypeSizeForSimpleKind(stk), IsSimpleTypeSignedInteger(stk)};
   }
 
   CVType cvt = tpi.getType(ti);
   switch (cvt.kind()) {
   case LF_MODIFIER: {
     ModifierRecord mfr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<ModifierRecord>(cvt, mfr));
+    cantFail(TypeDeserializer::deserializeAs<ModifierRecord>(cvt, mfr));
     return GetIntegralTypeInfo(mfr.ModifiedType, tpi);
   }
   case LF_POINTER: {
     PointerRecord pr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<PointerRecord>(cvt, pr));
+    cantFail(TypeDeserializer::deserializeAs<PointerRecord>(cvt, pr));
     return GetIntegralTypeInfo(pr.ReferentType, tpi);
   }
   case LF_ENUM: {
     EnumRecord er;
-    llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
     return GetIntegralTypeInfo(er.UnderlyingType, tpi);
   }
   default:
     assert(false && "Type is not integral!");
     return {0, false};
   }
 }
 

lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

static llvm::Optional<PublicSym32> FindPublicSym(const SegmentOffset &addr,
                                                  PublicsStream &publics) {
   llvm::FixedStreamArray<ulittle32_t> addr_map = publics.getAddressMap();
   auto iter = std::lower_bound(
       addr_map.begin(), addr_map.end(), addr,
       [&](const ulittle32_t &x, const SegmentOffset &y) {
         CVSymbol s1 = syms.readRecord(x);
         lldbassert(s1.kind() == S_PUB32);
         PublicSym32 p1;
-        llvm::cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(s1, p1));
+        cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(s1, p1));
         if (p1.Segment < y.segment)
           return true;
         return p1.Offset < y.offset;
       });
   if (iter == addr_map.end())
     return llvm::None;
   CVSymbol sym = syms.readRecord(*iter);
   lldbassert(sym.kind() == S_PUB32);
   PublicSym32 p;
-  llvm::cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(sym, p));
+  cantFail(SymbolDeserializer::deserializeAs<PublicSym32>(sym, p));
   if (p.Segment == addr.segment && p.Offset == addr.offset)
     return p;
   return llvm::None;
 }
 
 clang::Decl *PdbAstBuilder::GetOrCreateSymbolForId(PdbCompilandSymId id) {
   CVSymbol cvs = m_index.ReadSymbolRecord(id);
 
case PdbSymUidKind::GlobalSym: {
     CVSymbol global = m_index.ReadSymbolRecord(uid.asGlobalSym());
     switch (global.kind()) {
     case SymbolKind::S_GDATA32:
     case SymbolKind::S_LDATA32:
       return GetParentDeclContextForSymbol(global);
     case SymbolKind::S_PROCREF:
     case SymbolKind::S_LPROCREF: {
       ProcRefSym ref{global.kind()};
-      llvm::cantFail(
+      cantFail(
           SymbolDeserializer::deserializeAs<ProcRefSym>(global, ref));
       PdbCompilandSymId cu_sym_id{ref.modi(), ref.SymOffset};
       return GetParentDeclContext(cu_sym_id);
     }
     case SymbolKind::S_CONSTANT:
     case SymbolKind::S_UDT:
       return CreateDeclInfoForUndecoratedName(getSymbolName(global)).first;
     default:

 
 clang::TypedefNameDecl *
 PdbAstBuilder::GetOrCreateTypedefDecl(PdbGlobalSymId id) {
   if (clang::Decl *decl = TryGetDecl(id))
     return llvm::dyn_cast<clang::TypedefNameDecl>(decl);
 
   CVSymbol sym = m_index.ReadSymbolRecord(id);
   lldbassert(sym.kind() == S_UDT);
-  UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
+  UDTSym udt = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
 
   clang::DeclContext *scope = GetParentDeclContext(id);
 
   PdbTypeSymId real_type_id{udt.Type, false};
   clang::QualType qt = GetOrCreateType(real_type_id);
 
   std::string uname = DropNameScope(udt.Name);
 

 clang::QualType PdbAstBuilder::CreateType(PdbTypeSymId type) {
   if (type.index.isSimple())
     return CreateSimpleType(type.index);
 
   CVType cvt = m_index.tpi().getType(type.index);
 
   if (cvt.kind() == LF_MODIFIER) {
     ModifierRecord modifier;
-    llvm::cantFail(
+    cantFail(
         TypeDeserializer::deserializeAs<ModifierRecord>(cvt, modifier));
     return CreateModifierType(modifier);
   }
 
   if (cvt.kind() == LF_POINTER) {
     PointerRecord pointer;
-    llvm::cantFail(
+    cantFail(
         TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer));
     return CreatePointerType(pointer);
   }
 
   if (IsTagRecord(cvt)) {
     CVTagRecord tag = CVTagRecord::create(cvt);
     if (tag.kind() == CVTagRecord::Union)
       return CreateRecordType(type.index, tag.asUnion());
     if (tag.kind() == CVTagRecord::Enum)
       return CreateEnumType(type.index, tag.asEnum());
     return CreateRecordType(type.index, tag.asClass());
   }
 
   if (cvt.kind() == LF_ARRAY) {
     ArrayRecord ar;
-    llvm::cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
+    cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
     return CreateArrayType(ar);
   }
 
   if (cvt.kind() == LF_PROCEDURE) {
     ProcedureRecord pr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
+    cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
     return CreateFunctionType(pr.ArgumentList, pr.ReturnType, pr.CallConv);
   }
 
   if (cvt.kind() == LF_MFUNCTION) {
     MemberFunctionRecord mfr;
-    llvm::cantFail(
+    cantFail(
         TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
     return CreateFunctionType(mfr.ArgumentList, mfr.ReturnType, mfr.CallConv);
   }
 
   return {};
 }
 
 clang::QualType PdbAstBuilder::GetOrCreateType(PdbTypeSymId type) {
PdbAstBuilder::GetOrCreateFunctionDecl(PdbCompilandSymId func_id) {
   if (clang::NamespaceDecl *ns = llvm::dyn_cast<clang::NamespaceDecl>(parent)) {
     context_name = ns->getQualifiedNameAsString();
   } else if (clang::TagDecl *tag = llvm::dyn_cast<clang::TagDecl>(parent)) {
     context_name = tag->getQualifiedNameAsString();
   }
 
   CVSymbol cvs = m_index.ReadSymbolRecord(func_id);
   ProcSym proc(static_cast<SymbolRecordKind>(cvs.kind()));
-  llvm::cantFail(SymbolDeserializer::deserializeAs<ProcSym>(cvs, proc));
+  cantFail(SymbolDeserializer::deserializeAs<ProcSym>(cvs, proc));
 
   PdbTypeSymId type_id(proc.FunctionType);
   clang::QualType qt = GetOrCreateType(type_id);
   if (qt.isNull())
     return nullptr;
 
   clang::StorageClass storage = clang::SC_None;
   if (proc.Kind == SymbolRecordKind::ProcSym)

 }
 
 clang::QualType PdbAstBuilder::CreateFunctionType(
     TypeIndex args_type_idx, TypeIndex return_type_idx,
     llvm::codeview::CallingConvention calling_convention) {
   TpiStream &stream = m_index.tpi();
   CVType args_cvt = stream.getType(args_type_idx);
   ArgListRecord args;
-  llvm::cantFail(
+  cantFail(
       TypeDeserializer::deserializeAs<ArgListRecord>(args_cvt, args));
 
   llvm::ArrayRef<TypeIndex> arg_indices = llvm::makeArrayRef(args.ArgIndices);
   bool is_variadic = IsCVarArgsFunction(arg_indices);
   if (is_variadic)
     arg_indices = arg_indices.drop_back();
 
   std::vector<CompilerType> arg_types;

lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.cpp

 
 CVTagRecord CVTagRecord::create(CVType type) {
   assert(IsTagRecord(type) && "type is not a tag record!");
   switch (type.kind()) {
   case LF_CLASS:
   case LF_STRUCTURE:
   case LF_INTERFACE: {
     ClassRecord cr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(type, cr));
+    cantFail(TypeDeserializer::deserializeAs<ClassRecord>(type, cr));
     return CVTagRecord(std::move(cr));
   }
   case LF_UNION: {
     UnionRecord ur;
-    llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(type, ur));
+    cantFail(TypeDeserializer::deserializeAs<UnionRecord>(type, ur));
     return CVTagRecord(std::move(ur));
   }
   case LF_ENUM: {
     EnumRecord er;
-    llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(type, er));
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(type, er));
     return CVTagRecord(std::move(er));
   }
   default:
     llvm_unreachable("Unreachable!");
   }
 }
 
 CVTagRecord::CVTagRecord(ClassRecord &&c)

 bool lldb_private::npdb::IsForwardRefUdt(CVType cvt) {
   ClassRecord cr;
   UnionRecord ur;
   EnumRecord er;
   switch (cvt.kind()) {
   case LF_CLASS:
   case LF_STRUCTURE:
   case LF_INTERFACE:
-    llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, cr));
+    cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, cr));
     return cr.isForwardRef();
   case LF_UNION:
-    llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, ur));
+    cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, ur));
     return ur.isForwardRef();
   case LF_ENUM:
-    llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
     return er.isForwardRef();
   default:
     return false;
   }
 }
 
 bool lldb_private::npdb::IsTagRecord(llvm::codeview::CVType cvt) {
   switch (cvt.kind()) {
TypeIndex lldb_private::npdb::GetFieldListIndex(CVType cvt) {
   default:
     llvm_unreachable("Unreachable!");
   }
 }
 
 TypeIndex lldb_private::npdb::LookThroughModifierRecord(CVType modifier) {
   lldbassert(modifier.kind() == LF_MODIFIER);
   ModifierRecord mr;
-  llvm::cantFail(TypeDeserializer::deserializeAs<ModifierRecord>(modifier, mr));
+  cantFail(TypeDeserializer::deserializeAs<ModifierRecord>(modifier, mr));
   return mr.ModifiedType;
 }
 
 llvm::StringRef lldb_private::npdb::DropNameScope(llvm::StringRef name) {
   return MSVCUndecoratedNameParser::DropScope(name);
 }
 
 VariableInfo lldb_private::npdb::GetVariableNameInfo(CVSymbol sym) {
PdbTypeSymId lldb_private::npdb::GetBestPossibleDecl(PdbTypeSymId id,
   if (!IsTagRecord(cvt))
     return id;
 
   // Tag records that are not forward decls are full decls, hence they are the
   // best.
   if (!IsForwardRefUdt(cvt))
     return id;
 
-  return llvm::cantFail(tpi.findFullDeclForForwardRef(id.index));
+  return cantFail(tpi.findFullDeclForForwardRef(id.index));
 }
 
 template <typename RecordType> static size_t GetSizeOfTypeInternal(CVType cvt) {
   RecordType record;
-  llvm::cantFail(TypeDeserializer::deserializeAs<RecordType>(cvt, record));
+  cantFail(TypeDeserializer::deserializeAs<RecordType>(cvt, record));
   return record.getSize();
 }
 
 size_t lldb_private::npdb::GetSizeOfType(PdbTypeSymId id,
                                          llvm::pdb::TpiStream &tpi) {
   if (id.index.isSimple()) {
     switch (id.index.getSimpleMode()) {
     case SimpleTypeMode::Direct:
       return GetTypeSizeForSimpleKind(id.index.getSimpleKind());
     case SimpleTypeMode::NearPointer32:
     case SimpleTypeMode::FarPointer32:
       return 4;
     case SimpleTypeMode::NearPointer64:
       return 8;
     case SimpleTypeMode::NearPointer128:
       return 16;
     default:
       break;
     }
     return 0;
   }
 
   TypeIndex index = id.index;
   if (IsForwardRefUdt(index, tpi))
-    index = llvm::cantFail(tpi.findFullDeclForForwardRef(index));
+    index = cantFail(tpi.findFullDeclForForwardRef(index));
 
   CVType cvt = tpi.getType(index);
   switch (cvt.kind()) {
   case LF_MODIFIER:
     return GetSizeOfType({LookThroughModifierRecord(cvt)}, tpi);
   case LF_ENUM: {
     EnumRecord record;
-    llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, record));
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, record));
     return GetSizeOfType({record.UnderlyingType}, tpi);
   }
   case LF_POINTER:
     return GetSizeOfTypeInternal<PointerRecord>(cvt);
   case LF_ARRAY:
     return GetSizeOfTypeInternal<ArrayRecord>(cvt);
   case LF_CLASS:
   case LF_STRUCTURE:

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

TypeSP SymbolFileNativePDB::CreateType(PdbTypeSymId type_id, CompilerType ct) {
   if (type_id.index.isSimple())
     return CreateSimpleType(type_id.index, ct);
 
   TpiStream &stream = type_id.is_ipi ? m_index->ipi() : m_index->tpi();
   CVType cvt = stream.getType(type_id.index);
 
   if (cvt.kind() == LF_MODIFIER) {
     ModifierRecord modifier;
-    llvm::cantFail(
+    cantFail(
         TypeDeserializer::deserializeAs<ModifierRecord>(cvt, modifier));
     return CreateModifierType(type_id, modifier, ct);
   }
 
   if (cvt.kind() == LF_POINTER) {
     PointerRecord pointer;
-    llvm::cantFail(
+    cantFail(
         TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer));
     return CreatePointerType(type_id, pointer, ct);
   }
 
   if (IsClassRecord(cvt.kind())) {
     ClassRecord cr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, cr));
+    cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, cr));
     return CreateTagType(type_id, cr, ct);
   }
 
   if (cvt.kind() == LF_ENUM) {
     EnumRecord er;
-    llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
     return CreateTagType(type_id, er, ct);
   }
 
   if (cvt.kind() == LF_UNION) {
     UnionRecord ur;
-    llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, ur));
+    cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, ur));
     return CreateTagType(type_id, ur, ct);
   }
 
   if (cvt.kind() == LF_ARRAY) {
     ArrayRecord ar;
-    llvm::cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
+    cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
     return CreateArrayType(type_id, ar, ct);
   }
 
   if (cvt.kind() == LF_PROCEDURE) {
     ProcedureRecord pr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
+    cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
     return CreateProcedureType(type_id, pr, ct);
   }
   if (cvt.kind() == LF_MFUNCTION) {
     MemberFunctionRecord mfr;
-    llvm::cantFail(TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
+    cantFail(TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
     return CreateFunctionType(type_id, mfr, ct);
   }
 
   return nullptr;
 }
 
 TypeSP SymbolFileNativePDB::CreateAndCacheType(PdbTypeSymId type_id) {
   // If they search for a UDT which is a forward ref, try and resolve the full
VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbGlobalSymId var_id) {
   uint32_t offset = 0;
   bool is_external = false;
   switch (sym.kind()) {
   case S_GDATA32:
     is_external = true;
     LLVM_FALLTHROUGH;
   case S_LDATA32: {
     DataSym ds(sym.kind());
-    llvm::cantFail(SymbolDeserializer::deserializeAs<DataSym>(sym, ds));
+    cantFail(SymbolDeserializer::deserializeAs<DataSym>(sym, ds));
     ti = ds.Type;
     scope = (sym.kind() == S_GDATA32) ? eValueTypeVariableGlobal
                                       : eValueTypeVariableStatic;
     name = ds.Name;
     section = ds.Segment;
     offset = ds.DataOffset;
     addr = m_index->MakeVirtualAddress(ds.Segment, ds.DataOffset);
     break;
   }
   case S_GTHREAD32:
     is_external = true;
     LLVM_FALLTHROUGH;
   case S_LTHREAD32: {
     ThreadLocalDataSym tlds(sym.kind());
-    llvm::cantFail(
+    cantFail(
         SymbolDeserializer::deserializeAs<ThreadLocalDataSym>(sym, tlds));
     ti = tlds.Type;
     name = tlds.Name;
     section = tlds.Segment;
     offset = tlds.DataOffset;
     addr = m_index->MakeVirtualAddress(tlds.Segment, tlds.DataOffset);
     scope = eValueTypeVariableThreadLocal;
     break;

 }
 
 lldb::VariableSP
 SymbolFileNativePDB::CreateConstantSymbol(PdbGlobalSymId var_id,
                                           const CVSymbol &cvs) {
   TpiStream &tpi = m_index->tpi();
   ConstantSym constant(cvs.kind());
 
-  llvm::cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(cvs, constant));
+  cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(cvs, constant));
   std::string global_name("::");
   global_name += constant.Name;
   PdbTypeSymId tid(constant.Type, false);
   SymbolFileTypeSP type_sp =
       std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
 
   Declaration decl;
   Variable::RangeList ranges;
size_t SymbolFileNativePDB::ParseTypes(CompileUnit &comp_unit) {
 
   // Next look for S_UDT records in the globals stream.
   for (const uint32_t gid : m_index->globals().getGlobalsTable()) {
     PdbGlobalSymId global{gid, false};
     CVSymbol sym = m_index->ReadSymbolRecord(global);
     if (sym.kind() != S_UDT)
       continue;
 
-    UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
+    UDTSym udt = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
     bool is_typedef = true;
     if (IsTagRecord(PdbTypeSymId{udt.Type, false}, m_index->tpi())) {
       CVType cvt = m_index->tpi().getType(udt.Type);
       llvm::StringRef name = CVTagRecord::create(cvt).name();
       if (name == udt.Name)
         is_typedef = false;
     }
 
VariableSP SymbolFileNativePDB::GetOrCreateLocalVariable(
 
   return CreateLocalVariable(scope_id, var_id, is_param);
 }
 
 TypeSP SymbolFileNativePDB::CreateTypedef(PdbGlobalSymId id) {
   CVSymbol sym = m_index->ReadSymbolRecord(id);
   lldbassert(sym.kind() == SymbolKind::S_UDT);
 
-  UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
+  UDTSym udt = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
 
   TypeSP target_type = GetOrCreateType(udt.Type);
 
   (void)m_ast->GetOrCreateTypedefDecl(id);
 
   Declaration decl;
   return std::make_shared<lldb_private::Type>(
       toOpaqueUid(id), this, ConstString(udt.Name), target_type->GetByteSize(),

lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp

UdtRecordCompleter::UdtRecordCompleter(PdbTypeSymId id,
                                        clang::TagDecl &tag_decl,
                                        PdbAstBuilder &ast_builder,
                                        TpiStream &tpi)
     : m_id(id), m_derived_ct(derived_ct), m_tag_decl(tag_decl),
       m_ast_builder(ast_builder), m_tpi(tpi) {
   CVType cvt = m_tpi.getType(m_id.index);
   switch (cvt.kind()) {
   case LF_ENUM:
-    llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, m_cvr.er));
+    cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, m_cvr.er));
     break;
   case LF_UNION:
-    llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, m_cvr.ur));
+    cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, m_cvr.ur));
     break;
   case LF_CLASS:
   case LF_STRUCTURE:
-    llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, m_cvr.cr));
+    cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, m_cvr.cr));
     break;
   default:
     llvm_unreachable("unreachable!");
   }
 }
 
 clang::QualType UdtRecordCompleter::AddBaseClassForTypeIndex(
     llvm::codeview::TypeIndex ti, llvm::codeview::MemberAccess access,
Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
   uint64_t offset = data_member.FieldOffset * 8;
   uint32_t bitfield_width = 0;
 
   TypeIndex ti(data_member.Type);
   if (!ti.isSimple()) {
     CVType cvt = m_tpi.getType(ti);
     if (cvt.kind() == LF_BITFIELD) {
       BitFieldRecord bfr;
-      llvm::cantFail(TypeDeserializer::deserializeAs<BitFieldRecord>(cvt, bfr));
+      cantFail(TypeDeserializer::deserializeAs<BitFieldRecord>(cvt, bfr));
       offset += bfr.BitOffset;
       bitfield_width = bfr.BitSize;
       ti = bfr.Type;
     }
   }
 
   clang::QualType member_qt = m_ast_builder.GetOrCreateType(PdbTypeSymId(ti));
   m_ast_builder.CompleteType(member_qt);

 Error UdtRecordCompleter::visitKnownMember(CVMemberRecord &cvr,
                                            OverloadedMethodRecord &overloaded) {
   TypeIndex method_list_idx = overloaded.MethodList;
 
   CVType method_list_type = m_tpi.getType(method_list_idx);
   assert(method_list_type.kind() == LF_METHODLIST);
 
   MethodOverloadListRecord method_list;
-  llvm::cantFail(TypeDeserializer::deserializeAs<MethodOverloadListRecord>(
+  cantFail(TypeDeserializer::deserializeAs<MethodOverloadListRecord>(
       method_list_type, method_list));
 
   for (const OneMethodRecord &method : method_list.Methods)
     AddMethod(overloaded.Name, method.Type, method.getAccess(),
               method.getOptions(), method.Attrs);
 
   return Error::success();
 }

lldb/unittests/Target/ExecutionContextTest.cpp

 using namespace lldb_private;
 using namespace lldb_private::repro;
 using namespace lldb;
 
 namespace {
 class ExecutionContextTest : public ::testing::Test {
 public:
   void SetUp() override {
-    llvm::cantFail(Reproducer::Initialize(ReproducerMode::Off, llvm::None));
+    cantFail(Reproducer::Initialize(ReproducerMode::Off, llvm::None));
     FileSystem::Initialize();
     HostInfo::Initialize();
     platform_linux::PlatformLinux::Initialize();
   }
   void TearDown() override {
     platform_linux::PlatformLinux::Terminate();
     HostInfo::Terminate();
     FileSystem::Terminate();

llvm/include/llvm/Support/Error.h

 #endif
 };
 
 /// Report a serious error, calling any installed error handler. See
 /// ErrorHandling.h.
 LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err,
                                                 bool gen_crash_diag = true);
 
+namespace detail {
+
+inline LLVM_ATTRIBUTE_NORETURN void
+handleError(Error Err, const char *Msg, const char *file, unsigned line) {
+  if (!Msg)
+    Msg = "Failure value returned from cantFail wrapped call";
+#ifndef NDEBUG
+  std::string Str;
+  raw_string_ostream OS(Str);
+  OS << Err << "\n" << Msg;
+  if (file)
+    OS << " at " << file << ":" << line;
+  Msg = OS.str().c_str();
+#endif
+  llvm_unreachable(Msg);
+}
+
 /// Report a fatal error if Err is a failure value.
 ///
 /// This function can be used to wrap calls to fallible functions ONLY when it
 /// is known that the Error will always be a success value. E.g.
 ///
 ///   @code{.cpp}
 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 ///   // true. If DoFallibleOperation is false then foo always returns
 ///   // Error::success().
 ///   Error foo(bool DoFallibleOperation);
 ///
 ///   cantFail(foo(false));
 ///   @endcode
-inline void cantFail(Error Err, const char *Msg = nullptr) {
-  if (Err) {
-    if (!Msg)
-      Msg = "Failure value returned from cantFail wrapped call";
-#ifndef NDEBUG
-    std::string Str;
-    raw_string_ostream OS(Str);
-    OS << Msg << "\n" << Err;
-    Msg = OS.str().c_str();
-#endif
-    llvm_unreachable(Msg);
-  }
+inline void cantFail(const char *file, unsigned line, Error Err,
+                     const char *Msg = nullptr) {
+  if (Err)
+    handleError(std::move(Err), Msg, file, line);
 }
 
 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
 /// returns the contained value.
 ///
 /// This function can be used to wrap calls to fallible functions ONLY when it
 /// is known that the Error will always be a success value. E.g.
 ///
 ///   @code{.cpp}
 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 ///   // true. If DoFallibleOperation is false then foo always returns an int.
 ///   Expected<int> foo(bool DoFallibleOperation);
 ///
 ///   int X = cantFail(foo(false));
 ///   @endcode
 template <typename T>
-T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
+T cantFail(const char *file, unsigned line, Expected<T> ValOrErr,
+           const char *Msg = nullptr) {
   if (ValOrErr)
     return std::move(*ValOrErr);
-  else {
-    if (!Msg)
-      Msg = "Failure value returned from cantFail wrapped call";
-#ifndef NDEBUG
-    std::string Str;
-    raw_string_ostream OS(Str);
-    auto E = ValOrErr.takeError();
-    OS << Msg << "\n" << E;
-    Msg = OS.str().c_str();
-#endif
-    llvm_unreachable(Msg);
-  }
+  handleError(std::move(ValOrErr.takeError()), Msg, file, line);
 }
 
 /// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
 /// returns the contained reference.
 ///
 /// This function can be used to wrap calls to fallible functions ONLY when it
 /// is known that the Error will always be a success value. E.g.
 ///
 ///   @code{.cpp}
 ///   // foo only attempts the fallible operation if DoFallibleOperation is
 ///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
 ///   Expected<Bar&> foo(bool DoFallibleOperation);
 ///
 ///   Bar &X = cantFail(foo(false));
 ///   @endcode
 template <typename T>
-T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
+T &cantFail(const char *file, unsigned line, Expected<T &> ValOrErr,
+            const char *Msg = nullptr) {
   if (ValOrErr)
     return *ValOrErr;
-  else {
-    if (!Msg)
-      Msg = "Failure value returned from cantFail wrapped call";
+  handleError(std::move(ValOrErr.takeError()), Msg, file, line);
+}
+} // namespace detail
+
 #ifndef NDEBUG
-    std::string Str;
-    raw_string_ostream OS(Str);
-    auto E = ValOrErr.takeError();
-    OS << Msg << "\n" << E;
-    Msg = OS.str().c_str();
+#define cantFail(...) ::llvm::detail::cantFail(__FILE__, __LINE__, __VA_ARGS__)
+#else
+#define cantFail(...) ::llvm::detail::cantFail(nullptr, 0, __VA_ARGS__)
 #endif
-    llvm_unreachable(Msg);
-  }
-}
 
 /// Helper for testing applicability of, and applying, handlers for
 /// ErrorInfo types.
 template <typename HandlerT>
 class ErrorHandlerTraits
     : public ErrorHandlerTraits<decltype(
           &std::remove_reference<HandlerT>::type::operator())> {};
 

llvm/unittests/Support/ErrorTest.cpp

TEST(Error, FailureToHandle) {
   auto FailToHandle = []() {
     handleAllErrors(make_error<CustomError>(7), [&](const CustomSubError &SE) {
       errs() << "This should never be called";
       exit(1);
     });
   };
 
   EXPECT_DEATH(FailToHandle(),
-               "Failure value returned from cantFail wrapped call\n"
-               "CustomError \\{7\\}")
+               "CustomError \\{7\\}\n"
+               "Failure value returned from cantFail wrapped call")
       << "Unhandled Error in handleAllErrors call did not cause an "
          "abort()";
 }
 #endif
 
 // Test that handleAllUnhandledErrors crashes if an error is returned from a
 // handler.
 // Test runs in debug mode only.
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 TEST(Error, FailureFromHandler) {
   auto ReturnErrorFromHandler = []() {
     handleAllErrors(make_error<CustomError>(7),
                     [&](std::unique_ptr<CustomSubError> SE) {
                       return Error(std::move(SE));
                     });
   };
 
   EXPECT_DEATH(ReturnErrorFromHandler(),
-               "Failure value returned from cantFail wrapped call\n"
-               "CustomError \\{7\\}")
+               "CustomError \\{7\\}\n"
+               "Failure value returned from cantFail wrapped call")
       << " Error returned from handler in handleAllErrors call did not "
          "cause abort()";
 }
 #endif
 
 // Test that we can return values from handleErrors.
 TEST(Error, CatchErrorFromHandler) {
   int ErrorInfo = 0;

 }
 
 // Test that cantFail results in a crash if you pass it a failure value.
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS && !defined(NDEBUG)
 TEST(Error, CantFailDeath) {
   EXPECT_DEATH(cantFail(make_error<StringError>("Original error message",
                                                 inconvertibleErrorCode()),
                         "Cantfail call failed"),
-               "Cantfail call failed\n"
-               "Original error message")
+               "Original error message\n"
+               "Cantfail call failed")
       << "cantFail(Error) did not cause an abort for failure value";
 
   EXPECT_DEATH(
       {
         auto IEC = inconvertibleErrorCode();
         int X = cantFail(Expected<int>(make_error<StringError>("foo", IEC)));
         (void)X;
       },
       "Failure value returned from cantFail wrapped call")
     << "cantFail(Expected<int>) did not cause an abort for failure value";
 }
 #endif
 
+TEST(Error, CantFailSourceLocation) {
+  std::string ErrStr;
+  raw_string_ostream OS(ErrStr);
+  OS << "\nFailure value returned from cantFail wrapped call";
+
+#if defined(NDEBUG)
+  // __FILE__ and __LINE_ not added
+  OS << "\n";
+  EXPECT_DEATH(cantFail(make_error<CustomError>(1)), OS.str())
+      << "cantFail(Error) did not cause an abort for failure value";
+#else
+  // __FILE__ and __LINE__ added
+  int Line = __LINE__;
+  OS << " at " << __FILE__ << ":" << (Line + 2) << "\n";
+  EXPECT_DEATH(cantFail(make_error<CustomError>(1)), OS.str())
+      << "cantFail(Error) did not cause an abort for failure value";
+#endif
+}
 
 // Test Checked Expected<T> in success mode.
 TEST(Error, CheckedExpectedInSuccessMode) {
   Expected<int> A = 7;
   EXPECT_TRUE(!!A) << "Expected with non-error value doesn't convert to 'true'";
   // Access is safe in second test, since we checked the error in the first.
   EXPECT_EQ(*A, 7) << "Incorrect Expected non-error value";
 }