[WIP] Enable `-Wstrict-calls-without-prototype` by default

[delcypher]

Summary

This patch enables the -Wstrict-calls-without-prototype warning by
default and fixes the existing clang test suite to pass.

This patch is considered work-in-progress because the patch it is
based on is not finalized. It is also unclear at this point whether this warning should actually
be enabled by default. So this patch serves to illustrate the changes
that would need to be made to have the warning on by default.

rdar://87118271

[delcypher]

This change depends on https://reviews.llvm.org/D116635.

[NoQ]

Ooof you fixed a lot of static analyzer tests. If you ever get tired of this, feel free to -w them entirely because the driver's --analyze flag implies -w anyway. Hmm, maybe we should even change %clang_analyze_cc1 to include -w.

[aaron.ballman]

I don't see a justification for enabling this diagnostic by default in C89 mode. I can imagine users wanting to opt into this behavior for C89, but it certainly shouldn't be diagnosing correct code by default.

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">;
 def warn_strict_prototypes : Warning<
   "this %select{function declaration is not|block declaration is not|"
   "old-style function definition is not preceded by}0 a prototype">,
   InGroup<DiagGroup<"strict-prototypes">>, DefaultIgnore;
 def warn_call_function_without_prototype : Warning<
   "calling function %0 with arguments when function has no prototype">, InGroup<
-  DiagGroup<"strict-calls-without-prototype">>, DefaultIgnore;
+  DiagGroup<"strict-calls-without-prototype">>;
 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/test/Analysis/casts.c

 typedef unsigned char __uint8_t;
 typedef unsigned int __uint32_t;
 typedef __uint32_t __darwin_socklen_t;
 typedef __uint8_t sa_family_t;
 typedef __darwin_socklen_t socklen_t;
 struct sockaddr { sa_family_t sa_family; };
 struct sockaddr_storage {};
 
