[clangd] Errors in TestTU cause test failures unless suppressed with error-ok.

[sammccall]

Summary

The historic behavior of TestTU is to gather diagnostics and otherwise ignore
them. So if a test has a syntax error, and doesn't assert diagnostics, it
silently misbehaves.
This can be annoying when developing tests, as evidenced by various tests
gaining "assert no diagnostics" where that's not really the point of the test.

This patch aims to make that default behavior. For the first error
(not warning), TestTU will call ADD_FAILURE().

This can be suppressed with a comment containing "error-ok". For now that will
suppress any errors in the TU. We can make this stricter later -verify style.
(-verify itself is hard to reuse because of DiagnosticConsumer interfaces...)
A magic-comment was chosen over a TestTU option because of table-driven tests.

In addition to the behavior change, this patch:

• adds //error-ok where we're knowingly testing invalid code (e.g. for diagnostics, crash-resilience, or token-level tests)
• fixes a bunch of errors in the checked-in tests, mostly trivial (missing ;)
• removes a bunch of now-redundant instances of "assert no diagnostics"

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt

[kadircet]

LGTM, thanks for the cleanup!

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

84

should we make this more obscure, something like // TESTTU: error-ok ?

Even though it sounds implausible, just in case someone spells error-ok as part of the test, and silently drops the error :D

[sammccall]

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

84

I don't think this is the worst or most-likely failure mode, compared to suppressing too many errors.
The extra-verbosity would make it annoying to put inline.

I'd rather switch to clang -verify or otherwise ensure it only suppresses errors on the same line.
But that adds complexity, and this is a strict improvement on what we have today.

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

struct Test {
     const char *DeducedType;
   } Tests[] = {
       {"^auto i = 0;", "int"},
       {"^auto f(){ return 1;};", "int"},
   };
   for (Test T : Tests) {
     Annotations File(T.AnnotatedCode);
     auto AST = TestTU::withCode(File.code()).build();
-    ASSERT_TRUE(AST.getDiagnostics().empty())
-        << AST.getDiagnostics().begin()->Message;
     SourceManagerForFile SM("foo.cpp", File.code());
 
     for (Position Pos : File.points()) {
       auto Location = sourceLocationInMainFile(SM.get(), Pos);
       ASSERT_TRUE(!!Location) << llvm::toString(Location.takeError());
       auto DeducedType = getDeducedType(AST.getASTContext(), *Location);
       EXPECT_EQ(DeducedType->getAsString(), T.DeducedType);
     }

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

const char *Tests[] = {
         #endif
       )cpp",
       R"cpp(
         // Macros from token concatenations not included.
         #define $1[[CONCAT]](X) X##A()
         #define $2[[PREPEND]](X) MACRO##X()
         #define $3[[MACROA]]() 123
         int B = $1[[CONCAT]](MACRO);
-        int D = $2[[PREPEND]](A)
+        int D = $2[[PREPEND]](A);
       )cpp",
       R"cpp(
         // FIXME: Macro names in a definition are not detected.
         #define $1[[MACRO_ARGS2]](X, Y) X Y
         #define $2[[FOO]] BAR
         #define $3[[BAR]] 1
         int A = $2[[FOO]];
       )cpp"};

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

Position pos(int line, int character) {
   Res.line = line;
   Res.character = character;
   return Res;
 }
 
 TEST(DiagnosticsTest, DiagnosticRanges) {
   // Check we report correct ranges, including various edge-cases.
   Annotations Test(R"cpp(
+    // error-ok
     namespace test{};
     void $decl[[foo]]();
     class T{$explicit[[]]$constructor[[T]](int a);};
     int main() {
       $typo[[go\
 o]]();
       foo()$semicolon[[]]//with comments
       $unk[[unknown]]();
EXPECT_THAT(
           AllOf(Diag(Test.range("constructor"),
                      "single-argument constructors must be marked explicit to "
                      "avoid unintentional implicit conversions"),
                 WithFix(Fix(Test.range("explicit"), "explicit ",
                             "insert 'explicit '")))));
 }
 
 TEST(DiagnosticsTest, FlagsMatter) {
-  Annotations Test("[[void]] main() {}");
+  Annotations Test("[[void]] main() {} // error-ok");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
                                 WithFix(Fix(Test.range(), "int",
                                             "change 'void' to 'int'")))));
   // Same code built as C gets different diagnostics.
   TU.Filename = "Plain.c";
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "return type of 'main' is not 'int'"),
           WithFix(Fix(Test.range(), "int", "change return type to 'int'")))));
 }
 
 TEST(DiagnosticsTest, DiagnosticPreamble) {
   Annotations Test(R"cpp(
-    #include $[["not-found.h"]]
+    #include $[["not-found.h"]] // error-ok
   )cpp");
 
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(::testing::AllOf(
                   Diag(Test.range(), "'not-found.h' file not found"),
                   DiagSource(Diag::Clang), DiagName("pp_file_not_found"))));
 }
EXPECT_THAT(
                              "point context; possible loss of precision"),
           DiagSource(Diag::ClangTidy), DiagName("bugprone-integer-division"))));
 }
 
 TEST(DiagnosticTest, ClangTidyWarningAsError) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
-      double f = [[8]] / i;
+      double f = [[8]] / i; // error-ok
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyChecks = "bugprone-integer-division";
   TU.ClangTidyWarningsAsErrors = "bugprone-integer-division";
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "result of integer division used in a floating "
                              "point context; possible loss of precision"),
           DiagSource(Diag::ClangTidy), DiagName("bugprone-integer-division"),
           DiagSeverity(DiagnosticsEngine::Error))));
 }
 
 TEST(DiagnosticTest, LongFixMessages) {
   // We limit the size of printed code.
   Annotations Source(R"cpp(
     int main() {
+      // error-ok
       int somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier;
       [[omereallyreallyreallyreallyreallyreallyreallyreallylongidentifier]]= 10;
     }
   )cpp");
   TestTU TU = TestTU::withCode(Source.code());
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       ElementsAre(WithFix(Fix(
           Source.range(),
           "somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier",
           "change 'omereallyreallyreallyreallyreallyreallyreallyreall…' to "
           "'somereallyreallyreallyreallyreallyreallyreallyreal…'"))));
   // Only show changes up to a first newline.
   Source = Annotations(R"cpp(
+    // error-ok
     int main() {
       int ident;
       [[ide\
-n]] = 10;
+n]] = 10; // error-ok
     }
   )cpp");
-  TU = TestTU::withCode(Source.code());
+  TU.Code = Source.code();
   EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(WithFix(
                   Fix(Source.range(), "ident", "change 'ide\\…' to 'ident'"))));
 }
 
 TEST(DiagnosticTest, ClangTidyWarningAsErrorTrumpsSuppressionComment) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
