Clang Project

clang_source_code/test/SemaObjCXX/overload.mm
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
CodeThinker, Enjoy your reading code