1 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s 2 @interface Foo 3 @end 4 5 @implementation Foo 6 7 void 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 30 int& f(A*); // expected-note {{candidate}} 31 float& f(B*); // expected-note {{candidate}} 32 void g(A*); 33 34 int& h(A*); 35 float& h(id); 36 37 void 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 53 void 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 58 void 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 64 int& cv(A*); // expected-note {{previous declaration}} expected-note 2 {{not viable}} 65 float& cv(const A*); // expected-error {{cannot be overloaded}} 66 67 int& cv2(void*); 68 float& cv2(const void*); 69 70 void 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. 80 int& qualid(id<P0>); // expected-note {{previous declaration}} expected-note {{not viable}} 81 float& qualid(id<P1>); // expected-error {{cannot be overloaded}} 82 83 void 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; 96 typedef struct { 97 void (*throw_exc)(id); 98 } 99 objc_exception_functions_t; 100 101 void (*_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 106 namespace 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 116 namespace 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 125 namespace 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 144 namespace 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 153 namespace 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 166 namespace 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 175 namespace class_id { 176 // it's okay to overload Class with id. 177 void f(Class) { } 178 void f(id) { } 179 } 180