-      double f = [[8]] / i;  // NOLINT
+      double f = [[8]] / i;  // NOLINT // error-ok
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyChecks = "bugprone-integer-division";
   TU.ClangTidyWarningsAsErrors = "bugprone-integer-division";
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "result of integer division used in a floating "
                              "point context; possible loss of precision"),
           DiagSource(Diag::ClangTidy), DiagName("bugprone-integer-division"),
           DiagSeverity(DiagnosticsEngine::Error))));
 }
 
 TEST(DiagnosticsTest, Preprocessor) {
   // This looks like a preamble, but there's an #else in the middle!
   // Check that:
   //  - the #else doesn't generate diagnostics (we had this bug)
   //  - we get diagnostics from the taken branch
   //  - we get no diagnostics from the not taken branch
   Annotations Test(R"cpp(
     #ifndef FOO
     #define FOO
-      int a = [[b]];
+      int a = [[b]]; // error-ok
     #else
       int x = y;
     #endif
     )cpp");
   EXPECT_THAT(
       TestTU::withCode(Test.code()).build().getDiagnostics(),
       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'b'")));
 }
 
 TEST(DiagnosticsTest, InsideMacros) {
   Annotations Test(R"cpp(
     #define TEN 10
     #define RET(x) return x + 10
 
     int* foo() {
-      RET($foo[[0]]);
+      RET($foo[[0]]); // error-ok
     }
     int* bar() {
       return $bar[[TEN]];
     }
     )cpp");
   EXPECT_THAT(TestTU::withCode(Test.code()).build().getDiagnostics(),
               ElementsAre(Diag(Test.range("foo"),
                                "cannot initialize return object of type "
                                "'int *' with an rvalue of type 'int'"),
                           Diag(Test.range("bar"),
                                "cannot initialize return object of type "
                                "'int *' with an rvalue of type 'int'")));
 }
 
 TEST(DiagnosticsTest, NoFixItInMacro) {
   Annotations Test(R"cpp(
     #define Define(name) void name() {}
 
-    [[Define]](main)
+    [[Define]](main) // error-ok
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
                                 Not(WithFix(_)))));
 }
 
 TEST(ClangdTest, MSAsm) {
for (const auto &S : Syms) {
     Sym.Definition.FileURI = S.DeclaringFile.c_str();
     Sym.IncludeHeaders.emplace_back(S.IncludeHeader, 1);
     Slab.insert(Sym);
   }
   return MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
 }
 
 TEST(IncludeFixerTest, IncompleteType) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
   class X;
   $nested[[X::]]Nested n;
 }
 class Y : $base[[public ns::X]] {};
 int main() {
   ns::X *x;
   x$access[[->]]f();
EXPECT_THAT(
                             "Add include \"x.h\" for symbol ns::X"))),
           AllOf(Diag(Test.range("access"),
                      "member access into incomplete type 'ns::X'"),
                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Add include \"x.h\" for symbol ns::X")))));
 }
 
 TEST(IncludeFixerTest, NoSuggestIncludeWhenNoDefinitionInHeader) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
   class X;
 }
 class Y : $base[[public ns::X]] {};
 int main() {
   ns::X *x;
   x$access[[->]]f();
 }
int main() {
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Test.range("base"), "base class has incomplete type"),
                   Diag(Test.range("access"),
                        "member access into incomplete type 'ns::X'")));
 }
 
 TEST(IncludeFixerTest, Typo) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
 void foo() {
   $unqualified1[[X]] x;
   // No fix if the unresolved type is used as specifier. (ns::)X::Nested will be
   // considered the unresolved type.
   $unqualified2[[X]]::Nested n;
 }
 }
EXPECT_THAT(
                             "Add include \"x.h\" for symbol ns::X"))),
           AllOf(Diag(Test.range("global"),
                      "no type named 'Global' in the global namespace"),
                 WithFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
                             "Add include \"global.h\" for symbol Global")))));
 }
 
 TEST(IncludeFixerTest, MultipleMatchedSymbols) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace na {
 namespace nb {
 void foo() {
   $unqualified[[X]] x;
 }
 }
 }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""},
        SymbolWithHeader{"na::nb::X", "unittest:///b.h", "\"b.h\""}});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Test.range("unqualified"), "unknown type name 'X'"),
                   WithFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
                               "Add include \"a.h\" for symbol na::X"),
                           Fix(Test.range("insert"), "#include \"b.h\"\n",
                               "Add include \"b.h\" for symbol na::nb::X")))));
 }
 
 TEST(IncludeFixerTest, NoCrashMemebrAccess) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
     struct X { int  xyz; };
     void g() { X x; x.$[[xy]] }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(Diag(Test.range(), "no member named 'xy' in 'X'")));
 }
 
 TEST(IncludeFixerTest, UseCachedIndexResults) {
   // As index results for the identical request are cached, more than 5 fixes
   // are generated.
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]void foo() {
   $x1[[X]] x;
   $x2[[X]] x;
   $x3[[X]] x;
   $x4[[X]] x;
   $x5[[X]] x;
   $x6[[X]] x;
   $x7[[X]] x;
if (D.Fixes.size() != 1) {
       continue;
     }
     EXPECT_EQ(D.Fixes[0].Message,
               std::string("Add include \"a.h\" for symbol X"));
   }
 }
 
 TEST(IncludeFixerTest, UnresolvedNameAsSpecifier) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
 }
 void g() {  ns::$[[scope]]::X_Y();  }
   )cpp");
   TestTU TU;
   TU.Code = Test.code();
   // FIXME: Figure out why this is needed and remove it, PR43662.
   TU.ExtraArgs.push_back("-fno-ms-compatibility");
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"ns::scope::X_Y", "unittest:///x.h", "\"x.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       TU.build().getDiagnostics(),
       UnorderedElementsAre(AllOf(
           Diag(Test.range(), "no member named 'scope' in namespace 'ns'"),
           WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                       "Add include \"x.h\" for symbol ns::scope::X_Y")))));
 }
 
 TEST(IncludeFixerTest, UnresolvedSpecifierWithSemaCorrection) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace clang {
 void f() {
   // "clangd::" will be corrected to "clang::" by Sema.
   $q1[[clangd]]::$x[[X]] x;
   $q2[[clangd]]::$ns[[ns]]::Y y;
 }
 }
   )cpp");
EXPECT_THAT(
           AllOf(Diag(Test.range("ns"),
                      "no member named 'ns' in namespace 'clang'"),
                 WithFix(Fix(
                     Test.range("insert"), "#include \"y.h\"\n",
                     "Add include \"y.h\" for symbol clang::clangd::ns::Y")))));
 }
 
 TEST(IncludeFixerTest, SpecifiedScopeIsNamespaceAlias) {
-  Annotations Test(R"cpp(
+  Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace a {}
 namespace b = a;
 namespace c {
   b::$[[X]] x;
 }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
TEST(IncludeFixerTest, NoCrashOnTemplateInstantiations) {
   Annotations Test(R"cpp(
     template <typename T> struct Templ {
       template <typename U>
       typename U::type operator=(const U &);
     };
 
     struct A {
       Templ<char> s;
-      A() { [[a]]; } // this caused crashes if we compute scopes lazily.
+      A() { [[a]]; /*error-ok*/ } // crash if we compute scopes lazily.
     };
   )cpp");
 
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol({});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(Diag(Test.range(), "use of undeclared identifier 'a'")));
 }
 
 TEST(DiagsInHeaders, DiagInsideHeader) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
-  Annotations Header("[[no_type_spec]];");
+  Annotations Header("[[no_type_spec]]; // error-ok");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", Header.code()}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: C++ requires a "
                                      "type specifier for all declarations"),
                   WithNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, DiagInTransitiveInclude) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.AdditionalFiles = {{"a.h", "#include \"b.h\""}, {"b.h", "no_type_spec;"}};
