Improve the strict prototype diagnostic behavior

[aaron.ballman]

Summary

Post-commit feedback on https://reviews.llvm.org/D122895 pointed out that the diagnostic wording for some code was using "declaration" in a confusing way, such as:

int foo(); // warning: a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x

int foo(int arg) { // warning: a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x
  return 5;
}

And that we had other minor issues with the diagnostics being somewhat confusing.

This patch addresses the confusion by reworking the implementation to be a bit more simple and a bit less chatty. Specifically, it changes the warning and note diagnostics to be able to specify "declaration" or "definition" as appropriate, and it changes the function merging logic so that the function without a prototype is always what gets warned on, and the function with a prototype is sometimes what gets noted. Additionally, when diagnosing a K&R C definition that is preceded by a function without a prototype, we don't note the prior declaration, we warn on it because it will also be changing behavior in C2x.

[jyknight]

This confuses me.

Looking at behavior with default flags:

We won't emit a -Wdeprecated-non-prototype warning for int foo();, until we subsequently find int foo(int arg) { return 5; }. Since we definitely have the context of what's going on at that point, in order to have determined that there's a conflict, what prevents doing the "right thing": emitting only 1 warning (at the definition site) and 1 note (at the declaration site)?

[aaron.ballman]

In D125814#3520137, @jyknight wrote:

This confuses me.

Looking at behavior with default flags:

We won't emit a -Wdeprecated-non-prototype warning for int foo();, until we subsequently find int foo(int arg) { return 5; }.

Close, but not quite. With default flags, we won't warn for int foo(); until we see a subsequent int foo(int arg) (regardless of whether it's a declaration or a definition).

Since we definitely have the context of what's going on at that point, in order to have determined that there's a conflict, what prevents doing the "right thing": emitting only 1 warning (at the definition site) and 1 note (at the declaration site)?

I'm going to continue to investigate; I recall arriving at this complex logic because I was trying to balance the deprecation warning diagnostics against the changes behavior diagnostics to keep the chattiness down. However, maybe this logic can now be simplified if I reword the diagnostic messages somewhat and rearrange some of the logic. I'll see what I can come up with.

[aaron.ballman]

Went with a more simple implementation approach and the diagnostic results seem to be a mild improvement in terms of wording and behavior.

[aaron.ballman]

Ping

[jyknight]

Good improvement, but an additional change to wording for just the zero-arg non-prototype function declaration case could help a lot. The fact that zero-arg it's only being warned about because of the "...because of" note isn't particularly clear -- especially when the "because of" isn't emitted.

So, suggestion for zero-arg-specific warning text:
this function %select{declaration|definition}0 without a prototype is deprecated before C2x, and is treated as a zero-parameter prototype in C2x, conflicting with a %select{previous|subsequent}1 declaration. Then, the note_func_decl_changes_behavior text can just be e.g.: conflicting prototype is here

That'd result in: printf 'int f();\nint f(a) int a; {return 1;}' | build/bin/clang -c -fsyntax-only -xc - showing:

<stdin>:2:5: warning: a function definition without a prototype is deprecated in all versions of C and is not supported in C2x [-Wdeprecated-non-prototype]
int f(a) int a; {return 1;}
    ^
<stdin>:1:5: warning: this function declaration without a prototype is deprecated before C2x, and is treated as a zero-parameter prototype in C2x, conflicting with a subsequent declaration [-Wdeprecated-non-prototype]
int f();
    ^

[dexonsmith]

(I’ll be happy with whatever you two sort out here!)

[aaron.ballman]

Update based on review feedback.

[aaron.ballman]

In D125814#3535452, @jyknight wrote:

Good improvement, but an additional change to wording for just the zero-arg non-prototype function declaration case could help a lot. The fact that zero-arg it's only being warned about because of the "...because of" note isn't particularly clear -- especially when the "because of" isn't emitted.

So, suggestion for zero-arg-specific warning text:

Thanks for the suggestion! I've implemented something along these lines in this patch and I think the diagnostics are better this way.

[jyknight]

clang/lib/Sema/SemaDecl.cpp

3959

"when the new declaration is a definition without a prototype" perhaps?

