[clangd] Drop TestTUs dependency on gtest

[kadircet]

Summary

TestTU now prints errors to llvm::errs and aborts on failures via
llvm_unreachable, rather than executing ASSERT_FALSE.

We'd like to make use of these testing libraries in different test suits that
might be compiling with a different gtest version than LLVM has.

[sammccall]

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

75

I don't love using llvm_unreachable for error handling (esp environment sensitive kind like this), it compiles down to UB in ndebug mode.

Log + abort would be preferable I think, though it's one extra line.

121–122

I think we should replace this one with abort() too now

121–122

this check is now a log message that could still let the test pass
Make it an assert instead?

(I think assert without any early return is appropriate per normal llvm style)

149

this needs to fail the test. abort()?

[kadircet]

• Use log + abort instead of llvm_unreachable to not rely on UB.

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

75

ah I thought it always compiled down to abort (and sometimes inserted a builtin to indicate noreturn). looks like i've missed the conditional macro definition.

121–122

aborting instead of just assert(false), since the rest of the code assumes AST->getDiagnostics has a value.

[sammccall]

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

121–122

This is actually a can't-happen condition even if the test is messed up, and we normally assert on those before dereferencing a pointer. But up to you.

[kadircet]

• Assert for daigs rather than abort.

clang-tools-extra/clangd/index/Symbol.h

 private:
   SymbolSlab(llvm::BumpPtrAllocator Arena, std::vector<Symbol> Symbols)
       : Arena(std::move(Arena)), Symbols(std::move(Symbols)) {}
 
   llvm::BumpPtrAllocator Arena; // Owns Symbol data that the Symbols do not.
   std::vector<Symbol> Symbols;  // Sorted by SymbolID to allow lookup.
 };
 
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolSlab &Slab);
+
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_SYMBOL_H

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

SymbolSlab SymbolSlab::Builder::build() && {
   // We may have unused strings from overwritten symbols. Build a new arena.
   llvm::BumpPtrAllocator NewArena;
   llvm::UniqueStringSaver Strings(NewArena);
   for (auto &S : SortedSymbols)
     own(S, Strings);
   return SymbolSlab(std::move(NewArena), std::move(SortedSymbols));
 }
 
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolSlab &Slab) {
+  OS << "{";
+  llvm::StringRef Sep = "";
+  for (const auto &S : Slab) {
+    OS << Sep << S;
+    Sep = ", ";
+  }
+  OS << "}";
+  return OS;
+}
 } // namespace clangd
 } // namespace clang

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

 #include "TestFS.h"
 #include "index/FileIndex.h"
 #include "index/MemIndex.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/Utils.h"
 #include "llvm/ADT/ScopeExit.h"
