1// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s 2@interface Foo 3@end 4 5@implementation Foo 6 7void func(id); 8 9+ zone { 10 func(self); 11 return self; 12} 13@end 14 15@protocol P0 16@end 17 18@protocol P1 19@end 20 21@interface A <P0> 22@end 23 24@interface B : A 25@end 26 27@interface C <P1> 28@end 29 30int& f(A*); // expected-note {{candidate}} 31float& f(B*); // expected-note {{candidate}} 32void g(A*); 33 34int& h(A*); 35float& h(id); 36 37void test0(A* a, B* b, id val) { 38 int& i1 = f(a); 39 float& f1 = f(b); 40 41 // GCC succeeds here, which is clearly ridiculous. 42 float& f2 = f(val); // expected-error {{ambiguous}} 43 44 g(a); 45 g(b); 46 g(val); 47 int& i2 = h(a); 48 float& f3 = h(val); 49 50 int& i3 = h(b); 51} 52 53void test1(A* a) { 54 B* b = a; // expected-warning{{incompatible pointer types initializing 'B *' with an expression of type 'A *'}} 55 B *c; c = a; // expected-warning{{incompatible pointer types assigning to 'B *' from 'A *'}} 56} 57 58void test2(A** ap) { 59 B** bp = ap; // expected-warning{{incompatible pointer types initializing 'B **' with an expression of type 'A **'}} 60 bp = ap; // expected-warning{{incompatible pointer types assigning to 'B **' from 'A **'}} 61} 62 63// FIXME: we should either allow overloading here or give a better diagnostic 64int& cv(A*); // expected-note {{previous declaration}} expected-note 2 {{not viable}} 65float& cv(const A*); // expected-error {{cannot be overloaded}} 66 67int& cv2(void*); 68float& cv2(const void*); 69 70void cv_test(A* a, B* b, const A* ac, const B* bc) { 71 int &i1 = cv(a); 72 int &i2 = cv(b); 73 float &f1 = cv(ac); // expected-error {{no matching function}} 74 float &f2 = cv(bc); // expected-error {{no matching function}} 75 int& i3 = cv2(a); 76 float& f3 = cv2(ac); 77} 78 79// We agree with GCC that these can't be overloaded. 80int& qualid(id<P0>); // expected-note {{previous declaration}} expected-note {{not viable}} 81float& qualid(id<P1>); // expected-error {{cannot be overloaded}} 82 83void qualid_test(A *a, B *b, C *c) { 84 int& i1 = qualid(a); 85 int& i2 = qualid(b); 86 87 // This doesn't work only because the overload was rejected above. 88 float& f1 = qualid(c); // expected-error {{no matching function}} 89 90 id<P0> p1 = 0; 91 p1 = 0; 92} 93 94 95@class NSException; 96typedef struct { 97 void (*throw_exc)(id); 98} 99objc_exception_functions_t; 100 101void (*_NSExceptionRaiser(void))(NSException *) { 102 objc_exception_functions_t exc_funcs; 103 return exc_funcs.throw_exc; // expected-warning{{incompatible pointer types returning 'void (*)(id)' from a function with result type 'void (*)(NSException *)'}} 104} 105 106namespace test5 { 107 void foo(bool); 108 void foo(void *); 109 110 void test(id p) { 111 foo(p); 112 } 113} 114 115// rdar://problem/8592139 116namespace test6 { 117 void foo(id); // expected-note{{candidate function}} 118 void foo(A*) __attribute__((unavailable)); // expected-note {{explicitly made unavailable}} 119 120 void test(B *b) { 121 foo(b); // expected-error {{call to unavailable function 'foo'}} 122 } 123} 124 125namespace rdar8714395 { 126 int &f(const void*); 127 float &f(const Foo*); 128 129 int &f2(const void*); 130 float &f2(Foo const* const *); 131 132 int &f3(const void*); 133 float &f3(Foo const**); 134 135 void g(Foo *p) { 136 float &fr = f(p); 137 float &fr2 = f2(&p); 138 int &ir = f3(&p); 139 } 140 141 142} 143 144namespace rdar8734046 { 145 void f1(id); 146 void f2(id<P0>); 147 void g(const A *a) { 148 f1(a); 149 f2(a); 150 } 151} 152 153namespace PR9735 { 154 int &f3(const A*); 155 float &f3(const void*); 156 157 void test_f(B* b, const B* bc) { 158 int &ir1 = f3(b); 159 int &ir2 = f3(bc); 160 } 161} 162 163@interface D : B 164@end 165 166namespace rdar9327203 { 167 int &f(void* const&, int); 168 float &f(void* const&, long); 169 170 void g(id x) { 171 int &fr = (f)(x, 0); 172 } 173} 174 175namespace class_id { 176 // it's okay to overload Class with id. 177 void f(Class) { } 178 void f(id) { } 179} 180