[aaron.ballman]

clang/lib/Sema/SemaDecl.cpp

3959

Done!

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_declaration_not_a_prototype : Note<
   "this declaration is not a prototype; add %select{'void'|parameter declarations}0 "
   "to make it %select{a prototype for a zero-parameter function|one}0">;
 // This is not actually an extension, but we only want it to be enabled in
 // -pedantic mode and this is the most direct way of accomplishing that.
 def warn_strict_prototypes : Extension<
   "a %select{function|block}0 declaration without a prototype is deprecated "
   "%select{in all versions of C|}0">, InGroup<StrictPrototypes>;
 def warn_non_prototype_changes_behavior : Warning<
-  "a function declaration without a prototype is deprecated in all versions of "
-  "C and is not supported in C2x">, InGroup<DeprecatedNonPrototype>;
-def note_func_decl_changes_behavior : Note<
-  "a function declaration without a prototype is not supported in C2x">;
+  "a function %select{declaration|definition}0 without a prototype is "
+  "deprecated in all versions of C %select{and is not supported in C2x|and is "
+  "treated as a zero-parameter prototype in C2x, conflicting with a "
+  "%select{previous|subsequent}2 %select{declaration|definition}3}1">,
+  InGroup<DeprecatedNonPrototype>;
+def note_conflicting_prototype : Note<"conflicting prototype is here">;
 def warn_missing_variable_declarations : Warning<
   "no previous extern declaration for non-static variable %0">,
   InGroup<DiagGroup<"missing-variable-declarations">>, DefaultIgnore;
 def note_static_for_internal_linkage : Note<
   "declare 'static' if the %select{variable|function}0 is not intended to be "
   "used outside of this translation unit">;
 def err_static_data_member_reinitialization :
   Error<"static data member %0 already has an initializer">;

clang/lib/Sema/SemaDecl.cpp