+  TU.AdditionalFiles = {{"a.h", "#include \"b.h\""},
+                        {"b.h", "no_type_spec; // error-ok"}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: C++ requires a "
                                      "type specifier for all declarations")));
 }
 
 TEST(DiagsInHeaders, DiagInMultipleHeaders) {
   Annotations Main(R"cpp(
     #include $a[["a.h"]]
     #include $b[["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.AdditionalFiles = {{"a.h", "no_type_spec;"}, {"b.h", "no_type_spec;"}};
+  TU.AdditionalFiles = {{"a.h", "no_type_spec; // error-ok"},
+                        {"b.h", "no_type_spec; // error-ok"}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range("a"), "in included file: C++ requires a type "
                                         "specifier for all declarations"),
                   Diag(Main.range("b"), "in included file: C++ requires a type "
                                         "specifier for all declarations")));
 }
 
 TEST(DiagsInHeaders, PreferExpansionLocation) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     #include "b.h"
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.AdditionalFiles = {{"a.h", "#include \"b.h\"\n"},
-                        {"b.h", "#ifndef X\n#define X\nno_type_spec;\n#endif"}};
+  TU.AdditionalFiles = {
+      {"a.h", "#include \"b.h\"\n"},
+      {"b.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
                                         "in included file: C++ requires a type "
                                         "specifier for all declarations")));
 }
 
 TEST(DiagsInHeaders, PreferExpansionLocationMacros) {
   Annotations Main(R"cpp(
     #define X
     #include "a.h"
     #undef X
     #include [["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
-  TU.AdditionalFiles = {{"a.h", "#include \"c.h\"\n"},
-                        {"b.h", "#include \"c.h\"\n"},
-                        {"c.h", "#ifndef X\n#define X\nno_type_spec;\n#endif"}};
+  TU.AdditionalFiles = {
+      {"a.h", "#include \"c.h\"\n"},
+      {"c.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: C++ requires a "
                                      "type specifier for all declarations")));
 }
 
 TEST(DiagsInHeaders, LimitDiagsOutsideMainFile) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     #include "b.h"
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "#include \"c.h\"\n"},
                         {"b.h", "#include \"c.h\"\n"},
                         {"c.h", R"cpp(
       #ifndef X
       #define X
-      no_type_spec_0;
+      no_type_spec_0; // error-ok
       no_type_spec_1;
       no_type_spec_2;
       no_type_spec_3;
       no_type_spec_4;
       no_type_spec_5;
       no_type_spec_6;
       no_type_spec_7;
       no_type_spec_8;
       no_type_spec_9;
       no_type_spec_10;
       #endif)cpp"}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: C++ requires a "
                                      "type specifier for all declarations")));
 }
 
 TEST(DiagsInHeaders, OnlyErrorOrFatal) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header(R"cpp(
-    [[no_type_spec]];
+    [[no_type_spec]]; // error-ok
     int x = 5/0;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", Header.code()}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: C++ requires "
                                      "a type specifier for all declarations"),
                   WithNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, FromNonWrittenSources) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header(R"cpp(
     int x = 5/0;
-    int b = [[FOO]];)cpp");
+    int b = [[FOO]]; // error-ok)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", Header.code()}};
   TU.ExtraArgs = {"-DFOO=NOOO"};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(),
                        "in included file: use of undeclared identifier 'NOOO'"),
                   WithNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, ErrorFromMacroExpansion) {
   Annotations Main(R"cpp(
   void bar() {
-    int fo;
+    int fo; // error-ok
     #include [["a.h"]]
   })cpp");
   Annotations Header(R"cpp(
   #define X foo
   X;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", Header.code()}};
   EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: use of undeclared "
                                      "identifier 'foo'; did you mean 'fo'?")));
 }
 
 TEST(DiagsInHeaders, ErrorFromMacroArgument) {
   Annotations Main(R"cpp(
   void bar() {
-    int fo;
+    int fo; // error-ok
     #include [["a.h"]]
   })cpp");
   Annotations Header(R"cpp(
   #define X(arg) arg
   X(foo);)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", Header.code()}};
   EXPECT_THAT(TU.build().getDiagnostics(),

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

TEST(FileIndexTest, Relations) {
   Index.relations(Req, [&](const SymbolID &, const Symbol &) { ++Results; });
   EXPECT_EQ(Results, 1u);
 }
 
 TEST(FileIndexTest, ReferencesInMainFileWithPreamble) {
   TestTU TU;
   TU.HeaderCode = "class Foo{};";
   Annotations Main(R"cpp(
-    #include "foo.h"
     void f() {
       [[Foo]] foo;
     }
   )cpp");
   TU.Code = Main.code();
   auto AST = TU.build();
   FileIndex Index;
   Index.updateMain(testPath(TU.Filename), AST);

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

protected:
   // Asserts that `Code` has a marked selection of a node `NodeType`,
   // and returns allTargetDecls() as PrintedDecl structs.
   // Use via EXPECT_DECLS().
   std::vector<PrintedDecl> assertNodeAndPrintDecls(const char *NodeType) {
     llvm::Annotations A(Code);
     auto TU = TestTU::withCode(A.code());
     TU.ExtraArgs = Flags;
     auto AST = TU.build();
-    EXPECT_THAT(AST.getDiagnostics(), ::testing::IsEmpty()) << Code;
     llvm::Annotations::Range R = A.range();
     SelectionTree Selection(AST.getASTContext(), AST.getTokens(), R.Begin,
                             R.End);
     const SelectionTree::Node *N = Selection.commonAncestor();
     if (!N) {
       ADD_FAILURE() << "No node selected!\n" << Code;
       return {};
     }
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++2a");
 
     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();
 
     std::vector<ReferenceLoc> Refs;
     if (const auto *Func = llvm::dyn_cast<FunctionDecl>(TestDecl))
       findExplicitReferences(Func->getBody(), [&Refs](ReferenceLoc R) {
         Refs.push_back(std::move(R));

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

class Foo {})cpp";
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
     auto AST = TU.build();
-    ASSERT_TRUE(AST.getDiagnostics().empty());
 
     auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
     ASSERT_TRUE(H);
     HoverInfo Expected;
     Expected.SymRange = T.range();
     Case.ExpectedBuilder(Expected);
 
     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
TEST(Hover, NoHover) {
 
   for (const auto &Test : Tests) {
     SCOPED_TRACE(Test);
 
     Annotations T(Test);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     auto AST = TU.build();
-    ASSERT_TRUE(AST.getDiagnostics().empty());
-
     auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
     ASSERT_FALSE(H);
   }
 }
 
 TEST(Hover, All) {
   struct {
     const char *const Code;
TEST(Hover, All) {
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     TU.ExtraArgs.push_back("-Wno-gnu-designator");
     auto AST = TU.build();
-    for (const auto &D : AST.getDiagnostics())
-      ADD_FAILURE() << D;
-    ASSERT_TRUE(AST.getDiagnostics().empty());
 
     auto H = getHover(AST, T.point(), format::getLLVMStyle(), Index.get());
     ASSERT_TRUE(H);
     HoverInfo Expected;
     Expected.SymRange = T.range();
     Case.ExpectedBuilder(Expected);
 
     SCOPED_TRACE(H->present().asPlainText());
TEST(Hover, DocsFromIndex) {
   void foo() {
     au^to t = X<int>();
     X^<int> w;
     (void)w;
   })cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
-  for (const auto &D : AST.getDiagnostics())
-    ADD_FAILURE() << D;
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   Symbol IndexSym;
   IndexSym.ID = *getSymbolID(&findDecl(AST, "X"));
   IndexSym.Documentation = "comment from index";
   SymbolSlab::Builder Symbols;
   Symbols.insert(IndexSym);
   auto Index =
       MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
 
void foo() {
     X^<int>();
     b^ar<int>();
     au^to T = ba^z<X<int>>;
     ba^z<int> = 0;
   })cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
-  for (const auto &D : AST.getDiagnostics())
-    ADD_FAILURE() << D;
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   for (const auto &P : T.points()) {
     auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
     ASSERT_TRUE(H);
     EXPECT_EQ(H->Documentation, "doc");
   }
 }
 
 TEST(Hover, DocsFromMostSpecial) {
   Annotations T(R"cpp(
   // doc1
   template <typename T> class $doc1^X {};
   // doc2
   template <> class $doc2^X<int> {};
   // doc3
   template <typename T> class $doc3^X<T*> {};
   void foo() {
     X$doc1^<char>();
     X$doc2^<int>();
     X$doc3^<int*>();
   })cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
-  for (const auto &D : AST.getDiagnostics())
-    ADD_FAILURE() << D;
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   for (auto Comment : {"doc1", "doc2", "doc3"}) {
     for (const auto &P : T.points(Comment)) {
       auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
       ASSERT_TRUE(H);
       EXPECT_EQ(H->Documentation, Comment);
     }
   }
 }
const std::function<void(HoverInfo &)> ExpectedBuilder;
             HI.Type = "unsigned long";
             HI.Value = "1";
           }},
   };
   for (const auto &C : Cases) {
     Annotations T(C.Code);
     TestTU TU = TestTU::withCode(T.code());
     auto AST = TU.build();
-    for (const auto &D : AST.getDiagnostics())
-      ADD_FAILURE() << D;
-
     auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
     ASSERT_TRUE(H);
     HoverInfo ExpectedHover;
     C.ExpectedBuilder(ExpectedHover);
     // We don't check for Type as it might differ on different platforms.
     EXPECT_EQ(H->Name, ExpectedHover.Name);
     EXPECT_EQ(H->Value, ExpectedHover.Value);
   }
 }
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST(ParsedASTTest, TokensAfterPreamble) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"(
     int foo();
   )";
   TU.Code = R"cpp(
       #include "foo.h"
       first_token;
       void test() {
+        // error-ok: invalid syntax, just examining token stream
       }
       last_token
 )cpp";
   auto AST = TU.build();
   const syntax::TokenBuffer &T = AST.getTokens();
   const auto &SM = AST.getSourceManager();
 
   ASSERT_GT(T.expandedTokens().size(), 2u);

 }
 
 TEST(ParsedASTTest, CollectsMainFileMacroExpansions) {
   Annotations TestCase(R"cpp(
     #define ^MACRO_ARGS(X, Y) X Y
     // - preamble ends
     ^ID(int A);
     // Macro arguments included.
-    ^MACRO_ARGS(^MACRO_ARGS(^MACRO_EXP(int), A), ^ID(= 2));
+    ^MACRO_ARGS(^MACRO_ARGS(^MACRO_EXP(int), E), ^ID(= 2));
 
     // Macro names inside other macros not included.
     #define ^MACRO_ARGS2(X, Y) X Y
     #define ^FOO BAR
     #define ^BAR 1
-    int A = ^FOO;
+    int F = ^FOO;
 
     // Macros from token concatenations not included.
     #define ^CONCAT(X) X##A()
     #define ^PREPEND(X) MACRO##X()
     #define ^MACROA() 123
-    int B = ^CONCAT(MACRO);
-    int D = ^PREPEND(A)
+    int G = ^CONCAT(MACRO);
+    int H = ^PREPEND(A);
 
     // Macros included not from preamble not included.
     #include "foo.inc"
 
+    int printf(const char*, ...);
+    void exit(int);
     #define ^assert(COND) if (!(COND)) { printf("%s", #COND); exit(0); }
 
     void test() {
       // Includes macro expansions in arguments that are expressions
       ^assert(0 <= ^BAR);
     }
 
     #ifdef ^UNDEFINED

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

INSTANTIATE_TEST_CASE_P(ASTUtilsTests, ASTUtils,
                                   template <> void ^Foz<3, 5, 8>() {};)cpp",
                                 {"<3, 5, 8>"}},
                             {
                                 R"cpp(
                                   template <class X> class Bar {};
                                   template <template <class> class ...>
                                   class Aux {};
                                   template <> class ^Aux<Bar, Bar> {};
-                                  template <template <class> T>
+                                  template <template <class> class T>
                                   class ^Aux<T, T> {};)cpp",
                                 {"<Bar, Bar>", "<T, T>"}},
                             {
                                 R"cpp(
                                   template <typename T> T var = 1234;
                                   template <> int ^var<int> = 1;)cpp",
                                 {"<int>"}},
                             {
                                 R"cpp(
                                   template <typename T> struct Foo;
                                   struct Bar { friend class Foo<int>; };
                                   template <> struct ^Foo<int> {};)cpp",
                                 {"<int>"}},
                             {
                                 R"cpp(
                                   template<class T>
                                   T S = T(10);
                                   template <class T>
                                   int ^S<T*> = 0;
                                   template <>
                                   int ^S<double> = 0;)cpp",
                                 {"<T *>", "<double>"}},
