Only do typo correction for implicit function decls when

they are treated as errors.

Doing typo correction when these are just warnings slows down the
compilation of source which deliberately uses implicit function
declarations.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@146153 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 793cbf31bf1ab4847dfde26f3ccde1e12429422c..09ada7e55dc430287d2ddffd27a7a0ab86081d0b 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -7259,36 +7259,36 @@ NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
     return Pos->second;
   }
 
-  // See if we can find a typo correction.
-  TypoCorrection Corrected;
-  FunctionDecl *Func = 0;
-  std::string CorrectedStr;
-  std::string CorrectedQuotedStr;
-  if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc),
-                                    LookupOrdinaryName, S, 0))) {
-    // Since this is an implicit function declaration, we are only
-    // interested in a potential typo for a function name.
-    if ((Func = dyn_cast_or_null<FunctionDecl>(
-            Corrected.getCorrectionDecl()))) {
-      CorrectedStr = Corrected.getAsString(getLangOptions());
-      CorrectedQuotedStr = Corrected.getQuoted(getLangOptions());
-    }
-  }
-
   // Extension in C99.  Legal in C90, but warn about it.
+  unsigned diag_id;
   if (II.getName().startswith("__builtin_"))
-    Diag(Loc, diag::err_builtin_unknown) << &II;
+    diag_id = diag::err_builtin_unknown;
   else if (getLangOptions().C99)
-    Diag(Loc, diag::ext_implicit_function_decl) << &II;
+    diag_id = diag::ext_implicit_function_decl;
   else
-    Diag(Loc, diag::warn_implicit_function_decl) << &II;
-
-  if (Func) {
-    // If we found a typo correction, then suggest that.
-    Diag(Loc, diag::note_function_suggestion) << CorrectedQuotedStr
-        << FixItHint::CreateReplacement(Loc, CorrectedStr);
-    if (Func->getLocation().isValid() && !II.getName().startswith("__builtin_"))
-      Diag(Func->getLocation(), diag::note_previous_decl) << CorrectedQuotedStr;
+    diag_id = diag::warn_implicit_function_decl;
+  Diag(Loc, diag_id) << &II;
+
+  // Because typo correction is expensive, only do it if the implicit
+  // function declaration is going to be treated as an error.
+  if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
+    TypoCorrection Corrected;
+    if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc),
+                                      LookupOrdinaryName, S, 0))) {
+      NamedDecl *Decl = Corrected.getCorrectionDecl();
+      if (FunctionDecl *Func = dyn_cast_or_null<FunctionDecl>(Decl)) {
+        std::string CorrectedStr = Corrected.getAsString(getLangOptions());
+        std::string CorrectedQuotedStr = Corrected.getQuoted(getLangOptions());
+
+        Diag(Loc, diag::note_function_suggestion) << CorrectedQuotedStr
+            << FixItHint::CreateReplacement(Loc, CorrectedStr);
+
+        if (Func->getLocation().isValid()
+            && !II.getName().startswith("__builtin_"))
+          Diag(Func->getLocation(), diag::note_previous_decl)
+              << CorrectedQuotedStr;
+      }
+    }
   }
 
   // Set a Declarator for the implicit definition: int foo();

diff --git a/test/Sema/c89.c b/test/Sema/c89.c
index e4cdc11be1cd75339bb07dbd7bd1dd7b87e80c35..e11cd4e6f1d27b712c8ad94c7bbc46f64b74c432 100644 (file)
--- a/test/Sema/c89.c
+++ b/test/Sema/c89.c
@@ -83,9 +83,9 @@ int test14() { return (&*test14)(); }
 
 int test15[5] = { [2] = 1 }; /* expected-warning {{designated initializers are a C99 feature}} */
 
-extern int printf(__const char *__restrict __format, ...); /* expected-note{{'printf' declared here}} */
+extern int printf(__const char *__restrict __format, ...);
 
+/* Warn, but don't suggest typo correction. */
 void test16() {
-  printg("Hello, world!\n"); /* expected-warning {{implicit declaration of function 'printg'}}
-                                expected-note {{did you mean 'printf'?}} */
+  printg("Hello, world!\n"); /* expected-warning {{implicit declaration of function 'printg'}} */
 }

diff --git a/test/Sema/implicit-decl.c b/test/Sema/implicit-decl.c
index 72e42e05bb654c5bfc98fb6abe4d68c4ad7c06e7..2e1a8652546fd13e86a12b8010b4967aaa564f88 100644 (file)
--- a/test/Sema/implicit-decl.c
+++ b/test/Sema/implicit-decl.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 %s -verify -fsyntax-only
+// RUN: %clang_cc1 %s -verify -fsyntax-only -Werror
 
 typedef int int32_t;
 typedef unsigned char Boolean;
@@ -10,10 +10,10 @@ void func() {
    const char compDesc[16 + 1];
    int32_t compCount = 0;
    if (_CFCalendarDecomposeAbsoluteTimeV(compDesc, vector, compCount)) { // expected-note {{previous implicit declaration is here}} \
-         expected-warning {{implicit declaration of function '_CFCalendarDecomposeAbsoluteTimeV' is invalid in C99}}
+         expected-error {{implicit declaration of function '_CFCalendarDecomposeAbsoluteTimeV' is invalid in C99}}
    }
 
-   printg("Hello, World!\n"); // expected-warning{{implicit declaration of function 'printg' is invalid in C99}} \
+   printg("Hello, World!\n"); // expected-error{{implicit declaration of function 'printg' is invalid in C99}} \
                               // expected-note{{did you mean 'printf'?}}
 
   __builtin_is_les(1, 3); // expected-error{{use of unknown builtin '__builtin_is_les'}} \