blob: 40f35d93b2bd41d27a519d81547a2f8a2635cd3d (
about) (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
#if !__has_feature(objc_instancetype)
# error Missing 'instancetype' feature macro.
#endif
@interface Root
+ (instancetype)alloc;
- (instancetype)init; // expected-note{{overridden method is part of the 'init' method family}}
- (instancetype)self;
- (Class)class;
@property (assign) Root *selfProp;
- (instancetype)selfProp;
@end
@protocol Proto1
@optional
- (instancetype)methodInProto1;
@end
@protocol Proto2
@optional
- (instancetype)methodInProto2; // expected-note{{overridden method returns an instance of its class type}}
- (instancetype)otherMethodInProto2; // expected-note{{overridden method returns an instance of its class type}}
@end
@interface Subclass1 : Root
- (instancetype)initSubclass1;
- (void)methodOnSubclass1;
+ (instancetype)allocSubclass1;
@end
@interface Subclass2 : Root
- (instancetype)initSubclass2;
- (void)methodOnSubclass2;
@end
// Sanity check: the basic initialization pattern.
void test_instancetype_alloc_init_simple() {
Root *r1 = [[Root alloc] init];
Subclass1 *sc1 = [[Subclass1 alloc] init];
}
// Test that message sends to instancetype methods have the right type.
void test_instancetype_narrow_method_search() {
// instancetype on class methods
Subclass1 *sc1 = [[Subclass1 alloc] initSubclass2]; // expected-warning{{'Subclass1' may not respond to 'initSubclass2'}}
Subclass2 *sc2 = [[Subclass2 alloc] initSubclass2]; // okay
// instancetype on instance methods
[[[Subclass1 alloc] init] methodOnSubclass2]; // expected-warning{{'Subclass1' may not respond to 'methodOnSubclass2'}}
[[[Subclass2 alloc] init] methodOnSubclass2];
// instancetype on class methods using protocols
typedef Subclass1<Proto1> SC1Proto1;
typedef Subclass1<Proto2> SC1Proto2;
[[SC1Proto1 alloc] methodInProto2]; // expected-warning{{method '-methodInProto2' not found (return type defaults to 'id')}}
[[SC1Proto2 alloc] methodInProto2];
// instancetype on instance methods
Subclass1<Proto1> *sc1proto1 = 0;
[[sc1proto1 self] methodInProto2]; // expected-warning{{method '-methodInProto2' not found (return type defaults to 'id')}}
Subclass1<Proto2> *sc1proto2 = 0;
[[sc1proto2 self] methodInProto2];
// Exact type checks
typeof([[Subclass1 alloc] init]) *ptr1 = (Subclass1 **)0;
typeof([[Subclass2 alloc] init]) *ptr2 = (Subclass2 **)0;
// Message sends to Class.
Subclass1<Proto1> *sc1proto1_2 = [[[sc1proto1 class] alloc] init];
// Property access
[sc1proto1.self methodInProto2]; // expected-warning{{method '-methodInProto2' not found (return type defaults to 'id')}}
[sc1proto2.self methodInProto2];
[Subclass1.alloc initSubclass2]; // expected-warning{{'Subclass1' may not respond to 'initSubclass2'}}
[Subclass2.alloc initSubclass2];
[sc1proto1.selfProp methodInProto2]; // expected-warning{{method '-methodInProto2' not found (return type defaults to 'id')}}
[sc1proto2.selfProp methodInProto2];
}
// Test that message sends to super methods have the right type.
@interface Subsubclass1 : Subclass1
- (instancetype)initSubclass1;
+ (instancetype)allocSubclass1;
- (void)onlyInSubsubclass1;
@end
@implementation Subsubclass1
- (instancetype)initSubclass1 {
// Check based on method search.
[[super initSubclass1] methodOnSubclass2]; // expected-warning{{'Subsubclass1' may not respond to 'methodOnSubclass2'}}
[super.initSubclass1 methodOnSubclass2]; // expected-warning{{'Subsubclass1' may not respond to 'methodOnSubclass2'}}
self = [super init]; // common pattern
// Exact type check.
typeof([super initSubclass1]) *ptr1 = (Subsubclass1**)0;
return self;
}
+ (instancetype)allocSubclass1 {
// Check based on method search.
[[super allocSubclass1] methodOnSubclass2]; // expected-warning{{'Subsubclass1' may not respond to 'methodOnSubclass2'}}
// The ASTs don't model super property accesses well enough to get this right
[super.allocSubclass1 methodOnSubclass2]; // expected-warning{{'Subsubclass1' may not respond to 'methodOnSubclass2'}}
// Exact type check.
typeof([super allocSubclass1]) *ptr1 = (Subsubclass1**)0;
return [super allocSubclass1];
}
- (void)onlyInSubsubclass1 {}
@end
// Check compatibility rules for inheritance of related return types.
@class Subclass4;
@interface Subclass3 <Proto1, Proto2>
- (Subclass3 *)methodInProto1;
- (Subclass4 *)methodInProto2; // expected-warning{{method is expected to return an instance of its class type 'Subclass3', but is declared to return 'Subclass4 *'}}
@end
@interface Subclass4 : Root
+ (Subclass4 *)alloc; // okay
- (Subclass3 *)init; // expected-warning{{method is expected to return an instance of its class type 'Subclass4', but is declared to return 'Subclass3 *'}}
- (id)self; // expected-note{{overridden method is part of the 'self' method family}}
- (instancetype)initOther;
@end
@protocol Proto3 <Proto1, Proto2>
@optional
- (id)methodInProto1;
- (Subclass1 *)methodInProto2;
- (int)otherMethodInProto2; // expected-warning{{protocol method is expected to return an instance of the implementing class, but is declared to return 'int'}}
@end
@implementation Subclass4
+ (id)alloc {
return self; // expected-warning{{incompatible pointer types casting 'Class' to type 'Subclass4 *'}}
}
- (Subclass3 *)init { return 0; } // don't complain: we lost the related return type
- (Subclass3 *)self { return 0; } // expected-warning{{method is expected to return an instance of its class type 'Subclass4', but is declared to return 'Subclass3 *'}}
- (Subclass4 *)initOther { return 0; }
@end
// Check that inherited related return types influence the types of
// message sends.
void test_instancetype_inherited() {
[[Subclass4 alloc] initSubclass1]; // expected-warning{{'Subclass4' may not respond to 'initSubclass1'}}
[[Subclass4 alloc] initOther];
}
// Check that related return types tighten up the semantics of
// Objective-C method implementations.
@implementation Subclass2
- (instancetype)initSubclass2 {
Subclass1 *sc1 = [[Subclass1 alloc] init];
return sc1; // expected-warning{{incompatible pointer types casting 'Subclass1 *' to type 'Subclass2 *'}}
}
- (void)methodOnSubclass2 {}
- (id)self {
Subclass1 *sc1 = [[Subclass1 alloc] init];
return sc1; // expected-warning{{incompatible pointer types casting 'Subclass1 *' to type 'Subclass2 *'}}
}
@end
@interface MyClass : Root
+ (int)myClassMethod;
@end
@implementation MyClass
+ (int)myClassMethod { return 0; }
- (void)blah {
int i = [[MyClass self] myClassMethod];
}
@end
|
