clang/test/Sema/overloadable.c

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s -Wincompatible-pointer-types -Wno-strict-prototypes
   2
   3 int var __attribute__((overloadable)); // expected-error{{'overloadable' attribute only applies to functions}}
   4 void bad_attr_target(int) [[clang::overloadable]]; // expected-error{{'overloadable' attribute cannot be applied to types}}
   5 void params(void) __attribute__((overloadable(12))); // expected-error {{'overloadable' attribute takes no arguments}}
   6
   7 int *f(int) __attribute__((overloadable)); // expected-note{{previous overload of function is here}}
   8 float *f(float);
   9 int *f(int); // expected-error{{redeclaration of 'f' must have the 'overloadable' attribute}} \
  10              // expected-note{{previous declaration is here}}
  11 double *f(double) __attribute__((overloadable)); // okay, new
  12
  13 // Ensure we don't complain about overloadable on implicitly declared functions.
  14 int isdigit(int) __attribute__((overloadable));
  15
  16 void test_f(int iv, float fv, double dv) {
  17   int *ip = f(iv);
  18   float *fp = f(fv);
  19   double *dp = f(dv);
  20 }
  21
  22 int *accept_funcptr(int (*)()) __attribute__((overloadable)); //         \
  23   // expected-note{{candidate function}}
  24 float *accept_funcptr(int (*)(int, double)) __attribute__((overloadable)); //  \
  25   // expected-note{{candidate function}}
  26
  27 void test_funcptr(int (*f1)(int, double),
  28                   int (*f2)(int, float)) {
  29   float *fp = accept_funcptr(f1);
  30   accept_funcptr(f2); // expected-error{{no matching function for call to 'accept_funcptr'}}
  31 }
  32
  33 struct X { int x; float y; };
  34 struct Y { int x; float y; };
  35 int* accept_struct(struct X x) __attribute__((__overloadable__));
  36 float* accept_struct(struct Y y) __attribute__((overloadable));
  37
  38 void test_struct(struct X x, struct Y y) {
  39   int *ip = accept_struct(x);
  40   float *fp = accept_struct(y);
  41 }
  42
  43 double *f(int) __attribute__((overloadable)); // expected-error{{conflicting types for 'f'}}
  44
  45 double promote(float) __attribute__((__overloadable__));
  46 double promote(double) __attribute__((__overloadable__));
  47 long double promote(long double) __attribute__((__overloadable__));
  48
  49 void promote(...) __attribute__((__overloadable__, __unavailable__)); // expected-note {{marked unavailable here}}
  50
  51 void test_promote(short* sp) {
  52   promote(1.0);
  53   promote(sp); // expected-error{{'promote' is unavailable}}
  54 }
  55
  56 // PR6600
  57 typedef double Double;
  58 typedef Double DoubleVec __attribute__((vector_size(16)));
  59 typedef int Int;
  60 typedef Int IntVec __attribute__((vector_size(16)));
  61 double magnitude(DoubleVec) __attribute__((__overloadable__));
  62 double magnitude(IntVec) __attribute__((__overloadable__));
  63 double test_p6600(DoubleVec d) {
  64   return magnitude(d) * magnitude(d);
  65 }
  66
  67 // PR7738
  68 extern int __attribute__((overloadable)) f0(); // expected-error{{'overloadable' function 'f0' must have a prototype}}
  69 typedef int f1_type();
  70 f1_type __attribute__((overloadable)) f1; // expected-error{{'overloadable' function 'f1' must have a prototype}}
  71
  72 void test() {
  73   f0();
  74   f1();
  75 }
  76
  77 // Validate that the invalid function doesn't stay overloadable.
  78 int __attribute__((overloadable)) invalid(); // expected-error{{'overloadable' function 'invalid' must have a prototype}}
  79 int __attribute__((overloadable)) invalid(int); // expected-error{{redeclaration of 'invalid' must not have the 'overloadable' attribute}}
  80                                                 // expected-note@-2{{previous unmarked overload of function is here}}
  81 void use_invalid(void) {
  82   invalid(); // expected-error{{too few arguments to function call, expected 1, have 0}}
  83              // expected-note@-4{{'invalid' declared here}}
  84   invalid(1);
  85 }
  86
  87 void before_local_1(int) __attribute__((overloadable));
  88 void before_local_2(int); // expected-note {{here}}
  89 void before_local_3(int) __attribute__((overloadable));
  90 void local() {
  91   void before_local_1(char);
  92   void before_local_2(char); // expected-error {{conflicting types}}
  93   void before_local_3(char) __attribute__((overloadable));
  94   void after_local_1(char);
  95   void after_local_2(char) __attribute__((overloadable));
  96   void after_local_3(char) __attribute__((overloadable));
  97 }
  98 void after_local_1(int) __attribute__((overloadable));
  99 void after_local_2(int);
 100 void after_local_3(int) __attribute__((overloadable));
 101
 102 // Make sure we allow C-specific conversions in C.
 103 void conversions() {
 104   void foo(char *c) __attribute__((overloadable));
 105   void foo(char *c) __attribute__((overloadable, enable_if(c, "nope.jpg")));
 106
 107   void *ptr;
 108   foo(ptr);
 109
 110   void multi_type(unsigned char *c) __attribute__((overloadable));
 111   void multi_type(signed char *c) __attribute__((overloadable));
 112   unsigned char *c;
 113   multi_type(c);
 114 }
 115
 116 // Ensure that we allow C-specific type conversions in C
 117 void fn_type_conversions() {
 118   void foo(void *c) __attribute__((overloadable));
 119   void foo(char *c) __attribute__((overloadable));
 120   void (*ptr1)(void *) = &foo;
 121   void (*ptr2)(char *) = &foo;
 122   void (*ambiguous)(int *) = &foo; // expected-error{{initializing 'void (*)(int *)' with an expression of incompatible type '<overloaded function type>'}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}}
 123   void *vp_ambiguous = &foo; // expected-error{{initializing 'void *' with an expression of incompatible type '<overloaded function type>'}} expected-note@-5{{candidate function}} expected-note@-4{{candidate function}}
 124
 125   void (*specific1)(int *) = (void (*)(void *))&foo; // expected-error{{incompatible function pointer types initializing 'void (*)(int *)' with an expression of type 'void (*)(void *)'}}
 126   void *specific2 = (void (*)(void *))&foo;
 127
 128   void disabled(void *c) __attribute__((overloadable, enable_if(0, "")));
 129   void disabled(int *c) __attribute__((overloadable, enable_if(c, "")));
 130   void disabled(char *c) __attribute__((overloadable, enable_if(1, "The function name lies.")));
 131   // To be clear, these should all point to the last overload of 'disabled'
 132   void (*dptr1)(char *c) = &disabled;
 133   void (*dptr2)(void *c) = &disabled; // expected-error{{incompatible function pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}} expected-note@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function made ineligible by enable_if}} expected-note@-3{{candidate function has type mismatch at 1st parameter (expected 'void *' but has 'char *')}}
 134   void (*dptr3)(int *c) = &disabled; // expected-error{{incompatible function pointer types initializing 'void (*)(int *)' with an expression of type '<overloaded function type>'}} expected-note@-6{{candidate function made ineligible by enable_if}} expected-note@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function has type mismatch at 1st parameter (expected 'int *' but has 'char *')}}
 135
 136   void *specific_disabled = &disabled;
 137 }
 138
 139 void incompatible_pointer_type_conversions() {
 140   char charbuf[1];
 141   unsigned char ucharbuf[1];
 142   int intbuf[1];
 143
 144   void foo(char *c) __attribute__((overloadable));
 145   void foo(short *c) __attribute__((overloadable));
 146   foo(charbuf);
 147   foo(ucharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-3{{candidate function}} expected-note@-2{{candidate function}}
 148   foo(intbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}}
 149
 150   void bar(unsigned char *c) __attribute__((overloadable));
 151   void bar(signed char *c) __attribute__((overloadable));
 152   bar(charbuf); // expected-error{{call to 'bar' is ambiguous}} expected-note@-2{{candidate function}} expected-note@-1{{candidate function}}
 153   bar(ucharbuf);
 154   bar(intbuf); // expected-error{{call to 'bar' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}}
 155 }
 156
 157 void dropping_qualifiers_is_incompatible() {
 158   const char ccharbuf[1];
 159   volatile char vcharbuf[1];
 160
 161   void foo(char *c) __attribute__((overloadable));
 162   void foo(const volatile unsigned char *c) __attribute__((overloadable));
 163
 164   foo(ccharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-3{{candidate function}} expected-note@-2{{candidate function}}
 165   foo(vcharbuf); // expected-error{{call to 'foo' is ambiguous}} expected-note@-4{{candidate function}} expected-note@-3{{candidate function}}
 166 }
 167
 168 void overloadable_with_global() {
 169   void wg_foo(void) __attribute__((overloadable)); // expected-note{{previous}}
 170   void wg_foo(int) __attribute__((overloadable));
 171 }
 172
 173 int wg_foo; // expected-error{{redefinition of 'wg_foo' as different kind of symbol}}
 174
 175 #if !__has_extension(overloadable_unmarked)
 176 #error "We should have unmarked overload support"
 177 #endif
 178
 179 void to_foo0(int);
 180 void to_foo0(double) __attribute__((overloadable)); // expected-note{{previous overload}}
 181 void to_foo0(int);
 182 void to_foo0(double); // expected-error{{must have the 'overloadable' attribute}}
 183 void to_foo0(int);
 184
 185 void to_foo1(int) __attribute__((overloadable)); // expected-note 2{{previous overload}}
 186 void to_foo1(double);
 187 void to_foo1(int); // expected-error{{must have the 'overloadable' attribute}}
 188 void to_foo1(double);
 189 void to_foo1(int); // expected-error{{must have the 'overloadable' attribute}}
 190
 191 void to_foo2(int); // expected-note{{previous unmarked overload}}
 192 void to_foo2(double) __attribute__((overloadable)); // expected-note 2{{previous overload}}
 193 void to_foo2(int) __attribute__((overloadable)); // expected-error {{must not have the 'overloadable' attribute}}
 194 void to_foo2(double); // expected-error{{must have the 'overloadable' attribute}}
 195 void to_foo2(int);
 196 void to_foo2(double); // expected-error{{must have the 'overloadable' attribute}}
 197 void to_foo2(int);
 198
 199 void to_foo3(int);
 200 void to_foo3(double) __attribute__((overloadable)); // expected-note{{previous overload}}
 201 void to_foo3(int);
 202 void to_foo3(double); // expected-error{{must have the 'overloadable' attribute}}
 203
 204 void to_foo4(int) __attribute__((overloadable)); // expected-note{{previous overload}}
 205 void to_foo4(int); // expected-error{{must have the 'overloadable' attribute}}
 206 void to_foo4(double) __attribute__((overloadable));
 207
 208 void to_foo5(int);
 209 void to_foo5(int); // expected-note 3{{previous unmarked overload}}
 210 void to_foo5(float) __attribute__((overloadable));
 211 void to_foo5(double); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
 212 void to_foo5(float) __attribute__((overloadable));
 213 void to_foo5(short); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
 214 void to_foo5(long); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
 215 void to_foo5(double) __attribute__((overloadable));
 216
 217 void to_foo6(int) __attribute__((enable_if(1, ""), overloadable)); // expected-note{{previous overload}}
 218 void to_foo6(int) __attribute__((enable_if(1, ""))); // expected-error{{must have the 'overloadable' attribute}}
 219 void to_foo6(int) __attribute__((enable_if(1, ""), overloadable));
 220
 221 void to_foo7(int) __attribute__((enable_if(1, ""))); // expected-note{{previous unmarked overload}}
 222 void to_foo7(int) __attribute__((enable_if(1, ""), overloadable)); // expected-error{{must not have the 'overloadable' attribute}}
 223 void to_foo7(int) __attribute__((enable_if(1, "")));
 224
 225 void to_foo8(char *__attribute__((pass_object_size(0))))
 226   __attribute__((enable_if(1, "")));
 227 void to_foo8(char *__attribute__((pass_object_size(0))))
 228   __attribute__((overloadable));
 229
 230 void to_foo9(int); // expected-note{{previous unmarked overload}}
 231 // FIXME: It would be nice if we did better with the "previous unmarked
 232 // overload" diag.
 233 void to_foo9(int) __attribute__((overloadable)); // expected-error{{must not have the 'overloadable' attribute}} expected-note{{previous declaration}} expected-note{{previous unmarked overload}}
 234 void to_foo9(float); // expected-error{{conflicting types for 'to_foo9'}}
 235 void to_foo9(float) __attribute__((overloadable));
 236 void to_foo9(double); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
 237 void to_foo9(double) __attribute__((overloadable));
 238
 239 void to_foo10(int) __attribute__((overloadable));
 240 void to_foo10(double); // expected-note{{previous unmarked overload}}
 241 // no "note: previous redecl" if no previous decl has `overloadable`
 242 // spelled out
 243 void to_foo10(float); // expected-error{{at most one overload for a given name may lack the 'overloadable' attribute}}
 244 void to_foo10(float); // expected-error{{must have the 'overloadable' attribute}}
 245 void to_foo10(float); // expected-error{{must have the 'overloadable' attribute}}
 246
 247 // Bug: we used to treat `__typeof__(foo)` as though it was `__typeof__(&foo)`
 248 // if `foo` was overloaded with only one function that could have its address
 249 // taken.
 250 void typeof_function_is_not_a_pointer() {
 251   void not_a_pointer(void *) __attribute__((overloadable));
 252   void not_a_pointer(char *__attribute__((pass_object_size(1))))
 253     __attribute__((overloadable));
 254
 255   __typeof__(not_a_pointer) *fn;
 256
 257   void take_fn(void (*)(void *));
 258   // if take_fn is passed a void (**)(void *), we'll get a warning.
 259   take_fn(fn);
 260 }
 261
 262 // PR53805
 263 // We previously failed to consider the attribute being written before the
 264 // declaration when considering whether to allow a variadic signature with no
 265 // other parameters, and so we handled these cases differently.
 266 __attribute__((overloadable)) void can_overload_1(...); // ok, was previously rejected
 267 void can_overload_2(...) __attribute__((overloadable)); // ok
 268 [[clang::overloadable]] void can_overload_3(...);       // ok, was previously rejected
 269 void can_overload_4 [[clang::overloadable]] (...);      // ok
 270 void cannot_overload(...) [[clang::overloadable]];      // expected-error {{ISO C requires a named parameter before '...'}} \
 271                                                         // expected-error {{'overloadable' attribute cannot be applied to types}}