[clangd] Assert that the testcases in FindExplicitReferencesTest.All have no diagnostics

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

[ilya-biryukov]

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

571

ADD_FAILURE() should be enough to indicate there are errors to the users.
No need to crash additionally.

Could you remove this assert?

751

Could we assert there are no errors instead?
Having warnings is totally fine and allows to avoid changing testcases (like this one)

[nridge]

Address review comments

[merge_guards_bot]

Unit tests: pass. 61726 tests passed, 0 failed and 779 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[ilya-biryukov]

LGTM, thanks!

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

898

NIT: is this change redundant now? This was probably a warning, not an error.

[nridge]

Address nit

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

898

You're right, reverted this change.

[merge_guards_bot]

Unit tests: pass. 61771 tests passed, 0 failed and 780 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

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

AllRefs annotateReferencesInFoo(llvm::StringRef Code) {
     TU.Code = Code;
 
     // FIXME: Auto-completion in a template requires disabling delayed template
     // parsing.
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
     TU.ExtraArgs.push_back("-std=c++17");
 
     auto AST = TU.build();
+    for (auto &D : AST.getDiagnostics()) {
+      if (D.Severity > DiagnosticsEngine::Warning)
+        ADD_FAILURE() << D << Code;
+    }
 
     auto *TestDecl = &findDecl(AST, "foo");
     if (auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
       TestDecl = T->getTemplatedDecl();
     auto &Func = llvm::cast<FunctionDecl>(*TestDecl);
 
     std::vector<ReferenceLoc> Refs;
     findExplicitReferences(Func.getBody(), [&Refs](ReferenceLoc R) {
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
             }
           )cpp",
         "0: targets = {valias}\n"
         "1: targets = {vi}, decl\n"
         "2: targets = {valias}\n"
         "3: targets = {vb}, decl\n"},
        // MemberExpr should know their using declaration.
        {R"cpp(
-            struct X { void func(int); }
+            struct X { void func(int); };
             struct Y : X {
               using X::func;
             };
             void foo(Y y) {
               $0^y.$1^func(1);
             }
         )cpp",
         "0: targets = {y}\n"
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
         )cpp",
         "0: targets = {bar}\n"},
        // References from a macro.
        {R"cpp(
             #define FOO a
             #define BAR b
 
             void foo(int a, int b) {
               $0^FOO+$1^BAR;
             }
         )cpp",
         "0: targets = {a}\n"
         "1: targets = {b}\n"},
        // No references from implicit nodes.
        {R"cpp(
             struct vector {
               int *begin();
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
        // Template template parameters.
        {R"cpp(
             template <class T> struct vector {};
 
             template <template<class> class TT, template<class> class ...TP>
             void foo() {
               $0^TT<int> $1^x;
               $2^foo<$3^TT>();
-              $4^foo<$5^vector>()
+              $4^foo<$5^vector>();
               $6^foo<$7^TP...>();
             }
         )cpp",
         "0: targets = {TT}\n"
         "1: targets = {x}, decl\n"
         "2: targets = {foo}\n"
         "3: targets = {TT}\n"
         "4: targets = {foo}\n"
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
                };
                // base initializer
                class $4^Derived : public $5^Base {
                  $6^Base $7^B;
                  $8^Derived() : $9^Base() {}
                };
                // delegating initializer
                class $10^Foo {
                  $11^Foo(int);
                  $12^Foo(): $13^Foo(111) {}
                };
              }
            )cpp",
         "0: targets = {X}, decl\n"
         "1: targets = {foo()::X::abc}, decl\n"
         "2: targets = {foo()::X::X}, decl\n"
         "3: targets = {foo()::X::abc}\n"
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
              }
            )cpp",
            "0: targets = {x}, decl\n"
            "1: targets = {fptr}, decl\n"
            "2: targets = {a}, decl\n"},
        // Namespace aliases should be handled properly.
        {
            R"cpp(
-                namespace ns { struct Type {} }
+                namespace ns { struct Type {}; }
                 namespace alias = ns;
                 namespace rec_alias = alias;
 
                 void foo() {
                   $0^ns::$1^Type $2^a;
                   $3^alias::$4^Type $5^b;
                   $6^rec_alias::$7^Type $8^c;
                 }