-                        })),);
+                        })), );
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST(QualityTests, SymbolRelevanceSignalExtraction) {
 
   int ::header_main() {}
   int main();
 
   [[deprecated]]
   int deprecated() { return 0; }
 
   namespace { struct X { void y() { int z; } }; }
-  struct S{}
+  struct S{};
   )cpp";
   auto AST = Test.build();
 
   SymbolRelevanceSignals Relevance;
   Relevance.merge(CodeCompletionResult(&findDecl(AST, "deprecated"),
                                        /*Priority=*/42, nullptr, false,
                                        /*Accessible=*/false));
   EXPECT_EQ(Relevance.NameMatch, SymbolRelevanceSignals().NameMatch);

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

llvm::StringRef Tests[] = {
           f.~/*something*/[[^Foo]]();
           f.~[[^Foo]]();
         }
       )cpp",
 
       // Derived destructor explicit call.
       R"cpp(
         class [[Bas^e]] {};
-        class Derived : public [[Bas^e]] {}
+        class Derived : public [[Bas^e]] {};
 
         int main() {
           [[Bas^e]] *foo = new Derived();
           foo->[[^Base]]::~[[^Base]]();
         }
       )cpp",
 
       // CXXConstructor initializer list.

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

Case Cases[] = {
       {"[[^void foo^()]];", "FunctionDecl"},
       {"[[void ^foo()]];", "FunctionDecl"},
       // Tricky case: two VarDecls share a specifier.
       {"[[int ^a]], b;", "VarDecl"},
       {"[[int a, ^b]];", "VarDecl"},
       // Tricky case: CXXConstructExpr wants to claim the whole init range.
       {
           R"cpp(
-            class X { X(int); };
+            struct X { X(int); };
             class Y {
               X x;
               Y() : [[^x(4)]] {}
             };
           )cpp",
           "CXXCtorInitializer", // Not the CXXConstructExpr!
       },
       // Tricky case: anonymous struct is a sibling of the VarDecl.
Case Cases[] = {
       {
           R"cpp(
             struct Str {
               const char *begin();
               const char *end();
             };
             Str makeStr(const char*);
             void loop() {
-              for (const char* C : [[mak^eStr("foo"^)]])
+              for (const char C : [[mak^eStr("foo"^)]])
                 ;
             }
           )cpp",
           "CallExpr"},
 
       // User-defined literals are tricky: is 12_i one token or two?
       // For now we treat it as one, and the UserDefinedLiteral as a leaf.
       {
for (const auto* N : T.commonAncestor()->Children) {
     EXPECT_EQ("IntegerLiteral", N->kind());
     EXPECT_TRUE(N->Selected);
   }
 
   // Verify that the common assert() macro doesn't suffer from this.
   // (This is because we don't associate the stringified token with the arg).
   Case = R"cpp(
     void die(const char*);
-    #define assert(x) (x ? (void)0 : die(#x)
+    #define assert(x) (x ? (void)0 : die(#x))
     void foo() { assert(^42); }
   )cpp";
   Test = Annotations(Case);
   AST = TestTU::withCode(Test.code()).build();
   T = makeSelectionTree(Case, AST);
 
   EXPECT_EQ("IntegerLiteral", T.commonAncestor()->kind());
 }

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

)cpp",
         $LocalVariable[[AA]].$Method[[foo]]();
         $LocalVariable[[AA]].$Field[[E]].$Field[[C]];
         $Class[[A]]::$StaticField[[S]] = 90;
       }
     )cpp",
       R"cpp(
       struct $Class[[AA]] {
         int $Field[[A]];
-      }
+      };
       int $Variable[[B]];
       $Class[[AA]] $Variable[[A]]{$Variable[[B]]};
     )cpp",
       R"cpp(
       namespace $Namespace[[a]] {
         struct $Class[[A]] {};
         typedef char $Primitive[[C]];
       }
)cpp"
       $Class[[A]] &$Class[[A]]::operator=($Class[[A]] &&$Parameter[[O]]) = default;
     )cpp",
       R"cpp(
       enum $Enum[[En]] {
         $EnumConstant[[EC]],
       };
       class $Class[[Foo]] {};
       class $Class[[Bar]] {
+      public:
         $Class[[Foo]] $Field[[Fo]];
         $Enum[[En]] $Field[[E]];
         int $Field[[I]];
         $Class[[Bar]] ($Class[[Foo]] $Parameter[[F]],
                 $Enum[[En]] $Parameter[[E]])
         : $Field[[Fo]] ($Parameter[[F]]), $Field[[E]] ($Parameter[[E]]),
           $Field[[I]] (123) {}
       };
)cpp",
         }
       };
 
       void $Function[[foo]]() {
         $Class[[F]] $LocalVariable[[FF]];
         $Class[[G]]<$Class[[F]], &$Class[[F]]::$Method[[f]]> $LocalVariable[[GG]];
         $LocalVariable[[GG]].$Method[[foo]](&$LocalVariable[[FF]]);
         $Class[[A]]<$Function[[foo]]> $LocalVariable[[AA]];
+      }
     )cpp",
       // Tokens that share a source range but have conflicting Kinds are not
       // highlighted.
       R"cpp(
       #define $Macro[[DEF_MULTIPLE]](X) namespace X { class X { int X; }; }
       #define $Macro[[DEF_CLASS]](T) class T {};
       // Preamble ends.
       $Macro[[DEF_MULTIPLE]](XYZ);
)cpp",
         $LocalVariable[[variable]] = 20.1;
         $Macro[[MACRO_CONCAT]](var, 2, float);
         $Macro[[DEF_VAR_T]]($Class[[A]], $Macro[[CPY]](
               $Macro[[CPY]]($LocalVariable[[Nested]])),
             $Macro[[CPY]]($Class[[A]]()));
         $Macro[[INC_VAR]]($LocalVariable[[variable]]);
       }
       void $Macro[[SOME_NAME]]();