-#include "gtest/gtest.h"
+#include "llvm/Support/ScopedPrinter.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstdlib>
 
 namespace clang {
 namespace clangd {
 
 ParseInputs TestTU::inputs(MockFS &FS) const {
   std::string FullFilename = testPath(Filename),
               FullHeaderName = testPath(HeaderFilename),
               ImportThunk = testPath("import_thunk.h");
ParseInputs TestTU::inputs(MockFS &FS) const {
   if (ClangTidyProvider)
     Inputs.ClangTidyProvider = ClangTidyProvider;
   Inputs.Index = ExternalIndex;
   return Inputs;
 }
 
 void initializeModuleCache(CompilerInvocation &CI) {
   llvm::SmallString<128> ModuleCachePath;
-  ASSERT_FALSE(
-      llvm::sys::fs::createUniqueDirectory("module-cache", ModuleCachePath));
+  if (llvm::sys::fs::createUniqueDirectory("module-cache", ModuleCachePath)) {
+    llvm::errs() << "Failed to create temp directory for module-cache";
+    std::abort();
+  }
   CI.getHeaderSearchOpts().ModuleCachePath = ModuleCachePath.c_str();
 }
 
 void deleteModuleCache(const std::string ModuleCachePath) {
   if (!ModuleCachePath.empty()) {
-    ASSERT_FALSE(llvm::sys::fs::remove_directories(ModuleCachePath));
+    if (llvm::sys::fs::remove_directories(ModuleCachePath)) {
+      llvm::errs() << "Failed to delete temp directory for module-cache";
+      std::abort();
+    }
   }
 }
 
 std::shared_ptr<const PreambleData>
 TestTU::preamble(PreambleParsedCallback PreambleCallback) const {
   MockFS FS;
   auto Inputs = inputs(FS);
   IgnoreDiagnostics Diags;
ParsedAST TestTU::build() const {
   auto ModuleCacheDeleter = llvm::make_scope_exit(
       std::bind(deleteModuleCache, CI->getHeaderSearchOpts().ModuleCachePath));
 
   auto Preamble = clang::clangd::buildPreamble(testPath(Filename), *CI, Inputs,
                                                /*StoreInMemory=*/true,
                                                /*PreambleCallback=*/nullptr);
   auto AST = ParsedAST::build(testPath(Filename), Inputs, std::move(CI),
                               Diags.take(), Preamble);
   if (!AST.hasValue()) {
-    ADD_FAILURE() << "Failed to build code:\n" << Code;
-    llvm_unreachable("Failed to build TestTU!");
-  }
-  if (!AST->getDiagnostics()) {
-    ADD_FAILURE() << "TestTU should always build an AST with a fresh Preamble"
-                  << Code;
-    return std::move(*AST);
+    llvm::errs() << "Failed to build code:\n" << Code;
+    std::abort();
   }
+  assert(AST->getDiagnostics() &&
+         "TestTU should always build an AST with a fresh Preamble");
   // Check for error diagnostics and report gtest failures (unless expected).
   // This guards against accidental syntax errors silently subverting tests.
   // error-ok is awfully primitive - using clang -verify would be nicer.
   // Ownership and layering makes it pretty hard.
   bool ErrorOk = [&, this] {
     llvm::StringLiteral Marker = "error-ok";
     if (llvm::StringRef(Code).contains(Marker) ||
         llvm::StringRef(HeaderCode).contains(Marker))
       return true;
     for (const auto &KV : this->AdditionalFiles)
       if (llvm::StringRef(KV.second).contains(Marker))
         return true;
     return false;
   }();
   if (!ErrorOk) {
     // We always build AST with a fresh preamble in TestTU.
     for (const auto &D : *AST->getDiagnostics())
       if (D.Severity >= DiagnosticsEngine::Error) {
-        ADD_FAILURE()
+        llvm::errs()
             << "TestTU failed to build (suppress with /*error-ok*/): \n"
             << D << "\n\nFor code:\n"
             << Code;
-        break; // Just report first error for simplicity.
+        std::abort(); // Stop after first error for simplicity.
       }
   }
   return std::move(*AST);
 }
 
 SymbolSlab TestTU::headerSymbols() const {
   auto AST = build();
   return std::get<0>(indexHeaderSymbols(/*Version=*/"null", AST.getASTContext(),

 }
 
 const Symbol &findSymbol(const SymbolSlab &Slab, llvm::StringRef QName) {
   const Symbol *Result = nullptr;
   for (const Symbol &S : Slab) {
     if (QName != (S.Scope + S.Name).str())
       continue;
     if (Result) {
-      ADD_FAILURE() << "Multiple symbols named " << QName << ":\n"
-                    << *Result << "\n---\n"
-                    << S;
+      llvm::errs() << "Multiple symbols named " << QName << ":\n"
       assert(false && "QName is not unique");
     }
     Result = &S;
   }
   if (!Result) {
-    ADD_FAILURE() << "No symbol named " << QName << " in "
-                  << ::testing::PrintToString(Slab);
+    llvm::errs() << "No symbol named " << QName << " in "
+                 << llvm::to_string(Slab);
     assert(false && "No symbol with QName");
   }
   return *Result;
 }
 
 const NamedDecl &findDecl(ParsedAST &AST, llvm::StringRef QName) {
   auto &Ctx = AST.getASTContext();
   auto LookupDecl = [&Ctx](const DeclContext &Scope,
bool VisitNamedDecl(const NamedDecl *ND) {
       if (F(*ND))
         Decls.push_back(ND);
       return true;
     }
   } Visitor;
   Visitor.F = Filter;
   Visitor.TraverseDecl(AST.getASTContext().getTranslationUnitDecl());
   if (Visitor.Decls.size() != 1) {
-    ADD_FAILURE() << Visitor.Decls.size() << " symbols matched.";
+    llvm::errs() << Visitor.Decls.size() << " symbols matched.";
     assert(Visitor.Decls.size() == 1);
   }
   return *Visitor.Decls.front();
 }
 
 const NamedDecl &findUnqualifiedDecl(ParsedAST &AST, llvm::StringRef Name) {
   return findDecl(AST, [Name](const NamedDecl &ND) {
     if (auto *ID = ND.getIdentifier())
       if (ID->getName() == Name)
         return true;
     return false;
   });
 }
 
 } // namespace clangd
 } // namespace clang