if (New->hasWrittenPrototype() != Old->hasWrittenPrototype() &&
         WithProto = New;
         WithoutProto = Old;
       } else {
         WithProto = Old;
         WithoutProto = New;
       }
 
       if (WithProto->getNumParams() != 0) {
-        // The function definition has parameters, so this will change
-        // behavior in C2x.
-        //
-        // If we already warned about about the function without a prototype
-        // being deprecated, add a note that it also changes behavior. If we
-        // didn't warn about it being deprecated (because the diagnostic is
-        // not enabled), warn now that it is deprecated and changes behavior.
-        bool AddNote = false;
-        if (Diags.isIgnored(diag::warn_strict_prototypes,
-                            WithoutProto->getLocation())) {
-          if (WithoutProto->getBuiltinID() == 0 &&
-              !WithoutProto->isImplicit() &&
-              SourceMgr.isBeforeInTranslationUnit(WithoutProto->getLocation(),
-                                                  WithProto->getLocation())) {
-            PartialDiagnostic PD =
-                PDiag(diag::warn_non_prototype_changes_behavior);
-            if (TypeSourceInfo *TSI = WithoutProto->getTypeSourceInfo()) {
-              if (auto FTL = TSI->getTypeLoc().getAs<FunctionNoProtoTypeLoc>())
-                PD << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
-            }
-            Diag(WithoutProto->getLocation(), PD);
-          }
-        } else {
-          AddNote = true;
-        }
-
-        // Because the function with a prototype has parameters but a previous
-        // declaration had none, the function with the prototype will also
-        // change behavior in C2x.
-        if (WithProto->getBuiltinID() == 0 && !WithProto->isImplicit()) {
-          if (SourceMgr.isBeforeInTranslationUnit(
-                  WithProto->getLocation(), WithoutProto->getLocation())) {
-            // If the function with the prototype comes before the function
-            // without the prototype, we only want to diagnose the one without
-            // the prototype.
-            Diag(WithoutProto->getLocation(),
-                 diag::warn_non_prototype_changes_behavior);
-          } else {
-            // Otherwise, diagnose the one with the prototype, and potentially
-            // attach a note to the one without a prototype if needed.
-            Diag(WithProto->getLocation(),
-                 diag::warn_non_prototype_changes_behavior);
-            if (AddNote && WithoutProto->getBuiltinID() == 0)
-              Diag(WithoutProto->getLocation(),
-                   diag::note_func_decl_changes_behavior);
-          }
-        } else if (AddNote && WithoutProto->getBuiltinID() == 0 &&
-                   !WithoutProto->isImplicit()) {
-          // If we were supposed to add a note but the function with a
-          // prototype is a builtin or was implicitly declared, which means we
-          // have nothing to attach the note to, so we issue a warning instead.
+        if (WithoutProto->getBuiltinID() == 0 && !WithoutProto->isImplicit()) {
+          // The one without the prototype will be changing behavior in C2x, so
+          // warn about that one so long as it's a user-visible declaration.
+          bool IsWithoutProtoADef = false, IsWithProtoADef = false;
+          if (WithoutProto == New)
+            IsWithoutProtoADef = NewDeclIsDefn;
+          else
+            IsWithProtoADef = NewDeclIsDefn;
           Diag(WithoutProto->getLocation(),
-               diag::warn_non_prototype_changes_behavior);
+               diag::warn_non_prototype_changes_behavior)
+              << IsWithoutProtoADef << (WithoutProto->getNumParams() ? 0 : 1)
+              << (WithoutProto == Old) << IsWithProtoADef;
+
+          // The reason the one without the prototype will be changing behavior
+          // is because of the one with the prototype, so note that so long as
+          // it's a user-visible declaration. There is one exception to this:
+          // when the new declaration is a definition without a prototype, the
+          // old declaration with a prototype is not the cause of the issue,
+          // and that does not need to be noted because the one with a
+          // prototype will not change behavior in C2x.
+          if (WithProto->getBuiltinID() == 0 && !WithProto->isImplicit() &&
+              !IsWithoutProtoADef)
+            Diag(WithProto->getLocation(), diag::note_conflicting_prototype);
         }
       }
     }
 
     if (Context.typesAreCompatible(OldQType, NewQType)) {
       const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
       const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
       const FunctionProtoType *OldProto = nullptr;
if (FD) {
         // If we have a possible prototype and it declares a function with a
         // prototype, we don't want to diagnose it; if we have a possible
         // prototype and it has no prototype, it may have already been
         // diagnosed in SemaType.cpp as deprecated depending on whether
         // -Wstrict-prototypes is enabled. If we already warned about it being
         // deprecated, add a note that it also changes behavior. If we didn't
         // warn about it being deprecated (because the diagnostic is not
         // enabled), warn now that it is deprecated and changes behavior.
-        bool AddNote = false;
-        if (PossiblePrototype) {
-          if (Diags.isIgnored(diag::warn_strict_prototypes,
-                              PossiblePrototype->getLocation())) {
 
-            PartialDiagnostic PD =
-                PDiag(diag::warn_non_prototype_changes_behavior);
-            if (TypeSourceInfo *TSI = PossiblePrototype->getTypeSourceInfo()) {
-              if (auto FTL = TSI->getTypeLoc().getAs<FunctionNoProtoTypeLoc>())
-                PD << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
-            }
-            Diag(PossiblePrototype->getLocation(), PD);
-          } else {
-            AddNote = true;
-          }
-        }
-
-        // Because this function definition has no prototype and it has
-        // parameters, it will definitely change behavior in C2x.
-        Diag(FD->getLocation(), diag::warn_non_prototype_changes_behavior);
-        if (AddNote)
+        // This K&R C function definition definitely changes behavior in C2x,
+        // so diagnose it.
+        Diag(FD->getLocation(), diag::warn_non_prototype_changes_behavior)
+            << /*definition*/ 1 << /* not supported in C2x */ 0;
+
+        // If we have a possible prototype for the function which is a user-
+        // visible declaration, we already tested that it has no prototype.
+        // This will change behavior in C2x. This gets a warning rather than a
+        // note because it's the same behavior-changing problem as with the
+        // definition.
+        if (PossiblePrototype)
           Diag(PossiblePrototype->getLocation(),
-               diag::note_func_decl_changes_behavior);
+               diag::warn_non_prototype_changes_behavior)
+              << /*declaration*/ 0 << /* conflicting */ 1 << /*subsequent*/ 1
+              << /*definition*/ 1;
       }
 
       // Warn on CPUDispatch with an actual body.
       if (FD->isMultiVersion() && FD->hasAttr<CPUDispatchAttr>() && Body)
         if (const auto *CmpndBody = dyn_cast<CompoundStmt>(Body))
           if (!CmpndBody->body_empty())
             Diag(CmpndBody->body_front()->getBeginLoc(),
                  diag::warn_dispatch_body_ignored);