-      $Macro[[DEF_VAR]]($Variable[[XYZ]], 567);
+      $Macro[[DEF_VAR]]($Variable[[MMMMM]], 567);
       $Macro[[DEF_VAR_REV]](756, $Variable[[AB]]);
 
       #define $Macro[[CALL_FN]](F) F();
       #define $Macro[[DEF_FN]](F) void F ()
       $Macro[[DEF_FN]]($Function[[g]]) {
         $Macro[[CALL_FN]]($Function[[foo]]);
       }
     )cpp",
$InactiveCode[[]]      #endif
     )cpp",
       // Highlighting of template template arguments.
       R"cpp(
       template <template <class> class $TemplateParameter[[TT]],
                 template <class> class ...$TemplateParameter[[TTs]]>
       struct $Class[[Foo]] {
         $Class[[Foo]]<$TemplateParameter[[TT]], $TemplateParameter[[TTs]]...>
           *$Field[[t]];
-      }
+      };
     )cpp",
       // Inactive code highlighting
       R"cpp(
       // Code in the preamble.
       // Inactive lines get an empty InactiveCode token at the beginning.
 $InactiveCode[[]]      #ifdef $Macro[[test]]
 $InactiveCode[[]]      #endif
 
sizeof...($TemplateParameter[[Elements]]);
   for (const auto &TestCase : TestCases) {
     checkHighlightings(TestCase);
   }
 
   checkHighlightings(R"cpp(
     class $Class[[A]] {
       #include "imp.h"
     };
-    #endif
   )cpp",
                      {{"imp.h", R"cpp(
     int someMethod();
     void otherMethod();
   )cpp"}});
 
   // A separate test for macros in headers.
   checkHighlightings(R"cpp(

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

std::pair<const char *, std::vector<SymbolDetails>>
           void bar(int aaa) {
             int bbb = a^aa;
           }
         )cpp",
               {CreateExpectedSymbolDetails("aaa", "bar",
                                            "c:TestTU.cpp@38@F@bar#I#@aaa")}},
           {
               R"cpp( // Lambda capture
+          void foo() {
             int ii;
             auto lam = [ii]() {
               return i^i;
             };
+          }
         )cpp",
