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 63int& cv(A*); 64float& cv(const A*); 65 66int& cv2(void*); 67float& cv2(const void*); 68 69void cv_test(A* a, B* b, const A* ac, const B* bc) { 70 int &i1 = cv(a); 71 int &i2 = cv(b); 72 float &f1 = cv(ac); 73 float &f2 = cv(bc); 74 int& i3 = cv2(a); 75 float& f3 = cv2(ac); 76} 77 78int& qualid(id<P0>); 79float& qualid(id<P1>); 80 81void qualid_test(A *a, B *b, C *c) { 82 int& i1 = qualid(a); 83 int& i2 = qualid(b); 84 85 float& f1 = qualid(c); 86 87 id<P0> p1 = 0; 88 p1 = 0; 89} 90 91 92@class NSException; 93typedef struct { 94 void (*throw_exc)(id); 95} 96objc_exception_functions_t; 97 98void (*_NSExceptionRaiser(void))(NSException *) { 99 objc_exception_functions_t exc_funcs; 100 return exc_funcs.throw_exc; // expected-warning{{incompatible pointer types returning 'void (*)(id)' from a function with result type 'void (*)(NSException *)'}} 101} 102 103namespace test5 { 104 void foo(bool); 105 void foo(void *); 106 107 void test(id p) { 108 foo(p); 109 } 110} 111 112// rdar://problem/8592139 113namespace test6 { 114 void foo(id); 115 void foo(A*) __attribute__((unavailable)); // expected-note {{marked unavailable here}} 116 117 void test(B *b) { 118 foo(b); // expected-error {{'foo' is unavailable}} 119 } 120} 121 122namespace rdar8714395 { 123 int &f(const void*); 124 float &f(const Foo*); 125 126 int &f2(const void*); 127 float &f2(Foo const* const *); 128 129 int &f3(const void*); 130 float &f3(Foo const**); 131 132 void g(Foo *p) { 133 float &fr = f(p); 134 float &fr2 = f2(&p); 135 int &ir = f3(&p); 136 } 137 138 139} 140 141namespace rdar8734046 { 142 void f1(id); 143 void f2(id<P0>); 144 void g(const A *a) { 145 f1(a); 146 f2(a); 147 } 148} 149 150namespace PR9735 { 151 int &f3(const A*); 152 float &f3(const void*); 153 154 void test_f(B* b, const B* bc) { 155 int &ir1 = f3(b); 156 int &ir2 = f3(bc); 157 } 158} 159 160@interface D : B 161@end 162 163namespace rdar9327203 { 164 int &f(void* const&, int); 165 float &f(void* const&, long); 166 167 void g(id x) { 168 int &fr = (f)(x, 0); 169 } 170} 171 172namespace class_id { 173 // it's okay to overload Class with id. 174 void f(Class) { } 175 void f(id) { } 176} 177 178@interface NSDictionary<__covariant KeyType, __covariant ObjectType> : A 179@end 180 181@interface NSMutableDictionary<KeyType, ObjectType> : NSDictionary<KeyType, ObjectType> 182@end 183 184namespace rdar20124827 { 185 186int overload(NSDictionary *) { return 1; } 187 188__attribute__((deprecated)) // expected-note {{'overload' has been explicitly marked deprecated here}} 189int overload(NSMutableDictionary *) { return 0; } 190 191__attribute__((deprecated)) 192void overload2(NSDictionary *); // expected-note {{candidate function}} 193void overload2(NSDictionary<A *, A *> *); // expected-note {{candidate function}} 194 195void test(NSDictionary *d1, NSDictionary<A *, A *> *d2, NSMutableDictionary<A *, A *> *m1) { 196 overload(d1); 197 overload(d2); // no warning 198 overload(m1); // expected-warning {{'overload' is deprecated}} 199 overload2(d2); // no warning 200 overload2(m1); // expected-error {{call to 'overload2' is ambiguous}} 201} 202 203} 204 205namespace StringLiterals { 206void f(const char(&&)[5]); 207void f(const wchar_t(&&)[5]); 208void f(const char16_t(&&)[5]); 209void f(const char32_t(&&)[5]); 210void g() { 211 f({"abc"}); 212 f({(((@encode(int))))}); 213 f({L"abc"}); 214 f({uR"(abc)"}); 215 f({(UR"(abc)")}); 216} 217} // namespace StringLiterals 218