clang/test/C/drs/dr0xx.c

  * conditional-expression, which excludes the comma operator.
  */
 int dr032 = (1, 2); /* expected-warning {{left operand of comma operator has no effect}} */
 
 #if __STDC_VERSION__ < 202000L
 /* WG14 DR035: partial
  * Questions about definition of functions without a prototype
  */
-void dr035_1(a, b) /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} */
+void dr035_1(a, b) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
   int a(enum b {x, y}); /* expected-warning {{declaration of 'enum b' will not be visible outside of this function}} */
   int b; {
   int test = x; /* expected-error {{use of undeclared identifier 'x'}} */
 }
 
-void dr035_2(c) /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} */
+void dr035_2(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
   enum m{q, r} c; { /* expected-warning {{declaration of 'enum m' will not be visible outside of this function}} */
   /* FIXME: This should be accepted because the scope of m, q, and r ends at
    * the closing brace of the function per C89 6.1.2.1.
    */
   int test = q; /* expected-error {{use of undeclared identifier 'q'}} */
 }
 #endif /* __STDC_VERSION__ < 202000L */
 

  * conformance not because we diagnose the UB when we could but because we're
  * not obligated to do anything about it and we make it "just work" via the
  * usual conversion rules.
  *
  * This behavior is specific to functions without prototypes. A function with
  * a prototype causes implicit conversions rather than relying on default
  * argument promotion and warm thoughts.
  */
-void dr070_1(c) /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} */
+void dr070_1(c) /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
   int c; {
 }
 
 void dr070_2(void) {
   dr070_1(6);
   dr070_1(6U); /* Pedantically UB */
 }
 #endif /* __STDC_VERSION__ < 202000L */

clang/test/CodeGen/2009-06-01-addrofknr.c

 // RUN: %clang_cc1 %s -o %t -emit-llvm -verify -std=c89
 // PR4289
 
 struct funcptr {
   int (*func)();
 };
 
-static int func(f) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+static int func(f) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
   void *f;
 {
   return 0;
 }
 
 int
 main(int argc, char *argv[])
 {
   struct funcptr fp;
 
   fp.func = &func;
   fp.func = func;
 }

clang/test/Parser/declarators.c

 void test2(int *P, int A) {
   struct str;
 
   // Hard case for array decl, not Array[*].
   int Array[*(int*)P+A];
 }
 
 typedef int atype;