-              {CreateExpectedSymbolDetails("ii", "", "c:@ii")}},
+              {CreateExpectedSymbolDetails("ii", "foo",
+                                           "c:TestTU.cpp@54@F@foo#@ii")}},
           {
               R"cpp( // Macro reference
           #define MACRO 5\nint i = MAC^RO;
         )cpp",
               {CreateExpectedSymbolDetails("MACRO", "",
                                            "c:TestTU.cpp@38@macro@MACRO")}},
           {
               R"cpp( // Macro reference

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

struct TestTU {
   llvm::Optional<std::string> ClangTidyChecks;
   llvm::Optional<std::string> ClangTidyWarningsAsErrors;
   // Index to use when building AST.
   const SymbolIndex *ExternalIndex = nullptr;
 
   // Simulate a header guard of the header (using an #import directive).
   bool ImplicitHeaderGuard = true;
 
+  // By default, build() will report Error diagnostics as GTest errors.
+  // Suppress this behavior by adding an 'error-ok' comment to the code.
   ParsedAST build() const;
   SymbolSlab headerSymbols() const;
   std::unique_ptr<SymbolIndex> index() const;
 };
 
 // Look up an index symbol by qualified name, which must be unique.
 const Symbol &findSymbol(const SymbolSlab &, llvm::StringRef QName);
 // Look up an AST symbol by qualified name, which must be unique and top-level.

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

 //===--- TestTU.cpp - Scratch source files for testing --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestTU.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
 #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"
 
 namespace clang {
 namespace clangd {
 
 ParsedAST TestTU::build() const {
   std::string FullFilename = testPath(Filename),
auto Preamble =
                     /*OldCompileCommand=*/Inputs.CompileCommand, Inputs,
                     /*StoreInMemory=*/true, /*PreambleCallback=*/nullptr);
   auto AST =
       buildAST(FullFilename, std::move(CI), Diags.take(), Inputs, Preamble);
   if (!AST.hasValue()) {
     ADD_FAILURE() << "Failed to build code:\n" << Code;
     llvm_unreachable("Failed to build TestTU!");
   }
+  // 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.
+  if (llvm::none_of(Files, [](const auto &KV) {
+        return llvm::StringRef(KV.second).contains("error-ok");
+      })) {
+    for (const auto &D : AST->getDiagnostics())
+      if (D.Severity >= DiagnosticsEngine::Error) {
+        ADD_FAILURE()
+            << "TestTU failed to build (suppress with /*error-ok*/): \n"
+            << D << "\n\nFor code:\n"
+            << Code;
+        break; // Just report first error for simplicity.
+      }
+  }
   return std::move(*AST);
 }
 
 SymbolSlab TestTU::headerSymbols() const {
   auto AST = build();
   return std::get<0>(indexHeaderSymbols(AST.getASTContext(),
                                         AST.getPreprocessorPtr(),
                                         AST.getCanonicalIncludes()));

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

for (auto Path : RelPaths) {
     ASSERT_THAT_EXPECTED(Res, llvm::Succeeded());
     EXPECT_EQ(Res->first, testPath(Path));
   }
 }
 
 TWEAK_TEST(SwapIfBranches);
 TEST_F(SwapIfBranchesTest, Test) {
   Context = Function;
-  EXPECT_EQ(apply("^if (true) {return 100;} else {continue;}"),
-            "if (true) {continue;} else {return 100;}");
-  EXPECT_EQ(apply("^if () {return 100;} else {continue;}"),
-            "if () {continue;} else {return 100;}")
+  EXPECT_EQ(apply("^if (true) {return;} else {(void)0;}"),
+            "if (true) {(void)0;} else {return;}");
+  EXPECT_EQ(apply("^if (/*error-ok*/) {return;} else {(void)0;}"),
+            "if (/*error-ok*/) {(void)0;} else {return;}")
       << "broken condition";
-  EXPECT_AVAILABLE("^i^f^^(^t^r^u^e^) { return 100; } ^e^l^s^e^ { continue; }");
-  EXPECT_UNAVAILABLE("if (true) {^return ^100;^ } else { ^continue^;^ }");
+  EXPECT_AVAILABLE("^i^f^^(^t^r^u^e^) { return; } ^e^l^s^e^ { return; }");
+  EXPECT_UNAVAILABLE("if (true) {^return ^;^ } else { ^return^;^ }");
   // Available in subexpressions of the condition;
-  EXPECT_THAT("if(2 + [[2]] + 2) { return 2 + 2 + 2; } else {continue;}",
-              isAvailable());
+  EXPECT_THAT("if(2 + [[2]] + 2) { return; } else {return;}", isAvailable());
   // But not as part of the branches.
-  EXPECT_THAT("if(2 + 2 + 2) { return 2 + [[2]] + 2; } else { continue; }",
+  EXPECT_THAT("if(2 + 2 + 2) { [[return]]; } else { return; }",
               Not(isAvailable()));
   // Range covers the "else" token, so available.
-  EXPECT_THAT("if(2 + 2 + 2) { return 2 + [[2 + 2; } else {continue;]]}",
-              isAvailable());
+  EXPECT_THAT("if(2 + 2 + 2) { return[[; } else {return;]]}", isAvailable());
   // Not available in compound statements in condition.
-  EXPECT_THAT(
-      "if([]{return [[true]];}()) { return 2 + 2 + 2; } else { continue; }",
+  EXPECT_THAT("if([]{return [[true]];}()) { return; } else { return; }",
               Not(isAvailable()));
   // Not available if both sides aren't braced.
   EXPECT_THAT("^if (1) return; else { return; }", Not(isAvailable()));
   // Only one if statement is supported!
   EXPECT_THAT("[[if(1){}else{}if(2){}else{}]]", Not(isAvailable()));
 }
 
 TWEAK_TEST(RawStringLiteral);
 TEST_F(RawStringLiteralTest, Test) {
TEST_F(ObjCLocalizeStringLiteralTest, Test) {
   const char *Input = R"(id x = [[@"test"]];)";
   const char *Output = R"(id x = NSLocalizedString(@"test", @"");)";
   EXPECT_EQ(apply(Input), Output);
 }
 
 TWEAK_TEST(DumpAST);
 TEST_F(DumpASTTest, Test) {
   EXPECT_AVAILABLE("^int f^oo() { re^turn 2 ^+ 2; }");
-  EXPECT_UNAVAILABLE("/*c^omment*/ int foo() return 2 ^ + 2; }");
+  EXPECT_UNAVAILABLE("/*c^omment*/ int foo() { return 2 ^ + 2; }");
   EXPECT_THAT(apply("int x = 2 ^+ 2;"),
               AllOf(StartsWith("message:"), HasSubstr("BinaryOperator"),
                     HasSubstr("'+'"), HasSubstr("|-IntegerLiteral"),
                     HasSubstr("<col:9> 'int' 2\n`-IntegerLiteral"),
                     HasSubstr("<col:13> 'int' 2")));
 }
 
 TWEAK_TEST(DumpSymbol);
 TEST_F(DumpSymbolTest, Test) {
   std::string ID = R"("id":"CA2EBE44A1D76D2A")";
   std::string USR = R"("usr":"c:@F@foo#")";
   EXPECT_THAT(apply("void f^oo();"),
               AllOf(StartsWith("message:"), testing::HasSubstr(ID),
                     testing::HasSubstr(USR)));
 }
 
 TWEAK_TEST(ShowSelectionTree);
 TEST_F(ShowSelectionTreeTest, Test) {
   EXPECT_AVAILABLE("^int f^oo() { re^turn 2 ^+ 2; }");
-  EXPECT_AVAILABLE("/*c^omment*/ int foo() return 2 ^ + 2; }");
+  EXPECT_AVAILABLE("/*c^omment*/ int foo() { return 2 ^ + 2; }");
 
   const char *Output = R"(message:
  TranslationUnitDecl 
    VarDecl int x = fcall(2 + 2)
     .CallExpr fcall(2 + 2)
        ImplicitCastExpr fcall
         .DeclRefExpr fcall
       .BinaryOperator 2 + 2
         *IntegerLiteral 2
 )";
   EXPECT_EQ(apply("int fcall(int); int x = fca[[ll(2 +]]2);"), Output);
 }
 
 TWEAK_TEST(DumpRecordLayout);
 TEST_F(DumpRecordLayoutTest, Test) {
   EXPECT_AVAILABLE("^s^truct ^X ^{ int x; ^};");
   EXPECT_THAT("struct X { int ^a; };", Not(isAvailable()));
   EXPECT_THAT("struct ^X;", Not(isAvailable()));
   EXPECT_THAT("template <typename T> struct ^X { T t; };", Not(isAvailable()));
   EXPECT_THAT("enum ^X {};", Not(isAvailable()));
 
-  EXPECT_THAT(apply("struct ^X { int x; int y; }"),
+  EXPECT_THAT(apply("struct ^X { int x; int y; };"),
               AllOf(StartsWith("message:"), HasSubstr("0 |   int x")));
 }
 
 TWEAK_TEST(ExtractVariable);
 TEST_F(ExtractVariableTest, Test) {
   const char *AvailableCases = R"cpp(
     int xyz(int a = 1) {
       struct T {
void f() {
       do
         a = [[1]];
       while(a < [[3]]);
     }
   )cpp";
   EXPECT_AVAILABLE(AvailableCases);
 
   const char *NoCrashCases = R"cpp(
+    // error-ok: broken code, but shouldn't crash
     template<typename T, typename ...Args>
     struct Test<T, Args...> {
     Test(const T &v) :val[[(^]]) {}
       T val;
     };
   )cpp";
   EXPECT_UNAVAILABLE(NoCrashCases);
 
void f(int b = [[1]]) {
         int x = 1, y = a + 1, a = 1, z = [[a + 1]];
       if(int a = 1)
         if([[a + 1]] == 4)
           a = [[[[a]] +]] 1;
       // for loop
       for(int a = 1, b = 2, c = 3; a > [[b + c]]; [[a++]])
         a = [[a + 1]];
       // lambda
-      auto lamb = [&[[a]], &[[b]]](int r = [[1]]) {return 1;}
+      auto lamb = [&[[a]], &[[b]]](int r = [[1]]) {return 1;};
       // assignment
       xyz([[a = 5]]);
       xyz([[a *= 5]]);
       // Variable DeclRefExpr
       a = [[b]];
       // statement expression
       [[xyz()]];
       while (a)
TEST_F(AnnotateHighlightingsTest, Test) {
   EXPECT_EQ(apply("void f1(); void f2() {^}"),
             "void f1(); "
             "void /* entity.name.function.cpp */f2() {}");
 }
 
 TWEAK_TEST(ExpandMacro);
 TEST_F(ExpandMacroTest, Test) {
   Header = R"cpp(
+    // error-ok: not real c++, just token manipulation
     #define FOO 1 2 3
     #define FUNC(X) X+X+X
     #define EMPTY
     #define EMPTY_FN(X)
   )cpp";
 
   // Available on macro names, not available anywhere else.
   EXPECT_AVAILABLE("^F^O^O^ BAR ^F^O^O^");

 
 TWEAK_TEST(ExpandAutoType);
 TEST_F(ExpandAutoTypeTest, Test) {
 
   Header = R"cpp(
     namespace ns {
       struct Class {
         struct Nested {};
-      }
+      };
       void Func();
     }
     inline namespace inl_ns {
       namespace {
         struct Visible {};
       }
     }
   )cpp";
 
   EXPECT_AVAILABLE("^a^u^t^o^ i = 0;");
   EXPECT_UNAVAILABLE("auto ^i^ ^=^ ^0^;^");
 
   // check primitive type
   EXPECT_EQ(apply("[[auto]] i = 0;"), "int i = 0;");
   EXPECT_EQ(apply("au^to i = 0;"), "int i = 0;");
   // check classes and namespaces
   EXPECT_EQ(apply("^auto C = ns::Class::Nested();"),
             "ns::Class::Nested C = ns::Class::Nested();");
   // check that namespaces are shortened
   EXPECT_EQ(apply("namespace ns { void f() { ^auto C = Class(); } }"),
             "namespace ns { void f() { Class C = Class(); } }");
   // undefined functions should not be replaced
-  EXPECT_THAT(apply("au^to x = doesnt_exist();"),
+  EXPECT_THAT(apply("au^to x = doesnt_exist(); // error-ok"),
               StartsWith("fail: Could not deduce type for 'auto' type"));
   // function pointers should not be replaced
   EXPECT_THAT(apply("au^to x = &ns::Func;"),
               StartsWith("fail: Could not expand type of function pointer"));
   // lambda types are not replaced
   EXPECT_THAT(apply("au^to x = []{};"),
               StartsWith("fail: Could not expand type of lambda expression"));
   // inline namespaces
   EXPECT_EQ(apply("au^to x = inl_ns::Visible();"),
             "Visible x = inl_ns::Visible();");
   // local class
   EXPECT_EQ(apply("namespace x { void y() { struct S{}; ^auto z = S(); } }"),
             "namespace x { void y() { struct S{}; S z = S(); } }");
   // replace array types
-  EXPECT_EQ(apply(R"cpp(au^to x = "test")cpp"),
-            R"cpp(const char * x = "test")cpp");
+  EXPECT_EQ(apply(R"cpp(au^to x = "test";)cpp"),
+            R"cpp(const char * x = "test";)cpp");
 
   EXPECT_UNAVAILABLE("dec^ltype(au^to) x = 10;");
 
   // FIXME: Auto-completion in a template requires disabling delayed template
   // parsing.
   ExtraArgs.push_back("-fno-delayed-template-parsing");
   // unknown types in a template should not be replaced
   EXPECT_THAT(apply("template <typename T> void x() { ^auto y = T::z(); }"),
TEST_F(DefineInlineTest, TriggersOnFunctionDecl) {
   vo^i[[d^ ^f]]^oo();
 
   [[vo^id ]]foo[[()]] {[[
     [[(void)(5+3);
     return;]]
   }]]
 
   // Definition with no body.
-  class Bar { Bar() = def^ault; }
+  class Bar { Bar() = def^ault; };
   )cpp");
 }
 
 TEST_F(DefineInlineTest, NoForwardDecl) {
   Header = "void bar();";
   EXPECT_UNAVAILABLE(R"cpp(
   void bar() {
     return;

 TEST_F(DefineInlineTest, TransformDecls) {
   auto Test = R"cpp(
     void foo();
     void f^oo() {
       class Foo {
       public:
         void foo();
         int x;
-        static int y;
       };
-      Foo::y = 0;
 
       enum En { Zero, One };
       En x = Zero;
 
       enum class EnClass { Zero, One };
       EnClass y = EnClass::Zero;
     })cpp";
   auto Expected = R"cpp(
     void foo(){
       class Foo {
       public:
         void foo();
         int x;
-        static int y;
       };
-      Foo::y = 0;
 
       enum En { Zero, One };
       En x = Zero;
 
       enum class EnClass { Zero, One };
       EnClass y = EnClass::Zero;
     }
     )cpp";
TEST_F(DefineInlineTest, HandleMacros) {
 
   std::pair<llvm::StringRef, llvm::StringRef> Cases[] = {
       // We don't qualify declarations coming from macros.
       {R"cpp(
           #define BODY Foo
           namespace a { class Foo{}; }
           void foo();
           using namespace a;
-          void f^oo(){BODY})cpp",
+          void f^oo(){BODY();})cpp",
        R"cpp(
           #define BODY Foo
           namespace a { class Foo{}; }
-          void foo(){BODY}
+          void foo(){BODY();}
           using namespace a;
           )cpp"},
 
       // Macro is not visible at declaration location, but we proceed.
       {R"cpp(
           void foo();
           #define BODY return;
           void f^oo(){BODY})cpp",
TEST_F(DefineInlineTest, AddInline) {
   ExtraFiles["a.h"] = "constexpr void foo();";
   apply(R"cpp(#include "a.h"
               constexpr void fo^o() {})cpp",
         &EditedFiles);
   EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
                                testPath("a.h"), "constexpr void foo(){}")));
 
   // Class members don't need "inline".
-  ExtraFiles["a.h"] = "struct Foo { void foo(); }";
+  ExtraFiles["a.h"] = "struct Foo { void foo(); };";
   apply(R"cpp(#include "a.h"
               void Foo::fo^o() {})cpp",
         &EditedFiles);
   EXPECT_THAT(EditedFiles,
               testing::ElementsAre(FileWithContents(
-                  testPath("a.h"), "struct Foo { void foo(){} }")));
+                  testPath("a.h"), "struct Foo { void foo(){} };")));
 
   // Function template doesn't need to be "inline"d.
   ExtraFiles["a.h"] = "template <typename T> void foo();";
   apply(R"cpp(#include "a.h"
               template <typename T>
               void fo^o() {})cpp",
         &EditedFiles);
   EXPECT_THAT(EditedFiles,
class Foo {
       Fo^o() = default;
       F^oo(const Foo&) = delete;
     };)cpp");
 
   // Not available within templated classes, as it is hard to spell class name
   // out-of-line in such cases.
   EXPECT_UNAVAILABLE(R"cpp(
     template <typename> struct Foo { void fo^o(){} };
-    })cpp");
+    )cpp");
 }
 
 TEST_F(DefineOutlineTest, FailsWithoutSource) {
   FileName = "Test.hpp";
   llvm::StringRef Test = "void fo^o() { return; }";
   llvm::StringRef Expected =
       "fail: Couldn't find a suitable implementation file.";
   EXPECT_EQ(apply(Test), Expected);
TEST_F(DefineOutlineTest, QualifyReturnValue) {
   ExtraFiles["Test.cpp"] = "";
 
   struct {
     llvm::StringRef Test;
     llvm::StringRef ExpectedHeader;
     llvm::StringRef ExpectedSource;
   } Cases[] = {
       {R"cpp(
-        namespace a { class Foo; }
+        namespace a { class Foo{}; }
         using namespace a;
-        Foo fo^o() { return; })cpp",
+        Foo fo^o() { return {}; })cpp",
        R"cpp(
-        namespace a { class Foo; }
+        namespace a { class Foo{}; }
         using namespace a;
         Foo foo() ;)cpp",
-       "a::Foo foo() { return; }"},
+       "a::Foo foo() { return {}; }"},
       {R"cpp(
         namespace a {
           class Foo {
             class Bar {};
             Bar fo^o() { return {}; }
           };
         })cpp",
        R"cpp(
         namespace a {
           class Foo {
             class Bar {};
             Bar foo() ;
           };
         })cpp",
        "a::Foo::Bar a::Foo::foo() { return {}; }\n"},
       {R"cpp(
-        class Foo;
-        Foo fo^o() { return; })cpp",
+        class Foo {};
+        Foo fo^o() { return {}; })cpp",
        R"cpp(
