[clangd] Fix tests for implicit C function declaration

[ArcsinX]

Summary

clangd code fixes at D122983 were not right.
We need to check that clangd provides IncludeFixer fixits for implicit function declaration even if this is not an error (e.g. implicit function declaration in C89).

[aaron.ballman]

LGTM, but someone with more clangd experience should do the final sign off (seeing as how I caused the issue in the first place, sorry about that!).

[sammccall]

Thanks!

(And not surprising at all this regressed, the mechanism clangd is using here is extremely fragile, we just couldn't come up with a better one :-()

clang-tools-extra/clangd/ParsedAST.cpp

if (PreserveDiags) {
     }
 
     // Clang only corrects typos for use of undeclared functions in C if that
     // use is an error. Include fixer relies on typo correction, so pretend
     // this is an error. (The actual typo correction is nice too).
     // We restore the original severity in the level adjuster.
     // FIXME: It would be better to have a real API for this, but what?
     for (auto ID : {diag::ext_implicit_function_decl_c99,
+                    diag::ext_implicit_lib_function_decl,
                     diag::ext_implicit_lib_function_decl_c99,
                     diag::warn_implicit_function_decl}) {
       OverriddenSeverity.try_emplace(
           ID, Clang->getDiagnostics().getDiagnosticLevel(ID, SourceLocation()));
       Clang->getDiagnostics().setSeverity(ID, diag::Severity::Error,
                                           SourceLocation());
     }
 

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

TEST(IncludeFixerTest, NoCrashOnTemplateInstantiations) {
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'a'")));
 }
 
 TEST(IncludeFixerTest, HeaderNamedInDiag) {
   Annotations Test(R"cpp(
     $insert[[]]int main() {
-      [[printf]](""); // error-ok
+      [[printf]]("");
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
-  TU.ExtraArgs = {"-xc"};
+  TU.ExtraArgs = {"-xc", "-std=c99",
+                  "-Wno-error=implicit-function-declaration"};
   auto Index = buildIndexWithSymbol({});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "call to undeclared library function 'printf' "
                              "with type 'int (const char *, ...)'; ISO C99 "
                              "and later do not support implicit function "
                              "declarations"),
           withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
                       "Include <stdio.h> for symbol printf")))));
+
+  TU.ExtraArgs = {"-xc", "-std=c89"};
+  EXPECT_THAT(
+      *TU.build().getDiagnostics(),
+      ElementsAre(AllOf(
+          Diag(Test.range(), "implicitly declaring library function 'printf' "
+                             "with type 'int (const char *, ...)'"),
+          withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
+                      "Include <stdio.h> for symbol printf")))));
 }
 
 TEST(IncludeFixerTest, CImplicitFunctionDecl) {
-  Annotations Test("void x() { [[foo]](); /* error-ok */ }");
+  Annotations Test("void x() { [[foo]](); }");
   auto TU = TestTU::withCode(Test.code());
   TU.Filename = "test.c";
-  TU.ExtraArgs.push_back("-std=c99");
+  TU.ExtraArgs = {"-std=c99", "-Wno-error=implicit-function-declaration"};
 
   Symbol Sym = func("foo");
   Sym.Flags |= Symbol::IndexedForCodeCompletion;
   Sym.CanonicalDeclaration.FileURI = "unittest:///foo.h";
   Sym.IncludeHeaders.emplace_back("\"foo.h\"", 1);
 
   SymbolSlab::Builder Slab;
   Slab.insert(Sym);
   auto Index =
       MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(),
                "call to undeclared function 'foo'; ISO C99 and later do not "
                "support implicit function declarations"),
           withFix(Fix(Range{}, "#include \"foo.h\"\n",
                       "Include \"foo.h\" for symbol foo")))));
+
+  TU.ExtraArgs = {"-std=c89", "-Wall"};
+  EXPECT_THAT(*TU.build().getDiagnostics(),
+              ElementsAre(AllOf(
+                  Diag(Test.range(), "implicit declaration of function 'foo'"),
+                  withFix(Fix(Range{}, "#include \"foo.h\"\n",
+                              "Include \"foo.h\" for symbol foo")))));
 }
 
 TEST(DiagsInHeaders, DiagInsideHeader) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header("[[no_type_spec]]; // error-ok");
   TestTU TU = TestTU::withCode(Main.code());