-void test3(x,            /* expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} */
+void test3(x,            /* expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} */
            atype         /* expected-error {{unexpected type name 'atype': expected identifier}} */
           ) int x, atype; {}
 
 void test4(x, x) int x; {} // expected-error {{redefinition of parameter 'x'}} \
-                           // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+                           // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
 
 // PR3031
 int (test5), ;  // expected-error {{expected identifier or '('}}
 
 
 
 // PR3963 & rdar://6759604 - test error recovery for mistyped "typenames".

 
 void test14a(void);
 void *test14b = (void*)test14a; // Make sure test14a didn't get skipped.
 
 // rdar://problem/8358508
 long struct X { int x; } test15(void); // expected-error {{'long struct' is invalid}}
 
 void test16(i) int i j; { } // expected-error {{expected ';' at end of declaration}} \
-                            // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+                            // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 void test17(i, j) int i, j k; { } // expected-error {{expected ';' at end of declaration}} \
-                                  // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+                                  // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 void knrNoSemi(i) int i { } // expected-error {{expected ';' at end of declaration}} \
-                            // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+                            // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
 // PR12595
 void test18(void) {
   int x = 4+(5-12));  // expected-error {{extraneous ')' before ';'}}
 }
 
 enum E1 { e1 }: // expected-error {{expected ';'}}
 struct EnumBitfield { // expected-warning {{struct without named members is a GNU extension}}

clang/test/Sema/arg-duplicate.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c99
 
-int f3(y, x,       // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+int f3(y, x,       // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
        x)          // expected-error {{redefinition of parameter}}
   int y, 
       x,           // expected-note {{previous declaration is here}}
       x;           // expected-error {{redefinition of parameter}}
 {
   return x + y; 
 } 
 
 void f4(void) { 
   f3 (1, 1, 2, 3, 4); // expected-warning{{too many arguments}}
 }
 

clang/test/Sema/knr-def-call.c

 // RUN: %clang_cc1 -triple i386-pc-unknown -Wconversion -Wliteral-conversion -fsyntax-only -verify %s
 
 // C DR #316, PR 3626.
-void f0(a, b, c, d) int a,b,c,d; {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void f0(a, b, c, d) int a,b,c,d; {} // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 void t0(void) {
   f0(1);  // expected-warning{{too few arguments}}
 }
 
-void f1(a, b) int a, b; {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void f1(a, b) int a, b; {} // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 void t1(void) {
   f1(1, 2, 3); // expected-warning{{too many arguments}}
 }
 
 void f2(float); // expected-note{{previous declaration is here}}
 void f2(x) float x; { } // expected-warning{{promoted type 'double' of K&R function parameter is not compatible with the parameter type 'float' declared in a previous prototype}} \
-                           expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+                           expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
 typedef void (*f3)(void);
 f3 t3(int b) { return b? f0 : f1; } // okay
 
 // <rdar://problem/8193107>
 void f4() {
     char *rindex();
 }
 
 // FIXME: we should diagnose this case, but when merging function declarations,
 // we don't diagnose it because the function is a builtin.
 char *rindex(s, c)
      register char *s, c; // expected-warning{{promoted type 'char *' of K&R function parameter is not compatible with the parameter type 'const char *' declared in a previous prototype}}
 {
   return 0;
 }
 
 // PR8314
 void proto(int);
-void proto(x) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void proto(x) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
      int x;
 {
 }
 
 void use_proto() {
   proto(42.1); // expected-warning{{implicit conversion from 'double' to 'int' changes value from 42.1 to 42}}
   (&proto)(42.1); // expected-warning{{implicit conversion from 'double' to 'int' changes value from 42.1 to 42}}
 }
 
 // PR31020
 void func(short d) __attribute__((cdecl)); // expected-note{{previous declaration is here}}
-void __attribute__((cdecl)) func(d) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void __attribute__((cdecl)) func(d) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
   short d; // expected-warning{{promoted type 'int' of K&R function parameter is not compatible with the parameter type 'short' declared in a previous prototype}}
 {}

clang/test/Sema/knr-variadic-def.c

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s -std=c99
 // PR4287
 
 #include <stdarg.h>
 char *foo = "test";
 int test(char*,...);
 
-int test(fmt) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+int test(fmt) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
         char*fmt;
 {
         va_list ap;
         char*a;
         int x;
 
         va_start(ap,fmt);
         a=va_arg(ap,char*);
         x=(a!=foo);
         va_end(ap);
         return x;
 }
 
 void exit(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
-int main(argc,argv) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+int main(argc,argv) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
         int argc;char**argv;
 {
         exit(test("",foo));
 }
 

clang/test/Sema/warn-deprecated-non-prototype.c

 
 void whatever(void) {
   extern void hoo_boy(); // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 }
 
 void again() {} // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
 // On by default warnings
-void func();                 // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} \
-                                strict-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
-                                strict-note {{a function declaration without a prototype is not supported in C2x}}
-void func(a, b) int a, b; {} // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void func();                 // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is treated as a zero-parameter prototype in C2x, conflicting with a subsequent definition}} \
+                                strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+void func(a, b) int a, b; {} // both-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
-void one_more(a, b) int a, b; {} // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void one_more(a, b) int a, b; {} // both-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
 void sheesh(int a);
-void sheesh(a) int a; {} // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void sheesh(a) int a; {} // both-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
 void another(); // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
 int main(void) {
   another(1, 2);  // both-warning {{passing arguments to 'another' without a prototype is deprecated in all versions of C and is not supported in C2x}}
 }
 
-void order1();        // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} \
-                         strict-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
-                         strict-note {{a function declaration without a prototype is not supported in C2x}}
-void order1(int i);   // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void order1();        // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is treated as a zero-parameter prototype in C2x, conflicting with a subsequent declaration}} \
+                         strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+void order1(int i);   // both-note {{conflicting prototype is here}}
 
-void order2(int i);
-void order2();        // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} \
+void order2(int i);   // both-note {{conflicting prototype is here}}
+void order2();        // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is treated as a zero-parameter prototype in C2x, conflicting with a previous declaration}} \
                          strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
-void order3();        // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} \
-                         strict-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
-                         strict-note {{a function declaration without a prototype is not supported in C2x}}
-void order3(int i) {} // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void order3();        // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is treated as a zero-parameter prototype in C2x, conflicting with a subsequent definition}} \
+                         strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
+void order3(int i) {} // both-note {{conflicting prototype is here}}
 
 // Just because the prototype is variadic doesn't mean we shouldn't warn on the
 // K&R C function definition; this still changes behavior in C2x.
 void test(char*,...);
-void test(fmt)        // both-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void test(fmt)        // both-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
         char*fmt;
 {
 }
 
-// FIXME: we get two diagnostics here when running in pedantic mode. The first
-// comes when forming the function type for the definition, and the second
-// comes from merging the function declarations together. The second is the
-// point at which we know the behavior has changed (because we can see the
-// previous declaration at that point), but we've already issued the type
-// error by that point. It's not ideal to be this chatty, but this situation
-// should be pretty rare.
 void blapp(int); // both-note {{previous declaration is here}}
 void blapp() { } // both-error {{conflicting types for 'blapp'}} \
                  // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}
 
 // Disable -Wdeprecated-non-prototype
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-non-prototype"
 void depr_non_prot(); // strict-warning {{a function declaration without a prototype is deprecated in all versions of C}}

clang/test/Sema/warn-strict-prototypes.c

void bar3(void) {
   // casting function w/out prototype to unspecified params function type
   (void)(void(*)()) foo1; // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}}
                           // CHECK: fix-it:"{{.*}}":{[[@LINE-1]]:18-[[@LINE-1]]:18}:"void"
   // .. specified params
   (void)(void(*)(void)) foo1;
 }
 
 // K&R function definition not preceded by full prototype
-int foo9(a, b) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+int foo9(a, b) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
   int a, b;
 {
   return a + b;
 }
 
 // Function declaration with no types
 void foo10(); // expected-warning {{a function declaration without a prototype is deprecated in all versions of C}} \
-                 expected-note {{a function declaration without a prototype is not supported in C2x}}
+                 expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is treated as a zero-parameter prototype in C2x, conflicting with a subsequent definition}}
               // CHECK: fix-it:"{{.*}}":{[[@LINE-2]]:12-[[@LINE-2]]:12}:"void"
 // K&R function definition with incomplete param list declared
-void foo10(p, p2) void *p; {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}} \
+void foo10(p, p2) void *p; {} // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}} \
                                  expected-warning {{parameter 'p2' was not declared, defaults to 'int'; ISO C99 and later do not support implicit int}}
 
 void foo11(int p, int p2);
-void foo11(p, p2) int p; int p2; {} // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void foo11(p, p2) int p; int p2; {} // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
 
 // PR31020
-void __attribute__((cdecl)) foo12(d) // expected-warning {{a function declaration without a prototype is deprecated in all versions of C and is not supported in C2x}}
+void __attribute__((cdecl)) foo12(d) // expected-warning {{a function definition without a prototype is deprecated in all versions of C and is not supported in C2x}}
   short d;
 {}
 
 // No warnings for variadic functions. Overloadable attribute is required
 // to avoid err_ellipsis_first_param error.
 // rdar://problem/33251668
 void foo13(...) __attribute__((overloadable));
 void foo13(...) __attribute__((overloadable)) {}