-        class Foo;
+        class Foo {};
         Foo foo() ;)cpp",
-       "Foo foo() { return; }"},
+       "Foo foo() { return {}; }"},
   };
   llvm::StringMap<std::string> EditedFiles;
   for (auto &Case : Cases) {
     apply(Case.Test, &EditedFiles);
     EXPECT_EQ(apply(Case.Test, &EditedFiles), Case.ExpectedHeader);
     EXPECT_THAT(EditedFiles, testing::ElementsAre(FileWithContents(
                                  testPath("Test.cpp"), Case.ExpectedSource)));
   }

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

int main() {
   Ch^ild2 ch^ild2;
   ch^ild2.c = 1;
 }
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   for (Position Pt : Source.points()) {
     const CXXRecordDecl *RD = findRecordTypeAt(AST, Pt);
     EXPECT_EQ(&findDecl(AST, "Child2"), static_cast<const NamedDecl *>(RD));
   }
 }
 
 TEST(FindRecordTypeAt, Method) {
   Annotations Source(R"cpp(
 struct Child2 {
   void met^hod ();
   void met^hod (int x);
 };
 
 int main() {
   Child2 child2;
   child2.met^hod(5);
 }
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   for (Position Pt : Source.points()) {
     const CXXRecordDecl *RD = findRecordTypeAt(AST, Pt);
     EXPECT_EQ(&findDecl(AST, "Child2"), static_cast<const NamedDecl *>(RD));
   }
 }
 
 TEST(FindRecordTypeAt, Field) {
   Annotations Source(R"cpp(
 struct Child2 {
   int fi^eld;
 };
 
 int main() {
   Child2 child2;
   child2.fi^eld = 5;
 }
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   for (Position Pt : Source.points()) {
     const CXXRecordDecl *RD = findRecordTypeAt(AST, Pt);
     // A field does not unambiguously specify a record type
     // (possible associated reocrd types could be the field's type,
     // or the type of the record that the field is a member of).
     EXPECT_EQ(nullptr, RD);
   }
 }

 struct Child2 : Child1 {
   int c;
 };
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   const CXXRecordDecl *Parent =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Parent"));
   const CXXRecordDecl *Child1 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child1"));
   const CXXRecordDecl *Child2 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child2"));
 
   EXPECT_THAT(typeParents(Parent), ElementsAre());

 struct Child : Parent1, Parent3 {
   int d;
 };
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   const CXXRecordDecl *Parent1 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Parent1"));
   const CXXRecordDecl *Parent2 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Parent2"));
   const CXXRecordDecl *Parent3 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Parent3"));
   const CXXRecordDecl *Child = dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child"));
 

 
 template <typename T>
 struct Child : Parent {};
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   const CXXRecordDecl *Parent =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Parent"));
   const CXXRecordDecl *Child =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Child"))->getTemplatedDecl();
 
   EXPECT_THAT(typeParents(Child), ElementsAre(Parent));
 }
 

 struct Child1 : Parent<float> {};
 
 struct Child2 : Parent<int> {};
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   const CXXRecordDecl *Parent =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Parent"))->getTemplatedDecl();
   const CXXRecordDecl *ParentSpec =
       dyn_cast<CXXRecordDecl>(&findDeclWithTemplateArgs(AST, "Parent<int>"));
   const CXXRecordDecl *Child1 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child1"));
   const CXXRecordDecl *Child2 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child2"));

 
 template <>
 struct Child<int> : Parent {};
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   const CXXRecordDecl *Parent =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Parent"));
   const CXXRecordDecl *Child =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Child"))->getTemplatedDecl();
   const CXXRecordDecl *ChildSpec =
       dyn_cast<CXXRecordDecl>(&findDeclWithTemplateArgs(AST, "Child<int>"));
 
   EXPECT_THAT(typeParents(Child), ElementsAre());

 
 template <typename T>
 struct Child3 : T {};
 )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   const CXXRecordDecl *Parent =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Parent"))->getTemplatedDecl();
   const CXXRecordDecl *Child1 =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Child1"))->getTemplatedDecl();
   const CXXRecordDecl *Child2 =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Child2"))->getTemplatedDecl();
   const CXXRecordDecl *Child3 =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Child3"))->getTemplatedDecl();
)cpp");
   }
 }
 
 TEST(TypeHierarchy, RecursiveHierarchyUnbounded) {
   Annotations Source(R"cpp(
   template <int N>
   struct $SDef[[S]] : S<N + 1> {};
 
-  S^<0> s;
+  S^<0> s; // error-ok
   )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   TU.ExtraArgs.push_back("-ftemplate-depth=10");
   auto AST = TU.build();
 
   // The compiler should produce a diagnostic for hitting the
   // template instantiation depth.
TEST(TypeHierarchy, RecursiveHierarchyBounded) {
   template <int N>
   struct Foo {
     S$SRefDependent^<N> s;
   };)cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
 
-  ASSERT_TRUE(AST.getDiagnostics().empty());
-
   // Make sure getTypeHierarchy() doesn't get into an infinite recursion
   // for either a concrete starting point or a dependent starting point.
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.point("SRefConcrete"), 0, TypeHierarchyDirection::Parents);
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(
       *Result,
       AllOf(WithName("S<2>"), WithKind(SymbolKind::Struct),
TEST(TypeHierarchy, DeriveFromImplicitSpec) {
   struct Child : Parent<int> {};
 
   Parent<int> Fo^o;
   )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
-  ASSERT_TRUE(AST.getDiagnostics().empty());
 
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
       testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(*Result,
               AllOf(WithName("Parent<int>"), WithKind(SymbolKind::Struct),
                     Children(AllOf(WithName("Child"),
                                    WithKind(SymbolKind::Struct), Children()))));
 }
 
 TEST(TypeHierarchy, DeriveFromPartialSpec) {
   Annotations Source(R"cpp(
   template <typename T> struct Parent {};
   template <typename T> struct Parent<T*> {};
 
   struct Child : Parent<int*> {};
 
   Parent<int> Fo^o;
   )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
-  ASSERT_TRUE(AST.getDiagnostics().empty());
 
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
       testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(*Result, AllOf(WithName("Parent<int>"),
                              WithKind(SymbolKind::Struct), Children()));
 }
 
 TEST(TypeHierarchy, DeriveFromTemplate) {
   Annotations Source(R"cpp(
   template <typename T>
   struct Parent {};
 
   template <typename T>
   struct Child : Parent<T> {};
 
   Parent<int> Fo^o;
   )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
-  ASSERT_TRUE(AST.getDiagnostics().empty());
 
   // FIXME: We'd like this to return the implicit specialization Child<int>,
   //        but currently libIndex does not expose relationships between
   //        implicit specializations.
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
       testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));

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