-void getsockname();
+void getsockname(int, struct sockaddr *, socklen_t *);
 
 #ifndef EAGERLY_ASSUME
 
 void f(int sock) {
   struct sockaddr_storage storage;
   struct sockaddr* sockaddr = (struct sockaddr*)&storage; // expected-warning{{Casting data to a larger structure type and accessing a field can lead to memory access errors or data corruption}}
   socklen_t addrlen = sizeof(storage);
   getsockname(sock, sockaddr, &addrlen);

clang/test/Analysis/inline.c

-// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -Wno-strict-calls-without-prototype %s
 
 void clang_analyzer_eval(int);
 void clang_analyzer_checkInlined(int);
 
 int test1_f1() {
   int y = 1;
   y++;
   clang_analyzer_checkInlined(1); // expected-warning{{TRUE}}

clang/test/Analysis/misc-ps-region-store.m

 
 // This test case illustrates how a typeless array of bytes casted to a
 // struct should be treated as initialized.  RemoveDeadBindings previously
 // had a bug that caused 'x' to lose its default symbolic value after the
 // assignment to 'p', thus causing 'p->z' to evaluate to "undefined".
 struct ArrayWrapper { unsigned char y[16]; };
 struct WrappedStruct { unsigned z; };
 
-void test_handle_array_wrapper_helper();
+void test_handle_array_wrapper_helper(struct ArrayWrapper *);
 
 int test_handle_array_wrapper() {
   struct ArrayWrapper x;
   test_handle_array_wrapper_helper(&x);
   struct WrappedStruct *p = (struct WrappedStruct*) x.y; // expected-warning{{Casting a non-structure type to a structure type and accessing a field can lead to memory access errors or data corruption}}
   return p->z;  // no-warning
 }
 

clang/test/Analysis/misc-ps.m

 
 // This case tests that CastRegion handles casts involving BlockPointerTypes.
 // It should not crash.
 void test_block_cast() {
   id test_block_cast_aux();
   (void (^)(void *))test_block_cast_aux(); // expected-warning{{expression result unused}}
 }
 
-int OSAtomicCompareAndSwap32Barrier();
+int OSAtomicCompareAndSwap32Barrier(int, int, int *);
 
 // Test comparison of 'id' instance variable to a null void* constant after
 // performing an OSAtomicCompareAndSwap32Barrier.
 // This previously was a crash in RegionStoreManager.
 @interface TestIdNull {
   id x;
 }
 -(int)foo;

 void test_invalidate_cast_int() {
   void test_invalidate_cast_int_aux(unsigned *i);
   signed i;  
   test_invalidate_cast_int_aux((unsigned*) &i);
   if (i < 0)
     return;
 }
 
-int ivar_getOffset();
+int ivar_getOffset(Ivar);
 
 // Reduced from a crash involving the cast of an Objective-C symbolic region to
 // 'char *'
 static NSNumber *test_ivar_offset(id self, SEL _cmd, Ivar inIvar) {
   return [[[NSNumber allocWithZone:((void*)0)] initWithBool:*(_Bool *)((char *)self + ivar_getOffset(inIvar))] autorelease];
 }
 
 // Reduced from a crash in StoreManager::CastRegion involving a divide-by-zero.

clang/test/Analysis/null-deref-ps.c

if (!p)
     if (p)
       *p = 1; // no-warning
   
   if (q)
     if (!q)
       *q = 1; // no-warning
 }
 
-int* qux();
+int *qux(unsigned);
 
 int f9(unsigned len) {
   assert (len != 0);
   int *p = 0;
   unsigned i;
 
   for (i = 0; i < len; ++i)
    p = qux(i);

clang/test/Analysis/solver-sym-simplification-adjustment.c

 // RUN: %clang_analyze_cc1 %s \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=debug.ExprInspection \
 // RUN:   -analyzer-config eagerly-assume=false \
 // RUN:   -verify
 
 void clang_analyzer_warnIfReached();
-void clang_analyzer_eval();
+void clang_analyzer_eval(int);
 
 void test_simplification_adjustment_concrete_int(int b, int c) {
   if (b < 0 || b > 1)  // b: [0,1]
     return;
   if (c < -1 || c > 1) // c: [-1,1]
     return;
   if (c + b != 0)      // c + b == 0
     return;

clang/test/Analysis/solver-sym-simplification-concreteint.c

 // RUN: %clang_analyze_cc1 %s \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=debug.ExprInspection \
 // RUN:   -analyzer-config eagerly-assume=false \
 // RUN:   -verify
 
 void clang_analyzer_warnIfReached();
-void clang_analyzer_eval();
+void clang_analyzer_eval(int);
 
 void test_simplification_to_concrete_int_infeasible(int b, int c) {
   if (c + b != 0)     // c + b == 0
     return;
   if (b != 1)         // b == 1  --> c + 1 == 0
     return;
   if (c != 1)         // c == 1  --> 1 + 1 == 0 contradiction
     return;

clang/test/CodeGen/functions.c

-// RUN: %clang_cc1 %s -triple i386-unknown-unknown -emit-llvm -o - -verify | FileCheck %s
+// RUN: %clang_cc1 %s -triple i386-unknown-unknown -emit-llvm -o - -verify -Wno-strict-calls-without-prototype | FileCheck %s
 
 int g();
 
 int foo(int i) {
   return g(i);
 }
 
 int g(int i) {

clang/test/Sema/arg-duplicate.c

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-strict-calls-without-prototype %s
 
 int f3(y, x, 
        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/block-misc.c

 void test16(__block int i) { // expected-error {{__block attribute not allowed, only allowed on local variables}}
   int size = 5;
   extern __block double extern_var; // expected-error {{__block attribute not allowed, only allowed on local variables}}
   static __block char * pch; // expected-error {{__block attribute not allowed, only allowed on local variables}}
   __block int a[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}}
   __block int (*ap)[size]; // expected-error {{__block attribute not allowed on declaration with a variably modified type}}
 }
 
-void f();
+void f(void (*)(int));
+void f2(void (^)(int));
 
 void test17() {
   void (^bp)(int);
   void (*rp)(int);
   void (^bp1)();
   void *vp = bp;
 
   f(1 ? bp : vp);
   f(1 ? vp : bp);
-  f(1 ? bp : bp1);
+  f2(1 ? bp : bp1);
   (void)(bp > rp); // expected-error {{invalid operands}}
   (void)(bp > 0); // expected-error {{invalid operands}}
   (void)(bp > bp); // expected-error {{invalid operands}}
   (void)(bp > vp); // expected-error {{invalid operands}}
   f(1 ? bp : rp); // expected-error {{incompatible operand types ('void (^)(int)' and 'void (*)(int)')}}
   (void)(bp == 1); // expected-error {{invalid operands to binary expression}}
   (void)(bp == 0);
   (void)(1 == bp); // expected-error {{invalid operands to binary expression}}

clang/test/Sema/extern-redecl.c

char test6_fn2;
       extern int test6_array1[];
       extern int test6_array2[];
       (void)sizeof(test6_array1); // ok
       (void)sizeof(test6_array2); // expected-error {{incomplete type}}
 
       void test6_fn1();
       void test6_fn2();
       test6_fn1(1.2); // expected-error {{passing 'double' to parameter of incompatible type 'int *'}}
-      // FIXME: This is valid, but we should warn on it.
-      test6_fn2(1.2);
+      test6_fn2(1.2); // expected-warning{{calling function 'test6_fn2' with arguments when function has no prototype}}
+      // expected-note@-3{{'test6_fn2' declared here}}
     }
   }
 }

clang/test/Sema/function-redecl.c

 extern __typeof (i0) i1;
 extern __typeof (i1) i1;
 
 typedef int a();
 typedef int a2(int*);
 a x;
 a2 x2; // expected-note{{passing argument to parameter here}}
 void test_x() {
-  x(5);
+  x(5); // expected-warning{{calling function 'x' with arguments when function has no prototype}}
+  // expected-note@-4{{'x' declared here}}
   x2(5); // expected-warning{{incompatible integer to pointer conversion passing 'int' to parameter of type 'int *'}}
 }
 
 enum e0 {one}; 
 void f3(); 
 void f3(enum e0 x) {}
 
 enum incomplete_enum;
 void f4(); // expected-note {{previous declaration is here}}
 void f4(enum incomplete_enum); // expected-error {{conflicting types for 'f4'}}

clang/test/Sema/function.c

 int t6(int x, g);   // expected-warning {{type specifier missing, defaults to 'int'}}
 
 int t7(, );       // expected-error {{expected parameter declarator}} expected-error {{expected parameter declarator}}
 int t8(, int a);  // expected-error {{expected parameter declarator}}
 int t9(int a, );  // expected-error {{expected parameter declarator}}
 
 
 // PR2042
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wstrict-calls-without-prototype"
 void t10(){}
 void t11(){t10(1);} // expected-warning{{too many arguments}}
+#pragma clang diagnostic pop
 
 // PR3208
 void t12(int) {}  // c2x-warning{{omitting the parameter name in a function definition is a C2x extension}}
 
 // PR2790
 void t13() {
   return 0; // expected-error {{void function 't13' should not return a value}}
 }

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; {}
 void t0(void) {
+  // expected-warning@+2{{calling function 'f0' with arguments when function has no prototype}}
+  // expected-note@-3{{'f0' declared here}}
   f0(1);  // expected-warning{{too few arguments}}
 }
 
 void f1(a, b) int a, b; {}
 void t1(void) {
+  // expected-warning@+2{{calling function 'f1' with arguments when function has no prototype}}
+  // expected-note@-3{{'f1' declared here}}
   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}}
 
 typedef void (*f3)(void);
 f3 t3(int b) { return b? f0 : f1; } // okay

 // PR8314
 void proto(int);
 void proto(x)
      int x;
 {
 }
 
 void use_proto() {
+  // FIXME(dliew): Perhaps we shouldn't warn about this?
+  // expected-warning@+2{{calling function 'proto' with arguments when function has no prototype}}
+  // expected-note@-8{{'proto' declared here}}
   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)
   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
+// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wno-strict-calls-without-prototype %s
 // expected-no-diagnostics
 // PR4287
 
 #include <stdarg.h>
 char *foo = "test";
 int test(char*,...);
 
 int test(fmt)

clang/test/Sema/merge-decls.c

void test4_f(a)
   int v[sizeof(a) == 1 ? 1 : -1];
 }
 
 int test5_f(int (*)[10]);
 int test5_f(int (*x)[]) {
   return sizeof(*x); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int[]'}}
 }
 
+// FIXME(dliew): shouldn't warn here
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wstrict-calls-without-prototype"
 void test6_f(int (*a)[11]);
 void test6_f(a)
    int (*a)[];
 {}
 void test6_g() {
   int arr[10];
   test6_f(&arr); // expected-warning {{incompatible pointer types passing 'int (*)[10]' to parameter of type 'int (*)[11]}}
 }
+#pragma clang diagnostic pop
 
 void test7_f(int (*)[10]);
 void test7_f(int (*)[]); // expected-note {{passing argument to parameter here}}
 void test7_g() {
   int x[5];
   test7_f(&x); // expected-warning {{incompatible pointer types passing 'int (*)[5]' to parameter of type 'int (*)[10]}}
 }

clang/test/Sema/sizeless-1.c

 void __attribute__((overloadable)) overf(svint16_t);
 
 void __attribute__((overloadable)) overf8(svint8_t); // expected-note + {{not viable}}
 void __attribute__((overloadable)) overf8(int);      // expected-note + {{not viable}}
 
 void __attribute__((overloadable)) overf16(svint16_t); // expected-note + {{not viable}}
 void __attribute__((overloadable)) overf16(int);       // expected-note + {{not viable}}
 
-void noproto();
+void noproto(); // expected-note{{'noproto' declared here}}
 void varargs(int, ...);
 
 void unused() {
   svint8_t unused_int8; // expected-warning {{unused}}
 }
 
 struct incomplete_struct *incomplete_ptr;
 
void func(int sel) {
   overf(local_int16);
 
   overf8(local_int8);
   overf8(local_int16); // expected-error {{no matching function}}
 
   overf16(local_int8); // expected-error {{no matching function}}
   overf16(local_int16);
 
-  noproto(local_int8);
+  noproto(local_int8); // expected-warning{{calling function 'noproto' with arguments when function has no prototype}}
   varargs(1, local_int8, local_int16);
 
   global_int8_ptr++;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr--;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   ++global_int8_ptr;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   --global_int8_ptr;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr + 1;               // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr - 1;               // expected-error {{arithmetic on a pointer to sizeless type}}

clang/test/Sema/unused-expr.c

 }
 
 // rdar://7186119
 int t5f(void) __attribute__((warn_unused_result));
 void t5() {
   t5f();   // expected-warning {{ignoring return value of function declared with 'warn_unused_result' attribute}}
 }
 
-
 int fn1() __attribute__ ((warn_unused_result));
-int fn2() __attribute__ ((pure));
-int fn3() __attribute__ ((__const));
+int fn2(int, int) __attribute__((pure));
+int fn3(int) __attribute__((__const));
 // rdar://6587766
 int t6() {
   if (fn1() < 0 || fn2(2,1) < 0 || fn3(2) < 0)  // no warnings
     return -1;
 
   fn1();  // expected-warning {{ignoring return value of function declared with 'warn_unused_result' attribute}}
   fn2(92, 21);  // expected-warning {{ignoring return value of function declared with pure attribute}}
   fn3(42);  // expected-warning {{ignoring return value of function declared with const attribute}}

 int fn5() __attribute__ ((__const));
 
 // Don't warn for unused expressions in macro bodies; however, do warn for
 // unused expressions in macro arguments. Macros below are reduced from code
 // found in the wild.
 #define NOP(a) (a)
 #define M1(a, b) (long)foo((a), (b))
 #define M2 (long)0;
-#define M3(a) (t3(a), fn2())
+#define M3(a) (t3(a), fn2(0, 1))
 #define M4(a, b) (foo((a), (b)) ? 0 : t3(a), 1)
 #define M5(a, b) (foo((a), (b)), 1)
 #define M6() fn1()
-#define M7() fn2()
+#define M7() fn2(0, 1)
 void t11(int i, int j) {
   M1(i, j);  // no warning
   NOP((long)foo(i, j)); // expected-warning {{expression result unused}}
   M2;  // no warning
   NOP((long)0); // expected-warning {{expression result unused}}
   M3(i); // no warning
-  NOP((t3(i), fn2())); // expected-warning {{ignoring return value}}
+  NOP((t3(i), fn2(0, 0))); // expected-warning {{ignoring return value}}
   M4(i, j); // no warning
   NOP((foo(i, j) ? 0 : t3(i), 1)); // expected-warning {{expression result unused}}
   M5(i, j); // no warning
   NOP((foo(i, j), 1)); // expected-warning {{expression result unused}}
   M6(); // expected-warning {{ignoring return value}}
   M7(); // no warning
 }
 #undef NOP

clang/test/SemaObjC/nonnull.m

 extern void func1 (void (^block1)(), void (^block2)(), int) __attribute__((nonnull));
 
 extern void func3 (void (^block1)(), int, void (^block2)(), int)
 __attribute__((nonnull(1,3)));
 
 extern void func4 (void (^block1)(), void (^block2)()) __attribute__((nonnull(1)))
 __attribute__((nonnull(2)));
 
-void func6();
-void func7();
+void func6(NSObject *);
+void func7(NSObject *);
 
 void
 foo (int i1, int i2, int i3, void (^cp1)(), void (^cp2)(), void (^cp3)())
 {
   func1(cp1, cp2, i1);
   
   func1(0, cp2, i1);  // expected-warning {{null passed to a callee that requires a non-null argument}}
   func1(cp1, 0, i1);  // expected-warning {{null passed to a callee that requires a non-null argument}}

 typedef union {
     long first;
     struct dispatch_object_s *_do;
 } dispatch_object_t __attribute__((transparent_union));
 
 __attribute__((nonnull))
 void _dispatch_queue_push_list(dispatch_object_t _head); // no warning
 
-void func6(dispatch_object_t _head) {
+void func8(dispatch_object_t _head) {
   _dispatch_queue_push_list(0); // expected-warning {{null passed to a callee that requires a non-null argument}}
   _dispatch_queue_push_list(_head._do);  // no warning
 }
 
 // rdar://9287695
 #define NULL (void*)0
 
 @interface NSObject 

clang/test/SemaObjC/protocol-archane.m

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-pointer-to-int-cast -Wno-objc-root-class %s
 // rdar://5986251
 
 @protocol SomeProtocol
 - (void) bar;
 @end
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wstrict-calls-without-prototype"
 void bar();
 void foo(id x) {
   bar((short<SomeProtocol>)x); // expected-error {{expected ')'}} expected-note {{to match this '('}}
   bar((<SomeProtocol>)x);      // expected-warning {{protocol has no object type specified; defaults to qualified 'id'}}
 
   [(<SomeProtocol>)x bar];      // expected-warning {{protocol has no object type specified; defaults to qualified 'id'}}
 }
+#pragma clang diagnostic pop
 
 @protocol MyProtocol
 - (void)doSomething;
 @end
 
 @interface MyClass
 - (void)m1:(id <MyProtocol> const)arg1;