blob: b6ab85ccab0ddb1399c2e97b7e6d57132a5d60de (
plain) (
blame)
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
|
// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class -fobjc-default-synthesize-properties %s
// rdar: //8550657
@interface NSArray @end
@interface NSMutableArray : NSArray @end
@interface MyClass
{
NSMutableArray * _array;
}
@property (readonly) NSMutableArray * array;
@end
@interface MyClass ()
@property (readwrite, retain) NSMutableArray * array;
@end
@implementation MyClass
@synthesize array=_array;
@end
int main(void)
{
return 0;
}
// rdar://6137845
class TCPPObject
{
public:
TCPPObject(const TCPPObject& inObj);
TCPPObject();
~TCPPObject();
TCPPObject& operator=(const TCPPObject& inObj); // expected-note {{'operator=' declared here}}
private:
void* fData;
};
class Trivial
{
public:
Trivial(const Trivial& inObj);
Trivial();
~Trivial();
private:
void* fData;
};
@interface MyDocument
{
@private
TCPPObject _cppObject;
TCPPObject _ncppObject;
Trivial _tcppObject;
}
@property (assign, readwrite) const TCPPObject& cppObject;
@property (assign, readwrite, nonatomic) const TCPPObject& ncppObject;
@property (assign, readwrite) const Trivial& tcppObject;
@end
@implementation MyDocument
@synthesize cppObject = _cppObject; // expected-error {{atomic property of reference type 'const TCPPObject &' cannot have non-trivial assignment operator}}
@synthesize ncppObject = _ncppObject;
@synthesize tcppObject = _tcppObject;
@end
struct IncompleteStruct; // expected-note 2 {{forward declaration of 'IncompleteStruct'}}
struct ConvertToIncomplete { operator IncompleteStruct&(); };
@interface SynthIncompleteRef
@property (readonly, nonatomic) IncompleteStruct& x; // expected-note {{property declared here}}
@property (readonly, nonatomic) IncompleteStruct& y; // expected-note {{property declared here}}
@end
@implementation SynthIncompleteRef // expected-error {{cannot synthesize property 'x' with incomplete type 'IncompleteStruct'}}
@synthesize y; // expected-error {{cannot synthesize property 'y' with incomplete type 'IncompleteStruct'}}
@end
// Check error handling for instantiation during property synthesis.
template<typename T> class TemplateClass1 {
T *x; // expected-error {{'x' declared as a pointer to a reference of type 'int &'}}
};
template<typename T> class TemplateClass2 {
TemplateClass2& operator=(TemplateClass1<T>);
TemplateClass2& operator=(TemplateClass2) { T(); } // expected-error {{reference to type 'int' requires an initializer}} \
// expected-note 2 {{implicitly declared private here}} \
// expected-note {{'operator=' declared here}}
};
__attribute__((objc_root_class)) @interface InterfaceWithTemplateProperties
@property TemplateClass2<int&> intprop;
@property TemplateClass2<int&> &floatprop;
@end
@implementation InterfaceWithTemplateProperties // expected-error 2 {{'operator=' is a private member of 'TemplateClass2<int &>'}} \
// expected-error {{atomic property of reference type 'TemplateClass2<int &> &' cannot have non-trivial assignment operator}} \
// expected-note {{in instantiation of template class}} \
// expected-note {{in instantiation of member function}}
@end
|
