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

   1 //===--- DiagnosticsTests.cpp ------------------------------------*- C++-*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "../clang-tidy/ClangTidyOptions.h"
  10 #include "Annotations.h"
  11 #include "Config.h"
  12 #include "Diagnostics.h"
  13 #include "Feature.h"
  14 #include "FeatureModule.h"
  15 #include "ParsedAST.h"
  16 #include "Protocol.h"
  17 #include "TestFS.h"
  18 #include "TestIndex.h"
  19 #include "TestTU.h"
  20 #include "TidyProvider.h"
  21 #include "index/MemIndex.h"
  22 #include "index/Ref.h"
  23 #include "index/Relation.h"
  24 #include "index/Symbol.h"
  25 #include "support/Context.h"
  26 #include "support/Path.h"
  27 #include "clang/AST/Decl.h"
  28 #include "clang/Basic/Diagnostic.h"
  29 #include "clang/Basic/DiagnosticSema.h"
  30 #include "clang/Basic/LLVM.h"
  31 #include "clang/Basic/Specifiers.h"
  32 #include "llvm/ADT/ArrayRef.h"
  33 #include "llvm/ADT/StringRef.h"
  34 #include "llvm/Support/JSON.h"
  35 #include "llvm/Support/ScopedPrinter.h"
  36 #include "llvm/Support/TargetSelect.h"
  37 #include "llvm/Testing/Support/SupportHelpers.h"
  38 #include "gmock/gmock.h"
  39 #include "gtest/gtest.h"
  40 #include <cstddef>
  41 #include <memory>
  42 #include <optional>
  43 #include <string>
  44 #include <utility>
  45 #include <vector>
  46
  47 namespace clang {
  48 namespace clangd {
  49 namespace {
  50
  51 using ::testing::_;
  52 using ::testing::AllOf;
  53 using ::testing::Contains;
  54 using ::testing::Each;
  55 using ::testing::ElementsAre;
  56 using ::testing::Field;
  57 using ::testing::IsEmpty;
  58 using ::testing::Not;
  59 using ::testing::Pair;
  60 using ::testing::SizeIs;
  61 using ::testing::UnorderedElementsAre;
  62
  63 ::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher) {
  64   return Field(&Diag::Fixes, ElementsAre(FixMatcher));
  65 }
  66
  67 ::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher1,
  68                                          ::testing::Matcher<Fix> FixMatcher2) {
  69   return Field(&Diag::Fixes, UnorderedElementsAre(FixMatcher1, FixMatcher2));
  70 }
  71
  72 ::testing::Matcher<const Diag &> withID(unsigned ID) {
  73   return Field(&Diag::ID, ID);
  74 }
  75 ::testing::Matcher<const Diag &>
  76 withNote(::testing::Matcher<Note> NoteMatcher) {
  77   return Field(&Diag::Notes, ElementsAre(NoteMatcher));
  78 }
  79
  80 ::testing::Matcher<const Diag &>
  81 withNote(::testing::Matcher<Note> NoteMatcher1,
  82          ::testing::Matcher<Note> NoteMatcher2) {
  83   return Field(&Diag::Notes, UnorderedElementsAre(NoteMatcher1, NoteMatcher2));
  84 }
  85
  86 ::testing::Matcher<const Diag &>
  87 withTag(::testing::Matcher<DiagnosticTag> TagMatcher) {
  88   return Field(&Diag::Tags, Contains(TagMatcher));
  89 }
  90
  91 MATCHER_P(hasRange, Range, "") { return arg.Range == Range; }
  92
  93 MATCHER_P2(Diag, Range, Message,
  94            "Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
  95   return arg.Range == Range && arg.Message == Message;
  96 }
  97
  98 MATCHER_P3(Fix, Range, Replacement, Message,
  99            "Fix " + llvm::to_string(Range) + " => " +
 100                ::testing::PrintToString(Replacement) + " = [" + Message + "]") {
 101   return arg.Message == Message && arg.Edits.size() == 1 &&
 102          arg.Edits[0].range == Range && arg.Edits[0].newText == Replacement;
 103 }
 104
 105 MATCHER_P(fixMessage, Message, "") { return arg.Message == Message; }
 106
 107 MATCHER_P(equalToLSPDiag, LSPDiag,
 108           "LSP diagnostic " + llvm::to_string(LSPDiag)) {
 109   if (toJSON(arg) != toJSON(LSPDiag)) {
 110     *result_listener << llvm::formatv("expected:\n{0:2}\ngot\n{1:2}",
 111                                       toJSON(LSPDiag), toJSON(arg))
 112                             .str();
 113     return false;
 114   }
 115   return true;
 116 }
 117
 118 MATCHER_P(diagSource, S, "") { return arg.Source == S; }
 119 MATCHER_P(diagName, N, "") { return arg.Name == N; }
 120 MATCHER_P(diagSeverity, S, "") { return arg.Severity == S; }
 121
 122 MATCHER_P(equalToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
 123   if (arg.Message != Fix.Message)
 124     return false;
 125   if (arg.Edits.size() != Fix.Edits.size())
 126     return false;
 127   for (std::size_t I = 0; I < arg.Edits.size(); ++I) {
 128     if (arg.Edits[I].range != Fix.Edits[I].range ||
 129         arg.Edits[I].newText != Fix.Edits[I].newText)
 130       return false;
 131   }
 132   return true;
 133 }
 134
 135 // Helper function to make tests shorter.
 136 Position pos(int Line, int Character) {
 137   Position Res;
 138   Res.line = Line;
 139   Res.character = Character;
 140   return Res;
 141 }
 142
 143 // Normally returns the provided diagnostics matcher.
 144 // If clang-tidy checks are not linked in, returns a matcher for no diagnostics!
 145 // This is intended for tests where the diagnostics come from clang-tidy checks.
 146 // We don't #ifdef each individual test as it's intrusive and we want to ensure
 147 // that as much of the test is still compiled an run as possible.
 148 ::testing::Matcher<std::vector<clangd::Diag>>
 149 ifTidyChecks(::testing::Matcher<std::vector<clangd::Diag>> M) {
 150   if (!CLANGD_TIDY_CHECKS)
 151     return IsEmpty();
 152   return M;
 153 }
 154
 155 TEST(DiagnosticsTest, DiagnosticRanges) {
 156   // Check we report correct ranges, including various edge-cases.
 157   Annotations Test(R"cpp(
 158     // error-ok
 159     #define ID(X) X
 160     namespace test{};
 161     void $decl[[foo]]();
 162     int main() {
 163       struct Container { int* begin(); int* end(); } *container;
 164       for (auto i : $insertstar[[]]$range[[container]]) {
 165       }
 166
 167       $typo[[go\
 168 o]]();
 169       foo()$semicolon[[]]//with comments
 170       $unk[[unknown]]();
 171       double $type[[bar]] = "foo";
 172       struct Foo { int x; }; Foo a;
 173       a.$nomember[[y]];
 174       test::$nomembernamespace[[test]];
 175       $macro[[ID($macroarg[[fod]])]]();
 176     }
 177   )cpp");
 178   auto TU = TestTU::withCode(Test.code());
 179   EXPECT_THAT(
 180       TU.build().getDiagnostics(),
 181       ElementsAre(
 182           // Make sure the whole token is highlighted.
 183           AllOf(Diag(Test.range("range"),
 184                      "invalid range expression of type 'struct Container *'; "
 185                      "did you mean to dereference it with '*'?"),
 186                 withFix(Fix(Test.range("insertstar"), "*", "insert '*'"))),
 187           // This range spans lines.
 188           AllOf(Diag(Test.range("typo"),
 189                      "use of undeclared identifier 'goo'; did you mean 'foo'?"),
 190                 diagSource(Diag::Clang), diagName("undeclared_var_use_suggest"),
 191                 withFix(
 192                     Fix(Test.range("typo"), "foo", "change 'go\\…' to 'foo'")),
 193                 // This is a pretty normal range.
 194                 withNote(Diag(Test.range("decl"), "'foo' declared here"))),
 195           // This range is zero-width and insertion. Therefore make sure we are
 196           // not expanding it into other tokens. Since we are not going to
 197           // replace those.
 198           AllOf(Diag(Test.range("semicolon"), "expected ';' after expression"),
 199                 withFix(Fix(Test.range("semicolon"), ";", "insert ';'"))),
 200           // This range isn't provided by clang, we expand to the token.
 201           Diag(Test.range("unk"), "use of undeclared identifier 'unknown'"),
 202           Diag(Test.range("type"),
 203                "cannot initialize a variable of type 'double' with an lvalue "
 204                "of type 'const char[4]'"),
 205           Diag(Test.range("nomember"), "no member named 'y' in 'Foo'"),
 206           Diag(Test.range("nomembernamespace"),
 207                "no member named 'test' in namespace 'test'"),
 208           AllOf(Diag(Test.range("macro"),
 209                      "use of undeclared identifier 'fod'; did you mean 'foo'?"),
 210                 withFix(Fix(Test.range("macroarg"), "foo",
 211                             "change 'fod' to 'foo'")))));
 212 }
 213
 214 // Verify that the -Wswitch case-not-covered diagnostic range covers the
 215 // whole expression. This is important because the "populate-switch" tweak
 216 // fires for the full expression range (see tweaks/PopulateSwitchTests.cpp).
 217 // The quickfix flow only works end-to-end if the tweak can be triggered on
 218 // the diagnostic's range.
 219 TEST(DiagnosticsTest, WSwitch) {
 220   Annotations Test(R"cpp(
 221     enum A { X };
 222     struct B { A a; };
 223     void foo(B b) {
 224       switch ([[b.a]]) {}
 225     }
 226   )cpp");
 227   auto TU = TestTU::withCode(Test.code());
 228   TU.ExtraArgs = {"-Wswitch"};
 229   EXPECT_THAT(TU.build().getDiagnostics(),
 230               ElementsAre(Diag(Test.range(),
 231                                "enumeration value 'X' not handled in switch")));
 232 }
 233
 234 TEST(DiagnosticsTest, FlagsMatter) {
 235   Annotations Test("[[void]] main() {} // error-ok");
 236   auto TU = TestTU::withCode(Test.code());
 237   EXPECT_THAT(TU.build().getDiagnostics(),
 238               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
 239                                 withFix(Fix(Test.range(), "int",
 240                                             "change 'void' to 'int'")))));
 241   // Same code built as C gets different diagnostics.
 242   TU.Filename = "Plain.c";
 243   EXPECT_THAT(
 244       TU.build().getDiagnostics(),
 245       ElementsAre(AllOf(
 246           Diag(Test.range(), "return type of 'main' is not 'int'"),
 247           withFix(Fix(Test.range(), "int", "change return type to 'int'")))));
 248 }
 249
 250 TEST(DiagnosticsTest, DiagnosticPreamble) {
 251   Annotations Test(R"cpp(
 252     #include $[["not-found.h"]] // error-ok
 253   )cpp");
 254
 255   auto TU = TestTU::withCode(Test.code());
 256   EXPECT_THAT(TU.build().getDiagnostics(),
 257               ElementsAre(::testing::AllOf(
 258                   Diag(Test.range(), "'not-found.h' file not found"),
 259                   diagSource(Diag::Clang), diagName("pp_file_not_found"))));
 260 }
 261
 262 TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
 263   Annotations Test(R"cpp(
 264     float foo = [[0.1f]];
 265   )cpp");
 266   auto TU = TestTU::withCode(Test.code());
 267   // Enable alias clang-tidy checks, these check emits the same diagnostics
 268   // (except the check name).
 269   TU.ClangTidyProvider = addTidyChecks("readability-uppercase-literal-suffix,"
 270                                        "hicpp-uppercase-literal-suffix");
 271   // Verify that we filter out the duplicated diagnostic message.
 272   EXPECT_THAT(
 273       TU.build().getDiagnostics(),
 274       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
 275           Diag(Test.range(),
 276                "floating point literal has suffix 'f', which is not uppercase"),
 277           diagSource(Diag::ClangTidy)))));
 278
 279   Test = Annotations(R"cpp(
 280     template<typename T>
 281     void func(T) {
 282       float f = [[0.3f]];
 283     }
 284     void k() {
 285       func(123);
 286       func(2.0);
 287     }
 288   )cpp");
 289   TU.Code = std::string(Test.code());
 290   // The check doesn't handle template instantiations which ends up emitting
 291   // duplicated messages, verify that we deduplicate them.
 292   EXPECT_THAT(
 293       TU.build().getDiagnostics(),
 294       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
 295           Diag(Test.range(),
 296                "floating point literal has suffix 'f', which is not uppercase"),
 297           diagSource(Diag::ClangTidy)))));
 298 }
 299
 300 TEST(DiagnosticsTest, ClangTidy) {
 301   Annotations Test(R"cpp(
 302     #include $deprecated[["assert.h"]]
 303
 304     #define $macrodef[[SQUARE]](X) (X)*(X)
 305     int $main[[main]]() {
 306       int y = 4;
 307       return SQUARE($macroarg[[++]]y);
 308       return $doubled[[sizeof(sizeof(int))]];
 309     }
 310
 311     // misc-no-recursion uses a custom traversal from the TUDecl
 312     void foo();
 313     void $bar[[bar]]() {
 314       foo();
 315     }
 316     void $foo[[foo]]() {
 317       bar();
 318     }
 319   )cpp");
 320   auto TU = TestTU::withCode(Test.code());
 321   TU.HeaderFilename = "assert.h"; // Suppress "not found" error.
 322   TU.ClangTidyProvider = addTidyChecks("bugprone-sizeof-expression,"
 323                                        "bugprone-macro-repeated-side-effects,"
 324                                        "modernize-deprecated-headers,"
 325                                        "modernize-use-trailing-return-type,"
 326                                        "misc-no-recursion");
 327   TU.ExtraArgs.push_back("-Wno-unsequenced");
 328   EXPECT_THAT(
 329       TU.build().getDiagnostics(),
 330       ifTidyChecks(UnorderedElementsAre(
 331           AllOf(Diag(Test.range("deprecated"),
 332                      "inclusion of deprecated C++ header 'assert.h'; consider "
 333                      "using 'cassert' instead"),
 334                 diagSource(Diag::ClangTidy),
 335                 diagName("modernize-deprecated-headers"),
 336                 withFix(Fix(Test.range("deprecated"), "<cassert>",
 337                             "change '\"assert.h\"' to '<cassert>'"))),
 338           Diag(Test.range("doubled"),
 339                "suspicious usage of 'sizeof(sizeof(...))'"),
 340           AllOf(Diag(Test.range("macroarg"),
 341                      "side effects in the 1st macro argument 'X' are "
 342                      "repeated in "
 343                      "macro expansion"),
 344                 diagSource(Diag::ClangTidy),
 345                 diagName("bugprone-macro-repeated-side-effects"),
 346                 withNote(Diag(Test.range("macrodef"),
 347                               "macro 'SQUARE' defined here"))),
 348           AllOf(Diag(Test.range("main"),
 349                      "use a trailing return type for this function"),
 350                 diagSource(Diag::ClangTidy),
 351                 diagName("modernize-use-trailing-return-type"),
 352                 // Verify there's no "[check-name]" suffix in the message.
 353                 withFix(fixMessage(
 354                     "use a trailing return type for this function"))),
 355           Diag(Test.range("foo"),
 356                "function 'foo' is within a recursive call chain"),
 357           Diag(Test.range("bar"),
 358                "function 'bar' is within a recursive call chain"))));
 359 }
 360
 361 TEST(DiagnosticsTest, ClangTidyEOF) {
 362   // clang-format off
 363   Annotations Test(R"cpp(
 364   [[#]]include <b.h>
 365   #include "a.h")cpp");
 366   // clang-format on
 367   auto TU = TestTU::withCode(Test.code());
 368   TU.ExtraArgs = {"-isystem."};
 369   TU.AdditionalFiles["a.h"] = TU.AdditionalFiles["b.h"] = "";
 370   TU.ClangTidyProvider = addTidyChecks("llvm-include-order");
 371   EXPECT_THAT(
 372       TU.build().getDiagnostics(),
 373       ifTidyChecks(Contains(
 374           AllOf(Diag(Test.range(), "#includes are not sorted properly"),
 375                 diagSource(Diag::ClangTidy), diagName("llvm-include-order")))));
 376 }
 377
 378 TEST(DiagnosticTest, TemplatesInHeaders) {
 379   // Diagnostics from templates defined in headers are placed at the expansion.
 380   Annotations Main(R"cpp(
 381     Derived<int> [[y]]; // error-ok
 382   )cpp");
 383   Annotations Header(R"cpp(
 384     template <typename T>
 385     struct Derived : [[T]] {};
 386   )cpp");
 387   TestTU TU = TestTU::withCode(Main.code());
 388   TU.HeaderCode = Header.code().str();
 389   EXPECT_THAT(
 390       TU.build().getDiagnostics(),
 391       ElementsAre(AllOf(
 392           Diag(Main.range(), "in template: base specifier must name a class"),
 393           withNote(Diag(Header.range(), "error occurred here"),
 394                    Diag(Main.range(), "in instantiation of template class "
 395                                       "'Derived<int>' requested here")))));
 396 }
 397
 398 TEST(DiagnosticTest, MakeUnique) {
 399   // We usually miss diagnostics from header functions as we don't parse them.
 400   // std::make_unique is an exception.
 401   Annotations Main(R"cpp(
 402     struct S { S(char*); };
 403     auto x = std::[[make_unique]]<S>(42); // error-ok
 404   )cpp");
 405   TestTU TU = TestTU::withCode(Main.code());
 406   TU.HeaderCode = R"cpp(
 407     namespace std {
 408     // These mocks aren't quite right - we omit unique_ptr for simplicity.
 409     // forward is included to show its body is not needed to get the diagnostic.
 410     template <typename T> T&& forward(T& t);
 411     template <typename T, typename... A> T* make_unique(A&&... args) {
 412        return new T(std::forward<A>(args)...);
 413     }
 414     }
 415   )cpp";
 416   EXPECT_THAT(TU.build().getDiagnostics(),
 417               UnorderedElementsAre(
 418                   Diag(Main.range(),
 419                        "in template: "
 420                        "no matching constructor for initialization of 'S'")));
 421 }
 422
 423 TEST(DiagnosticTest, CoroutineInHeader) {
 424   StringRef CoroutineH = R"cpp(
 425 namespace std {
 426 template <class Ret, typename... T>
 427 struct coroutine_traits { using promise_type = typename Ret::promise_type; };
 428
 429 template <class Promise = void>
 430 struct coroutine_handle {
 431   static coroutine_handle from_address(void *) noexcept;
 432   static coroutine_handle from_promise(Promise &promise);
 433   constexpr void* address() const noexcept;
 434 };
 435 template <>
 436 struct coroutine_handle<void> {
 437   template <class PromiseType>
 438   coroutine_handle(coroutine_handle<PromiseType>) noexcept;
 439   static coroutine_handle from_address(void *);
 440   constexpr void* address() const noexcept;
 441 };
 442
 443 struct awaitable {
 444   bool await_ready() noexcept { return false; }
 445   void await_suspend(coroutine_handle<>) noexcept {}
 446   void await_resume() noexcept {}
 447 };
 448 } // namespace std
 449   )cpp";
 450
 451   StringRef Header = R"cpp(
 452 #include "coroutine.h"
 453 template <typename T> struct [[clang::coro_return_type]] Gen {
 454   struct promise_type {
 455     Gen<T> get_return_object() {
 456       return {};
 457     }
 458     std::awaitable  initial_suspend();
 459     std::awaitable  final_suspend() noexcept;
 460     void unhandled_exception();
 461     void return_value(T t);
 462   };
 463 };
 464
 465 Gen<int> foo_coro(int b) { co_return b; }
 466   )cpp";
 467   Annotations Main(R"cpp(
 468 // error-ok
 469 #include "header.hpp"
 470 Gen<int> $[[bar_coro]](int b) { return foo_coro(b); }
 471   )cpp");
 472   TestTU TU = TestTU::withCode(Main.code());
 473   TU.AdditionalFiles["coroutine.h"] = std::string(CoroutineH);
 474   TU.AdditionalFiles["header.hpp"] = std::string(Header);
 475   TU.ExtraArgs.push_back("--std=c++20");
 476   EXPECT_THAT(TU.build().getDiagnostics(), ElementsAre(hasRange(Main.range())));
 477 }
 478
 479 TEST(DiagnosticTest, MakeShared) {
 480   // We usually miss diagnostics from header functions as we don't parse them.
 481   // std::make_shared is only parsed when --parse-forwarding-functions is set
 482   Annotations Main(R"cpp(
 483     struct S { S(char*); };
 484     auto x = std::[[make_shared]]<S>(42); // error-ok
 485   )cpp");
 486   TestTU TU = TestTU::withCode(Main.code());
 487   TU.HeaderCode = R"cpp(
 488     namespace std {
 489     // These mocks aren't quite right - we omit shared_ptr for simplicity.
 490     // forward is included to show its body is not needed to get the diagnostic.
 491     template <typename T> T&& forward(T& t);
 492     template <typename T, typename... A> T* make_shared(A&&... args) {
 493        return new T(std::forward<A>(args)...);
 494     }
 495     }
 496   )cpp";
 497   TU.ParseOpts.PreambleParseForwardingFunctions = true;
 498   EXPECT_THAT(TU.build().getDiagnostics(),
 499               UnorderedElementsAre(
 500                   Diag(Main.range(),
 501                        "in template: "
 502                        "no matching constructor for initialization of 'S'")));
 503 }
 504
 505 TEST(DiagnosticTest, NoMultipleDiagnosticInFlight) {
 506   Annotations Main(R"cpp(
 507     template <typename T> struct Foo {
 508       T *begin();
 509       T *end();
 510     };
 511     struct LabelInfo {
 512       int a;
 513       bool b;
 514     };
 515
 516     void f() {
 517       Foo<LabelInfo> label_info_map;
 518       [[for]] (auto it = label_info_map.begin(); it != label_info_map.end(); ++it) {
 519         auto S = *it;
 520       }
 521     }
 522   )cpp");
 523   TestTU TU = TestTU::withCode(Main.code());
 524   TU.ClangTidyProvider = addTidyChecks("modernize-loop-convert");
 525   EXPECT_THAT(
 526       TU.build().getDiagnostics(),
 527       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
 528           Diag(Main.range(), "use range-based for loop instead"),
 529           diagSource(Diag::ClangTidy), diagName("modernize-loop-convert")))));
 530 }
 531
 532 TEST(DiagnosticTest, RespectsDiagnosticConfig) {
 533   Annotations Main(R"cpp(
 534     // error-ok
 535     void x() {
 536       [[unknown]]();
 537       $ret[[return]] 42;
 538     }
 539   )cpp");
 540   auto TU = TestTU::withCode(Main.code());
 541   EXPECT_THAT(
 542       TU.build().getDiagnostics(),
 543       ElementsAre(Diag(Main.range(), "use of undeclared identifier 'unknown'"),
 544                   Diag(Main.range("ret"),
 545                        "void function 'x' should not return a value")));
 546   Config Cfg;
 547   Cfg.Diagnostics.Suppress.insert("return-mismatch");
 548   WithContextValue WithCfg(Config::Key, std::move(Cfg));
 549   EXPECT_THAT(TU.build().getDiagnostics(),
 550               ElementsAre(Diag(Main.range(),
 551                                "use of undeclared identifier 'unknown'")));
 552 }
 553
 554 TEST(DiagnosticTest, RespectsDiagnosticConfigInHeader) {
 555   Annotations Header(R"cpp(
 556     int x = "42";  // error-ok
 557   )cpp");
 558   Annotations Main(R"cpp(
 559     #include "header.hpp"
 560   )cpp");
 561   auto TU = TestTU::withCode(Main.code());
 562   TU.AdditionalFiles["header.hpp"] = std::string(Header.code());
 563   Config Cfg;
 564   Cfg.Diagnostics.Suppress.insert("init_conversion_failed");
 565   WithContextValue WithCfg(Config::Key, std::move(Cfg));
 566   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 567 }
 568
 569 TEST(DiagnosticTest, ClangTidySuppressionComment) {
 570   Annotations Main(R"cpp(
 571     int main() {
 572       int i = 3;
 573       double d = 8 / i;  // NOLINT
 574       // NOLINTNEXTLINE
 575       double e = 8 / i;
 576       #define BAD 8 / i
 577       double f = BAD;  // NOLINT
 578       double g = [[8]] / i;
 579       #define BAD2 BAD
 580       double h = BAD2;  // NOLINT
 581       // NOLINTBEGIN
 582       double x = BAD2;
 583       double y = BAD2;
 584       // NOLINTEND
 585
 586       // verify no crashes on unmatched nolints.
 587       // NOLINTBEGIN
 588     }
 589   )cpp");
 590   TestTU TU = TestTU::withCode(Main.code());
 591   TU.ClangTidyProvider = addTidyChecks("bugprone-integer-division");
 592   EXPECT_THAT(
 593       TU.build().getDiagnostics(),
 594       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
 595           Diag(Main.range(), "result of integer division used in a floating "
 596                              "point context; possible loss of precision"),
 597           diagSource(Diag::ClangTidy),
 598           diagName("bugprone-integer-division")))));
 599 }
 600
 601 TEST(DiagnosticTest, ClangTidySystemMacro) {
 602   Annotations Main(R"cpp(
 603     #include "user.h"
 604     #include "system.h"
 605     int i = 3;
 606     double x = $inline[[8]] / i;
 607     double y = $user[[DIVIDE_USER]](i);
 608     double z = DIVIDE_SYS(i);
 609   )cpp");
 610
 611   auto TU = TestTU::withCode(Main.code());
 612   TU.AdditionalFiles["user.h"] = R"cpp(
 613     #define DIVIDE_USER(Y) 8/Y
 614   )cpp";
 615   TU.AdditionalFiles["system.h"] = R"cpp(
 616     #pragma clang system_header
 617     #define DIVIDE_SYS(Y) 8/Y
 618   )cpp";
 619
 620   TU.ClangTidyProvider = addTidyChecks("bugprone-integer-division");
 621   std::string BadDivision = "result of integer division used in a floating "
 622                             "point context; possible loss of precision";
 623
 624   // Expect to see warning from user macros, but not system macros.
 625   // This matches clang-tidy --system-headers=0 (the default).
 626   EXPECT_THAT(TU.build().getDiagnostics(),
 627               ifTidyChecks(
 628                   UnorderedElementsAre(Diag(Main.range("inline"), BadDivision),
 629                                        Diag(Main.range("user"), BadDivision))));
 630 }
 631
 632 TEST(DiagnosticTest, ClangTidyWarningAsError) {
 633   Annotations Main(R"cpp(
 634     int main() {
 635       int i = 3;
 636       double f = [[8]] / i; // error-ok
 637     }
 638   )cpp");
 639   TestTU TU = TestTU::withCode(Main.code());
 640   TU.ClangTidyProvider =
 641       addTidyChecks("bugprone-integer-division", "bugprone-integer-division");
 642   EXPECT_THAT(
 643       TU.build().getDiagnostics(),
 644       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
 645           Diag(Main.range(), "result of integer division used in a floating "
 646                              "point context; possible loss of precision"),
 647           diagSource(Diag::ClangTidy), diagName("bugprone-integer-division"),
 648           diagSeverity(DiagnosticsEngine::Error)))));
 649 }
 650
 651 TidyProvider addClangArgs(std::vector<llvm::StringRef> ExtraArgs,
 652                           llvm::StringRef Checks) {
 653   return [ExtraArgs = std::move(ExtraArgs), Checks = Checks.str()](
 654              tidy::ClangTidyOptions &Opts, llvm::StringRef) {
 655     if (!Opts.ExtraArgs)
 656       Opts.ExtraArgs.emplace();
 657     for (llvm::StringRef Arg : ExtraArgs)
 658       Opts.ExtraArgs->emplace_back(Arg);
 659     if (!Checks.empty())
 660       Opts.Checks = Checks;
 661   };
 662 }
 663
 664 TEST(DiagnosticTest, ClangTidyEnablesClangWarning) {
 665   Annotations Main(R"cpp( // error-ok
 666     static void [[foo]]() {}
 667   )cpp");
 668   TestTU TU = TestTU::withCode(Main.code());
 669   // This is always emitted as a clang warning, not a clang-tidy diagnostic.
 670   auto UnusedFooWarning =
 671       AllOf(Diag(Main.range(), "unused function 'foo'"),
 672             diagName("-Wunused-function"), diagSource(Diag::Clang),
 673             diagSeverity(DiagnosticsEngine::Warning));
 674
 675   // Check the -Wunused warning isn't initially on.
 676   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 677
 678   // We enable warnings based on clang-tidy extra args, if the matching
 679   // clang-diagnostic- is there.
 680   TU.ClangTidyProvider =
 681       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-function");
 682   EXPECT_THAT(TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning));
 683
 684   // clang-diagnostic-* is acceptable
 685   TU.ClangTidyProvider = addClangArgs({"-Wunused"}, "clang-diagnostic-*");
 686   EXPECT_THAT(TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning));
 687   // And plain * (may turn on other checks too).
 688   TU.ClangTidyProvider = addClangArgs({"-Wunused"}, "*");
 689   EXPECT_THAT(TU.build().getDiagnostics(), Contains(UnusedFooWarning));
 690   // And we can explicitly exclude a category too.
 691   TU.ClangTidyProvider = addClangArgs(
 692       {"-Wunused"}, "clang-diagnostic-*,-clang-diagnostic-unused-function");
 693   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 694
 695   // Without the exact check specified, the warnings are not enabled.
 696   TU.ClangTidyProvider = addClangArgs({"-Wunused"}, "clang-diagnostic-unused");
 697   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 698
 699   // We don't respect other args.
 700   TU.ClangTidyProvider = addClangArgs({"-Wunused", "-Dfoo=bar"},
 701                                       "clang-diagnostic-unused-function");
 702   EXPECT_THAT(TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning))
 703       << "Not unused function 'bar'!";
 704
 705   // -Werror doesn't apply to warnings enabled by clang-tidy extra args.
 706   TU.ExtraArgs = {"-Werror"};
 707   TU.ClangTidyProvider =
 708       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-function");
 709   EXPECT_THAT(TU.build().getDiagnostics(),
 710               ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
 711
 712   // But clang-tidy extra args won't *downgrade* errors to warnings either.
 713   TU.ExtraArgs = {"-Wunused", "-Werror"};
 714   TU.ClangTidyProvider =
 715       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-function");
 716   EXPECT_THAT(TU.build().getDiagnostics(),
 717               ElementsAre(diagSeverity(DiagnosticsEngine::Error)));
 718
 719   // FIXME: we're erroneously downgrading the whole group, this should be Error.
 720   TU.ExtraArgs = {"-Wunused-function", "-Werror"};
 721   TU.ClangTidyProvider =
 722       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-label");
 723   EXPECT_THAT(TU.build().getDiagnostics(),
 724               ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
 725
 726   // This looks silly, but it's the typical result if a warning is enabled by a
 727   // high-level .clang-tidy file and disabled by a low-level one.
 728   TU.ExtraArgs = {};
 729   TU.ClangTidyProvider = addClangArgs({"-Wunused", "-Wno-unused"},
 730                                       "clang-diagnostic-unused-function");
 731   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 732
 733   // Overriding only works in the proper order.
 734   TU.ClangTidyProvider =
 735       addClangArgs({"-Wunused"}, {"clang-diagnostic-unused-function"});
 736   EXPECT_THAT(TU.build().getDiagnostics(), SizeIs(1));
 737
 738   // More specific vs less-specific: match clang behavior
 739   TU.ClangTidyProvider = addClangArgs({"-Wunused", "-Wno-unused-function"},
 740                                       {"clang-diagnostic-unused-function"});
 741   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 742   TU.ClangTidyProvider = addClangArgs({"-Wunused-function", "-Wno-unused"},
 743                                       {"clang-diagnostic-unused-function"});
 744   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 745
 746   // We do allow clang-tidy config to disable warnings from the compile
 747   // command. It's unclear this is ideal, but it's hard to avoid.
 748   TU.ExtraArgs = {"-Wunused"};
 749   TU.ClangTidyProvider = addClangArgs({"-Wno-unused"}, {});
 750   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 751 }
 752
 753 TEST(DiagnosticTest, LongFixMessages) {
 754   // We limit the size of printed code.
 755   Annotations Source(R"cpp(
 756     int main() {
 757       // error-ok
 758       int somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier;
 759       [[omereallyreallyreallyreallyreallyreallyreallyreallylongidentifier]]= 10;
 760     }
 761   )cpp");
 762   TestTU TU = TestTU::withCode(Source.code());
 763   EXPECT_THAT(
 764       TU.build().getDiagnostics(),
 765       ElementsAre(withFix(Fix(
 766           Source.range(),
 767           "somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier",
 768           "change 'omereallyreallyreallyreallyreallyreallyreallyreall…' to "
 769           "'somereallyreallyreallyreallyreallyreallyreallyreal…'"))));
 770   // Only show changes up to a first newline.
 771   Source = Annotations(R"cpp(
 772     // error-ok
 773     int main() {
 774       int ident;
 775       [[ide\
 776 n]] = 10; // error-ok
 777     }
 778   )cpp");
 779   TU.Code = std::string(Source.code());
 780   EXPECT_THAT(TU.build().getDiagnostics(),
 781               ElementsAre(withFix(
 782                   Fix(Source.range(), "ident", "change 'ide\\…' to 'ident'"))));
 783 }
 784
 785 TEST(DiagnosticTest, NewLineFixMessage) {
 786   Annotations Source("int a;[[]]");
 787   TestTU TU = TestTU::withCode(Source.code());
 788   TU.ExtraArgs = {"-Wnewline-eof"};
 789   EXPECT_THAT(
 790       TU.build().getDiagnostics(),
 791       ElementsAre(withFix((Fix(Source.range(), "\n", "insert '\\n'")))));
 792 }
 793
 794 TEST(DiagnosticTest, ClangTidySuppressionCommentTrumpsWarningAsError) {
 795   Annotations Main(R"cpp(
 796     int main() {
 797       int i = 3;
 798       double f = [[8]] / i;  // NOLINT
 799     }
 800   )cpp");
 801   TestTU TU = TestTU::withCode(Main.code());
 802   TU.ClangTidyProvider =
 803       addTidyChecks("bugprone-integer-division", "bugprone-integer-division");
 804   EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre());
 805 }
 806
 807 TEST(DiagnosticTest, ClangTidyNoLiteralDataInMacroToken) {
 808   Annotations Main(R"cpp(
 809     #define SIGTERM 15
 810     using pthread_t = int;
 811     int pthread_kill(pthread_t thread, int sig);
 812     int func() {
 813       pthread_t thread;
 814       return pthread_kill(thread, 0);
 815     }
 816   )cpp");
 817   TestTU TU = TestTU::withCode(Main.code());
 818   TU.ClangTidyProvider = addTidyChecks("bugprone-bad-signal-to-kill-thread");
 819   EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre()); // no-crash
 820 }
 821
 822 TEST(DiagnosticTest, ElseAfterReturnRange) {
 823   Annotations Main(R"cpp(
 824     int foo(int cond) {
 825     if (cond == 1) {
 826       return 42;
 827     } [[else]] if (cond == 2) {
 828       return 43;
 829     }
 830     return 44;
 831     }
 832   )cpp");
 833   TestTU TU = TestTU::withCode(Main.code());
 834   TU.ClangTidyProvider = addTidyChecks("llvm-else-after-return");
 835   EXPECT_THAT(TU.build().getDiagnostics(),
 836               ifTidyChecks(ElementsAre(
 837                   Diag(Main.range(), "do not use 'else' after 'return'"))));
 838 }
 839
 840 TEST(DiagnosticTest, ClangTidySelfContainedDiags) {
 841   Annotations Main(R"cpp($MathHeader[[]]
 842     struct Foo{
 843       int A, B;
 844       Foo()$Fix[[]] {
 845         $A[[A = 1;]]
 846         $B[[B = 1;]]
 847       }
 848     };
 849     void InitVariables() {
 850       float $C[[C]]$CFix[[]];
 851       double $D[[D]]$DFix[[]];
 852     }
 853   )cpp");
 854   TestTU TU = TestTU::withCode(Main.code());
 855   TU.ClangTidyProvider =
 856       addTidyChecks("cppcoreguidelines-prefer-member-initializer,"
 857                     "cppcoreguidelines-init-variables");
 858   clangd::Fix ExpectedAFix;
 859   ExpectedAFix.Message =
 860       "'A' should be initialized in a member initializer of the constructor";
 861   ExpectedAFix.Edits.push_back(TextEdit{Main.range("Fix"), " : A(1)"});
 862   ExpectedAFix.Edits.push_back(TextEdit{Main.range("A"), ""});
 863
 864   // When invoking clang-tidy normally, this code would produce `, B(1)` as the
 865   // fix the `B` member, as it would think its already included the ` : ` from
 866   // the previous `A` fix.
 867   clangd::Fix ExpectedBFix;
 868   ExpectedBFix.Message =
 869       "'B' should be initialized in a member initializer of the constructor";
 870   ExpectedBFix.Edits.push_back(TextEdit{Main.range("Fix"), " : B(1)"});
 871   ExpectedBFix.Edits.push_back(TextEdit{Main.range("B"), ""});
 872
 873   clangd::Fix ExpectedCFix;
 874   ExpectedCFix.Message = "variable 'C' is not initialized";
 875   ExpectedCFix.Edits.push_back(TextEdit{Main.range("CFix"), " = NAN"});
 876   ExpectedCFix.Edits.push_back(
 877       TextEdit{Main.range("MathHeader"), "#include <math.h>\n\n"});
 878
 879   // Again in clang-tidy only the include directive would be emitted for the
 880   // first warning. However we need the include attaching for both warnings.
 881   clangd::Fix ExpectedDFix;
 882   ExpectedDFix.Message = "variable 'D' is not initialized";
 883   ExpectedDFix.Edits.push_back(TextEdit{Main.range("DFix"), " = NAN"});
 884   ExpectedDFix.Edits.push_back(
 885       TextEdit{Main.range("MathHeader"), "#include <math.h>\n\n"});
 886   EXPECT_THAT(
 887       TU.build().getDiagnostics(),
 888       ifTidyChecks(UnorderedElementsAre(
 889           AllOf(Diag(Main.range("A"), "'A' should be initialized in a member "
 890                                       "initializer of the constructor"),
 891                 withFix(equalToFix(ExpectedAFix))),
 892           AllOf(Diag(Main.range("B"), "'B' should be initialized in a member "
 893                                       "initializer of the constructor"),
 894                 withFix(equalToFix(ExpectedBFix))),
 895           AllOf(Diag(Main.range("C"), "variable 'C' is not initialized"),
 896                 withFix(equalToFix(ExpectedCFix))),
 897           AllOf(Diag(Main.range("D"), "variable 'D' is not initialized"),
 898                 withFix(equalToFix(ExpectedDFix))))));
 899 }
 900
 901 TEST(DiagnosticTest, ClangTidySelfContainedDiagsFormatting) {
 902   Annotations Main(R"cpp(
 903     class Interface {
 904     public:
 905       virtual void Reset1() = 0;
 906       virtual void Reset2() = 0;
 907     };
 908     class A : public Interface {
 909       // This will be marked by clangd to use override instead of virtual
 910       $virtual1[[virtual    ]]void $Reset1[[Reset1]]()$override1[[]];
 911       $virtual2[[virtual      ]]/**/void $Reset2[[Reset2]]()$override2[[]];
 912     };
 913   )cpp");
 914   TestTU TU = TestTU::withCode(Main.code());
 915   TU.ClangTidyProvider =
 916       addTidyChecks("cppcoreguidelines-explicit-virtual-functions,");
 917   clangd::Fix const ExpectedFix1{
 918       "prefer using 'override' or (rarely) 'final' "
 919       "instead of 'virtual'",
 920       {TextEdit{Main.range("override1"), " override"},
 921        TextEdit{Main.range("virtual1"), ""}},
 922       {}};
 923   clangd::Fix const ExpectedFix2{
 924       "prefer using 'override' or (rarely) 'final' "
 925       "instead of 'virtual'",
 926       {TextEdit{Main.range("override2"), " override"},
 927        TextEdit{Main.range("virtual2"), ""}},
 928       {}};
 929   // Note that in the Fix we expect the "virtual" keyword and the following
 930   // whitespace to be deleted
 931   EXPECT_THAT(TU.build().getDiagnostics(),
 932               ifTidyChecks(UnorderedElementsAre(
 933                   AllOf(Diag(Main.range("Reset1"),
 934                              "prefer using 'override' or (rarely) 'final' "
 935                              "instead of 'virtual'"),
 936                         withFix(equalToFix(ExpectedFix1))),
 937                   AllOf(Diag(Main.range("Reset2"),
 938                              "prefer using 'override' or (rarely) 'final' "
 939                              "instead of 'virtual'"),
 940                         withFix(equalToFix(ExpectedFix2))))));
 941 }
 942
 943 TEST(DiagnosticsTest, Preprocessor) {
 944   // This looks like a preamble, but there's an #else in the middle!
 945   // Check that:
 946   //  - the #else doesn't generate diagnostics (we had this bug)
 947   //  - we get diagnostics from the taken branch
 948   //  - we get no diagnostics from the not taken branch
 949   Annotations Test(R"cpp(
 950     #ifndef FOO
 951     #define FOO
 952       int a = [[b]]; // error-ok
 953     #else
 954       int x = y;
 955     #endif
 956     )cpp");
 957   EXPECT_THAT(
 958       TestTU::withCode(Test.code()).build().getDiagnostics(),
 959       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'b'")));
 960 }
 961
 962 TEST(DiagnosticsTest, IgnoreVerify) {
 963   auto TU = TestTU::withCode(R"cpp(
 964     int a; // expected-error {{}}
 965   )cpp");
 966   TU.ExtraArgs.push_back("-Xclang");
 967   TU.ExtraArgs.push_back("-verify");
 968   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 969 }
 970
 971 TEST(DiagnosticTest, IgnoreBEFilelistOptions) {
 972   auto TU = TestTU::withCode("");
 973   TU.ExtraArgs.push_back("-Xclang");
 974   for (const auto *DisableOption :
 975        {"-fsanitize-ignorelist=null", "-fprofile-list=null",
 976         "-fxray-always-instrument=null", "-fxray-never-instrument=null",
 977         "-fxray-attr-list=null"}) {
 978     TU.ExtraArgs.push_back(DisableOption);
 979     EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 980     TU.ExtraArgs.pop_back();
 981   }
 982 }
 983
 984 // Recursive main-file include is diagnosed, and doesn't crash.
 985 TEST(DiagnosticsTest, RecursivePreamble) {
 986   auto TU = TestTU::withCode(R"cpp(
 987     #include "foo.h" // error-ok
 988     int symbol;
 989   )cpp");
 990   TU.Filename = "foo.h";
 991   EXPECT_THAT(TU.build().getDiagnostics(),
 992               ElementsAre(diagName("pp_including_mainfile_in_preamble")));
 993   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 994 }
 995
 996 // Recursive main-file include with #pragma once guard is OK.
 997 TEST(DiagnosticsTest, RecursivePreamblePragmaOnce) {
 998   auto TU = TestTU::withCode(R"cpp(
 999     #pragma once
1000     #include "foo.h"
1001     int symbol;
1002   )cpp");
1003   TU.Filename = "foo.h";
1004   EXPECT_THAT(TU.build().getDiagnostics(),
1005               Not(Contains(diagName("pp_including_mainfile_in_preamble"))));
1006   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
1007 }
1008
1009 // Recursive main-file include with #ifndef guard should be OK.
1010 // However, it's not yet recognized (incomplete at end of preamble).
1011 TEST(DiagnosticsTest, RecursivePreambleIfndefGuard) {
1012   auto TU = TestTU::withCode(R"cpp(
1013     #ifndef FOO
1014     #define FOO
1015     #include "foo.h" // error-ok
1016     int symbol;
1017     #endif
1018   )cpp");
1019   TU.Filename = "foo.h";
1020   // FIXME: should be no errors here.
1021   EXPECT_THAT(TU.build().getDiagnostics(),
1022               ElementsAre(diagName("pp_including_mainfile_in_preamble")));
1023   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
1024 }
1025
1026 TEST(DiagnosticsTest, PreambleWithPragmaAssumeNonnull) {
1027   auto TU = TestTU::withCode(R"cpp(
1028 #pragma clang assume_nonnull begin
1029 void foo(int *x);
1030 #pragma clang assume_nonnull end
1031 )cpp");
1032   auto AST = TU.build();
1033   EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
1034   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
1035   ASSERT_TRUE(X->getOriginalType()->getNullability() ==
1036               NullabilityKind::NonNull);
1037 }
1038
1039 TEST(DiagnosticsTest, PreambleHeaderWithBadPragmaAssumeNonnull) {
1040   Annotations Header(R"cpp(
1041 #pragma clang assume_nonnull begin  // error-ok
1042 void foo(int *X);
1043 )cpp");
1044   auto TU = TestTU::withCode(R"cpp(
1045 #include "foo.h"  // unterminated assume_nonnull should not affect bar.
1046 void bar(int *Y);
1047 )cpp");
1048   TU.AdditionalFiles = {{"foo.h", std::string(Header.code())}};
1049   auto AST = TU.build();
1050   EXPECT_THAT(AST.getDiagnostics(),
1051               ElementsAre(diagName("pp_eof_in_assume_nonnull")));
1052   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
1053   ASSERT_TRUE(X->getOriginalType()->getNullability() ==
1054               NullabilityKind::NonNull);
1055   const auto *Y = cast<FunctionDecl>(findDecl(AST, "bar")).getParamDecl(0);
1056   ASSERT_FALSE(Y->getOriginalType()->getNullability());
1057 }
1058
1059 TEST(DiagnosticsTest, InsideMacros) {
1060   Annotations Test(R"cpp(
1061     #define TEN 10
1062     #define RET(x) return x + 10
1063
1064     int* foo() {
1065       RET($foo[[0]]); // error-ok
1066     }
1067     int* bar() {
1068       return $bar[[TEN]];
1069     }
1070     )cpp");
1071   EXPECT_THAT(TestTU::withCode(Test.code()).build().getDiagnostics(),
1072               ElementsAre(Diag(Test.range("foo"),
1073                                "cannot initialize return object of type "
1074                                "'int *' with an rvalue of type 'int'"),
1075                           Diag(Test.range("bar"),
1076                                "cannot initialize return object of type "
1077                                "'int *' with an rvalue of type 'int'")));
1078 }
1079
1080 TEST(DiagnosticsTest, NoFixItInMacro) {
1081   Annotations Test(R"cpp(
1082     #define Define(name) void name() {}
1083
1084     [[Define]](main) // error-ok
1085   )cpp");
1086   auto TU = TestTU::withCode(Test.code());
1087   EXPECT_THAT(TU.build().getDiagnostics(),
1088               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
1089                                 Not(withFix(_)))));
1090 }
1091
1092 TEST(DiagnosticsTest, PragmaSystemHeader) {
1093   Annotations Test("#pragma clang [[system_header]]\n");
1094   auto TU = TestTU::withCode(Test.code());
1095   EXPECT_THAT(
1096       TU.build().getDiagnostics(),
1097       ElementsAre(AllOf(
1098           Diag(Test.range(), "#pragma system_header ignored in main file"))));
1099   TU.Filename = "TestTU.h";
1100   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
1101 }
1102
1103 TEST(ClangdTest, MSAsm) {
1104   // Parsing MS assembly tries to use the target MCAsmInfo, which we don't link.
1105   // We used to crash here. Now clang emits a diagnostic, which we filter out.
1106   llvm::InitializeAllTargetInfos(); // As in ClangdMain
1107   auto TU = TestTU::withCode("void fn() { __asm { cmp cl,64 } }");
1108   TU.ExtraArgs = {"-fms-extensions"};
1109   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
1110 }
1111
1112 TEST(DiagnosticsTest, ToLSP) {
1113   URIForFile MainFile =
1114       URIForFile::canonicalize(testPath("foo/bar/main.cpp"), "");
1115   URIForFile HeaderFile =
1116       URIForFile::canonicalize(testPath("foo/bar/header.h"), "");
1117
1118   clangd::Diag D;
1119   D.ID = clang::diag::err_undeclared_var_use;
1120   D.Tags = {DiagnosticTag::Unnecessary};
1121   D.Name = "undeclared_var_use";
1122   D.Source = clangd::Diag::Clang;
1123   D.Message = "something terrible happened";
1124   D.Range = {pos(1, 2), pos(3, 4)};
1125   D.InsideMainFile = true;
1126   D.Severity = DiagnosticsEngine::Error;
1127   D.File = "foo/bar/main.cpp";
1128   D.AbsFile = std::string(MainFile.file());
1129   D.OpaqueData["test"] = "bar";
1130
1131   clangd::Note NoteInMain;
1132   NoteInMain.Message = "declared somewhere in the main file";
1133   NoteInMain.Range = {pos(5, 6), pos(7, 8)};
1134   NoteInMain.Severity = DiagnosticsEngine::Remark;
1135   NoteInMain.File = "../foo/bar/main.cpp";
1136   NoteInMain.InsideMainFile = true;
1137   NoteInMain.AbsFile = std::string(MainFile.file());
1138
1139   D.Notes.push_back(NoteInMain);
1140
1141   clangd::Note NoteInHeader;
1142   NoteInHeader.Message = "declared somewhere in the header file";
1143   NoteInHeader.Range = {pos(9, 10), pos(11, 12)};
1144   NoteInHeader.Severity = DiagnosticsEngine::Note;
1145   NoteInHeader.File = "../foo/baz/header.h";
1146   NoteInHeader.InsideMainFile = false;
1147   NoteInHeader.AbsFile = std::string(HeaderFile.file());
1148   D.Notes.push_back(NoteInHeader);
1149
1150   clangd::Fix F;
1151   F.Message = "do something";
1152   D.Fixes.push_back(F);
1153
1154   // Diagnostics should turn into these:
1155   clangd::Diagnostic MainLSP;
1156   MainLSP.range = D.Range;
1157   MainLSP.severity = getSeverity(DiagnosticsEngine::Error);
1158   MainLSP.code = "undeclared_var_use";
1159   MainLSP.source = "clang";
1160   MainLSP.message =
1161       R"(Something terrible happened (fix available)
1162
1163 main.cpp:6:7: remark: declared somewhere in the main file
1164
1165 ../foo/baz/header.h:10:11:
1166 note: declared somewhere in the header file)";
1167   MainLSP.tags = {DiagnosticTag::Unnecessary};
1168   MainLSP.data = D.OpaqueData;
1169
1170   clangd::Diagnostic NoteInMainLSP;
1171   NoteInMainLSP.range = NoteInMain.Range;
1172   NoteInMainLSP.severity = getSeverity(DiagnosticsEngine::Remark);
1173   NoteInMainLSP.message = R"(Declared somewhere in the main file
1174
1175 main.cpp:2:3: error: something terrible happened)";
1176
1177   ClangdDiagnosticOptions Opts;
1178   // Transform diagnostics and check the results.
1179   std::vector<std::pair<clangd::Diagnostic, std::vector<clangd::Fix>>> LSPDiags;
1180   toLSPDiags(D, MainFile, Opts,
1181              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix> Fixes) {
1182                LSPDiags.push_back(
1183                    {std::move(LSPDiag),
1184                     std::vector<clangd::Fix>(Fixes.begin(), Fixes.end())});
1185              });
1186
1187   EXPECT_THAT(
1188       LSPDiags,
1189       ElementsAre(Pair(equalToLSPDiag(MainLSP), ElementsAre(equalToFix(F))),
1190                   Pair(equalToLSPDiag(NoteInMainLSP), IsEmpty())));
1191   EXPECT_EQ(LSPDiags[0].first.code, "undeclared_var_use");
1192   EXPECT_EQ(LSPDiags[0].first.source, "clang");
1193   EXPECT_EQ(LSPDiags[1].first.code, "");
1194   EXPECT_EQ(LSPDiags[1].first.source, "");
1195
1196   // Same thing, but don't flatten notes into the main list.
1197   LSPDiags.clear();
1198   Opts.EmitRelatedLocations = true;
1199   toLSPDiags(D, MainFile, Opts,
1200              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix> Fixes) {
1201                LSPDiags.push_back(
1202                    {std::move(LSPDiag),
1203                     std::vector<clangd::Fix>(Fixes.begin(), Fixes.end())});
1204              });
1205   MainLSP.message = "Something terrible happened (fix available)";
1206   DiagnosticRelatedInformation NoteInMainDRI;
1207   NoteInMainDRI.message = "Declared somewhere in the main file";
1208   NoteInMainDRI.location.range = NoteInMain.Range;
1209   NoteInMainDRI.location.uri = MainFile;
1210   MainLSP.relatedInformation = {NoteInMainDRI};
1211   DiagnosticRelatedInformation NoteInHeaderDRI;
1212   NoteInHeaderDRI.message = "Declared somewhere in the header file";
1213   NoteInHeaderDRI.location.range = NoteInHeader.Range;
1214   NoteInHeaderDRI.location.uri = HeaderFile;
1215   MainLSP.relatedInformation = {NoteInMainDRI, NoteInHeaderDRI};
1216   EXPECT_THAT(LSPDiags, ElementsAre(Pair(equalToLSPDiag(MainLSP),
1217                                          ElementsAre(equalToFix(F)))));
1218 }
1219
1220 struct SymbolWithHeader {
1221   std::string QName;
1222   std::string DeclaringFile;
1223   std::string IncludeHeader;
1224 };
1225
1226 std::unique_ptr<SymbolIndex>
1227 buildIndexWithSymbol(llvm::ArrayRef<SymbolWithHeader> Syms) {
1228   SymbolSlab::Builder Slab;
1229   for (const auto &S : Syms) {
1230     Symbol Sym = cls(S.QName);
1231     Sym.Flags |= Symbol::IndexedForCodeCompletion;
1232     Sym.CanonicalDeclaration.FileURI = S.DeclaringFile.c_str();
1233     Sym.Definition.FileURI = S.DeclaringFile.c_str();
1234     Sym.IncludeHeaders.emplace_back(S.IncludeHeader, 1, Symbol::Include);
1235     Slab.insert(Sym);
1236   }
1237   return MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
1238 }
1239
1240 TEST(IncludeFixerTest, IncompleteType) {
1241   auto TU = TestTU::withHeaderCode("namespace ns { class X; } ns::X *x;");
1242   TU.ExtraArgs.push_back("-std=c++20");
1243   auto Index = buildIndexWithSymbol(
1244       {SymbolWithHeader{"ns::X", "unittest:///x.h", "\"x.h\""}});
1245   TU.ExternalIndex = Index.get();
1246
1247   std::vector<std::pair<llvm::StringRef, llvm::StringRef>> Tests{
1248       {"incomplete_nested_name_spec", "[[ns::X::]]Nested n;"},
1249       {"incomplete_base_class", "class Y : [[ns::X]] {};"},
1250       {"incomplete_member_access", "auto i = x[[->]]f();"},
1251       {"incomplete_type", "auto& [[[]]m] = *x;"},
1252       {"init_incomplete_type",
1253        "struct C { static int f(ns::X&); }; int i = C::f([[{]]});"},
1254       {"bad_cast_incomplete", "auto a = [[static_cast]]<ns::X>(0);"},
1255       {"template_nontype_parm_incomplete", "template <ns::X [[foo]]> int a;"},
1256       {"typecheck_decl_incomplete_type", "ns::X [[var]];"},
1257       {"typecheck_incomplete_tag", "auto i = [[(*x)]]->f();"},
1258       {"typecheck_nonviable_condition_incomplete",
1259        "struct A { operator ns::X(); } a; const ns::X &[[b]] = a;"},
1260       {"invalid_incomplete_type_use", "auto var = [[ns::X()]];"},
1261       {"sizeof_alignof_incomplete_or_sizeless_type",
1262        "auto s = [[sizeof]](ns::X);"},
1263       {"for_range_incomplete_type", "void foo() { for (auto i : [[*]]x ) {} }"},
1264       {"func_def_incomplete_result", "ns::X [[func]] () {}"},
1265       {"field_incomplete_or_sizeless", "class M { ns::X [[member]]; };"},
1266       {"array_incomplete_or_sizeless_type", "auto s = [[(ns::X[]){}]];"},
1267       {"call_incomplete_return", "ns::X f(); auto fp = &f; auto z = [[fp()]];"},
1268       {"call_function_incomplete_return", "ns::X foo(); auto a = [[foo()]];"},
1269       {"call_incomplete_argument", "int m(ns::X); int i = m([[*x]]);"},
1270       {"switch_incomplete_class_type", "void a() { [[switch]](*x) {} }"},
1271       {"delete_incomplete_class_type", "void f() { [[delete]] *x; }"},
1272       {"-Wdelete-incomplete", "void f() { [[delete]] x; }"},
1273       {"dereference_incomplete_type",
1274        R"cpp(void f() { asm("" : "=r"([[*]]x)::); })cpp"},
1275   };
1276   for (auto Case : Tests) {
1277     Annotations Main(Case.second);
1278     TU.Code = Main.code().str() + "\n // error-ok";
1279     EXPECT_THAT(
1280         TU.build().getDiagnostics(),
1281         ElementsAre(AllOf(diagName(Case.first), hasRange(Main.range()),
1282                           withFix(Fix(Range{}, "#include \"x.h\"\n",
1283                                       "Include \"x.h\" for symbol ns::X")))))
1284         << Case.second;
1285   }
1286 }
1287
1288 TEST(IncludeFixerTest, IncompleteEnum) {
1289   Symbol Sym = enm("X");
1290   Sym.Flags |= Symbol::IndexedForCodeCompletion;
1291   Sym.CanonicalDeclaration.FileURI = Sym.Definition.FileURI = "unittest:///x.h";
1292   Sym.IncludeHeaders.emplace_back("\"x.h\"", 1, Symbol::Include);
1293   SymbolSlab::Builder Slab;
1294   Slab.insert(Sym);
1295   auto Index =
1296       MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
1297
1298   TestTU TU;
1299   TU.ExternalIndex = Index.get();
1300   TU.ExtraArgs.push_back("-std=c++20");
1301   TU.ExtraArgs.push_back("-fno-ms-compatibility"); // else incomplete enum is OK
1302
1303   std::vector<std::pair<llvm::StringRef, llvm::StringRef>> Tests{
1304       {"incomplete_enum", "enum class X : int; using enum [[X]];"},
1305       {"underlying_type_of_incomplete_enum",
1306        "[[__underlying_type]](enum X) i;"},
1307   };
1308   for (auto Case : Tests) {
1309     Annotations Main(Case.second);
1310     TU.Code = Main.code().str() + "\n // error-ok";
1311     EXPECT_THAT(TU.build().getDiagnostics(),
1312                 Contains(AllOf(diagName(Case.first), hasRange(Main.range()),
1313                                withFix(Fix(Range{}, "#include \"x.h\"\n",
1314                                            "Include \"x.h\" for symbol X")))))
1315         << Case.second;
1316   }
1317 }
1318
1319 TEST(IncludeFixerTest, NoSuggestIncludeWhenNoDefinitionInHeader) {
1320   Annotations Test(R"cpp(// error-ok
1321 $insert[[]]namespace ns {
1322   class X;
1323 }
1324 class Y : $base[[public ns::X]] {};
1325 int main() {
1326   ns::X *x;
1327   x$access[[->]]f();
1328 }
1329   )cpp");
1330   auto TU = TestTU::withCode(Test.code());
1331   Symbol Sym = cls("ns::X");
1332   Sym.Flags |= Symbol::IndexedForCodeCompletion;
1333   Sym.CanonicalDeclaration.FileURI = "unittest:///x.h";
1334   Sym.Definition.FileURI = "unittest:///x.cc";
1335   Sym.IncludeHeaders.emplace_back("\"x.h\"", 1, Symbol::Include);
1336
1337   SymbolSlab::Builder Slab;
1338   Slab.insert(Sym);
1339   auto Index =
1340       MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
1341   TU.ExternalIndex = Index.get();
1342
1343   EXPECT_THAT(TU.build().getDiagnostics(),
1344               UnorderedElementsAre(
1345                   Diag(Test.range("base"), "base class has incomplete type"),
1346                   Diag(Test.range("access"),
1347                        "member access into incomplete type 'ns::X'")));
1348 }
1349
1350 TEST(IncludeFixerTest, Typo) {
1351   Annotations Test(R"cpp(// error-ok
1352 $insert[[]]namespace ns {
1353 void foo() {
1354   $unqualified1[[X]] x;
1355   // No fix if the unresolved type is used as specifier. (ns::)X::Nested will be
1356   // considered the unresolved type.
1357   $unqualified2[[X]]::Nested n;
1358 }
1359 struct S : $base[[X]] {};
1360 }
1361 void bar() {
1362   ns::$qualified1[[X]] x; // ns:: is valid.
1363   ns::$qualified2[[X]](); // Error: no member in namespace
1364
1365   ::$global[[Global]] glob;
1366 }
1367 using Type = ns::$template[[Foo]]<int>;
1368   )cpp");
1369   auto TU = TestTU::withCode(Test.code());
1370   auto Index = buildIndexWithSymbol(
1371       {SymbolWithHeader{"ns::X", "unittest:///x.h", "\"x.h\""},
1372        SymbolWithHeader{"Global", "unittest:///global.h", "\"global.h\""},
1373        SymbolWithHeader{"ns::Foo", "unittest:///foo.h", "\"foo.h\""}});
1374   TU.ExternalIndex = Index.get();
1375
1376   EXPECT_THAT(
1377       TU.build().getDiagnostics(),
1378       UnorderedElementsAre(
1379           AllOf(Diag(Test.range("unqualified1"), "unknown type name 'X'"),
1380                 diagName("unknown_typename"),
1381                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
1382                             "Include \"x.h\" for symbol ns::X"))),
1383           Diag(Test.range("unqualified2"), "use of undeclared identifier 'X'"),
1384           AllOf(Diag(Test.range("qualified1"),
1385                      "no type named 'X' in namespace 'ns'"),
1386                 diagName("typename_nested_not_found"),
1387                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
1388                             "Include \"x.h\" for symbol ns::X"))),
1389           AllOf(Diag(Test.range("qualified2"),
1390                      "no member named 'X' in namespace 'ns'"),
1391                 diagName("no_member"),
1392                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
1393                             "Include \"x.h\" for symbol ns::X"))),
1394           AllOf(Diag(Test.range("global"),
1395                      "no type named 'Global' in the global namespace"),
1396                 diagName("typename_nested_not_found"),
1397                 withFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
1398                             "Include \"global.h\" for symbol Global"))),
1399           AllOf(Diag(Test.range("template"),
1400                      "no template named 'Foo' in namespace 'ns'"),
1401                 diagName("no_member_template"),
1402                 withFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
1403                             "Include \"foo.h\" for symbol ns::Foo"))),
1404           AllOf(Diag(Test.range("base"), "expected class name"),
1405                 diagName("expected_class_name"),
1406                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
1407                             "Include \"x.h\" for symbol ns::X")))));
1408 }
1409
1410 TEST(IncludeFixerTest, TypoInMacro) {
1411   auto TU = TestTU::withCode(R"cpp(// error-ok
1412 #define ID(T) T
1413 X a1;
1414 ID(X a2);
1415 ns::X a3;
1416 ID(ns::X a4);
1417 namespace ns{};
1418 ns::X a5;
1419 ID(ns::X a6);
1420 )cpp");
1421   auto Index = buildIndexWithSymbol(
1422       {SymbolWithHeader{"X", "unittest:///x.h", "\"x.h\""},
1423        SymbolWithHeader{"ns::X", "unittest:///ns.h", "\"x.h\""}});
1424   TU.ExternalIndex = Index.get();
1425   // FIXME: -fms-compatibility (which is default on windows) breaks the
1426   // ns::X cases when the namespace is undeclared. Find out why!
1427   TU.ExtraArgs = {"-fno-ms-compatibility"};
1428   EXPECT_THAT(TU.build().getDiagnostics(), Each(withFix(_)));
1429 }
1430
1431 TEST(IncludeFixerTest, MultipleMatchedSymbols) {
1432   Annotations Test(R"cpp(// error-ok
1433 $insert[[]]namespace na {
1434 namespace nb {
1435 void foo() {
1436   $unqualified[[X]] x;
1437 }
1438 }
1439 }
1440   )cpp");
1441   auto TU = TestTU::withCode(Test.code());
1442   auto Index = buildIndexWithSymbol(
1443       {SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""},
1444        SymbolWithHeader{"na::nb::X", "unittest:///b.h", "\"b.h\""}});
1445   TU.ExternalIndex = Index.get();
1446
1447   EXPECT_THAT(TU.build().getDiagnostics(),
1448               UnorderedElementsAre(AllOf(
1449                   Diag(Test.range("unqualified"), "unknown type name 'X'"),
1450                   diagName("unknown_typename"),
1451                   withFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
1452                               "Include \"a.h\" for symbol na::X"),
1453                           Fix(Test.range("insert"), "#include \"b.h\"\n",
1454                               "Include \"b.h\" for symbol na::nb::X")))));
1455 }
1456
1457 TEST(IncludeFixerTest, NoCrashMemberAccess) {
1458   Annotations Test(R"cpp(// error-ok
1459     struct X { int  xyz; };
1460     void g() { X x; x.$[[xy]]; }
1461   )cpp");
1462   auto TU = TestTU::withCode(Test.code());
1463   auto Index = buildIndexWithSymbol(
1464       SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""});
1465   TU.ExternalIndex = Index.get();
1466
1467   EXPECT_THAT(
1468       TU.build().getDiagnostics(),
1469       UnorderedElementsAre(Diag(Test.range(), "no member named 'xy' in 'X'")));
1470 }
1471
1472 TEST(IncludeFixerTest, UseCachedIndexResults) {
1473   // As index results for the identical request are cached, more than 5 fixes
1474   // are generated.
1475   Annotations Test(R"cpp(// error-ok
1476 $insert[[]]void foo() {
1477   $x1[[X]] x;
1478   $x2[[X]] x;
1479   $x3[[X]] x;
1480   $x4[[X]] x;
1481   $x5[[X]] x;
1482   $x6[[X]] x;
1483   $x7[[X]] x;
1484 }
1485
1486 class X;
1487 void bar(X *x) {
1488   x$a1[[->]]f();
1489   x$a2[[->]]f();
1490   x$a3[[->]]f();
1491   x$a4[[->]]f();
1492   x$a5[[->]]f();
1493   x$a6[[->]]f();
1494   x$a7[[->]]f();
1495 }
1496   )cpp");
1497   auto TU = TestTU::withCode(Test.code());
1498   auto Index =
1499       buildIndexWithSymbol(SymbolWithHeader{"X", "unittest:///a.h", "\"a.h\""});
1500   TU.ExternalIndex = Index.get();
1501
1502   auto Parsed = TU.build();
1503   for (const auto &D : Parsed.getDiagnostics()) {
1504     if (D.Fixes.size() != 1) {
1505       ADD_FAILURE() << "D.Fixes.size() != 1";
1506       continue;
1507     }
1508     EXPECT_EQ(D.Fixes[0].Message, std::string("Include \"a.h\" for symbol X"));
1509   }
1510 }
1511
1512 TEST(IncludeFixerTest, UnresolvedNameAsSpecifier) {
1513   Annotations Test(R"cpp(// error-ok
1514 $insert[[]]namespace ns {
1515 }
1516 void g() {  ns::$[[scope]]::X_Y();  }
1517   )cpp");
1518   TestTU TU;
1519   TU.Code = std::string(Test.code());
1520   // FIXME: Figure out why this is needed and remove it, PR43662.
1521   TU.ExtraArgs.push_back("-fno-ms-compatibility");
1522   auto Index = buildIndexWithSymbol(
1523       SymbolWithHeader{"ns::scope::X_Y", "unittest:///x.h", "\"x.h\""});
1524   TU.ExternalIndex = Index.get();
1525
1526   EXPECT_THAT(
1527       TU.build().getDiagnostics(),
1528       UnorderedElementsAre(
1529           AllOf(Diag(Test.range(), "no member named 'scope' in namespace 'ns'"),
1530                 diagName("no_member"),
1531                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
1532                             "Include \"x.h\" for symbol ns::scope::X_Y")))));
1533 }
1534
1535 TEST(IncludeFixerTest, UnresolvedSpecifierWithSemaCorrection) {
1536   Annotations Test(R"cpp(// error-ok
1537 $insert[[]]namespace clang {
1538 void f() {
1539   // "clangd::" will be corrected to "clang::" by Sema.
1540   $q1[[clangd]]::$x[[X]] x;
1541   $q2[[clangd]]::$ns[[ns]]::Y y;
1542 }
1543 }
1544   )cpp");
1545   TestTU TU;
1546   TU.Code = std::string(Test.code());
1547   // FIXME: Figure out why this is needed and remove it, PR43662.
1548   TU.ExtraArgs.push_back("-fno-ms-compatibility");
1549   auto Index = buildIndexWithSymbol(
1550       {SymbolWithHeader{"clang::clangd::X", "unittest:///x.h", "\"x.h\""},
1551        SymbolWithHeader{"clang::clangd::ns::Y", "unittest:///y.h", "\"y.h\""}});
1552   TU.ExternalIndex = Index.get();
1553
1554   EXPECT_THAT(
1555       TU.build().getDiagnostics(),
1556       UnorderedElementsAre(
1557           AllOf(Diag(Test.range("q1"), "use of undeclared identifier 'clangd'; "
1558                                        "did you mean 'clang'?"),
1559                 diagName("undeclared_var_use_suggest"),
1560                 withFix(_, // change clangd to clang
1561                         Fix(Test.range("insert"), "#include \"x.h\"\n",
1562                             "Include \"x.h\" for symbol clang::clangd::X"))),
1563           AllOf(Diag(Test.range("x"), "no type named 'X' in namespace 'clang'"),
1564                 diagName("typename_nested_not_found"),
1565                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
1566                             "Include \"x.h\" for symbol clang::clangd::X"))),
1567           AllOf(
1568               Diag(Test.range("q2"), "use of undeclared identifier 'clangd'; "
1569                                      "did you mean 'clang'?"),
1570               diagName("undeclared_var_use_suggest"),
1571               withFix(_, // change clangd to clang
1572                       Fix(Test.range("insert"), "#include \"y.h\"\n",
1573                           "Include \"y.h\" for symbol clang::clangd::ns::Y"))),
1574           AllOf(Diag(Test.range("ns"),
1575                      "no member named 'ns' in namespace 'clang'"),
1576                 diagName("no_member"),
1577                 withFix(
1578                     Fix(Test.range("insert"), "#include \"y.h\"\n",
1579                         "Include \"y.h\" for symbol clang::clangd::ns::Y")))));
1580 }
1581
1582 TEST(IncludeFixerTest, SpecifiedScopeIsNamespaceAlias) {
1583   Annotations Test(R"cpp(// error-ok
1584 $insert[[]]namespace a {}
1585 namespace b = a;
1586 namespace c {
1587   b::$[[X]] x;
1588 }
1589   )cpp");
1590   auto TU = TestTU::withCode(Test.code());
1591   auto Index = buildIndexWithSymbol(
1592       SymbolWithHeader{"a::X", "unittest:///x.h", "\"x.h\""});
1593   TU.ExternalIndex = Index.get();
1594
1595   EXPECT_THAT(TU.build().getDiagnostics(),
1596               UnorderedElementsAre(AllOf(
1597                   Diag(Test.range(), "no type named 'X' in namespace 'a'"),
1598                   diagName("typename_nested_not_found"),
1599                   withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
1600                               "Include \"x.h\" for symbol a::X")))));
1601 }
1602
1603 TEST(IncludeFixerTest, NoCrashOnTemplateInstantiations) {
1604   Annotations Test(R"cpp(
1605     template <typename T> struct Templ {
1606       template <typename U>
1607       typename U::type operator=(const U &);
1608     };
1609
1610     struct A {
1611       Templ<char> s;
1612       A() { [[a]]; /*error-ok*/ } // crash if we compute scopes lazily.
1613     };
1614   )cpp");
1615
1616   auto TU = TestTU::withCode(Test.code());
1617   auto Index = buildIndexWithSymbol({});
1618   TU.ExternalIndex = Index.get();
1619
1620   EXPECT_THAT(
1621       TU.build().getDiagnostics(),
1622       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'a'")));
1623 }
1624
1625 TEST(IncludeFixerTest, HeaderNamedInDiag) {
1626   Annotations Test(R"cpp(
1627     $insert[[]]int main() {
1628       [[printf]]("");
1629     }
1630   )cpp");
1631   auto TU = TestTU::withCode(Test.code());
1632   TU.ExtraArgs = {"-xc", "-std=c99",
1633                   "-Wno-error=implicit-function-declaration"};
1634   auto Index = buildIndexWithSymbol({});
1635   TU.ExternalIndex = Index.get();
1636
1637   EXPECT_THAT(
1638       TU.build().getDiagnostics(),
1639       ElementsAre(AllOf(
1640           Diag(Test.range(), "call to undeclared library function 'printf' "
1641                              "with type 'int (const char *, ...)'; ISO C99 "
1642                              "and later do not support implicit function "
1643                              "declarations"),
1644           withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
1645                       "Include <stdio.h> for symbol printf")))));
1646
1647   TU.ExtraArgs = {"-xc", "-std=c89"};
1648   EXPECT_THAT(
1649       TU.build().getDiagnostics(),
1650       ElementsAre(AllOf(
1651           Diag(Test.range(), "implicitly declaring library function 'printf' "
1652                              "with type 'int (const char *, ...)'"),
1653           withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
1654                       "Include <stdio.h> for symbol printf")))));
1655 }
1656
1657 TEST(IncludeFixerTest, CImplicitFunctionDecl) {
1658   Annotations Test("void x() { [[foo]](); }");
1659   auto TU = TestTU::withCode(Test.code());
1660   TU.Filename = "test.c";
1661   TU.ExtraArgs = {"-std=c99", "-Wno-error=implicit-function-declaration"};
1662
1663   Symbol Sym = func("foo");
1664   Sym.Flags |= Symbol::IndexedForCodeCompletion;
1665   Sym.CanonicalDeclaration.FileURI = "unittest:///foo.h";
1666   Sym.IncludeHeaders.emplace_back("\"foo.h\"", 1, Symbol::Include);
1667
1668   SymbolSlab::Builder Slab;
1669   Slab.insert(Sym);
1670   auto Index =
1671       MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
1672   TU.ExternalIndex = Index.get();
1673
1674   EXPECT_THAT(
1675       TU.build().getDiagnostics(),
1676       ElementsAre(AllOf(
1677           Diag(Test.range(),
1678                "call to undeclared function 'foo'; ISO C99 and later do not "
1679                "support implicit function declarations"),
1680           withFix(Fix(Range{}, "#include \"foo.h\"\n",
1681                       "Include \"foo.h\" for symbol foo")))));
1682
1683   TU.ExtraArgs = {"-std=c89", "-Wall"};
1684   EXPECT_THAT(TU.build().getDiagnostics(),
1685               ElementsAre(AllOf(
1686                   Diag(Test.range(), "implicit declaration of function 'foo'"),
1687                   withFix(Fix(Range{}, "#include \"foo.h\"\n",
1688                               "Include \"foo.h\" for symbol foo")))));
1689 }
1690
1691 TEST(DiagsInHeaders, DiagInsideHeader) {
1692   Annotations Main(R"cpp(
1693     #include [["a.h"]]
1694     void foo() {})cpp");
1695   Annotations Header("[[no_type_spec]]; // error-ok");
1696   TestTU TU = TestTU::withCode(Main.code());
1697   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
1698   EXPECT_THAT(TU.build().getDiagnostics(),
1699               UnorderedElementsAre(AllOf(
1700                   Diag(Main.range(), "in included file: a type specifier is "
1701                                      "required for all declarations"),
1702                   withNote(Diag(Header.range(), "error occurred here")))));
1703 }
1704
1705 TEST(DiagsInHeaders, DiagInTransitiveInclude) {
1706   Annotations Main(R"cpp(
1707     #include [["a.h"]]
1708     void foo() {})cpp");
1709   TestTU TU = TestTU::withCode(Main.code());
1710   TU.AdditionalFiles = {{"a.h", "#include \"b.h\""},
1711                         {"b.h", "no_type_spec; // error-ok"}};
1712   EXPECT_THAT(TU.build().getDiagnostics(),
1713               UnorderedElementsAre(Diag(Main.range(),
1714                                         "in included file: a type specifier is "
1715                                         "required for all declarations")));
1716 }
1717
1718 TEST(DiagsInHeaders, DiagInMultipleHeaders) {
1719   Annotations Main(R"cpp(
1720     #include $a[["a.h"]]
1721     #include $b[["b.h"]]
1722     void foo() {})cpp");
1723   TestTU TU = TestTU::withCode(Main.code());
1724   TU.AdditionalFiles = {{"a.h", "no_type_spec; // error-ok"},
1725                         {"b.h", "no_type_spec; // error-ok"}};
1726   EXPECT_THAT(TU.build().getDiagnostics(),
1727               UnorderedElementsAre(
1728                   Diag(Main.range("a"), "in included file: a type specifier is "
1729                                         "required for all declarations"),
1730                   Diag(Main.range("b"), "in included file: a type specifier is "
1731                                         "required for all declarations")));
1732 }
1733
1734 TEST(DiagsInHeaders, PreferExpansionLocation) {
1735   Annotations Main(R"cpp(
1736     #include [["a.h"]]
1737     #include "b.h"
1738     void foo() {})cpp");
1739   TestTU TU = TestTU::withCode(Main.code());
1740   TU.AdditionalFiles = {
1741       {"a.h", "#include \"b.h\"\n"},
1742       {"b.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
1743   EXPECT_THAT(TU.build().getDiagnostics(),
1744               Contains(Diag(Main.range(), "in included file: a type specifier "
1745                                           "is required for all declarations")));
1746 }
1747
1748 TEST(DiagsInHeaders, PreferExpansionLocationMacros) {
1749   Annotations Main(R"cpp(
1750     #define X
1751     #include "a.h"
1752     #undef X
1753     #include [["b.h"]]
1754     void foo() {})cpp");
1755   TestTU TU = TestTU::withCode(Main.code());
1756   TU.AdditionalFiles = {
1757       {"a.h", "#include \"c.h\"\n"},
1758       {"b.h", "#include \"c.h\"\n"},
1759       {"c.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
1760   EXPECT_THAT(TU.build().getDiagnostics(),
1761               UnorderedElementsAre(Diag(Main.range(),
1762                                         "in included file: a type specifier is "
1763                                         "required for all declarations")));
1764 }
1765
1766 TEST(DiagsInHeaders, LimitDiagsOutsideMainFile) {
1767   Annotations Main(R"cpp(
1768     #include [["a.h"]]
1769     #include "b.h"
1770     void foo() {})cpp");
1771   TestTU TU = TestTU::withCode(Main.code());
1772   TU.AdditionalFiles = {{"a.h", "#include \"c.h\"\n"},
1773                         {"b.h", "#include \"c.h\"\n"},
1774                         {"c.h", R"cpp(
1775       #ifndef X
1776       #define X
1777       no_type_spec_0; // error-ok
1778       no_type_spec_1;
1779       no_type_spec_2;
1780       no_type_spec_3;
1781       no_type_spec_4;
1782       no_type_spec_5;
1783       no_type_spec_6;
1784       no_type_spec_7;
1785       no_type_spec_8;
1786       no_type_spec_9;
1787       no_type_spec_10;
1788       #endif)cpp"}};
1789   EXPECT_THAT(TU.build().getDiagnostics(),
1790               UnorderedElementsAre(Diag(Main.range(),
1791                                         "in included file: a type specifier is "
1792                                         "required for all declarations")));
1793 }
1794
1795 TEST(DiagsInHeaders, OnlyErrorOrFatal) {
1796   Annotations Main(R"cpp(
1797     #include [["a.h"]]
1798     void foo() {})cpp");
1799   Annotations Header(R"cpp(
1800     [[no_type_spec]]; // error-ok
1801     int x = 5/0;)cpp");
1802   TestTU TU = TestTU::withCode(Main.code());
1803   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
1804   EXPECT_THAT(TU.build().getDiagnostics(),
1805               UnorderedElementsAre(AllOf(
1806                   Diag(Main.range(), "in included file: a type specifier is "
1807                                      "required for all declarations"),
1808                   withNote(Diag(Header.range(), "error occurred here")))));
1809 }
1810
1811 TEST(DiagsInHeaders, OnlyDefaultErrorOrFatal) {
1812   Annotations Main(R"cpp(
1813     #include [["a.h"]] // get unused "foo" warning when building preamble.
1814     )cpp");
1815   Annotations Header(R"cpp(
1816     namespace { void foo() {} }
1817     void func() {foo();} ;)cpp");
1818   TestTU TU = TestTU::withCode(Main.code());
1819   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
1820   // promote warnings to errors.
1821   TU.ExtraArgs = {"-Werror", "-Wunused"};
1822   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
1823 }
1824
1825 TEST(DiagsInHeaders, FromNonWrittenSources) {
1826   Annotations Main(R"cpp(
1827     #include [["a.h"]]
1828     void foo() {})cpp");
1829   Annotations Header(R"cpp(
1830     int x = 5/0;
1831     int b = [[FOO]]; // error-ok)cpp");
1832   TestTU TU = TestTU::withCode(Main.code());
1833   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
1834   TU.ExtraArgs = {"-DFOO=NOOO"};
1835   EXPECT_THAT(TU.build().getDiagnostics(),
1836               UnorderedElementsAre(AllOf(
1837                   Diag(Main.range(),
1838                        "in included file: use of undeclared identifier 'NOOO'"),
1839                   withNote(Diag(Header.range(), "error occurred here")))));
1840 }
1841
1842 TEST(DiagsInHeaders, ErrorFromMacroExpansion) {
1843   Annotations Main(R"cpp(
1844   void bar() {
1845     int fo; // error-ok
1846     #include [["a.h"]]
1847   })cpp");
1848   Annotations Header(R"cpp(
1849   #define X foo
1850   X;)cpp");
1851   TestTU TU = TestTU::withCode(Main.code());
1852   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
1853   EXPECT_THAT(TU.build().getDiagnostics(),
1854               UnorderedElementsAre(
1855                   Diag(Main.range(), "in included file: use of undeclared "
1856                                      "identifier 'foo'; did you mean 'fo'?")));
1857 }
1858
1859 TEST(DiagsInHeaders, ErrorFromMacroArgument) {
1860   Annotations Main(R"cpp(
1861   void bar() {
1862     int fo; // error-ok
1863     #include [["a.h"]]
1864   })cpp");
1865   Annotations Header(R"cpp(
1866   #define X(arg) arg
1867   X(foo);)cpp");
1868   TestTU TU = TestTU::withCode(Main.code());
1869   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
1870   EXPECT_THAT(TU.build().getDiagnostics(),
1871               UnorderedElementsAre(
1872                   Diag(Main.range(), "in included file: use of undeclared "
1873                                      "identifier 'foo'; did you mean 'fo'?")));
1874 }
1875
1876 TEST(IgnoreDiags, FromNonWrittenInclude) {
1877   TestTU TU;
1878   TU.ExtraArgs.push_back("--include=a.h");
1879   TU.AdditionalFiles = {{"a.h", "void main();"}};
1880   // The diagnostic "main must return int" is from the header, we don't attempt
1881   // to render it in the main file as there is no written location there.
1882   EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre());
1883 }
1884
1885 TEST(ToLSPDiag, RangeIsInMain) {
1886   ClangdDiagnosticOptions Opts;
1887   clangd::Diag D;
1888   D.Range = {pos(1, 2), pos(3, 4)};
1889   D.Notes.emplace_back();
1890   Note &N = D.Notes.back();
1891   N.Range = {pos(2, 3), pos(3, 4)};
1892
1893   D.InsideMainFile = true;
1894   N.InsideMainFile = false;
1895   toLSPDiags(D, {}, Opts,
1896              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix>) {
1897                EXPECT_EQ(LSPDiag.range, D.Range);
1898              });
1899
1900   D.InsideMainFile = false;
1901   N.InsideMainFile = true;
1902   toLSPDiags(D, {}, Opts,
1903              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix>) {
1904                EXPECT_EQ(LSPDiag.range, N.Range);
1905              });
1906 }
1907
1908 TEST(ParsedASTTest, ModuleSawDiag) {
1909   TestTU TU;
1910
1911   auto AST = TU.build();
1912         #if 0
1913   EXPECT_THAT(AST.getDiagnostics(),
1914               testing::Contains(Diag(Code.range(), KDiagMsg.str())));
1915         #endif
1916 }
1917
1918 TEST(Preamble, EndsOnNonEmptyLine) {
1919   TestTU TU;
1920   TU.ExtraArgs = {"-Wnewline-eof"};
1921
1922   {
1923     TU.Code = "#define FOO\n  void bar();\n";
1924     auto AST = TU.build();
1925     EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
1926   }
1927   {
1928     Annotations Code("#define FOO[[]]");
1929     TU.Code = Code.code().str();
1930     auto AST = TU.build();
1931     EXPECT_THAT(
1932         AST.getDiagnostics(),
1933         testing::Contains(Diag(Code.range(), "no newline at end of file")));
1934   }
1935 }
1936
1937 TEST(Diagnostics, Tags) {
1938   TestTU TU;
1939   TU.ExtraArgs = {"-Wunused", "-Wdeprecated"};
1940   Annotations Test(R"cpp(
1941   void bar() __attribute__((deprecated));
1942   void foo() {
1943     int $unused[[x]];
1944     $deprecated[[bar]]();
1945   })cpp");
1946   TU.Code = Test.code().str();
1947   EXPECT_THAT(TU.build().getDiagnostics(),
1948               UnorderedElementsAre(
1949                   AllOf(Diag(Test.range("unused"), "unused variable 'x'"),
1950                         withTag(DiagnosticTag::Unnecessary)),
1951                   AllOf(Diag(Test.range("deprecated"), "'bar' is deprecated"),
1952                         withTag(DiagnosticTag::Deprecated))));
1953
1954   Test = Annotations(R"cpp(
1955     $typedef[[typedef int INT]];
1956   )cpp");
1957   TU.Code = Test.code();
1958   TU.ClangTidyProvider = addTidyChecks("modernize-use-using");
1959   EXPECT_THAT(
1960       TU.build().getDiagnostics(),
1961       ifTidyChecks(UnorderedElementsAre(
1962           AllOf(Diag(Test.range("typedef"), "use 'using' instead of 'typedef'"),
1963                 withTag(DiagnosticTag::Deprecated)))));
1964 }
1965
1966 TEST(Diagnostics, DeprecatedDiagsAreHints) {
1967   ClangdDiagnosticOptions Opts;
1968   std::optional<clangd::Diagnostic> Diag;
1969   clangd::Diag D;
1970   D.Range = {pos(1, 2), pos(3, 4)};
1971   D.InsideMainFile = true;
1972
1973   // Downgrade warnings with deprecated tags to remark.
1974   D.Tags = {Deprecated};
1975   D.Severity = DiagnosticsEngine::Warning;
1976   toLSPDiags(D, {}, Opts,
1977              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix>) {
1978                Diag = std::move(LSPDiag);
1979              });
1980   EXPECT_EQ(Diag->severity, getSeverity(DiagnosticsEngine::Remark));
1981   Diag.reset();
1982
1983   // Preserve errors.
1984   D.Severity = DiagnosticsEngine::Error;
1985   toLSPDiags(D, {}, Opts,
1986              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix>) {
1987                Diag = std::move(LSPDiag);
1988              });
1989   EXPECT_EQ(Diag->severity, getSeverity(DiagnosticsEngine::Error));
1990   Diag.reset();
1991
1992   // No-op without tag.
1993   D.Tags = {};
1994   D.Severity = DiagnosticsEngine::Warning;
1995   toLSPDiags(D, {}, Opts,
1996              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix>) {
1997                Diag = std::move(LSPDiag);
1998              });
1999   EXPECT_EQ(Diag->severity, getSeverity(DiagnosticsEngine::Warning));
2000 }
2001
2002 TEST(DiagnosticsTest, IncludeCleaner) {
2003   Annotations Test(R"cpp(
2004 $fix[[  $diag[[#include "unused.h"]]
2005 ]]
2006   #include "used.h"
2007
2008   #include "ignore.h"
2009
2010   #include <system_header.h>
2011
2012   void foo() {
2013     used();
2014   }
2015   )cpp");
2016   TestTU TU;
2017   TU.Code = Test.code().str();
2018   TU.AdditionalFiles["unused.h"] = R"cpp(
2019     #pragma once
2020     void unused() {}
2021   )cpp";
2022   TU.AdditionalFiles["used.h"] = R"cpp(
2023     #pragma once
2024     void used() {}
2025   )cpp";
2026   TU.AdditionalFiles["ignore.h"] = R"cpp(
2027     #pragma once
2028     void ignore() {}
2029   )cpp";
2030   TU.AdditionalFiles["system/system_header.h"] = "";
2031   TU.ExtraArgs = {"-isystem" + testPath("system")};
2032   Config Cfg;
2033   Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::Strict;
2034   // Set filtering.
2035   Cfg.Diagnostics.Includes.IgnoreHeader.emplace_back(
2036       [](llvm::StringRef Header) { return Header.ends_with("ignore.h"); });
2037   WithContextValue WithCfg(Config::Key, std::move(Cfg));
2038   auto AST = TU.build();
2039   EXPECT_THAT(
2040       AST.getDiagnostics(),
2041       Contains(AllOf(
2042           Diag(Test.range("diag"),
2043                "included header unused.h is not used directly"),
2044           withTag(DiagnosticTag::Unnecessary), diagSource(Diag::Clangd),
2045           withFix(Fix(Test.range("fix"), "", "remove #include directive")))));
2046   auto &Diag = AST.getDiagnostics().front();
2047   EXPECT_THAT(getDiagnosticDocURI(Diag.Source, Diag.ID, Diag.Name),
2048               llvm::ValueIs(Not(IsEmpty())));
2049   Cfg.Diagnostics.SuppressAll = true;
2050   WithContextValue SuppressAllWithCfg(Config::Key, std::move(Cfg));
2051   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
2052   Cfg.Diagnostics.SuppressAll = false;
2053   Cfg.Diagnostics.Suppress = {"unused-includes"};
2054   WithContextValue SuppressFilterWithCfg(Config::Key, std::move(Cfg));
2055   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
2056 }
2057
2058 TEST(DiagnosticsTest, FixItFromHeader) {
2059   llvm::StringLiteral Header(R"cpp(
2060     void foo(int *);
2061     void foo(int *, int);)cpp");
2062   Annotations Source(R"cpp(
2063   /*error-ok*/
2064     void bar() {
2065       int x;
2066       $diag[[foo]]($fix[[]]x, 1);
2067     })cpp");
2068   TestTU TU;
2069   TU.Code = Source.code().str();
2070   TU.HeaderCode = Header.str();
2071   EXPECT_THAT(
2072       TU.build().getDiagnostics(),
2073       UnorderedElementsAre(AllOf(
2074           Diag(Source.range("diag"), "no matching function for call to 'foo'"),
2075           withFix(Fix(Source.range("fix"), "&",
2076                       "candidate function not viable: no known conversion from "
2077                       "'int' to 'int *' for 1st argument; take the address of "
2078                       "the argument with &")))));
2079 }
2080
2081 TEST(DiagnosticsTest, UnusedInHeader) {
2082   // Clang diagnoses unused static inline functions outside headers.
2083   auto TU = TestTU::withCode("static inline void foo(void) {}");
2084   TU.ExtraArgs.push_back("-Wunused-function");
2085   TU.Filename = "test.c";
2086   EXPECT_THAT(TU.build().getDiagnostics(),
2087               ElementsAre(withID(diag::warn_unused_function)));
2088   // Sema should recognize a *.h file open in clangd as a header.
2089   // https://github.com/clangd/vscode-clangd/issues/360
2090   TU.Filename = "test.h";
2091   EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
2092 }
2093
2094 } // namespace
2095 } // namespace clangd
2096 } // namespace clang