for (const char *Test : Tests) {
     TestTU TU;
     TU.Code = T.code();
 
     // FIXME: Auto-completion in a template requires disabling delayed template
     // parsing.
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
 
     auto AST = TU.build();
-    for (auto &D : AST.getDiagnostics())
-      ADD_FAILURE() << D;
-    ASSERT_TRUE(AST.getDiagnostics().empty()) << Test;
-
     auto Results = locateSymbolAt(AST, T.point());
 
     if (!WantDecl) {
       EXPECT_THAT(Results, IsEmpty()) << Test;
     } else {
       ASSERT_THAT(Results, ::testing::SizeIs(1)) << Test;
       EXPECT_EQ(Results[0].PreferredDeclaration.range, *WantDecl) << Test;
       llvm::Optional<Range> GotDef;
const char *Tests[] = {
         } // namespace ns1
         int main() {
           ns1::[[Fo^o]]* Params;
         }
       )cpp",
 
       R"cpp(// Forward declaration
         class [[Foo]];
-        class [[Foo]] {}
+        class [[Foo]] {};
         int main() {
           [[Fo^o]] foo;
         }
       )cpp",
 
       R"cpp(// Function
         int [[foo]](int) {}
         int main() {
           auto *X = &[[^foo]];
-          [[foo]](42)
+          [[foo]](42);
         }
       )cpp",
 
       R"cpp(// Field
         struct Foo {
           int [[foo]];
           Foo() : [[foo]](0) {}
         };
std::vector<llvm::StringRef> ExpectedDecls;
               Q<T> y;
             })cpp",
           {},
       },
   };
   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(
         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);