blob: 84752d99bd8ddb7e12919d3f5d32e8341f47aaca [file] [log] [blame]
Ted Kremenek9d64c152010-03-12 00:38:38 +00001//===--- SemaObjCProperty.cpp - Semantic Analysis for ObjC @property ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for Objective C @property and
11// @synthesize declarations.
12//
13//===----------------------------------------------------------------------===//
14
John McCall2d887082010-08-25 22:03:47 +000015#include "clang/Sema/SemaInternal.h"
Argyrios Kyrtzidisc80553e2011-11-14 04:52:29 +000016#include "clang/AST/ASTMutationListener.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000017#include "clang/AST/DeclObjC.h"
18#include "clang/AST/ExprCXX.h"
19#include "clang/AST/ExprObjC.h"
Fariborz Jahanianedcc27f2012-05-21 17:02:43 +000020#include "clang/Basic/SourceManager.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000021#include "clang/Lex/Lexer.h"
22#include "clang/Lex/Preprocessor.h"
23#include "clang/Sema/Initialization.h"
John McCall50df6ae2010-08-25 07:03:20 +000024#include "llvm/ADT/DenseSet.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000025#include "llvm/ADT/SmallString.h"
Ted Kremenek9d64c152010-03-12 00:38:38 +000026
27using namespace clang;
28
Ted Kremenek28685ab2010-03-12 00:46:40 +000029//===----------------------------------------------------------------------===//
30// Grammar actions.
31//===----------------------------------------------------------------------===//
32
John McCall265941b2011-09-13 18:31:23 +000033/// getImpliedARCOwnership - Given a set of property attributes and a
34/// type, infer an expected lifetime. The type's ownership qualification
35/// is not considered.
36///
37/// Returns OCL_None if the attributes as stated do not imply an ownership.
38/// Never returns OCL_Autoreleasing.
39static Qualifiers::ObjCLifetime getImpliedARCOwnership(
40 ObjCPropertyDecl::PropertyAttributeKind attrs,
41 QualType type) {
42 // retain, strong, copy, weak, and unsafe_unretained are only legal
43 // on properties of retainable pointer type.
44 if (attrs & (ObjCPropertyDecl::OBJC_PR_retain |
45 ObjCPropertyDecl::OBJC_PR_strong |
46 ObjCPropertyDecl::OBJC_PR_copy)) {
John McCalld64c2eb2012-08-20 23:36:59 +000047 return Qualifiers::OCL_Strong;
John McCall265941b2011-09-13 18:31:23 +000048 } else if (attrs & ObjCPropertyDecl::OBJC_PR_weak) {
49 return Qualifiers::OCL_Weak;
50 } else if (attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained) {
51 return Qualifiers::OCL_ExplicitNone;
52 }
53
54 // assign can appear on other types, so we have to check the
55 // property type.
56 if (attrs & ObjCPropertyDecl::OBJC_PR_assign &&
57 type->isObjCRetainableType()) {
58 return Qualifiers::OCL_ExplicitNone;
59 }
60
61 return Qualifiers::OCL_None;
62}
63
John McCallf85e1932011-06-15 23:02:42 +000064/// Check the internal consistency of a property declaration.
65static void checkARCPropertyDecl(Sema &S, ObjCPropertyDecl *property) {
66 if (property->isInvalidDecl()) return;
67
68 ObjCPropertyDecl::PropertyAttributeKind propertyKind
69 = property->getPropertyAttributes();
70 Qualifiers::ObjCLifetime propertyLifetime
71 = property->getType().getObjCLifetime();
72
73 // Nothing to do if we don't have a lifetime.
74 if (propertyLifetime == Qualifiers::OCL_None) return;
75
John McCall265941b2011-09-13 18:31:23 +000076 Qualifiers::ObjCLifetime expectedLifetime
77 = getImpliedARCOwnership(propertyKind, property->getType());
78 if (!expectedLifetime) {
John McCallf85e1932011-06-15 23:02:42 +000079 // We have a lifetime qualifier but no dominating property
John McCall265941b2011-09-13 18:31:23 +000080 // attribute. That's okay, but restore reasonable invariants by
81 // setting the property attribute according to the lifetime
82 // qualifier.
83 ObjCPropertyDecl::PropertyAttributeKind attr;
84 if (propertyLifetime == Qualifiers::OCL_Strong) {
85 attr = ObjCPropertyDecl::OBJC_PR_strong;
86 } else if (propertyLifetime == Qualifiers::OCL_Weak) {
87 attr = ObjCPropertyDecl::OBJC_PR_weak;
88 } else {
89 assert(propertyLifetime == Qualifiers::OCL_ExplicitNone);
90 attr = ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
91 }
92 property->setPropertyAttributes(attr);
John McCallf85e1932011-06-15 23:02:42 +000093 return;
94 }
95
96 if (propertyLifetime == expectedLifetime) return;
97
98 property->setInvalidDecl();
99 S.Diag(property->getLocation(),
Argyrios Kyrtzidisb8b03132011-06-24 00:08:59 +0000100 diag::err_arc_inconsistent_property_ownership)
John McCallf85e1932011-06-15 23:02:42 +0000101 << property->getDeclName()
John McCall265941b2011-09-13 18:31:23 +0000102 << expectedLifetime
John McCallf85e1932011-06-15 23:02:42 +0000103 << propertyLifetime;
104}
105
Fariborz Jahaniandad633b2012-08-21 21:45:58 +0000106static unsigned deduceWeakPropertyFromType(Sema &S, QualType T) {
107 if ((S.getLangOpts().getGC() != LangOptions::NonGC &&
108 T.isObjCGCWeak()) ||
109 (S.getLangOpts().ObjCAutoRefCount &&
110 T.getObjCLifetime() == Qualifiers::OCL_Weak))
111 return ObjCDeclSpec::DQ_PR_weak;
112 return 0;
113}
114
Douglas Gregorb892d702013-01-21 19:42:21 +0000115/// \brief Check this Objective-C property against a property declared in the
116/// given protocol.
117static void
118CheckPropertyAgainstProtocol(Sema &S, ObjCPropertyDecl *Prop,
119 ObjCProtocolDecl *Proto,
120 llvm::SmallPtrSet<ObjCProtocolDecl *, 16> &Known) {
121 // Have we seen this protocol before?
122 if (!Known.insert(Proto))
123 return;
124
125 // Look for a property with the same name.
126 DeclContext::lookup_result R = Proto->lookup(Prop->getDeclName());
127 for (unsigned I = 0, N = R.size(); I != N; ++I) {
128 if (ObjCPropertyDecl *ProtoProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
129 S.DiagnosePropertyMismatch(Prop, ProtoProp, Proto->getIdentifier());
130 return;
131 }
132 }
133
134 // Check this property against any protocols we inherit.
135 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
136 PEnd = Proto->protocol_end();
137 P != PEnd; ++P) {
138 CheckPropertyAgainstProtocol(S, Prop, *P, Known);
139 }
140}
141
John McCalld226f652010-08-21 09:40:31 +0000142Decl *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc,
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000143 SourceLocation LParenLoc,
John McCalld226f652010-08-21 09:40:31 +0000144 FieldDeclarator &FD,
145 ObjCDeclSpec &ODS,
146 Selector GetterSel,
147 Selector SetterSel,
John McCalld226f652010-08-21 09:40:31 +0000148 bool *isOverridingProperty,
Ted Kremenek4a2e9ea2010-09-23 21:18:05 +0000149 tok::ObjCKeywordKind MethodImplKind,
150 DeclContext *lexicalDC) {
Bill Wendlingad017fa2012-12-20 19:22:21 +0000151 unsigned Attributes = ODS.getPropertyAttributes();
John McCallf85e1932011-06-15 23:02:42 +0000152 TypeSourceInfo *TSI = GetTypeForDeclarator(FD.D, S);
153 QualType T = TSI->getType();
Bill Wendlingad017fa2012-12-20 19:22:21 +0000154 Attributes |= deduceWeakPropertyFromType(*this, T);
Fariborz Jahaniandad633b2012-08-21 21:45:58 +0000155
Bill Wendlingad017fa2012-12-20 19:22:21 +0000156 bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) ||
Ted Kremenek28685ab2010-03-12 00:46:40 +0000157 // default is readwrite!
Bill Wendlingad017fa2012-12-20 19:22:21 +0000158 !(Attributes & ObjCDeclSpec::DQ_PR_readonly));
Ted Kremenek28685ab2010-03-12 00:46:40 +0000159 // property is defaulted to 'assign' if it is readwrite and is
160 // not retain or copy
Bill Wendlingad017fa2012-12-20 19:22:21 +0000161 bool isAssign = ((Attributes & ObjCDeclSpec::DQ_PR_assign) ||
Ted Kremenek28685ab2010-03-12 00:46:40 +0000162 (isReadWrite &&
Bill Wendlingad017fa2012-12-20 19:22:21 +0000163 !(Attributes & ObjCDeclSpec::DQ_PR_retain) &&
164 !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
165 !(Attributes & ObjCDeclSpec::DQ_PR_copy) &&
166 !(Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) &&
167 !(Attributes & ObjCDeclSpec::DQ_PR_weak)));
Fariborz Jahanian14086762011-03-28 23:47:18 +0000168
Douglas Gregoraabd0942013-01-21 19:05:22 +0000169 // Proceed with constructing the ObjCPropertyDecls.
Fariborz Jahaniana28948f2011-08-22 15:54:49 +0000170 ObjCContainerDecl *ClassDecl = cast<ObjCContainerDecl>(CurContext);
Douglas Gregoraabd0942013-01-21 19:05:22 +0000171 ObjCPropertyDecl *Res = 0;
172 if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
Fariborz Jahanianae415dc2010-07-13 22:04:56 +0000173 if (CDecl->IsClassExtension()) {
Douglas Gregoraabd0942013-01-21 19:05:22 +0000174 Res = HandlePropertyInClassExtension(S, AtLoc, LParenLoc,
Fariborz Jahanianae415dc2010-07-13 22:04:56 +0000175 FD, GetterSel, SetterSel,
176 isAssign, isReadWrite,
Bill Wendlingad017fa2012-12-20 19:22:21 +0000177 Attributes,
Argyrios Kyrtzidisdbbdec92011-11-06 18:58:12 +0000178 ODS.getPropertyAttributes(),
Fariborz Jahanianae415dc2010-07-13 22:04:56 +0000179 isOverridingProperty, TSI,
180 MethodImplKind);
Douglas Gregoraabd0942013-01-21 19:05:22 +0000181 if (!Res)
182 return 0;
Fariborz Jahanianae415dc2010-07-13 22:04:56 +0000183 }
Douglas Gregoraabd0942013-01-21 19:05:22 +0000184 }
185
186 if (!Res) {
187 Res = CreatePropertyDecl(S, ClassDecl, AtLoc, LParenLoc, FD,
188 GetterSel, SetterSel, isAssign, isReadWrite,
189 Attributes, ODS.getPropertyAttributes(),
190 TSI, MethodImplKind);
191 if (lexicalDC)
192 Res->setLexicalDeclContext(lexicalDC);
193 }
Ted Kremenek4a2e9ea2010-09-23 21:18:05 +0000194
Fariborz Jahanian842f07b2010-03-30 22:40:11 +0000195 // Validate the attributes on the @property.
Bill Wendlingad017fa2012-12-20 19:22:21 +0000196 CheckObjCPropertyAttributes(Res, AtLoc, Attributes,
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000197 (isa<ObjCInterfaceDecl>(ClassDecl) ||
198 isa<ObjCProtocolDecl>(ClassDecl)));
John McCallf85e1932011-06-15 23:02:42 +0000199
David Blaikie4e4d0842012-03-11 07:00:24 +0000200 if (getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +0000201 checkARCPropertyDecl(*this, Res);
202
Douglas Gregorb892d702013-01-21 19:42:21 +0000203 llvm::SmallPtrSet<ObjCProtocolDecl *, 16> KnownProtos;
Douglas Gregoraabd0942013-01-21 19:05:22 +0000204 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
Douglas Gregorb892d702013-01-21 19:42:21 +0000205 // For a class, compare the property against a property in our superclass.
206 bool FoundInSuper = false;
Douglas Gregoraabd0942013-01-21 19:05:22 +0000207 if (ObjCInterfaceDecl *Super = IFace->getSuperClass()) {
208 DeclContext::lookup_result R = Super->lookup(Res->getDeclName());
Douglas Gregorb892d702013-01-21 19:42:21 +0000209 for (unsigned I = 0, N = R.size(); I != N; ++I) {
210 if (ObjCPropertyDecl *SuperProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
Douglas Gregoraabd0942013-01-21 19:05:22 +0000211 DiagnosePropertyMismatch(Res, SuperProp, Super->getIdentifier());
Douglas Gregorb892d702013-01-21 19:42:21 +0000212 FoundInSuper = true;
213 break;
214 }
215 }
216 }
217
218 if (FoundInSuper) {
219 // Also compare the property against a property in our protocols.
220 for (ObjCInterfaceDecl::protocol_iterator P = IFace->protocol_begin(),
221 PEnd = IFace->protocol_end();
222 P != PEnd; ++P) {
223 CheckPropertyAgainstProtocol(*this, Res, *P, KnownProtos);
224 }
225 } else {
226 // Slower path: look in all protocols we referenced.
227 for (ObjCInterfaceDecl::all_protocol_iterator
228 P = IFace->all_referenced_protocol_begin(),
229 PEnd = IFace->all_referenced_protocol_end();
230 P != PEnd; ++P) {
231 CheckPropertyAgainstProtocol(*this, Res, *P, KnownProtos);
232 }
233 }
234 } else if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
235 for (ObjCCategoryDecl::protocol_iterator P = Cat->protocol_begin(),
236 PEnd = Cat->protocol_end();
237 P != PEnd; ++P) {
238 CheckPropertyAgainstProtocol(*this, Res, *P, KnownProtos);
239 }
240 } else {
241 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(ClassDecl);
242 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
243 PEnd = Proto->protocol_end();
244 P != PEnd; ++P) {
245 CheckPropertyAgainstProtocol(*this, Res, *P, KnownProtos);
Douglas Gregoraabd0942013-01-21 19:05:22 +0000246 }
247 }
248
Dmitri Gribenkoabd56c82012-07-13 01:06:46 +0000249 ActOnDocumentableDecl(Res);
Fariborz Jahanian842f07b2010-03-30 22:40:11 +0000250 return Res;
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000251}
Ted Kremenek2d2f9362010-03-12 00:49:00 +0000252
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000253static ObjCPropertyDecl::PropertyAttributeKind
Bill Wendlingad017fa2012-12-20 19:22:21 +0000254makePropertyAttributesAsWritten(unsigned Attributes) {
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000255 unsigned attributesAsWritten = 0;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000256 if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000257 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readonly;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000258 if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000259 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readwrite;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000260 if (Attributes & ObjCDeclSpec::DQ_PR_getter)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000261 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_getter;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000262 if (Attributes & ObjCDeclSpec::DQ_PR_setter)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000263 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_setter;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000264 if (Attributes & ObjCDeclSpec::DQ_PR_assign)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000265 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_assign;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000266 if (Attributes & ObjCDeclSpec::DQ_PR_retain)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000267 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_retain;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000268 if (Attributes & ObjCDeclSpec::DQ_PR_strong)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000269 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_strong;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000270 if (Attributes & ObjCDeclSpec::DQ_PR_weak)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000271 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_weak;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000272 if (Attributes & ObjCDeclSpec::DQ_PR_copy)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000273 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_copy;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000274 if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000275 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000276 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000277 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_nonatomic;
Bill Wendlingad017fa2012-12-20 19:22:21 +0000278 if (Attributes & ObjCDeclSpec::DQ_PR_atomic)
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000279 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_atomic;
280
281 return (ObjCPropertyDecl::PropertyAttributeKind)attributesAsWritten;
282}
283
Fariborz Jahanian5bf0e352012-05-21 17:10:28 +0000284static bool LocPropertyAttribute( ASTContext &Context, const char *attrName,
Fariborz Jahanianedcc27f2012-05-21 17:02:43 +0000285 SourceLocation LParenLoc, SourceLocation &Loc) {
286 if (LParenLoc.isMacroID())
287 return false;
288
289 SourceManager &SM = Context.getSourceManager();
290 std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(LParenLoc);
291 // Try to load the file buffer.
292 bool invalidTemp = false;
293 StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
294 if (invalidTemp)
295 return false;
296 const char *tokenBegin = file.data() + locInfo.second;
297
298 // Lex from the start of the given location.
299 Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
300 Context.getLangOpts(),
301 file.begin(), tokenBegin, file.end());
302 Token Tok;
303 do {
304 lexer.LexFromRawLexer(Tok);
305 if (Tok.is(tok::raw_identifier) &&
306 StringRef(Tok.getRawIdentifierData(), Tok.getLength()) == attrName) {
307 Loc = Tok.getLocation();
308 return true;
309 }
310 } while (Tok.isNot(tok::r_paren));
311 return false;
312
Fariborz Jahanian2b309fb2012-05-19 18:17:17 +0000313}
314
Fariborz Jahaniand9f95b32012-08-21 21:52:02 +0000315static unsigned getOwnershipRule(unsigned attr) {
Fariborz Jahaniandad633b2012-08-21 21:45:58 +0000316 return attr & (ObjCPropertyDecl::OBJC_PR_assign |
317 ObjCPropertyDecl::OBJC_PR_retain |
318 ObjCPropertyDecl::OBJC_PR_copy |
319 ObjCPropertyDecl::OBJC_PR_weak |
320 ObjCPropertyDecl::OBJC_PR_strong |
321 ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
322}
323
Douglas Gregoraabd0942013-01-21 19:05:22 +0000324ObjCPropertyDecl *
Fariborz Jahaniana28948f2011-08-22 15:54:49 +0000325Sema::HandlePropertyInClassExtension(Scope *S,
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000326 SourceLocation AtLoc,
327 SourceLocation LParenLoc,
328 FieldDeclarator &FD,
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000329 Selector GetterSel, Selector SetterSel,
330 const bool isAssign,
331 const bool isReadWrite,
Bill Wendlingad017fa2012-12-20 19:22:21 +0000332 const unsigned Attributes,
Argyrios Kyrtzidisdbbdec92011-11-06 18:58:12 +0000333 const unsigned AttributesAsWritten,
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000334 bool *isOverridingProperty,
John McCall83a230c2010-06-04 20:50:08 +0000335 TypeSourceInfo *T,
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000336 tok::ObjCKeywordKind MethodImplKind) {
Fariborz Jahanian58a76492011-08-22 18:34:22 +0000337 ObjCCategoryDecl *CDecl = cast<ObjCCategoryDecl>(CurContext);
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000338 // Diagnose if this property is already in continuation class.
Fariborz Jahaniana28948f2011-08-22 15:54:49 +0000339 DeclContext *DC = CurContext;
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000340 IdentifierInfo *PropertyId = FD.D.getIdentifier();
Fariborz Jahanian2a289142010-11-10 18:01:36 +0000341 ObjCInterfaceDecl *CCPrimary = CDecl->getClassInterface();
342
Douglas Gregord3297242013-01-16 23:00:23 +0000343 if (CCPrimary) {
Fariborz Jahanian2a289142010-11-10 18:01:36 +0000344 // Check for duplicate declaration of this property in current and
345 // other class extensions.
Douglas Gregord3297242013-01-16 23:00:23 +0000346 for (ObjCInterfaceDecl::known_extensions_iterator
347 Ext = CCPrimary->known_extensions_begin(),
348 ExtEnd = CCPrimary->known_extensions_end();
349 Ext != ExtEnd; ++Ext) {
350 if (ObjCPropertyDecl *prevDecl
351 = ObjCPropertyDecl::findPropertyDecl(*Ext, PropertyId)) {
Fariborz Jahanian2a289142010-11-10 18:01:36 +0000352 Diag(AtLoc, diag::err_duplicate_property);
353 Diag(prevDecl->getLocation(), diag::note_property_declare);
354 return 0;
355 }
356 }
Douglas Gregord3297242013-01-16 23:00:23 +0000357 }
358
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000359 // Create a new ObjCPropertyDecl with the DeclContext being
360 // the class extension.
Fariborz Jahanian88f5e9b2010-12-10 23:36:33 +0000361 // FIXME. We should really be using CreatePropertyDecl for this.
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000362 ObjCPropertyDecl *PDecl =
363 ObjCPropertyDecl::Create(Context, DC, FD.D.getIdentifierLoc(),
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000364 PropertyId, AtLoc, LParenLoc, T);
Argyrios Kyrtzidisb98ffde2011-10-18 19:49:16 +0000365 PDecl->setPropertyAttributesAsWritten(
Argyrios Kyrtzidisdbbdec92011-11-06 18:58:12 +0000366 makePropertyAttributesAsWritten(AttributesAsWritten));
Bill Wendlingad017fa2012-12-20 19:22:21 +0000367 if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
Fariborz Jahanian22f757b2010-03-22 23:25:52 +0000368 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
Bill Wendlingad017fa2012-12-20 19:22:21 +0000369 if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
Fariborz Jahanian22f757b2010-03-22 23:25:52 +0000370 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
Fariborz Jahanianb7b25652013-02-10 00:16:04 +0000371 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
372 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
373 if (Attributes & ObjCDeclSpec::DQ_PR_atomic)
374 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic);
Fariborz Jahanian88f5e9b2010-12-10 23:36:33 +0000375 // Set setter/getter selector name. Needed later.
376 PDecl->setGetterName(GetterSel);
377 PDecl->setSetterName(SetterSel);
Douglas Gregor91ae6b42011-07-15 15:30:21 +0000378 ProcessDeclAttributes(S, PDecl, FD.D);
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000379 DC->addDecl(PDecl);
380
381 // We need to look in the @interface to see if the @property was
382 // already declared.
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000383 if (!CCPrimary) {
384 Diag(CDecl->getLocation(), diag::err_continuation_class);
385 *isOverridingProperty = true;
John McCalld226f652010-08-21 09:40:31 +0000386 return 0;
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000387 }
388
389 // Find the property in continuation class's primary class only.
390 ObjCPropertyDecl *PIDecl =
391 CCPrimary->FindPropertyVisibleInPrimaryClass(PropertyId);
392
393 if (!PIDecl) {
394 // No matching property found in the primary class. Just fall thru
395 // and add property to continuation class's primary class.
Argyrios Kyrtzidisd7c15a62012-02-28 17:50:28 +0000396 ObjCPropertyDecl *PrimaryPDecl =
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000397 CreatePropertyDecl(S, CCPrimary, AtLoc, LParenLoc,
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000398 FD, GetterSel, SetterSel, isAssign, isReadWrite,
Bill Wendlingad017fa2012-12-20 19:22:21 +0000399 Attributes,AttributesAsWritten, T, MethodImplKind, DC);
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000400
401 // A case of continuation class adding a new property in the class. This
402 // is not what it was meant for. However, gcc supports it and so should we.
403 // Make sure setter/getters are declared here.
Argyrios Kyrtzidisd7c15a62012-02-28 17:50:28 +0000404 ProcessPropertyDecl(PrimaryPDecl, CCPrimary, /* redeclaredProperty = */ 0,
Ted Kremeneka054fb42010-09-21 20:52:59 +0000405 /* lexicalDC = */ CDecl);
Argyrios Kyrtzidisd7c15a62012-02-28 17:50:28 +0000406 PDecl->setGetterMethodDecl(PrimaryPDecl->getGetterMethodDecl());
407 PDecl->setSetterMethodDecl(PrimaryPDecl->getSetterMethodDecl());
Argyrios Kyrtzidisc80553e2011-11-14 04:52:29 +0000408 if (ASTMutationListener *L = Context.getASTMutationListener())
Argyrios Kyrtzidisd7c15a62012-02-28 17:50:28 +0000409 L->AddedObjCPropertyInClassExtension(PrimaryPDecl, /*OrigProp=*/0, CDecl);
410 return PrimaryPDecl;
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000411 }
Fariborz Jahaniane2351832012-02-02 18:54:58 +0000412 if (!Context.hasSameType(PIDecl->getType(), PDecl->getType())) {
413 bool IncompatibleObjC = false;
414 QualType ConvertedType;
Fariborz Jahanianff2a0ec2012-02-02 19:34:05 +0000415 // Relax the strict type matching for property type in continuation class.
416 // Allow property object type of continuation class to be different as long
Fariborz Jahanianad7eff22012-02-02 22:37:48 +0000417 // as it narrows the object type in its primary class property. Note that
418 // this conversion is safe only because the wider type is for a 'readonly'
419 // property in primary class and 'narrowed' type for a 'readwrite' property
420 // in continuation class.
Fariborz Jahaniane2351832012-02-02 18:54:58 +0000421 if (!isa<ObjCObjectPointerType>(PIDecl->getType()) ||
422 !isa<ObjCObjectPointerType>(PDecl->getType()) ||
423 (!isObjCPointerConversion(PDecl->getType(), PIDecl->getType(),
424 ConvertedType, IncompatibleObjC))
425 || IncompatibleObjC) {
426 Diag(AtLoc,
427 diag::err_type_mismatch_continuation_class) << PDecl->getType();
428 Diag(PIDecl->getLocation(), diag::note_property_declare);
Fariborz Jahanian6defd9f2012-09-17 20:57:19 +0000429 return 0;
Fariborz Jahaniane2351832012-02-02 18:54:58 +0000430 }
Fariborz Jahaniana4b984d2011-09-24 00:56:59 +0000431 }
432
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000433 // The property 'PIDecl's readonly attribute will be over-ridden
434 // with continuation class's readwrite property attribute!
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +0000435 unsigned PIkind = PIDecl->getPropertyAttributesAsWritten();
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000436 if (isReadWrite && (PIkind & ObjCPropertyDecl::OBJC_PR_readonly)) {
Fariborz Jahaniandad633b2012-08-21 21:45:58 +0000437 PIkind |= deduceWeakPropertyFromType(*this, PIDecl->getType());
Bill Wendlingad017fa2012-12-20 19:22:21 +0000438 unsigned ClassExtensionMemoryModel = getOwnershipRule(Attributes);
Fariborz Jahaniand9f95b32012-08-21 21:52:02 +0000439 unsigned PrimaryClassMemoryModel = getOwnershipRule(PIkind);
Fariborz Jahaniandad633b2012-08-21 21:45:58 +0000440 if (PrimaryClassMemoryModel && ClassExtensionMemoryModel &&
441 (PrimaryClassMemoryModel != ClassExtensionMemoryModel)) {
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000442 Diag(AtLoc, diag::warn_property_attr_mismatch);
443 Diag(PIDecl->getLocation(), diag::note_property_declare);
Ted Kremenek28685ab2010-03-12 00:46:40 +0000444 }
Ted Kremenek9944c762010-03-18 01:22:36 +0000445 DeclContext *DC = cast<DeclContext>(CCPrimary);
446 if (!ObjCPropertyDecl::findPropertyDecl(DC,
447 PIDecl->getDeclName().getAsIdentifierInfo())) {
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000448 // Protocol is not in the primary class. Must build one for it.
449 ObjCDeclSpec ProtocolPropertyODS;
450 // FIXME. Assuming that ObjCDeclSpec::ObjCPropertyAttributeKind
451 // and ObjCPropertyDecl::PropertyAttributeKind have identical
452 // values. Should consolidate both into one enum type.
453 ProtocolPropertyODS.
454 setPropertyAttributes((ObjCDeclSpec::ObjCPropertyAttributeKind)
455 PIkind);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +0000456 // Must re-establish the context from class extension to primary
457 // class context.
Fariborz Jahanian79394182011-08-22 20:15:24 +0000458 ContextRAII SavedContext(*this, CCPrimary);
459
John McCalld226f652010-08-21 09:40:31 +0000460 Decl *ProtocolPtrTy =
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000461 ActOnProperty(S, AtLoc, LParenLoc, FD, ProtocolPropertyODS,
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000462 PIDecl->getGetterName(),
463 PIDecl->getSetterName(),
Fariborz Jahaniana28948f2011-08-22 15:54:49 +0000464 isOverridingProperty,
Ted Kremenek4a2e9ea2010-09-23 21:18:05 +0000465 MethodImplKind,
466 /* lexicalDC = */ CDecl);
John McCalld226f652010-08-21 09:40:31 +0000467 PIDecl = cast<ObjCPropertyDecl>(ProtocolPtrTy);
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000468 }
469 PIDecl->makeitReadWriteAttribute();
Bill Wendlingad017fa2012-12-20 19:22:21 +0000470 if (Attributes & ObjCDeclSpec::DQ_PR_retain)
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000471 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
Bill Wendlingad017fa2012-12-20 19:22:21 +0000472 if (Attributes & ObjCDeclSpec::DQ_PR_strong)
John McCallf85e1932011-06-15 23:02:42 +0000473 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
Bill Wendlingad017fa2012-12-20 19:22:21 +0000474 if (Attributes & ObjCDeclSpec::DQ_PR_copy)
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000475 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
476 PIDecl->setSetterName(SetterSel);
477 } else {
Ted Kremenek788f4892010-10-21 18:49:42 +0000478 // Tailor the diagnostics for the common case where a readwrite
479 // property is declared both in the @interface and the continuation.
480 // This is a common error where the user often intended the original
481 // declaration to be readonly.
482 unsigned diag =
Bill Wendlingad017fa2012-12-20 19:22:21 +0000483 (Attributes & ObjCDeclSpec::DQ_PR_readwrite) &&
Ted Kremenek788f4892010-10-21 18:49:42 +0000484 (PIkind & ObjCPropertyDecl::OBJC_PR_readwrite)
485 ? diag::err_use_continuation_class_redeclaration_readwrite
486 : diag::err_use_continuation_class;
487 Diag(AtLoc, diag)
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000488 << CCPrimary->getDeclName();
489 Diag(PIDecl->getLocation(), diag::note_property_declare);
Fariborz Jahanian6defd9f2012-09-17 20:57:19 +0000490 return 0;
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000491 }
492 *isOverridingProperty = true;
493 // Make sure setter decl is synthesized, and added to primary class's list.
Ted Kremenek8254aa62010-09-21 18:28:43 +0000494 ProcessPropertyDecl(PIDecl, CCPrimary, PDecl, CDecl);
Argyrios Kyrtzidisd7c15a62012-02-28 17:50:28 +0000495 PDecl->setGetterMethodDecl(PIDecl->getGetterMethodDecl());
496 PDecl->setSetterMethodDecl(PIDecl->getSetterMethodDecl());
Argyrios Kyrtzidisc80553e2011-11-14 04:52:29 +0000497 if (ASTMutationListener *L = Context.getASTMutationListener())
498 L->AddedObjCPropertyInClassExtension(PDecl, PIDecl, CDecl);
Fariborz Jahanian6defd9f2012-09-17 20:57:19 +0000499 return PDecl;
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000500}
501
502ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S,
503 ObjCContainerDecl *CDecl,
504 SourceLocation AtLoc,
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000505 SourceLocation LParenLoc,
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000506 FieldDeclarator &FD,
507 Selector GetterSel,
508 Selector SetterSel,
509 const bool isAssign,
510 const bool isReadWrite,
Bill Wendlingad017fa2012-12-20 19:22:21 +0000511 const unsigned Attributes,
Argyrios Kyrtzidisdbbdec92011-11-06 18:58:12 +0000512 const unsigned AttributesAsWritten,
John McCall83a230c2010-06-04 20:50:08 +0000513 TypeSourceInfo *TInfo,
Ted Kremenek23173d72010-05-18 21:09:07 +0000514 tok::ObjCKeywordKind MethodImplKind,
515 DeclContext *lexicalDC){
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000516 IdentifierInfo *PropertyId = FD.D.getIdentifier();
John McCall83a230c2010-06-04 20:50:08 +0000517 QualType T = TInfo->getType();
Ted Kremenek28685ab2010-03-12 00:46:40 +0000518
519 // Issue a warning if property is 'assign' as default and its object, which is
520 // gc'able conforms to NSCopying protocol
David Blaikie4e4d0842012-03-11 07:00:24 +0000521 if (getLangOpts().getGC() != LangOptions::NonGC &&
Bill Wendlingad017fa2012-12-20 19:22:21 +0000522 isAssign && !(Attributes & ObjCDeclSpec::DQ_PR_assign))
John McCallc12c5bb2010-05-15 11:32:37 +0000523 if (const ObjCObjectPointerType *ObjPtrTy =
524 T->getAs<ObjCObjectPointerType>()) {
525 ObjCInterfaceDecl *IDecl = ObjPtrTy->getObjectType()->getInterface();
526 if (IDecl)
527 if (ObjCProtocolDecl* PNSCopying =
528 LookupProtocol(&Context.Idents.get("NSCopying"), AtLoc))
529 if (IDecl->ClassImplementsProtocol(PNSCopying, true))
530 Diag(AtLoc, diag::warn_implements_nscopying) << PropertyId;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000531 }
John McCallc12c5bb2010-05-15 11:32:37 +0000532 if (T->isObjCObjectType())
Ted Kremenek28685ab2010-03-12 00:46:40 +0000533 Diag(FD.D.getIdentifierLoc(), diag::err_statically_allocated_object);
534
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000535 DeclContext *DC = cast<DeclContext>(CDecl);
Ted Kremenek28685ab2010-03-12 00:46:40 +0000536 ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, DC,
537 FD.D.getIdentifierLoc(),
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +0000538 PropertyId, AtLoc, LParenLoc, TInfo);
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000539
Ted Kremenek9f550ff2010-03-15 20:11:46 +0000540 if (ObjCPropertyDecl *prevDecl =
541 ObjCPropertyDecl::findPropertyDecl(DC, PropertyId)) {
Ted Kremenek28685ab2010-03-12 00:46:40 +0000542 Diag(PDecl->getLocation(), diag::err_duplicate_property);
Ted Kremenek894ae6a2010-03-15 18:47:25 +0000543 Diag(prevDecl->getLocation(), diag::note_property_declare);
Ted Kremenek28685ab2010-03-12 00:46:40 +0000544 PDecl->setInvalidDecl();
545 }
Ted Kremenek23173d72010-05-18 21:09:07 +0000546 else {
Ted Kremenek28685ab2010-03-12 00:46:40 +0000547 DC->addDecl(PDecl);
Ted Kremenek23173d72010-05-18 21:09:07 +0000548 if (lexicalDC)
549 PDecl->setLexicalDeclContext(lexicalDC);
550 }
Ted Kremenek28685ab2010-03-12 00:46:40 +0000551
552 if (T->isArrayType() || T->isFunctionType()) {
553 Diag(AtLoc, diag::err_property_type) << T;
554 PDecl->setInvalidDecl();
555 }
556
557 ProcessDeclAttributes(S, PDecl, FD.D);
558
559 // Regardless of setter/getter attribute, we save the default getter/setter
560 // selector names in anticipation of declaration of setter/getter methods.
561 PDecl->setGetterName(GetterSel);
562 PDecl->setSetterName(SetterSel);
Argyrios Kyrtzidis0a68dc72011-07-12 04:30:16 +0000563 PDecl->setPropertyAttributesAsWritten(
Argyrios Kyrtzidisdbbdec92011-11-06 18:58:12 +0000564 makePropertyAttributesAsWritten(AttributesAsWritten));
Argyrios Kyrtzidis0a68dc72011-07-12 04:30:16 +0000565
Bill Wendlingad017fa2012-12-20 19:22:21 +0000566 if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
Ted Kremenek28685ab2010-03-12 00:46:40 +0000567 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
568
Bill Wendlingad017fa2012-12-20 19:22:21 +0000569 if (Attributes & ObjCDeclSpec::DQ_PR_getter)
Ted Kremenek28685ab2010-03-12 00:46:40 +0000570 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter);
571
Bill Wendlingad017fa2012-12-20 19:22:21 +0000572 if (Attributes & ObjCDeclSpec::DQ_PR_setter)
Ted Kremenek28685ab2010-03-12 00:46:40 +0000573 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter);
574
575 if (isReadWrite)
576 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
577
Bill Wendlingad017fa2012-12-20 19:22:21 +0000578 if (Attributes & ObjCDeclSpec::DQ_PR_retain)
Ted Kremenek28685ab2010-03-12 00:46:40 +0000579 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
580
Bill Wendlingad017fa2012-12-20 19:22:21 +0000581 if (Attributes & ObjCDeclSpec::DQ_PR_strong)
John McCallf85e1932011-06-15 23:02:42 +0000582 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
583
Bill Wendlingad017fa2012-12-20 19:22:21 +0000584 if (Attributes & ObjCDeclSpec::DQ_PR_weak)
John McCallf85e1932011-06-15 23:02:42 +0000585 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
586
Bill Wendlingad017fa2012-12-20 19:22:21 +0000587 if (Attributes & ObjCDeclSpec::DQ_PR_copy)
Ted Kremenek28685ab2010-03-12 00:46:40 +0000588 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
589
Bill Wendlingad017fa2012-12-20 19:22:21 +0000590 if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
John McCallf85e1932011-06-15 23:02:42 +0000591 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
592
Ted Kremenek28685ab2010-03-12 00:46:40 +0000593 if (isAssign)
594 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
595
John McCall265941b2011-09-13 18:31:23 +0000596 // In the semantic attributes, one of nonatomic or atomic is always set.
Bill Wendlingad017fa2012-12-20 19:22:21 +0000597 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
Ted Kremenek28685ab2010-03-12 00:46:40 +0000598 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
John McCall265941b2011-09-13 18:31:23 +0000599 else
Fariborz Jahanian45937ae2011-06-11 00:45:12 +0000600 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic);
Ted Kremenek28685ab2010-03-12 00:46:40 +0000601
John McCallf85e1932011-06-15 23:02:42 +0000602 // 'unsafe_unretained' is alias for 'assign'.
Bill Wendlingad017fa2012-12-20 19:22:21 +0000603 if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
John McCallf85e1932011-06-15 23:02:42 +0000604 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
605 if (isAssign)
606 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
607
Ted Kremenek28685ab2010-03-12 00:46:40 +0000608 if (MethodImplKind == tok::objc_required)
609 PDecl->setPropertyImplementation(ObjCPropertyDecl::Required);
610 else if (MethodImplKind == tok::objc_optional)
611 PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional);
Ted Kremenek28685ab2010-03-12 00:46:40 +0000612
Ted Kremeneke3d67bc2010-03-12 02:31:10 +0000613 return PDecl;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000614}
615
John McCallf85e1932011-06-15 23:02:42 +0000616static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc,
617 ObjCPropertyDecl *property,
618 ObjCIvarDecl *ivar) {
619 if (property->isInvalidDecl() || ivar->isInvalidDecl()) return;
620
John McCallf85e1932011-06-15 23:02:42 +0000621 QualType ivarType = ivar->getType();
622 Qualifiers::ObjCLifetime ivarLifetime = ivarType.getObjCLifetime();
John McCallf85e1932011-06-15 23:02:42 +0000623
John McCall265941b2011-09-13 18:31:23 +0000624 // The lifetime implied by the property's attributes.
625 Qualifiers::ObjCLifetime propertyLifetime =
626 getImpliedARCOwnership(property->getPropertyAttributes(),
627 property->getType());
John McCallf85e1932011-06-15 23:02:42 +0000628
John McCall265941b2011-09-13 18:31:23 +0000629 // We're fine if they match.
630 if (propertyLifetime == ivarLifetime) return;
John McCallf85e1932011-06-15 23:02:42 +0000631
John McCall265941b2011-09-13 18:31:23 +0000632 // These aren't valid lifetimes for object ivars; don't diagnose twice.
633 if (ivarLifetime == Qualifiers::OCL_None ||
634 ivarLifetime == Qualifiers::OCL_Autoreleasing)
635 return;
John McCallf85e1932011-06-15 23:02:42 +0000636
John McCalld64c2eb2012-08-20 23:36:59 +0000637 // If the ivar is private, and it's implicitly __unsafe_unretained
638 // becaues of its type, then pretend it was actually implicitly
639 // __strong. This is only sound because we're processing the
640 // property implementation before parsing any method bodies.
641 if (ivarLifetime == Qualifiers::OCL_ExplicitNone &&
642 propertyLifetime == Qualifiers::OCL_Strong &&
643 ivar->getAccessControl() == ObjCIvarDecl::Private) {
644 SplitQualType split = ivarType.split();
645 if (split.Quals.hasObjCLifetime()) {
646 assert(ivarType->isObjCARCImplicitlyUnretainedType());
647 split.Quals.setObjCLifetime(Qualifiers::OCL_Strong);
648 ivarType = S.Context.getQualifiedType(split);
649 ivar->setType(ivarType);
650 return;
651 }
652 }
653
John McCall265941b2011-09-13 18:31:23 +0000654 switch (propertyLifetime) {
655 case Qualifiers::OCL_Strong:
Argyrios Kyrtzidis135aa602012-12-12 22:48:25 +0000656 S.Diag(ivar->getLocation(), diag::err_arc_strong_property_ownership)
John McCall265941b2011-09-13 18:31:23 +0000657 << property->getDeclName()
658 << ivar->getDeclName()
659 << ivarLifetime;
660 break;
John McCallf85e1932011-06-15 23:02:42 +0000661
John McCall265941b2011-09-13 18:31:23 +0000662 case Qualifiers::OCL_Weak:
Argyrios Kyrtzidis135aa602012-12-12 22:48:25 +0000663 S.Diag(ivar->getLocation(), diag::error_weak_property)
John McCall265941b2011-09-13 18:31:23 +0000664 << property->getDeclName()
665 << ivar->getDeclName();
666 break;
John McCallf85e1932011-06-15 23:02:42 +0000667
John McCall265941b2011-09-13 18:31:23 +0000668 case Qualifiers::OCL_ExplicitNone:
Argyrios Kyrtzidis135aa602012-12-12 22:48:25 +0000669 S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership)
John McCall265941b2011-09-13 18:31:23 +0000670 << property->getDeclName()
671 << ivar->getDeclName()
672 << ((property->getPropertyAttributesAsWritten()
673 & ObjCPropertyDecl::OBJC_PR_assign) != 0);
674 break;
John McCallf85e1932011-06-15 23:02:42 +0000675
John McCall265941b2011-09-13 18:31:23 +0000676 case Qualifiers::OCL_Autoreleasing:
677 llvm_unreachable("properties cannot be autoreleasing");
John McCallf85e1932011-06-15 23:02:42 +0000678
John McCall265941b2011-09-13 18:31:23 +0000679 case Qualifiers::OCL_None:
680 // Any other property should be ignored.
John McCallf85e1932011-06-15 23:02:42 +0000681 return;
682 }
683
684 S.Diag(property->getLocation(), diag::note_property_declare);
Argyrios Kyrtzidis135aa602012-12-12 22:48:25 +0000685 if (propertyImplLoc.isValid())
686 S.Diag(propertyImplLoc, diag::note_property_synthesize);
John McCallf85e1932011-06-15 23:02:42 +0000687}
688
Fariborz Jahanian015f6082012-01-11 18:26:06 +0000689/// setImpliedPropertyAttributeForReadOnlyProperty -
690/// This routine evaludates life-time attributes for a 'readonly'
691/// property with no known lifetime of its own, using backing
692/// 'ivar's attribute, if any. If no backing 'ivar', property's
693/// life-time is assumed 'strong'.
694static void setImpliedPropertyAttributeForReadOnlyProperty(
695 ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {
696 Qualifiers::ObjCLifetime propertyLifetime =
697 getImpliedARCOwnership(property->getPropertyAttributes(),
698 property->getType());
699 if (propertyLifetime != Qualifiers::OCL_None)
700 return;
701
702 if (!ivar) {
703 // if no backing ivar, make property 'strong'.
704 property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
705 return;
706 }
707 // property assumes owenership of backing ivar.
708 QualType ivarType = ivar->getType();
709 Qualifiers::ObjCLifetime ivarLifetime = ivarType.getObjCLifetime();
710 if (ivarLifetime == Qualifiers::OCL_Strong)
711 property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
712 else if (ivarLifetime == Qualifiers::OCL_Weak)
713 property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
714 return;
715}
Ted Kremenek28685ab2010-03-12 00:46:40 +0000716
Fariborz Jahanian8dbda512013-05-20 21:20:24 +0000717/// DiagnosePropertyMismatchDeclInProtocols - diagnose properties declared
718/// in inherited protocols with mismatched types. Since any of them can
719/// be candidate for synthesis.
Benjamin Kramerb1a4d372013-05-23 15:53:44 +0000720static void
721DiagnosePropertyMismatchDeclInProtocols(Sema &S, SourceLocation AtLoc,
722 ObjCInterfaceDecl *ClassDecl,
Fariborz Jahanian8dbda512013-05-20 21:20:24 +0000723 ObjCPropertyDecl *Property) {
724 ObjCInterfaceDecl::ProtocolPropertyMap PropMap;
725 for (ObjCInterfaceDecl::all_protocol_iterator
726 PI = ClassDecl->all_referenced_protocol_begin(),
727 E = ClassDecl->all_referenced_protocol_end(); PI != E; ++PI) {
728 if (const ObjCProtocolDecl *PDecl = (*PI)->getDefinition())
729 PDecl->collectInheritedProtocolProperties(Property, PropMap);
730 }
731 if (ObjCInterfaceDecl *SDecl = ClassDecl->getSuperClass())
732 while (SDecl) {
733 for (ObjCInterfaceDecl::all_protocol_iterator
734 PI = SDecl->all_referenced_protocol_begin(),
735 E = SDecl->all_referenced_protocol_end(); PI != E; ++PI) {
736 if (const ObjCProtocolDecl *PDecl = (*PI)->getDefinition())
737 PDecl->collectInheritedProtocolProperties(Property, PropMap);
738 }
739 SDecl = SDecl->getSuperClass();
740 }
741
742 if (PropMap.empty())
743 return;
744
745 QualType RHSType = S.Context.getCanonicalType(Property->getType());
746 bool FirsTime = true;
747 for (ObjCInterfaceDecl::ProtocolPropertyMap::iterator
748 I = PropMap.begin(), E = PropMap.end(); I != E; I++) {
749 ObjCPropertyDecl *Prop = I->second;
750 QualType LHSType = S.Context.getCanonicalType(Prop->getType());
751 if (!S.Context.propertyTypesAreCompatible(LHSType, RHSType)) {
752 bool IncompatibleObjC = false;
753 QualType ConvertedType;
754 if (!S.isObjCPointerConversion(RHSType, LHSType, ConvertedType, IncompatibleObjC)
755 || IncompatibleObjC) {
756 if (FirsTime) {
757 S.Diag(Property->getLocation(), diag::warn_protocol_property_mismatch)
758 << Property->getType();
759 FirsTime = false;
760 }
761 S.Diag(Prop->getLocation(), diag::note_protocol_property_declare)
762 << Prop->getType();
763 }
764 }
765 }
766 if (!FirsTime && AtLoc.isValid())
767 S.Diag(AtLoc, diag::note_property_synthesize);
768}
769
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000770/// DiagnoseClassAndClassExtPropertyMismatch - diagnose inconsistant property
771/// attribute declared in primary class and attributes overridden in any of its
772/// class extensions.
773static void
774DiagnoseClassAndClassExtPropertyMismatch(Sema &S, ObjCInterfaceDecl *ClassDecl,
775 ObjCPropertyDecl *property) {
Bill Wendlingad017fa2012-12-20 19:22:21 +0000776 unsigned Attributes = property->getPropertyAttributesAsWritten();
777 bool warn = (Attributes & ObjCDeclSpec::DQ_PR_readonly);
Douglas Gregord3297242013-01-16 23:00:23 +0000778 for (ObjCInterfaceDecl::known_extensions_iterator
779 Ext = ClassDecl->known_extensions_begin(),
780 ExtEnd = ClassDecl->known_extensions_end();
781 Ext != ExtEnd; ++Ext) {
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000782 ObjCPropertyDecl *ClassExtProperty = 0;
Douglas Gregor0dfe23c2013-01-21 18:35:55 +0000783 DeclContext::lookup_result R = Ext->lookup(property->getDeclName());
784 for (unsigned I = 0, N = R.size(); I != N; ++I) {
785 ClassExtProperty = dyn_cast<ObjCPropertyDecl>(R[0]);
786 if (ClassExtProperty)
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000787 break;
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000788 }
Douglas Gregor0dfe23c2013-01-21 18:35:55 +0000789
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000790 if (ClassExtProperty) {
Fariborz Jahanianc78ff272012-06-20 23:18:57 +0000791 warn = false;
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000792 unsigned classExtPropertyAttr =
793 ClassExtProperty->getPropertyAttributesAsWritten();
794 // We are issuing the warning that we postponed because class extensions
795 // can override readonly->readwrite and 'setter' attributes originally
796 // placed on class's property declaration now make sense in the overridden
797 // property.
Bill Wendlingad017fa2012-12-20 19:22:21 +0000798 if (Attributes & ObjCDeclSpec::DQ_PR_readonly) {
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000799 if (!classExtPropertyAttr ||
Fariborz Jahaniana6e28f22012-08-24 20:10:53 +0000800 (classExtPropertyAttr &
801 (ObjCDeclSpec::DQ_PR_readwrite|
802 ObjCDeclSpec::DQ_PR_assign |
803 ObjCDeclSpec::DQ_PR_unsafe_unretained |
804 ObjCDeclSpec::DQ_PR_copy |
805 ObjCDeclSpec::DQ_PR_retain |
806 ObjCDeclSpec::DQ_PR_strong)))
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000807 continue;
808 warn = true;
809 break;
810 }
811 }
812 }
813 if (warn) {
814 unsigned setterAttrs = (ObjCDeclSpec::DQ_PR_assign |
815 ObjCDeclSpec::DQ_PR_unsafe_unretained |
816 ObjCDeclSpec::DQ_PR_copy |
817 ObjCDeclSpec::DQ_PR_retain |
818 ObjCDeclSpec::DQ_PR_strong);
Bill Wendlingad017fa2012-12-20 19:22:21 +0000819 if (Attributes & setterAttrs) {
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000820 const char * which =
Bill Wendlingad017fa2012-12-20 19:22:21 +0000821 (Attributes & ObjCDeclSpec::DQ_PR_assign) ?
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000822 "assign" :
Bill Wendlingad017fa2012-12-20 19:22:21 +0000823 (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) ?
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000824 "unsafe_unretained" :
Bill Wendlingad017fa2012-12-20 19:22:21 +0000825 (Attributes & ObjCDeclSpec::DQ_PR_copy) ?
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000826 "copy" :
Bill Wendlingad017fa2012-12-20 19:22:21 +0000827 (Attributes & ObjCDeclSpec::DQ_PR_retain) ?
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000828 "retain" : "strong";
829
830 S.Diag(property->getLocation(),
831 diag::warn_objc_property_attr_mutually_exclusive)
832 << "readonly" << which;
833 }
834 }
835
836
837}
838
Ted Kremenek28685ab2010-03-12 00:46:40 +0000839/// ActOnPropertyImplDecl - This routine performs semantic checks and
840/// builds the AST node for a property implementation declaration; declared
James Dennett699c9042012-06-15 07:13:21 +0000841/// as \@synthesize or \@dynamic.
Ted Kremenek28685ab2010-03-12 00:46:40 +0000842///
John McCalld226f652010-08-21 09:40:31 +0000843Decl *Sema::ActOnPropertyImplDecl(Scope *S,
844 SourceLocation AtLoc,
845 SourceLocation PropertyLoc,
846 bool Synthesize,
John McCalld226f652010-08-21 09:40:31 +0000847 IdentifierInfo *PropertyId,
Douglas Gregora4ffd852010-11-17 01:03:52 +0000848 IdentifierInfo *PropertyIvar,
849 SourceLocation PropertyIvarLoc) {
Ted Kremeneke9686572010-04-05 23:45:09 +0000850 ObjCContainerDecl *ClassImpDecl =
Fariborz Jahanian84e0ccf2011-09-19 16:32:32 +0000851 dyn_cast<ObjCContainerDecl>(CurContext);
Ted Kremenek28685ab2010-03-12 00:46:40 +0000852 // Make sure we have a context for the property implementation declaration.
853 if (!ClassImpDecl) {
854 Diag(AtLoc, diag::error_missing_property_context);
John McCalld226f652010-08-21 09:40:31 +0000855 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000856 }
Argyrios Kyrtzidisf9112422012-02-28 17:50:39 +0000857 if (PropertyIvarLoc.isInvalid())
858 PropertyIvarLoc = PropertyLoc;
Eli Friedmane4c043d2012-05-01 22:26:06 +0000859 SourceLocation PropertyDiagLoc = PropertyLoc;
860 if (PropertyDiagLoc.isInvalid())
861 PropertyDiagLoc = ClassImpDecl->getLocStart();
Ted Kremenek28685ab2010-03-12 00:46:40 +0000862 ObjCPropertyDecl *property = 0;
863 ObjCInterfaceDecl* IDecl = 0;
864 // Find the class or category class where this property must have
865 // a declaration.
866 ObjCImplementationDecl *IC = 0;
867 ObjCCategoryImplDecl* CatImplClass = 0;
868 if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {
869 IDecl = IC->getClassInterface();
870 // We always synthesize an interface for an implementation
871 // without an interface decl. So, IDecl is always non-zero.
872 assert(IDecl &&
873 "ActOnPropertyImplDecl - @implementation without @interface");
874
875 // Look for this property declaration in the @implementation's @interface
876 property = IDecl->FindPropertyDeclaration(PropertyId);
877 if (!property) {
878 Diag(PropertyLoc, diag::error_bad_property_decl) << IDecl->getDeclName();
John McCalld226f652010-08-21 09:40:31 +0000879 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000880 }
Fariborz Jahaniandd4430e2010-12-17 22:28:16 +0000881 unsigned PIkind = property->getPropertyAttributesAsWritten();
Fariborz Jahanian45937ae2011-06-11 00:45:12 +0000882 if ((PIkind & (ObjCPropertyDecl::OBJC_PR_atomic |
883 ObjCPropertyDecl::OBJC_PR_nonatomic) ) == 0) {
Fariborz Jahaniandd4430e2010-12-17 22:28:16 +0000884 if (AtLoc.isValid())
885 Diag(AtLoc, diag::warn_implicit_atomic_property);
886 else
887 Diag(IC->getLocation(), diag::warn_auto_implicit_atomic_property);
888 Diag(property->getLocation(), diag::note_property_declare);
889 }
890
Ted Kremenek28685ab2010-03-12 00:46:40 +0000891 if (const ObjCCategoryDecl *CD =
892 dyn_cast<ObjCCategoryDecl>(property->getDeclContext())) {
893 if (!CD->IsClassExtension()) {
894 Diag(PropertyLoc, diag::error_category_property) << CD->getDeclName();
895 Diag(property->getLocation(), diag::note_property_declare);
John McCalld226f652010-08-21 09:40:31 +0000896 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000897 }
898 }
Fariborz Jahanian2b309fb2012-05-19 18:17:17 +0000899 if (Synthesize&&
900 (PIkind & ObjCPropertyDecl::OBJC_PR_readonly) &&
901 property->hasAttr<IBOutletAttr>() &&
902 !AtLoc.isValid()) {
Fariborz Jahanian12564342013-02-08 23:32:30 +0000903 bool ReadWriteProperty = false;
904 // Search into the class extensions and see if 'readonly property is
905 // redeclared 'readwrite', then no warning is to be issued.
906 for (ObjCInterfaceDecl::known_extensions_iterator
907 Ext = IDecl->known_extensions_begin(),
908 ExtEnd = IDecl->known_extensions_end(); Ext != ExtEnd; ++Ext) {
909 DeclContext::lookup_result R = Ext->lookup(property->getDeclName());
910 if (!R.empty())
911 if (ObjCPropertyDecl *ExtProp = dyn_cast<ObjCPropertyDecl>(R[0])) {
912 PIkind = ExtProp->getPropertyAttributesAsWritten();
913 if (PIkind & ObjCPropertyDecl::OBJC_PR_readwrite) {
914 ReadWriteProperty = true;
915 break;
916 }
917 }
918 }
919
920 if (!ReadWriteProperty) {
Ted Kremeneka4475a62013-02-09 07:13:16 +0000921 Diag(property->getLocation(), diag::warn_auto_readonly_iboutlet_property)
922 << property->getName();
Fariborz Jahanian12564342013-02-08 23:32:30 +0000923 SourceLocation readonlyLoc;
924 if (LocPropertyAttribute(Context, "readonly",
925 property->getLParenLoc(), readonlyLoc)) {
926 SourceLocation endLoc =
927 readonlyLoc.getLocWithOffset(strlen("readonly")-1);
928 SourceRange ReadonlySourceRange(readonlyLoc, endLoc);
929 Diag(property->getLocation(),
930 diag::note_auto_readonly_iboutlet_fixup_suggest) <<
931 FixItHint::CreateReplacement(ReadonlySourceRange, "readwrite");
932 }
Fariborz Jahanianedcc27f2012-05-21 17:02:43 +0000933 }
Fariborz Jahanian2b309fb2012-05-19 18:17:17 +0000934 }
Fariborz Jahanian8dbda512013-05-20 21:20:24 +0000935 if (Synthesize && isa<ObjCProtocolDecl>(property->getDeclContext()))
936 DiagnosePropertyMismatchDeclInProtocols(*this, AtLoc, IDecl, property);
Fariborz Jahaniancea06d22012-06-20 22:57:42 +0000937
938 DiagnoseClassAndClassExtPropertyMismatch(*this, IDecl, property);
Fariborz Jahanian2b309fb2012-05-19 18:17:17 +0000939
Ted Kremenek28685ab2010-03-12 00:46:40 +0000940 } else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) {
941 if (Synthesize) {
942 Diag(AtLoc, diag::error_synthesize_category_decl);
John McCalld226f652010-08-21 09:40:31 +0000943 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000944 }
945 IDecl = CatImplClass->getClassInterface();
946 if (!IDecl) {
947 Diag(AtLoc, diag::error_missing_property_interface);
John McCalld226f652010-08-21 09:40:31 +0000948 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000949 }
950 ObjCCategoryDecl *Category =
951 IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier());
952
953 // If category for this implementation not found, it is an error which
954 // has already been reported eralier.
955 if (!Category)
John McCalld226f652010-08-21 09:40:31 +0000956 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000957 // Look for this property declaration in @implementation's category
958 property = Category->FindPropertyDeclaration(PropertyId);
959 if (!property) {
960 Diag(PropertyLoc, diag::error_bad_category_property_decl)
961 << Category->getDeclName();
John McCalld226f652010-08-21 09:40:31 +0000962 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000963 }
964 } else {
965 Diag(AtLoc, diag::error_bad_property_context);
John McCalld226f652010-08-21 09:40:31 +0000966 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000967 }
968 ObjCIvarDecl *Ivar = 0;
Eli Friedmane4c043d2012-05-01 22:26:06 +0000969 bool CompleteTypeErr = false;
Fariborz Jahanian74414712012-05-15 18:12:51 +0000970 bool compat = true;
Ted Kremenek28685ab2010-03-12 00:46:40 +0000971 // Check that we have a valid, previously declared ivar for @synthesize
972 if (Synthesize) {
973 // @synthesize
974 if (!PropertyIvar)
975 PropertyIvar = PropertyId;
Fariborz Jahanian015f6082012-01-11 18:26:06 +0000976 // Check that this is a previously declared 'ivar' in 'IDecl' interface
977 ObjCInterfaceDecl *ClassDeclared;
978 Ivar = IDecl->lookupInstanceVariable(PropertyIvar, ClassDeclared);
979 QualType PropType = property->getType();
980 QualType PropertyIvarType = PropType.getNonReferenceType();
Eli Friedmane4c043d2012-05-01 22:26:06 +0000981
982 if (RequireCompleteType(PropertyDiagLoc, PropertyIvarType,
Douglas Gregord10099e2012-05-04 16:32:21 +0000983 diag::err_incomplete_synthesized_property,
984 property->getDeclName())) {
Eli Friedmane4c043d2012-05-01 22:26:06 +0000985 Diag(property->getLocation(), diag::note_property_declare);
986 CompleteTypeErr = true;
987 }
988
David Blaikie4e4d0842012-03-11 07:00:24 +0000989 if (getLangOpts().ObjCAutoRefCount &&
Fariborz Jahanian015f6082012-01-11 18:26:06 +0000990 (property->getPropertyAttributesAsWritten() &
Fariborz Jahanian3efd3482012-01-11 19:48:08 +0000991 ObjCPropertyDecl::OBJC_PR_readonly) &&
992 PropertyIvarType->isObjCRetainableType()) {
Fariborz Jahanian015f6082012-01-11 18:26:06 +0000993 setImpliedPropertyAttributeForReadOnlyProperty(property, Ivar);
994 }
995
John McCallf85e1932011-06-15 23:02:42 +0000996 ObjCPropertyDecl::PropertyAttributeKind kind
997 = property->getPropertyAttributes();
John McCall265941b2011-09-13 18:31:23 +0000998
999 // Add GC __weak to the ivar type if the property is weak.
1000 if ((kind & ObjCPropertyDecl::OBJC_PR_weak) &&
David Blaikie4e4d0842012-03-11 07:00:24 +00001001 getLangOpts().getGC() != LangOptions::NonGC) {
1002 assert(!getLangOpts().ObjCAutoRefCount);
John McCall265941b2011-09-13 18:31:23 +00001003 if (PropertyIvarType.isObjCGCStrong()) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001004 Diag(PropertyDiagLoc, diag::err_gc_weak_property_strong_type);
John McCall265941b2011-09-13 18:31:23 +00001005 Diag(property->getLocation(), diag::note_property_declare);
1006 } else {
1007 PropertyIvarType =
1008 Context.getObjCGCQualType(PropertyIvarType, Qualifiers::Weak);
Fariborz Jahanianedc08822011-09-07 16:24:21 +00001009 }
Fariborz Jahanianedc08822011-09-07 16:24:21 +00001010 }
Fariborz Jahaniane95f8ef2012-06-20 17:18:31 +00001011 if (AtLoc.isInvalid()) {
1012 // Check when default synthesizing a property that there is
1013 // an ivar matching property name and issue warning; since this
1014 // is the most common case of not using an ivar used for backing
1015 // property in non-default synthesis case.
1016 ObjCInterfaceDecl *ClassDeclared=0;
1017 ObjCIvarDecl *originalIvar =
1018 IDecl->lookupInstanceVariable(property->getIdentifier(),
1019 ClassDeclared);
1020 if (originalIvar) {
1021 Diag(PropertyDiagLoc,
1022 diag::warn_autosynthesis_property_ivar_match)
Fariborz Jahanian25785322012-06-29 19:05:11 +00001023 << PropertyId << (Ivar == 0) << PropertyIvar
Fariborz Jahanian20e7d992012-06-29 18:43:30 +00001024 << originalIvar->getIdentifier();
Fariborz Jahaniane95f8ef2012-06-20 17:18:31 +00001025 Diag(property->getLocation(), diag::note_property_declare);
1026 Diag(originalIvar->getLocation(), diag::note_ivar_decl);
Fariborz Jahaniandd3284b2012-06-19 22:51:22 +00001027 }
Fariborz Jahaniane95f8ef2012-06-20 17:18:31 +00001028 }
1029
1030 if (!Ivar) {
John McCall265941b2011-09-13 18:31:23 +00001031 // In ARC, give the ivar a lifetime qualifier based on the
John McCallf85e1932011-06-15 23:02:42 +00001032 // property attributes.
David Blaikie4e4d0842012-03-11 07:00:24 +00001033 if (getLangOpts().ObjCAutoRefCount &&
John McCall265941b2011-09-13 18:31:23 +00001034 !PropertyIvarType.getObjCLifetime() &&
1035 PropertyIvarType->isObjCRetainableType()) {
John McCallf85e1932011-06-15 23:02:42 +00001036
John McCall265941b2011-09-13 18:31:23 +00001037 // It's an error if we have to do this and the user didn't
1038 // explicitly write an ownership attribute on the property.
Argyrios Kyrtzidis473506b2011-07-26 21:48:26 +00001039 if (!property->hasWrittenStorageAttribute() &&
John McCall265941b2011-09-13 18:31:23 +00001040 !(kind & ObjCPropertyDecl::OBJC_PR_strong)) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001041 Diag(PropertyDiagLoc,
Argyrios Kyrtzidis473506b2011-07-26 21:48:26 +00001042 diag::err_arc_objc_property_default_assign_on_object);
1043 Diag(property->getLocation(), diag::note_property_declare);
John McCall265941b2011-09-13 18:31:23 +00001044 } else {
1045 Qualifiers::ObjCLifetime lifetime =
1046 getImpliedARCOwnership(kind, PropertyIvarType);
1047 assert(lifetime && "no lifetime for property?");
Fariborz Jahanian6dce88d2011-12-09 19:55:11 +00001048 if (lifetime == Qualifiers::OCL_Weak) {
1049 bool err = false;
1050 if (const ObjCObjectPointerType *ObjT =
Richard Smitha8eaf002012-08-23 06:16:52 +00001051 PropertyIvarType->getAs<ObjCObjectPointerType>()) {
1052 const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl();
1053 if (ObjI && ObjI->isArcWeakrefUnavailable()) {
Fariborz Jahanian80abce32013-04-24 19:13:05 +00001054 Diag(property->getLocation(),
1055 diag::err_arc_weak_unavailable_property) << PropertyIvarType;
1056 Diag(ClassImpDecl->getLocation(), diag::note_implemented_by_class)
1057 << ClassImpDecl->getName();
Fariborz Jahanian6dce88d2011-12-09 19:55:11 +00001058 err = true;
1059 }
Richard Smitha8eaf002012-08-23 06:16:52 +00001060 }
John McCall0a7dd782012-08-21 02:47:43 +00001061 if (!err && !getLangOpts().ObjCARCWeak) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001062 Diag(PropertyDiagLoc, diag::err_arc_weak_no_runtime);
Fariborz Jahanian6dce88d2011-12-09 19:55:11 +00001063 Diag(property->getLocation(), diag::note_property_declare);
1064 }
John McCallf85e1932011-06-15 23:02:42 +00001065 }
Fariborz Jahanian6dce88d2011-12-09 19:55:11 +00001066
John McCallf85e1932011-06-15 23:02:42 +00001067 Qualifiers qs;
John McCall265941b2011-09-13 18:31:23 +00001068 qs.addObjCLifetime(lifetime);
John McCallf85e1932011-06-15 23:02:42 +00001069 PropertyIvarType = Context.getQualifiedType(PropertyIvarType, qs);
1070 }
John McCallf85e1932011-06-15 23:02:42 +00001071 }
1072
1073 if (kind & ObjCPropertyDecl::OBJC_PR_weak &&
David Blaikie4e4d0842012-03-11 07:00:24 +00001074 !getLangOpts().ObjCAutoRefCount &&
1075 getLangOpts().getGC() == LangOptions::NonGC) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001076 Diag(PropertyDiagLoc, diag::error_synthesize_weak_non_arc_or_gc);
John McCallf85e1932011-06-15 23:02:42 +00001077 Diag(property->getLocation(), diag::note_property_declare);
1078 }
1079
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00001080 Ivar = ObjCIvarDecl::Create(Context, ClassImpDecl,
Argyrios Kyrtzidisf9112422012-02-28 17:50:39 +00001081 PropertyIvarLoc,PropertyIvarLoc, PropertyIvar,
Fariborz Jahanian14086762011-03-28 23:47:18 +00001082 PropertyIvarType, /*Dinfo=*/0,
Fariborz Jahanian75049662010-12-15 23:29:04 +00001083 ObjCIvarDecl::Private,
Fariborz Jahanianad51e742010-07-17 00:59:30 +00001084 (Expr *)0, true);
Eli Friedmane4c043d2012-05-01 22:26:06 +00001085 if (CompleteTypeErr)
1086 Ivar->setInvalidDecl();
Daniel Dunbar29fa69a2010-04-02 19:44:54 +00001087 ClassImpDecl->addDecl(Ivar);
Richard Smith1b7f9cb2012-03-13 03:12:56 +00001088 IDecl->makeDeclVisibleInContext(Ivar);
Ted Kremenek28685ab2010-03-12 00:46:40 +00001089
John McCall260611a2012-06-20 06:18:46 +00001090 if (getLangOpts().ObjCRuntime.isFragile())
Eli Friedmane4c043d2012-05-01 22:26:06 +00001091 Diag(PropertyDiagLoc, diag::error_missing_property_ivar_decl)
1092 << PropertyId;
Ted Kremenek28685ab2010-03-12 00:46:40 +00001093 // Note! I deliberately want it to fall thru so, we have a
1094 // a property implementation and to avoid future warnings.
John McCall260611a2012-06-20 06:18:46 +00001095 } else if (getLangOpts().ObjCRuntime.isNonFragile() &&
Douglas Gregor60ef3082011-12-15 00:29:59 +00001096 !declaresSameEntity(ClassDeclared, IDecl)) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001097 Diag(PropertyDiagLoc, diag::error_ivar_in_superclass_use)
Ted Kremenek28685ab2010-03-12 00:46:40 +00001098 << property->getDeclName() << Ivar->getDeclName()
1099 << ClassDeclared->getDeclName();
1100 Diag(Ivar->getLocation(), diag::note_previous_access_declaration)
Daniel Dunbar4087f272010-08-17 22:39:59 +00001101 << Ivar << Ivar->getName();
Ted Kremenek28685ab2010-03-12 00:46:40 +00001102 // Note! I deliberately want it to fall thru so more errors are caught.
1103 }
Anna Zaks5bf5c2e2012-09-26 18:55:16 +00001104 property->setPropertyIvarDecl(Ivar);
1105
Ted Kremenek28685ab2010-03-12 00:46:40 +00001106 QualType IvarType = Context.getCanonicalType(Ivar->getType());
1107
1108 // Check that type of property and its ivar are type compatible.
Fariborz Jahanian74414712012-05-15 18:12:51 +00001109 if (!Context.hasSameType(PropertyIvarType, IvarType)) {
Fariborz Jahanian14086762011-03-28 23:47:18 +00001110 if (isa<ObjCObjectPointerType>(PropertyIvarType)
John McCallf85e1932011-06-15 23:02:42 +00001111 && isa<ObjCObjectPointerType>(IvarType))
Richard Smithb3cd3c02012-09-14 18:27:01 +00001112 compat =
Fariborz Jahanian62ac5d02010-05-18 23:04:17 +00001113 Context.canAssignObjCInterfaces(
Fariborz Jahanian14086762011-03-28 23:47:18 +00001114 PropertyIvarType->getAs<ObjCObjectPointerType>(),
Fariborz Jahanian62ac5d02010-05-18 23:04:17 +00001115 IvarType->getAs<ObjCObjectPointerType>());
Douglas Gregorb608b982011-01-28 02:26:04 +00001116 else {
Argyrios Kyrtzidisf9112422012-02-28 17:50:39 +00001117 compat = (CheckAssignmentConstraints(PropertyIvarLoc, PropertyIvarType,
1118 IvarType)
John McCalldaa8e4e2010-11-15 09:13:47 +00001119 == Compatible);
Douglas Gregorb608b982011-01-28 02:26:04 +00001120 }
Fariborz Jahanian62ac5d02010-05-18 23:04:17 +00001121 if (!compat) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001122 Diag(PropertyDiagLoc, diag::error_property_ivar_type)
Ted Kremenekf921a482010-03-23 19:02:22 +00001123 << property->getDeclName() << PropType
1124 << Ivar->getDeclName() << IvarType;
1125 Diag(Ivar->getLocation(), diag::note_ivar_decl);
Ted Kremenek28685ab2010-03-12 00:46:40 +00001126 // Note! I deliberately want it to fall thru so, we have a
1127 // a property implementation and to avoid future warnings.
1128 }
Fariborz Jahanian74414712012-05-15 18:12:51 +00001129 else {
1130 // FIXME! Rules for properties are somewhat different that those
1131 // for assignments. Use a new routine to consolidate all cases;
1132 // specifically for property redeclarations as well as for ivars.
1133 QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
1134 QualType rhsType =Context.getCanonicalType(IvarType).getUnqualifiedType();
1135 if (lhsType != rhsType &&
1136 lhsType->isArithmeticType()) {
1137 Diag(PropertyDiagLoc, diag::error_property_ivar_type)
1138 << property->getDeclName() << PropType
1139 << Ivar->getDeclName() << IvarType;
1140 Diag(Ivar->getLocation(), diag::note_ivar_decl);
1141 // Fall thru - see previous comment
1142 }
Ted Kremenek28685ab2010-03-12 00:46:40 +00001143 }
1144 // __weak is explicit. So it works on Canonical type.
John McCallf85e1932011-06-15 23:02:42 +00001145 if ((PropType.isObjCGCWeak() && !IvarType.isObjCGCWeak() &&
David Blaikie4e4d0842012-03-11 07:00:24 +00001146 getLangOpts().getGC() != LangOptions::NonGC)) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001147 Diag(PropertyDiagLoc, diag::error_weak_property)
Ted Kremenek28685ab2010-03-12 00:46:40 +00001148 << property->getDeclName() << Ivar->getDeclName();
Fariborz Jahanianedc08822011-09-07 16:24:21 +00001149 Diag(Ivar->getLocation(), diag::note_ivar_decl);
Ted Kremenek28685ab2010-03-12 00:46:40 +00001150 // Fall thru - see previous comment
1151 }
John McCallf85e1932011-06-15 23:02:42 +00001152 // Fall thru - see previous comment
Ted Kremenek28685ab2010-03-12 00:46:40 +00001153 if ((property->getType()->isObjCObjectPointerType() ||
1154 PropType.isObjCGCStrong()) && IvarType.isObjCGCWeak() &&
David Blaikie4e4d0842012-03-11 07:00:24 +00001155 getLangOpts().getGC() != LangOptions::NonGC) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001156 Diag(PropertyDiagLoc, diag::error_strong_property)
Ted Kremenek28685ab2010-03-12 00:46:40 +00001157 << property->getDeclName() << Ivar->getDeclName();
1158 // Fall thru - see previous comment
1159 }
1160 }
David Blaikie4e4d0842012-03-11 07:00:24 +00001161 if (getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +00001162 checkARCPropertyImpl(*this, PropertyLoc, property, Ivar);
Ted Kremenek28685ab2010-03-12 00:46:40 +00001163 } else if (PropertyIvar)
1164 // @dynamic
Eli Friedmane4c043d2012-05-01 22:26:06 +00001165 Diag(PropertyDiagLoc, diag::error_dynamic_property_ivar_decl);
John McCallf85e1932011-06-15 23:02:42 +00001166
Ted Kremenek28685ab2010-03-12 00:46:40 +00001167 assert (property && "ActOnPropertyImplDecl - property declaration missing");
1168 ObjCPropertyImplDecl *PIDecl =
1169 ObjCPropertyImplDecl::Create(Context, CurContext, AtLoc, PropertyLoc,
1170 property,
1171 (Synthesize ?
1172 ObjCPropertyImplDecl::Synthesize
1173 : ObjCPropertyImplDecl::Dynamic),
Douglas Gregora4ffd852010-11-17 01:03:52 +00001174 Ivar, PropertyIvarLoc);
Eli Friedmane4c043d2012-05-01 22:26:06 +00001175
Fariborz Jahanian74414712012-05-15 18:12:51 +00001176 if (CompleteTypeErr || !compat)
Eli Friedmane4c043d2012-05-01 22:26:06 +00001177 PIDecl->setInvalidDecl();
1178
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001179 if (ObjCMethodDecl *getterMethod = property->getGetterMethodDecl()) {
1180 getterMethod->createImplicitParams(Context, IDecl);
Eli Friedmane4c043d2012-05-01 22:26:06 +00001181 if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
Fariborz Jahanian0313f442010-10-15 22:42:59 +00001182 Ivar->getType()->isRecordType()) {
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001183 // For Objective-C++, need to synthesize the AST for the IVAR object to be
1184 // returned by the getter as it must conform to C++'s copy-return rules.
1185 // FIXME. Eventually we want to do this for Objective-C as well.
Eli Friedman9a14db32012-10-18 20:14:08 +00001186 SynthesizedFunctionScope Scope(*this, getterMethod);
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001187 ImplicitParamDecl *SelfDecl = getterMethod->getSelfDecl();
1188 DeclRefExpr *SelfExpr =
John McCallf4b88a42012-03-10 09:33:50 +00001189 new (Context) DeclRefExpr(SelfDecl, false, SelfDecl->getType(),
Eli Friedman9a14db32012-10-18 20:14:08 +00001190 VK_RValue, PropertyDiagLoc);
1191 MarkDeclRefReferenced(SelfExpr);
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001192 Expr *IvarRefExpr =
Eli Friedman9a14db32012-10-18 20:14:08 +00001193 new (Context) ObjCIvarRefExpr(Ivar, Ivar->getType(), PropertyDiagLoc,
Fariborz Jahanian0c701812013-04-02 18:57:54 +00001194 Ivar->getLocation(),
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001195 SelfExpr, true, true);
John McCall60d7b3a2010-08-24 06:29:42 +00001196 ExprResult Res =
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001197 PerformCopyInitialization(InitializedEntity::InitializeResult(
Eli Friedman9a14db32012-10-18 20:14:08 +00001198 PropertyDiagLoc,
Douglas Gregor3c9034c2010-05-15 00:13:29 +00001199 getterMethod->getResultType(),
1200 /*NRVO=*/false),
Eli Friedman9a14db32012-10-18 20:14:08 +00001201 PropertyDiagLoc,
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001202 Owned(IvarRefExpr));
1203 if (!Res.isInvalid()) {
1204 Expr *ResExpr = Res.takeAs<Expr>();
1205 if (ResExpr)
John McCall4765fa02010-12-06 08:20:24 +00001206 ResExpr = MaybeCreateExprWithCleanups(ResExpr);
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001207 PIDecl->setGetterCXXConstructor(ResExpr);
1208 }
1209 }
Fariborz Jahanian831fb962011-06-25 00:17:46 +00001210 if (property->hasAttr<NSReturnsNotRetainedAttr>() &&
1211 !getterMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
1212 Diag(getterMethod->getLocation(),
1213 diag::warn_property_getter_owning_mismatch);
1214 Diag(property->getLocation(), diag::note_property_declare);
1215 }
Fariborz Jahanianb8ed0712013-05-16 19:08:44 +00001216 if (getLangOpts().ObjCAutoRefCount && Synthesize)
1217 switch (getterMethod->getMethodFamily()) {
1218 case OMF_retain:
1219 case OMF_retainCount:
1220 case OMF_release:
1221 case OMF_autorelease:
1222 Diag(getterMethod->getLocation(), diag::err_arc_illegal_method_def)
1223 << 1 << getterMethod->getSelector();
1224 break;
1225 default:
1226 break;
1227 }
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001228 }
1229 if (ObjCMethodDecl *setterMethod = property->getSetterMethodDecl()) {
1230 setterMethod->createImplicitParams(Context, IDecl);
Eli Friedmane4c043d2012-05-01 22:26:06 +00001231 if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
1232 Ivar->getType()->isRecordType()) {
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001233 // FIXME. Eventually we want to do this for Objective-C as well.
Eli Friedman9a14db32012-10-18 20:14:08 +00001234 SynthesizedFunctionScope Scope(*this, setterMethod);
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001235 ImplicitParamDecl *SelfDecl = setterMethod->getSelfDecl();
1236 DeclRefExpr *SelfExpr =
John McCallf4b88a42012-03-10 09:33:50 +00001237 new (Context) DeclRefExpr(SelfDecl, false, SelfDecl->getType(),
Eli Friedman9a14db32012-10-18 20:14:08 +00001238 VK_RValue, PropertyDiagLoc);
1239 MarkDeclRefReferenced(SelfExpr);
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001240 Expr *lhs =
Eli Friedman9a14db32012-10-18 20:14:08 +00001241 new (Context) ObjCIvarRefExpr(Ivar, Ivar->getType(), PropertyDiagLoc,
Fariborz Jahanian0c701812013-04-02 18:57:54 +00001242 Ivar->getLocation(),
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001243 SelfExpr, true, true);
1244 ObjCMethodDecl::param_iterator P = setterMethod->param_begin();
1245 ParmVarDecl *Param = (*P);
John McCall3c3b7f92011-10-25 17:37:35 +00001246 QualType T = Param->getType().getNonReferenceType();
Eli Friedman9a14db32012-10-18 20:14:08 +00001247 DeclRefExpr *rhs = new (Context) DeclRefExpr(Param, false, T,
1248 VK_LValue, PropertyDiagLoc);
1249 MarkDeclRefReferenced(rhs);
1250 ExprResult Res = BuildBinOp(S, PropertyDiagLoc,
John McCall2de56d12010-08-25 11:45:40 +00001251 BO_Assign, lhs, rhs);
Fariborz Jahanian57e264e2011-10-06 18:38:18 +00001252 if (property->getPropertyAttributes() &
1253 ObjCPropertyDecl::OBJC_PR_atomic) {
1254 Expr *callExpr = Res.takeAs<Expr>();
1255 if (const CXXOperatorCallExpr *CXXCE =
Fariborz Jahanian13bf6332011-10-07 21:08:14 +00001256 dyn_cast_or_null<CXXOperatorCallExpr>(callExpr))
1257 if (const FunctionDecl *FuncDecl = CXXCE->getDirectCallee())
Fariborz Jahanian57e264e2011-10-06 18:38:18 +00001258 if (!FuncDecl->isTrivial())
Fariborz Jahanian20abee62012-01-10 00:37:01 +00001259 if (property->getType()->isReferenceType()) {
Eli Friedman9a14db32012-10-18 20:14:08 +00001260 Diag(PropertyDiagLoc,
Fariborz Jahanian20abee62012-01-10 00:37:01 +00001261 diag::err_atomic_property_nontrivial_assign_op)
Fariborz Jahanian57e264e2011-10-06 18:38:18 +00001262 << property->getType();
Fariborz Jahanian20abee62012-01-10 00:37:01 +00001263 Diag(FuncDecl->getLocStart(),
1264 diag::note_callee_decl) << FuncDecl;
1265 }
Fariborz Jahanian57e264e2011-10-06 18:38:18 +00001266 }
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001267 PIDecl->setSetterCXXAssignment(Res.takeAs<Expr>());
1268 }
1269 }
1270
Ted Kremenek28685ab2010-03-12 00:46:40 +00001271 if (IC) {
1272 if (Synthesize)
1273 if (ObjCPropertyImplDecl *PPIDecl =
1274 IC->FindPropertyImplIvarDecl(PropertyIvar)) {
1275 Diag(PropertyLoc, diag::error_duplicate_ivar_use)
1276 << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
1277 << PropertyIvar;
1278 Diag(PPIDecl->getLocation(), diag::note_previous_use);
1279 }
1280
1281 if (ObjCPropertyImplDecl *PPIDecl
1282 = IC->FindPropertyImplDecl(PropertyId)) {
1283 Diag(PropertyLoc, diag::error_property_implemented) << PropertyId;
1284 Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
John McCalld226f652010-08-21 09:40:31 +00001285 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +00001286 }
1287 IC->addPropertyImplementation(PIDecl);
David Blaikie4e4d0842012-03-11 07:00:24 +00001288 if (getLangOpts().ObjCDefaultSynthProperties &&
John McCall260611a2012-06-20 06:18:46 +00001289 getLangOpts().ObjCRuntime.isNonFragile() &&
Ted Kremenek71207fc2012-01-05 22:47:47 +00001290 !IDecl->isObjCRequiresPropertyDefs()) {
Fariborz Jahanianad51e742010-07-17 00:59:30 +00001291 // Diagnose if an ivar was lazily synthesdized due to a previous
1292 // use and if 1) property is @dynamic or 2) property is synthesized
Fariborz Jahaniancdaa6a82010-08-24 18:48:05 +00001293 // but it requires an ivar of different name.
Fariborz Jahanian411c25c2011-01-20 23:34:25 +00001294 ObjCInterfaceDecl *ClassDeclared=0;
Fariborz Jahanianad51e742010-07-17 00:59:30 +00001295 ObjCIvarDecl *Ivar = 0;
1296 if (!Synthesize)
1297 Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
1298 else {
1299 if (PropertyIvar && PropertyIvar != PropertyId)
1300 Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
1301 }
Fariborz Jahaniancdaa6a82010-08-24 18:48:05 +00001302 // Issue diagnostics only if Ivar belongs to current class.
1303 if (Ivar && Ivar->getSynthesize() &&
Douglas Gregor60ef3082011-12-15 00:29:59 +00001304 declaresSameEntity(IC->getClassInterface(), ClassDeclared)) {
Fariborz Jahanianad51e742010-07-17 00:59:30 +00001305 Diag(Ivar->getLocation(), diag::err_undeclared_var_use)
1306 << PropertyId;
1307 Ivar->setInvalidDecl();
1308 }
1309 }
Ted Kremenek28685ab2010-03-12 00:46:40 +00001310 } else {
1311 if (Synthesize)
1312 if (ObjCPropertyImplDecl *PPIDecl =
1313 CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001314 Diag(PropertyDiagLoc, diag::error_duplicate_ivar_use)
Ted Kremenek28685ab2010-03-12 00:46:40 +00001315 << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
1316 << PropertyIvar;
1317 Diag(PPIDecl->getLocation(), diag::note_previous_use);
1318 }
1319
1320 if (ObjCPropertyImplDecl *PPIDecl =
1321 CatImplClass->FindPropertyImplDecl(PropertyId)) {
Eli Friedmane4c043d2012-05-01 22:26:06 +00001322 Diag(PropertyDiagLoc, diag::error_property_implemented) << PropertyId;
Ted Kremenek28685ab2010-03-12 00:46:40 +00001323 Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
John McCalld226f652010-08-21 09:40:31 +00001324 return 0;
Ted Kremenek28685ab2010-03-12 00:46:40 +00001325 }
1326 CatImplClass->addPropertyImplementation(PIDecl);
1327 }
1328
John McCalld226f652010-08-21 09:40:31 +00001329 return PIDecl;
Ted Kremenek28685ab2010-03-12 00:46:40 +00001330}
1331
1332//===----------------------------------------------------------------------===//
1333// Helper methods.
1334//===----------------------------------------------------------------------===//
1335
Ted Kremenek9d64c152010-03-12 00:38:38 +00001336/// DiagnosePropertyMismatch - Compares two properties for their
1337/// attributes and types and warns on a variety of inconsistencies.
1338///
1339void
1340Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
1341 ObjCPropertyDecl *SuperProperty,
1342 const IdentifierInfo *inheritedName) {
1343 ObjCPropertyDecl::PropertyAttributeKind CAttr =
1344 Property->getPropertyAttributes();
1345 ObjCPropertyDecl::PropertyAttributeKind SAttr =
1346 SuperProperty->getPropertyAttributes();
1347 if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly)
1348 && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite))
1349 Diag(Property->getLocation(), diag::warn_readonly_property)
1350 << Property->getDeclName() << inheritedName;
1351 if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy)
1352 != (SAttr & ObjCPropertyDecl::OBJC_PR_copy))
1353 Diag(Property->getLocation(), diag::warn_property_attribute)
1354 << Property->getDeclName() << "copy" << inheritedName;
Fariborz Jahanian1b46d8d2011-10-08 17:45:33 +00001355 else if (!(SAttr & ObjCPropertyDecl::OBJC_PR_readonly)){
John McCallf85e1932011-06-15 23:02:42 +00001356 unsigned CAttrRetain =
1357 (CAttr &
1358 (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
1359 unsigned SAttrRetain =
1360 (SAttr &
1361 (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
1362 bool CStrong = (CAttrRetain != 0);
1363 bool SStrong = (SAttrRetain != 0);
1364 if (CStrong != SStrong)
1365 Diag(Property->getLocation(), diag::warn_property_attribute)
1366 << Property->getDeclName() << "retain (or strong)" << inheritedName;
1367 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001368
1369 if ((CAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)
Fariborz Jahanianb7b25652013-02-10 00:16:04 +00001370 != (SAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00001371 Diag(Property->getLocation(), diag::warn_property_attribute)
1372 << Property->getDeclName() << "atomic" << inheritedName;
Fariborz Jahanianb7b25652013-02-10 00:16:04 +00001373 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1374 }
1375 if (Property->getSetterName() != SuperProperty->getSetterName()) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00001376 Diag(Property->getLocation(), diag::warn_property_attribute)
1377 << Property->getDeclName() << "setter" << inheritedName;
Fariborz Jahanianb7b25652013-02-10 00:16:04 +00001378 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1379 }
1380 if (Property->getGetterName() != SuperProperty->getGetterName()) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00001381 Diag(Property->getLocation(), diag::warn_property_attribute)
1382 << Property->getDeclName() << "getter" << inheritedName;
Fariborz Jahanianb7b25652013-02-10 00:16:04 +00001383 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1384 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001385
1386 QualType LHSType =
1387 Context.getCanonicalType(SuperProperty->getType());
1388 QualType RHSType =
1389 Context.getCanonicalType(Property->getType());
1390
Fariborz Jahanianc286f382011-07-12 22:05:16 +00001391 if (!Context.propertyTypesAreCompatible(LHSType, RHSType)) {
Fariborz Jahanian8beb6a22011-07-13 17:55:01 +00001392 // Do cases not handled in above.
1393 // FIXME. For future support of covariant property types, revisit this.
1394 bool IncompatibleObjC = false;
1395 QualType ConvertedType;
1396 if (!isObjCPointerConversion(RHSType, LHSType,
1397 ConvertedType, IncompatibleObjC) ||
Fariborz Jahanian13546a82011-10-12 00:00:57 +00001398 IncompatibleObjC) {
Fariborz Jahanian8beb6a22011-07-13 17:55:01 +00001399 Diag(Property->getLocation(), diag::warn_property_types_are_incompatible)
1400 << Property->getType() << SuperProperty->getType() << inheritedName;
Fariborz Jahanian13546a82011-10-12 00:00:57 +00001401 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1402 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001403 }
1404}
1405
1406bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property,
1407 ObjCMethodDecl *GetterMethod,
1408 SourceLocation Loc) {
Fariborz Jahanian9abf88c2012-05-15 22:37:04 +00001409 if (!GetterMethod)
1410 return false;
1411 QualType GetterType = GetterMethod->getResultType().getNonReferenceType();
1412 QualType PropertyIvarType = property->getType().getNonReferenceType();
1413 bool compat = Context.hasSameType(PropertyIvarType, GetterType);
1414 if (!compat) {
1415 if (isa<ObjCObjectPointerType>(PropertyIvarType) &&
1416 isa<ObjCObjectPointerType>(GetterType))
1417 compat =
1418 Context.canAssignObjCInterfaces(
Fariborz Jahanian490a52b2012-05-29 19:56:01 +00001419 GetterType->getAs<ObjCObjectPointerType>(),
1420 PropertyIvarType->getAs<ObjCObjectPointerType>());
1421 else if (CheckAssignmentConstraints(Loc, GetterType, PropertyIvarType)
Fariborz Jahanian9abf88c2012-05-15 22:37:04 +00001422 != Compatible) {
1423 Diag(Loc, diag::error_property_accessor_type)
1424 << property->getDeclName() << PropertyIvarType
1425 << GetterMethod->getSelector() << GetterType;
1426 Diag(GetterMethod->getLocation(), diag::note_declared_at);
1427 return true;
1428 } else {
1429 compat = true;
1430 QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
1431 QualType rhsType =Context.getCanonicalType(GetterType).getUnqualifiedType();
1432 if (lhsType != rhsType && lhsType->isArithmeticType())
1433 compat = false;
Ted Kremenek9d64c152010-03-12 00:38:38 +00001434 }
1435 }
Fariborz Jahanian9abf88c2012-05-15 22:37:04 +00001436
1437 if (!compat) {
1438 Diag(Loc, diag::warn_accessor_property_type_mismatch)
1439 << property->getDeclName()
1440 << GetterMethod->getSelector();
1441 Diag(GetterMethod->getLocation(), diag::note_declared_at);
1442 return true;
1443 }
1444
Ted Kremenek9d64c152010-03-12 00:38:38 +00001445 return false;
1446}
1447
Ted Kremenek9d64c152010-03-12 00:38:38 +00001448/// MatchOneProtocolPropertiesInClass - This routine goes thru the list
1449/// of properties declared in a protocol and compares their attribute against
1450/// the same property declared in the class or category.
1451void
Douglas Gregor0dfe23c2013-01-21 18:35:55 +00001452Sema::MatchOneProtocolPropertiesInClass(Decl *CDecl, ObjCProtocolDecl *PDecl) {
1453 if (!CDecl)
1454 return;
1455
1456 // Category case.
1457 if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CDecl)) {
1458 // FIXME: We should perform this check when the property in the category
1459 // is declared.
Ted Kremenek9d64c152010-03-12 00:38:38 +00001460 assert (CatDecl && "MatchOneProtocolPropertiesInClass");
1461 if (!CatDecl->IsClassExtension())
1462 for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1463 E = PDecl->prop_end(); P != E; ++P) {
Douglas Gregor0dfe23c2013-01-21 18:35:55 +00001464 ObjCPropertyDecl *ProtoProp = *P;
1465 DeclContext::lookup_result R
1466 = CatDecl->lookup(ProtoProp->getDeclName());
1467 for (unsigned I = 0, N = R.size(); I != N; ++I) {
1468 if (ObjCPropertyDecl *CatProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
1469 if (CatProp != ProtoProp) {
1470 // Property protocol already exist in class. Diagnose any mismatch.
1471 DiagnosePropertyMismatch(CatProp, ProtoProp,
1472 PDecl->getIdentifier());
1473 }
1474 }
1475 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001476 }
1477 return;
1478 }
Douglas Gregor0dfe23c2013-01-21 18:35:55 +00001479
1480 // Class
1481 // FIXME: We should perform this check when the property in the class
1482 // is declared.
1483 ObjCInterfaceDecl *IDecl = cast<ObjCInterfaceDecl>(CDecl);
Ted Kremenek9d64c152010-03-12 00:38:38 +00001484 for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
Douglas Gregor0dfe23c2013-01-21 18:35:55 +00001485 E = PDecl->prop_end(); P != E; ++P) {
1486 ObjCPropertyDecl *ProtoProp = *P;
1487 DeclContext::lookup_result R
Douglas Gregoraabd0942013-01-21 19:05:22 +00001488 = IDecl->lookup(ProtoProp->getDeclName());
Douglas Gregor0dfe23c2013-01-21 18:35:55 +00001489 for (unsigned I = 0, N = R.size(); I != N; ++I) {
1490 if (ObjCPropertyDecl *ClassProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
1491 if (ClassProp != ProtoProp) {
1492 // Property protocol already exist in class. Diagnose any mismatch.
1493 DiagnosePropertyMismatch(ClassProp, ProtoProp,
1494 PDecl->getIdentifier());
1495 }
1496 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001497 }
Douglas Gregor0dfe23c2013-01-21 18:35:55 +00001498 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001499}
1500
Ted Kremenek9d64c152010-03-12 00:38:38 +00001501/// isPropertyReadonly - Return true if property is readonly, by searching
1502/// for the property in the class and in its categories and implementations
1503///
1504bool Sema::isPropertyReadonly(ObjCPropertyDecl *PDecl,
1505 ObjCInterfaceDecl *IDecl) {
1506 // by far the most common case.
1507 if (!PDecl->isReadOnly())
1508 return false;
1509 // Even if property is ready only, if interface has a user defined setter,
1510 // it is not considered read only.
1511 if (IDecl->getInstanceMethod(PDecl->getSetterName()))
1512 return false;
1513
1514 // Main class has the property as 'readonly'. Must search
1515 // through the category list to see if the property's
1516 // attribute has been over-ridden to 'readwrite'.
Douglas Gregord3297242013-01-16 23:00:23 +00001517 for (ObjCInterfaceDecl::visible_categories_iterator
1518 Cat = IDecl->visible_categories_begin(),
1519 CatEnd = IDecl->visible_categories_end();
1520 Cat != CatEnd; ++Cat) {
1521 if (Cat->getInstanceMethod(PDecl->getSetterName()))
Ted Kremenek9d64c152010-03-12 00:38:38 +00001522 return false;
1523 ObjCPropertyDecl *P =
Douglas Gregord3297242013-01-16 23:00:23 +00001524 Cat->FindPropertyDeclaration(PDecl->getIdentifier());
Ted Kremenek9d64c152010-03-12 00:38:38 +00001525 if (P && !P->isReadOnly())
1526 return false;
1527 }
1528
1529 // Also, check for definition of a setter method in the implementation if
1530 // all else failed.
1531 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurContext)) {
1532 if (ObjCImplementationDecl *IMD =
1533 dyn_cast<ObjCImplementationDecl>(OMD->getDeclContext())) {
1534 if (IMD->getInstanceMethod(PDecl->getSetterName()))
1535 return false;
1536 } else if (ObjCCategoryImplDecl *CIMD =
1537 dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) {
1538 if (CIMD->getInstanceMethod(PDecl->getSetterName()))
1539 return false;
1540 }
1541 }
1542 // Lastly, look through the implementation (if one is in scope).
1543 if (ObjCImplementationDecl *ImpDecl = IDecl->getImplementation())
1544 if (ImpDecl->getInstanceMethod(PDecl->getSetterName()))
1545 return false;
1546 // If all fails, look at the super class.
1547 if (ObjCInterfaceDecl *SIDecl = IDecl->getSuperClass())
1548 return isPropertyReadonly(PDecl, SIDecl);
1549 return true;
1550}
1551
1552/// CollectImmediateProperties - This routine collects all properties in
Douglas Gregor0dfe23c2013-01-21 18:35:55 +00001553/// the class and its conforming protocols; but not those in its super class.
Ted Kremenek9d64c152010-03-12 00:38:38 +00001554void Sema::CollectImmediateProperties(ObjCContainerDecl *CDecl,
Anna Zakse63aedd2012-10-31 01:18:22 +00001555 ObjCContainerDecl::PropertyMap &PropMap,
1556 ObjCContainerDecl::PropertyMap &SuperPropMap) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00001557 if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
1558 for (ObjCContainerDecl::prop_iterator P = IDecl->prop_begin(),
1559 E = IDecl->prop_end(); P != E; ++P) {
David Blaikie581deb32012-06-06 20:45:41 +00001560 ObjCPropertyDecl *Prop = *P;
Ted Kremenek9d64c152010-03-12 00:38:38 +00001561 PropMap[Prop->getIdentifier()] = Prop;
1562 }
1563 // scan through class's protocols.
Ted Kremenek53b94412010-09-01 01:21:15 +00001564 for (ObjCInterfaceDecl::all_protocol_iterator
1565 PI = IDecl->all_referenced_protocol_begin(),
1566 E = IDecl->all_referenced_protocol_end(); PI != E; ++PI)
Fariborz Jahaniancfa6a272010-06-29 18:12:32 +00001567 CollectImmediateProperties((*PI), PropMap, SuperPropMap);
Ted Kremenek9d64c152010-03-12 00:38:38 +00001568 }
1569 if (ObjCCategoryDecl *CATDecl = dyn_cast<ObjCCategoryDecl>(CDecl)) {
1570 if (!CATDecl->IsClassExtension())
1571 for (ObjCContainerDecl::prop_iterator P = CATDecl->prop_begin(),
1572 E = CATDecl->prop_end(); P != E; ++P) {
David Blaikie581deb32012-06-06 20:45:41 +00001573 ObjCPropertyDecl *Prop = *P;
Ted Kremenek9d64c152010-03-12 00:38:38 +00001574 PropMap[Prop->getIdentifier()] = Prop;
1575 }
1576 // scan through class's protocols.
Ted Kremenek53b94412010-09-01 01:21:15 +00001577 for (ObjCCategoryDecl::protocol_iterator PI = CATDecl->protocol_begin(),
Ted Kremenek9d64c152010-03-12 00:38:38 +00001578 E = CATDecl->protocol_end(); PI != E; ++PI)
Fariborz Jahaniancfa6a272010-06-29 18:12:32 +00001579 CollectImmediateProperties((*PI), PropMap, SuperPropMap);
Ted Kremenek9d64c152010-03-12 00:38:38 +00001580 }
1581 else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(CDecl)) {
1582 for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1583 E = PDecl->prop_end(); P != E; ++P) {
David Blaikie581deb32012-06-06 20:45:41 +00001584 ObjCPropertyDecl *Prop = *P;
Fariborz Jahaniancfa6a272010-06-29 18:12:32 +00001585 ObjCPropertyDecl *PropertyFromSuper = SuperPropMap[Prop->getIdentifier()];
1586 // Exclude property for protocols which conform to class's super-class,
1587 // as super-class has to implement the property.
Fariborz Jahaniana929ec72011-09-27 00:23:52 +00001588 if (!PropertyFromSuper ||
1589 PropertyFromSuper->getIdentifier() != Prop->getIdentifier()) {
Fariborz Jahaniancfa6a272010-06-29 18:12:32 +00001590 ObjCPropertyDecl *&PropEntry = PropMap[Prop->getIdentifier()];
1591 if (!PropEntry)
1592 PropEntry = Prop;
1593 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001594 }
1595 // scan through protocol's protocols.
1596 for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1597 E = PDecl->protocol_end(); PI != E; ++PI)
Fariborz Jahaniancfa6a272010-06-29 18:12:32 +00001598 CollectImmediateProperties((*PI), PropMap, SuperPropMap);
Ted Kremenek9d64c152010-03-12 00:38:38 +00001599 }
1600}
1601
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001602/// CollectSuperClassPropertyImplementations - This routine collects list of
1603/// properties to be implemented in super class(s) and also coming from their
1604/// conforming protocols.
1605static void CollectSuperClassPropertyImplementations(ObjCInterfaceDecl *CDecl,
Anna Zakse63aedd2012-10-31 01:18:22 +00001606 ObjCInterfaceDecl::PropertyMap &PropMap) {
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001607 if (ObjCInterfaceDecl *SDecl = CDecl->getSuperClass()) {
Fariborz Jahaniancfaed8d2013-02-14 22:33:34 +00001608 ObjCInterfaceDecl::PropertyDeclOrder PO;
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001609 while (SDecl) {
Fariborz Jahaniancfaed8d2013-02-14 22:33:34 +00001610 SDecl->collectPropertiesToImplement(PropMap, PO);
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001611 SDecl = SDecl->getSuperClass();
1612 }
1613 }
1614}
1615
Fariborz Jahanian26202292013-02-14 19:07:19 +00001616/// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
1617/// an ivar synthesized for 'Method' and 'Method' is a property accessor
1618/// declared in class 'IFace'.
1619bool
1620Sema::IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
1621 ObjCMethodDecl *Method, ObjCIvarDecl *IV) {
1622 if (!IV->getSynthesize())
1623 return false;
1624 ObjCMethodDecl *IMD = IFace->lookupMethod(Method->getSelector(),
1625 Method->isInstanceMethod());
1626 if (!IMD || !IMD->isPropertyAccessor())
1627 return false;
1628
1629 // look up a property declaration whose one of its accessors is implemented
1630 // by this method.
1631 for (ObjCContainerDecl::prop_iterator P = IFace->prop_begin(),
1632 E = IFace->prop_end(); P != E; ++P) {
1633 ObjCPropertyDecl *property = *P;
1634 if ((property->getGetterName() == IMD->getSelector() ||
1635 property->getSetterName() == IMD->getSelector()) &&
1636 (property->getPropertyIvarDecl() == IV))
1637 return true;
1638 }
1639 return false;
1640}
1641
1642
James Dennett699c9042012-06-15 07:13:21 +00001643/// \brief Default synthesizes all properties which must be synthesized
1644/// in class's \@implementation.
Ted Kremenekd2ee8092011-09-27 23:39:40 +00001645void Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl* IMPDecl,
1646 ObjCInterfaceDecl *IDecl) {
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001647
Anna Zaksb36ea372012-10-18 19:17:53 +00001648 ObjCInterfaceDecl::PropertyMap PropMap;
Fariborz Jahaniancfaed8d2013-02-14 22:33:34 +00001649 ObjCInterfaceDecl::PropertyDeclOrder PropertyOrder;
1650 IDecl->collectPropertiesToImplement(PropMap, PropertyOrder);
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001651 if (PropMap.empty())
1652 return;
Anna Zaksb36ea372012-10-18 19:17:53 +00001653 ObjCInterfaceDecl::PropertyMap SuperPropMap;
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001654 CollectSuperClassPropertyImplementations(IDecl, SuperPropMap);
1655
Fariborz Jahaniancfaed8d2013-02-14 22:33:34 +00001656 for (unsigned i = 0, e = PropertyOrder.size(); i != e; i++) {
1657 ObjCPropertyDecl *Prop = PropertyOrder[i];
Fariborz Jahanian6071af92013-06-07 20:26:51 +00001658 // Is there a matching property synthesize/dynamic?
1659 if (Prop->isInvalidDecl() ||
1660 Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1661 continue;
1662 // Property may have been synthesized by user.
1663 if (IMPDecl->FindPropertyImplDecl(Prop->getIdentifier()))
1664 continue;
1665 if (IMPDecl->getInstanceMethod(Prop->getGetterName())) {
1666 if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
1667 continue;
1668 if (IMPDecl->getInstanceMethod(Prop->getSetterName()))
1669 continue;
1670 }
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001671 // If property to be implemented in the super class, ignore.
Fariborz Jahanian6114a3c2013-03-12 19:46:17 +00001672 if (SuperPropMap[Prop->getIdentifier()]) {
1673 ObjCPropertyDecl *PropInSuperClass = SuperPropMap[Prop->getIdentifier()];
1674 if ((Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readwrite) &&
1675 (PropInSuperClass->getPropertyAttributes() &
Fariborz Jahanian1d0d2fe2013-03-12 22:22:38 +00001676 ObjCPropertyDecl::OBJC_PR_readonly) &&
Fariborz Jahanian5bdaef52013-03-21 20:50:53 +00001677 !IMPDecl->getInstanceMethod(Prop->getSetterName()) &&
1678 !IDecl->HasUserDeclaredSetterMethod(Prop)) {
Fariborz Jahanian6114a3c2013-03-12 19:46:17 +00001679 Diag(Prop->getLocation(), diag::warn_no_autosynthesis_property)
1680 << Prop->getIdentifier()->getName();
1681 Diag(PropInSuperClass->getLocation(), diag::note_property_declare);
1682 }
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001683 continue;
Fariborz Jahanian6114a3c2013-03-12 19:46:17 +00001684 }
Fariborz Jahaniana6ba40c2013-06-07 18:32:55 +00001685 if (ObjCPropertyImplDecl *PID =
1686 IMPDecl->FindPropertyImplIvarDecl(Prop->getIdentifier())) {
1687 if (PID->getPropertyDecl() != Prop) {
1688 Diag(Prop->getLocation(), diag::warn_no_autosynthesis_shared_ivar_property)
1689 << Prop->getIdentifier()->getName();
1690 if (!PID->getLocation().isInvalid())
1691 Diag(PID->getLocation(), diag::note_property_synthesize);
1692 }
1693 continue;
1694 }
Fariborz Jahanianf8aba8c2011-12-15 01:03:18 +00001695 if (isa<ObjCProtocolDecl>(Prop->getDeclContext())) {
1696 // We won't auto-synthesize properties declared in protocols.
1697 Diag(IMPDecl->getLocation(),
1698 diag::warn_auto_synthesizing_protocol_property);
1699 Diag(Prop->getLocation(), diag::note_property_declare);
1700 continue;
1701 }
Ted Kremenek2a6af6b2010-09-24 01:23:01 +00001702
1703 // We use invalid SourceLocations for the synthesized ivars since they
1704 // aren't really synthesized at a particular location; they just exist.
1705 // Saying that they are located at the @implementation isn't really going
1706 // to help users.
Fariborz Jahanian975eef62012-05-03 16:43:30 +00001707 ObjCPropertyImplDecl *PIDecl = dyn_cast_or_null<ObjCPropertyImplDecl>(
1708 ActOnPropertyImplDecl(S, SourceLocation(), SourceLocation(),
1709 true,
1710 /* property = */ Prop->getIdentifier(),
Anna Zaksad0ce532012-09-27 19:45:11 +00001711 /* ivar = */ Prop->getDefaultSynthIvarName(Context),
Argyrios Kyrtzidis390fff82012-06-08 02:16:11 +00001712 Prop->getLocation()));
Fariborz Jahanian975eef62012-05-03 16:43:30 +00001713 if (PIDecl) {
1714 Diag(Prop->getLocation(), diag::warn_missing_explicit_synthesis);
Fariborz Jahanian5ea66612012-05-08 18:03:39 +00001715 Diag(IMPDecl->getLocation(), diag::note_while_in_implementation);
Fariborz Jahanian975eef62012-05-03 16:43:30 +00001716 }
Ted Kremenek2a6af6b2010-09-24 01:23:01 +00001717 }
Fariborz Jahanian509d4772010-05-14 18:35:57 +00001718}
Ted Kremenek9d64c152010-03-12 00:38:38 +00001719
Fariborz Jahanian8697d302011-08-31 22:24:06 +00001720void Sema::DefaultSynthesizeProperties(Scope *S, Decl *D) {
John McCall260611a2012-06-20 06:18:46 +00001721 if (!LangOpts.ObjCDefaultSynthProperties || LangOpts.ObjCRuntime.isFragile())
Fariborz Jahanian8697d302011-08-31 22:24:06 +00001722 return;
1723 ObjCImplementationDecl *IC=dyn_cast_or_null<ObjCImplementationDecl>(D);
1724 if (!IC)
1725 return;
1726 if (ObjCInterfaceDecl* IDecl = IC->getClassInterface())
Ted Kremenek71207fc2012-01-05 22:47:47 +00001727 if (!IDecl->isObjCRequiresPropertyDefs())
Fariborz Jahanianeb4f2c52012-01-03 19:46:00 +00001728 DefaultSynthesizeProperties(S, IC, IDecl);
Fariborz Jahanian8697d302011-08-31 22:24:06 +00001729}
1730
Fariborz Jahanian17cb3262010-05-05 21:52:17 +00001731void Sema::DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
Fariborz Jahanianc775b1a2013-04-24 17:06:38 +00001732 ObjCContainerDecl *CDecl) {
Fariborz Jahanian277076a2012-12-19 18:58:55 +00001733 ObjCContainerDecl::PropertyMap NoNeedToImplPropMap;
1734 ObjCInterfaceDecl *IDecl;
1735 // Gather properties which need not be implemented in this class
1736 // or category.
1737 if (!(IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)))
1738 if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
1739 // For categories, no need to implement properties declared in
1740 // its primary class (and its super classes) if property is
1741 // declared in one of those containers.
Fariborz Jahaniancfaed8d2013-02-14 22:33:34 +00001742 if ((IDecl = C->getClassInterface())) {
1743 ObjCInterfaceDecl::PropertyDeclOrder PO;
1744 IDecl->collectPropertiesToImplement(NoNeedToImplPropMap, PO);
1745 }
Fariborz Jahanian277076a2012-12-19 18:58:55 +00001746 }
1747 if (IDecl)
1748 CollectSuperClassPropertyImplementations(IDecl, NoNeedToImplPropMap);
Fariborz Jahaniancfa6a272010-06-29 18:12:32 +00001749
Anna Zaksb36ea372012-10-18 19:17:53 +00001750 ObjCContainerDecl::PropertyMap PropMap;
Fariborz Jahanian277076a2012-12-19 18:58:55 +00001751 CollectImmediateProperties(CDecl, PropMap, NoNeedToImplPropMap);
Ted Kremenek9d64c152010-03-12 00:38:38 +00001752 if (PropMap.empty())
1753 return;
1754
1755 llvm::DenseSet<ObjCPropertyDecl *> PropImplMap;
1756 for (ObjCImplDecl::propimpl_iterator
1757 I = IMPDecl->propimpl_begin(),
1758 EI = IMPDecl->propimpl_end(); I != EI; ++I)
David Blaikie262bc182012-04-30 02:36:29 +00001759 PropImplMap.insert(I->getPropertyDecl());
Ted Kremenek9d64c152010-03-12 00:38:38 +00001760
Fariborz Jahanianc775b1a2013-04-24 17:06:38 +00001761 SelectorSet InsMap;
1762 // Collect property accessors implemented in current implementation.
1763 for (ObjCImplementationDecl::instmeth_iterator
1764 I = IMPDecl->instmeth_begin(), E = IMPDecl->instmeth_end(); I!=E; ++I)
1765 InsMap.insert((*I)->getSelector());
1766
1767 ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
1768 ObjCInterfaceDecl *PrimaryClass = 0;
1769 if (C && !C->IsClassExtension())
1770 if ((PrimaryClass = C->getClassInterface()))
1771 // Report unimplemented properties in the category as well.
1772 if (ObjCImplDecl *IMP = PrimaryClass->getImplementation()) {
1773 // When reporting on missing setter/getters, do not report when
1774 // setter/getter is implemented in category's primary class
1775 // implementation.
1776 for (ObjCImplementationDecl::instmeth_iterator
1777 I = IMP->instmeth_begin(), E = IMP->instmeth_end(); I!=E; ++I)
1778 InsMap.insert((*I)->getSelector());
1779 }
1780
Anna Zaksb36ea372012-10-18 19:17:53 +00001781 for (ObjCContainerDecl::PropertyMap::iterator
Ted Kremenek9d64c152010-03-12 00:38:38 +00001782 P = PropMap.begin(), E = PropMap.end(); P != E; ++P) {
1783 ObjCPropertyDecl *Prop = P->second;
1784 // Is there a matching propery synthesize/dynamic?
1785 if (Prop->isInvalidDecl() ||
1786 Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional ||
Douglas Gregor7cdc4572013-01-08 18:16:18 +00001787 PropImplMap.count(Prop) ||
1788 Prop->getAvailability() == AR_Unavailable)
Ted Kremenek9d64c152010-03-12 00:38:38 +00001789 continue;
Fariborz Jahanianc775b1a2013-04-24 17:06:38 +00001790 // When reporting on missing property getter implementation in
1791 // categories, do not report when they are declared in primary class,
1792 // class's protocol, or one of it super classes. This is because,
1793 // the class is going to implement them.
1794 if (!InsMap.count(Prop->getGetterName()) &&
1795 (PrimaryClass == 0 ||
Fariborz Jahanianf3f0f352013-04-25 21:59:34 +00001796 !PrimaryClass->lookupPropertyAccessor(Prop->getGetterName(), C))) {
Fariborz Jahanianb8607392011-08-27 21:55:47 +00001797 Diag(IMPDecl->getLocation(),
Ted Kremenek9d64c152010-03-12 00:38:38 +00001798 isa<ObjCCategoryDecl>(CDecl) ?
1799 diag::warn_setter_getter_impl_required_in_category :
1800 diag::warn_setter_getter_impl_required)
1801 << Prop->getDeclName() << Prop->getGetterName();
Fariborz Jahanianb8607392011-08-27 21:55:47 +00001802 Diag(Prop->getLocation(),
1803 diag::note_property_declare);
John McCall260611a2012-06-20 06:18:46 +00001804 if (LangOpts.ObjCDefaultSynthProperties && LangOpts.ObjCRuntime.isNonFragile())
Fariborz Jahanianda611a72012-01-04 23:16:13 +00001805 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CDecl))
Ted Kremenek71207fc2012-01-05 22:47:47 +00001806 if (const ObjCInterfaceDecl *RID = ID->isObjCRequiresPropertyDefs())
Fariborz Jahanianda611a72012-01-04 23:16:13 +00001807 Diag(RID->getLocation(), diag::note_suppressed_class_declare);
1808
Ted Kremenek9d64c152010-03-12 00:38:38 +00001809 }
Fariborz Jahanianc775b1a2013-04-24 17:06:38 +00001810 // When reporting on missing property setter implementation in
1811 // categories, do not report when they are declared in primary class,
1812 // class's protocol, or one of it super classes. This is because,
1813 // the class is going to implement them.
1814 if (!Prop->isReadOnly() && !InsMap.count(Prop->getSetterName()) &&
1815 (PrimaryClass == 0 ||
Fariborz Jahanianf3f0f352013-04-25 21:59:34 +00001816 !PrimaryClass->lookupPropertyAccessor(Prop->getSetterName(), C))) {
Fariborz Jahanianb8607392011-08-27 21:55:47 +00001817 Diag(IMPDecl->getLocation(),
Ted Kremenek9d64c152010-03-12 00:38:38 +00001818 isa<ObjCCategoryDecl>(CDecl) ?
1819 diag::warn_setter_getter_impl_required_in_category :
1820 diag::warn_setter_getter_impl_required)
1821 << Prop->getDeclName() << Prop->getSetterName();
Fariborz Jahanianb8607392011-08-27 21:55:47 +00001822 Diag(Prop->getLocation(),
1823 diag::note_property_declare);
John McCall260611a2012-06-20 06:18:46 +00001824 if (LangOpts.ObjCDefaultSynthProperties && LangOpts.ObjCRuntime.isNonFragile())
Fariborz Jahanianda611a72012-01-04 23:16:13 +00001825 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CDecl))
Ted Kremenek71207fc2012-01-05 22:47:47 +00001826 if (const ObjCInterfaceDecl *RID = ID->isObjCRequiresPropertyDefs())
Fariborz Jahanianda611a72012-01-04 23:16:13 +00001827 Diag(RID->getLocation(), diag::note_suppressed_class_declare);
Ted Kremenek9d64c152010-03-12 00:38:38 +00001828 }
1829 }
1830}
1831
1832void
1833Sema::AtomicPropertySetterGetterRules (ObjCImplDecl* IMPDecl,
1834 ObjCContainerDecl* IDecl) {
1835 // Rules apply in non-GC mode only
David Blaikie4e4d0842012-03-11 07:00:24 +00001836 if (getLangOpts().getGC() != LangOptions::NonGC)
Ted Kremenek9d64c152010-03-12 00:38:38 +00001837 return;
1838 for (ObjCContainerDecl::prop_iterator I = IDecl->prop_begin(),
1839 E = IDecl->prop_end();
1840 I != E; ++I) {
David Blaikie581deb32012-06-06 20:45:41 +00001841 ObjCPropertyDecl *Property = *I;
Argyrios Kyrtzidis94659e42011-01-31 21:34:11 +00001842 ObjCMethodDecl *GetterMethod = 0;
1843 ObjCMethodDecl *SetterMethod = 0;
1844 bool LookedUpGetterSetter = false;
1845
Bill Wendlingad017fa2012-12-20 19:22:21 +00001846 unsigned Attributes = Property->getPropertyAttributes();
John McCall265941b2011-09-13 18:31:23 +00001847 unsigned AttributesAsWritten = Property->getPropertyAttributesAsWritten();
Argyrios Kyrtzidis94659e42011-01-31 21:34:11 +00001848
John McCall265941b2011-09-13 18:31:23 +00001849 if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic) &&
1850 !(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
Argyrios Kyrtzidis94659e42011-01-31 21:34:11 +00001851 GetterMethod = IMPDecl->getInstanceMethod(Property->getGetterName());
1852 SetterMethod = IMPDecl->getInstanceMethod(Property->getSetterName());
1853 LookedUpGetterSetter = true;
1854 if (GetterMethod) {
1855 Diag(GetterMethod->getLocation(),
1856 diag::warn_default_atomic_custom_getter_setter)
Argyrios Kyrtzidis293a45e2011-01-31 23:20:03 +00001857 << Property->getIdentifier() << 0;
Argyrios Kyrtzidis94659e42011-01-31 21:34:11 +00001858 Diag(Property->getLocation(), diag::note_property_declare);
1859 }
1860 if (SetterMethod) {
1861 Diag(SetterMethod->getLocation(),
1862 diag::warn_default_atomic_custom_getter_setter)
Argyrios Kyrtzidis293a45e2011-01-31 23:20:03 +00001863 << Property->getIdentifier() << 1;
Argyrios Kyrtzidis94659e42011-01-31 21:34:11 +00001864 Diag(Property->getLocation(), diag::note_property_declare);
1865 }
1866 }
1867
Ted Kremenek9d64c152010-03-12 00:38:38 +00001868 // We only care about readwrite atomic property.
Bill Wendlingad017fa2012-12-20 19:22:21 +00001869 if ((Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) ||
1870 !(Attributes & ObjCPropertyDecl::OBJC_PR_readwrite))
Ted Kremenek9d64c152010-03-12 00:38:38 +00001871 continue;
1872 if (const ObjCPropertyImplDecl *PIDecl
1873 = IMPDecl->FindPropertyImplDecl(Property->getIdentifier())) {
1874 if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
1875 continue;
Argyrios Kyrtzidis94659e42011-01-31 21:34:11 +00001876 if (!LookedUpGetterSetter) {
1877 GetterMethod = IMPDecl->getInstanceMethod(Property->getGetterName());
1878 SetterMethod = IMPDecl->getInstanceMethod(Property->getSetterName());
1879 LookedUpGetterSetter = true;
1880 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00001881 if ((GetterMethod && !SetterMethod) || (!GetterMethod && SetterMethod)) {
1882 SourceLocation MethodLoc =
1883 (GetterMethod ? GetterMethod->getLocation()
1884 : SetterMethod->getLocation());
1885 Diag(MethodLoc, diag::warn_atomic_property_rule)
Fariborz Jahanian7d65f692011-10-06 23:47:58 +00001886 << Property->getIdentifier() << (GetterMethod != 0)
1887 << (SetterMethod != 0);
Fariborz Jahanian77bfb8b2012-02-29 22:18:55 +00001888 // fixit stuff.
1889 if (!AttributesAsWritten) {
1890 if (Property->getLParenLoc().isValid()) {
1891 // @property () ... case.
1892 SourceRange PropSourceRange(Property->getAtLoc(),
1893 Property->getLParenLoc());
1894 Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) <<
1895 FixItHint::CreateReplacement(PropSourceRange, "@property (nonatomic");
1896 }
1897 else {
1898 //@property id etc.
1899 SourceLocation endLoc =
1900 Property->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
1901 endLoc = endLoc.getLocWithOffset(-1);
1902 SourceRange PropSourceRange(Property->getAtLoc(), endLoc);
1903 Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) <<
1904 FixItHint::CreateReplacement(PropSourceRange, "@property (nonatomic) ");
1905 }
1906 }
1907 else if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic)) {
1908 // @property () ... case.
1909 SourceLocation endLoc = Property->getLParenLoc();
1910 SourceRange PropSourceRange(Property->getAtLoc(), endLoc);
1911 Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) <<
1912 FixItHint::CreateReplacement(PropSourceRange, "@property (nonatomic, ");
1913 }
1914 else
1915 Diag(MethodLoc, diag::note_atomic_property_fixup_suggest);
Ted Kremenek9d64c152010-03-12 00:38:38 +00001916 Diag(Property->getLocation(), diag::note_property_declare);
1917 }
1918 }
1919 }
1920}
1921
John McCallf85e1932011-06-15 23:02:42 +00001922void Sema::DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001923 if (getLangOpts().getGC() == LangOptions::GCOnly)
John McCallf85e1932011-06-15 23:02:42 +00001924 return;
1925
1926 for (ObjCImplementationDecl::propimpl_iterator
1927 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00001928 ObjCPropertyImplDecl *PID = *i;
John McCallf85e1932011-06-15 23:02:42 +00001929 if (PID->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
1930 continue;
1931
1932 const ObjCPropertyDecl *PD = PID->getPropertyDecl();
Fariborz Jahanian831fb962011-06-25 00:17:46 +00001933 if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() &&
1934 !D->getInstanceMethod(PD->getGetterName())) {
John McCallf85e1932011-06-15 23:02:42 +00001935 ObjCMethodDecl *method = PD->getGetterMethodDecl();
1936 if (!method)
1937 continue;
1938 ObjCMethodFamily family = method->getMethodFamily();
1939 if (family == OMF_alloc || family == OMF_copy ||
1940 family == OMF_mutableCopy || family == OMF_new) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001941 if (getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +00001942 Diag(PID->getLocation(), diag::err_ownin_getter_rule);
1943 else
Ted Kremenek920c9c12011-10-12 18:03:37 +00001944 Diag(PID->getLocation(), diag::warn_owning_getter_rule);
John McCallf85e1932011-06-15 23:02:42 +00001945 Diag(PD->getLocation(), diag::note_property_declare);
1946 }
1947 }
1948 }
1949}
1950
John McCall5de74d12010-11-10 07:01:40 +00001951/// AddPropertyAttrs - Propagates attributes from a property to the
1952/// implicitly-declared getter or setter for that property.
1953static void AddPropertyAttrs(Sema &S, ObjCMethodDecl *PropertyMethod,
1954 ObjCPropertyDecl *Property) {
1955 // Should we just clone all attributes over?
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001956 for (Decl::attr_iterator A = Property->attr_begin(),
1957 AEnd = Property->attr_end();
1958 A != AEnd; ++A) {
1959 if (isa<DeprecatedAttr>(*A) ||
1960 isa<UnavailableAttr>(*A) ||
1961 isa<AvailabilityAttr>(*A))
1962 PropertyMethod->addAttr((*A)->clone(S.Context));
1963 }
John McCall5de74d12010-11-10 07:01:40 +00001964}
1965
Ted Kremenek9d64c152010-03-12 00:38:38 +00001966/// ProcessPropertyDecl - Make sure that any user-defined setter/getter methods
1967/// have the property type and issue diagnostics if they don't.
1968/// Also synthesize a getter/setter method if none exist (and update the
1969/// appropriate lookup tables. FIXME: Should reconsider if adding synthesized
1970/// methods is the "right" thing to do.
1971void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property,
Ted Kremenek8254aa62010-09-21 18:28:43 +00001972 ObjCContainerDecl *CD,
1973 ObjCPropertyDecl *redeclaredProperty,
1974 ObjCContainerDecl *lexicalDC) {
1975
Ted Kremenek9d64c152010-03-12 00:38:38 +00001976 ObjCMethodDecl *GetterMethod, *SetterMethod;
1977
1978 GetterMethod = CD->getInstanceMethod(property->getGetterName());
1979 SetterMethod = CD->getInstanceMethod(property->getSetterName());
1980 DiagnosePropertyAccessorMismatch(property, GetterMethod,
1981 property->getLocation());
1982
1983 if (SetterMethod) {
1984 ObjCPropertyDecl::PropertyAttributeKind CAttr =
1985 property->getPropertyAttributes();
1986 if ((!(CAttr & ObjCPropertyDecl::OBJC_PR_readonly)) &&
1987 Context.getCanonicalType(SetterMethod->getResultType()) !=
1988 Context.VoidTy)
1989 Diag(SetterMethod->getLocation(), diag::err_setter_type_void);
1990 if (SetterMethod->param_size() != 1 ||
Fariborz Jahanian2aac0c92011-09-26 22:59:09 +00001991 !Context.hasSameUnqualifiedType(
Fariborz Jahanianbb13c322011-10-15 17:36:49 +00001992 (*SetterMethod->param_begin())->getType().getNonReferenceType(),
1993 property->getType().getNonReferenceType())) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00001994 Diag(property->getLocation(),
1995 diag::warn_accessor_property_type_mismatch)
1996 << property->getDeclName()
1997 << SetterMethod->getSelector();
1998 Diag(SetterMethod->getLocation(), diag::note_declared_at);
1999 }
2000 }
2001
2002 // Synthesize getter/setter methods if none exist.
2003 // Find the default getter and if one not found, add one.
2004 // FIXME: The synthesized property we set here is misleading. We almost always
2005 // synthesize these methods unless the user explicitly provided prototypes
2006 // (which is odd, but allowed). Sema should be typechecking that the
2007 // declarations jive in that situation (which it is not currently).
2008 if (!GetterMethod) {
2009 // No instance method of same name as property getter name was found.
2010 // Declare a getter method and add it to the list of methods
2011 // for this class.
Ted Kremeneka054fb42010-09-21 20:52:59 +00002012 SourceLocation Loc = redeclaredProperty ?
2013 redeclaredProperty->getLocation() :
2014 property->getLocation();
2015
2016 GetterMethod = ObjCMethodDecl::Create(Context, Loc, Loc,
2017 property->getGetterName(),
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002018 property->getType(), 0, CD, /*isInstance=*/true,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002019 /*isVariadic=*/false, /*isPropertyAccessor=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002020 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
Ted Kremenek9d64c152010-03-12 00:38:38 +00002021 (property->getPropertyImplementation() ==
2022 ObjCPropertyDecl::Optional) ?
2023 ObjCMethodDecl::Optional :
2024 ObjCMethodDecl::Required);
2025 CD->addDecl(GetterMethod);
John McCall5de74d12010-11-10 07:01:40 +00002026
2027 AddPropertyAttrs(*this, GetterMethod, property);
2028
Ted Kremenek23173d72010-05-18 21:09:07 +00002029 // FIXME: Eventually this shouldn't be needed, as the lexical context
2030 // and the real context should be the same.
Ted Kremeneka054fb42010-09-21 20:52:59 +00002031 if (lexicalDC)
Ted Kremenek23173d72010-05-18 21:09:07 +00002032 GetterMethod->setLexicalDeclContext(lexicalDC);
Fariborz Jahanian831fb962011-06-25 00:17:46 +00002033 if (property->hasAttr<NSReturnsNotRetainedAttr>())
2034 GetterMethod->addAttr(
2035 ::new (Context) NSReturnsNotRetainedAttr(Loc, Context));
John McCallb8463812013-04-04 01:38:37 +00002036
2037 if (getLangOpts().ObjCAutoRefCount)
2038 CheckARCMethodDecl(GetterMethod);
Ted Kremenek9d64c152010-03-12 00:38:38 +00002039 } else
2040 // A user declared getter will be synthesize when @synthesize of
2041 // the property with the same name is seen in the @implementation
Jordan Rose1e4691b2012-10-10 16:42:25 +00002042 GetterMethod->setPropertyAccessor(true);
Ted Kremenek9d64c152010-03-12 00:38:38 +00002043 property->setGetterMethodDecl(GetterMethod);
2044
2045 // Skip setter if property is read-only.
2046 if (!property->isReadOnly()) {
2047 // Find the default setter and if one not found, add one.
2048 if (!SetterMethod) {
2049 // No instance method of same name as property setter name was found.
2050 // Declare a setter method and add it to the list of methods
2051 // for this class.
Ted Kremenek8254aa62010-09-21 18:28:43 +00002052 SourceLocation Loc = redeclaredProperty ?
2053 redeclaredProperty->getLocation() :
2054 property->getLocation();
2055
2056 SetterMethod =
Argyrios Kyrtzidis491306a2011-10-03 06:37:04 +00002057 ObjCMethodDecl::Create(Context, Loc, Loc,
Ted Kremenek8254aa62010-09-21 18:28:43 +00002058 property->getSetterName(), Context.VoidTy, 0,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002059 CD, /*isInstance=*/true, /*isVariadic=*/false,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002060 /*isPropertyAccessor=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002061 /*isImplicitlyDeclared=*/true,
2062 /*isDefined=*/false,
Ted Kremenek9d64c152010-03-12 00:38:38 +00002063 (property->getPropertyImplementation() ==
2064 ObjCPropertyDecl::Optional) ?
Ted Kremenek8254aa62010-09-21 18:28:43 +00002065 ObjCMethodDecl::Optional :
2066 ObjCMethodDecl::Required);
2067
Ted Kremenek9d64c152010-03-12 00:38:38 +00002068 // Invent the arguments for the setter. We don't bother making a
2069 // nice name for the argument.
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00002070 ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterMethod,
2071 Loc, Loc,
Ted Kremenek9d64c152010-03-12 00:38:38 +00002072 property->getIdentifier(),
John McCallf85e1932011-06-15 23:02:42 +00002073 property->getType().getUnqualifiedType(),
Ted Kremenek9d64c152010-03-12 00:38:38 +00002074 /*TInfo=*/0,
John McCalld931b082010-08-26 03:08:43 +00002075 SC_None,
Ted Kremenek9d64c152010-03-12 00:38:38 +00002076 0);
Dmitri Gribenko55431692013-05-05 00:41:58 +00002077 SetterMethod->setMethodParams(Context, Argument, None);
John McCall5de74d12010-11-10 07:01:40 +00002078
2079 AddPropertyAttrs(*this, SetterMethod, property);
2080
Ted Kremenek9d64c152010-03-12 00:38:38 +00002081 CD->addDecl(SetterMethod);
Ted Kremenek23173d72010-05-18 21:09:07 +00002082 // FIXME: Eventually this shouldn't be needed, as the lexical context
2083 // and the real context should be the same.
Ted Kremenek8254aa62010-09-21 18:28:43 +00002084 if (lexicalDC)
Ted Kremenek23173d72010-05-18 21:09:07 +00002085 SetterMethod->setLexicalDeclContext(lexicalDC);
John McCallb8463812013-04-04 01:38:37 +00002086
2087 // It's possible for the user to have set a very odd custom
2088 // setter selector that causes it to have a method family.
2089 if (getLangOpts().ObjCAutoRefCount)
2090 CheckARCMethodDecl(SetterMethod);
Ted Kremenek9d64c152010-03-12 00:38:38 +00002091 } else
2092 // A user declared setter will be synthesize when @synthesize of
2093 // the property with the same name is seen in the @implementation
Jordan Rose1e4691b2012-10-10 16:42:25 +00002094 SetterMethod->setPropertyAccessor(true);
Ted Kremenek9d64c152010-03-12 00:38:38 +00002095 property->setSetterMethodDecl(SetterMethod);
2096 }
2097 // Add any synthesized methods to the global pool. This allows us to
2098 // handle the following, which is supported by GCC (and part of the design).
2099 //
2100 // @interface Foo
2101 // @property double bar;
2102 // @end
2103 //
2104 // void thisIsUnfortunate() {
2105 // id foo;
2106 // double bar = [foo bar];
2107 // }
2108 //
2109 if (GetterMethod)
2110 AddInstanceMethodToGlobalPool(GetterMethod);
2111 if (SetterMethod)
2112 AddInstanceMethodToGlobalPool(SetterMethod);
Argyrios Kyrtzidise15db6f2012-05-09 16:12:57 +00002113
2114 ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(CD);
2115 if (!CurrentClass) {
2116 if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(CD))
2117 CurrentClass = Cat->getClassInterface();
2118 else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(CD))
2119 CurrentClass = Impl->getClassInterface();
2120 }
2121 if (GetterMethod)
2122 CheckObjCMethodOverrides(GetterMethod, CurrentClass, Sema::RTC_Unknown);
2123 if (SetterMethod)
2124 CheckObjCMethodOverrides(SetterMethod, CurrentClass, Sema::RTC_Unknown);
Ted Kremenek9d64c152010-03-12 00:38:38 +00002125}
2126
John McCalld226f652010-08-21 09:40:31 +00002127void Sema::CheckObjCPropertyAttributes(Decl *PDecl,
Ted Kremenek9d64c152010-03-12 00:38:38 +00002128 SourceLocation Loc,
Bill Wendlingad017fa2012-12-20 19:22:21 +00002129 unsigned &Attributes,
Fariborz Jahaniancea06d22012-06-20 22:57:42 +00002130 bool propertyInPrimaryClass) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00002131 // FIXME: Improve the reported location.
John McCallf85e1932011-06-15 23:02:42 +00002132 if (!PDecl || PDecl->isInvalidDecl())
Ted Kremenek5fcd52a2010-04-05 22:39:42 +00002133 return;
2134
2135 ObjCPropertyDecl *PropertyDecl = cast<ObjCPropertyDecl>(PDecl);
Fariborz Jahanian842f07b2010-03-30 22:40:11 +00002136 QualType PropertyTy = PropertyDecl->getType();
Ted Kremenek9d64c152010-03-12 00:38:38 +00002137
David Blaikie4e4d0842012-03-11 07:00:24 +00002138 if (getLangOpts().ObjCAutoRefCount &&
Bill Wendlingad017fa2012-12-20 19:22:21 +00002139 (Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
Fariborz Jahanian015f6082012-01-11 18:26:06 +00002140 PropertyTy->isObjCRetainableType()) {
2141 // 'readonly' property with no obvious lifetime.
2142 // its life time will be determined by its backing ivar.
2143 unsigned rel = (ObjCDeclSpec::DQ_PR_unsafe_unretained |
2144 ObjCDeclSpec::DQ_PR_copy |
2145 ObjCDeclSpec::DQ_PR_retain |
2146 ObjCDeclSpec::DQ_PR_strong |
2147 ObjCDeclSpec::DQ_PR_weak |
2148 ObjCDeclSpec::DQ_PR_assign);
Bill Wendlingad017fa2012-12-20 19:22:21 +00002149 if ((Attributes & rel) == 0)
Fariborz Jahanian015f6082012-01-11 18:26:06 +00002150 return;
2151 }
2152
Fariborz Jahaniancea06d22012-06-20 22:57:42 +00002153 if (propertyInPrimaryClass) {
2154 // we postpone most property diagnosis until class's implementation
2155 // because, its readonly attribute may be overridden in its class
2156 // extensions making other attributes, which make no sense, to make sense.
Bill Wendlingad017fa2012-12-20 19:22:21 +00002157 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2158 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
Fariborz Jahaniancea06d22012-06-20 22:57:42 +00002159 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2160 << "readonly" << "readwrite";
2161 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00002162 // readonly and readwrite/assign/retain/copy conflict.
Bill Wendlingad017fa2012-12-20 19:22:21 +00002163 else if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2164 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite |
Ted Kremenek9d64c152010-03-12 00:38:38 +00002165 ObjCDeclSpec::DQ_PR_assign |
John McCallf85e1932011-06-15 23:02:42 +00002166 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Ted Kremenek9d64c152010-03-12 00:38:38 +00002167 ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00002168 ObjCDeclSpec::DQ_PR_retain |
2169 ObjCDeclSpec::DQ_PR_strong))) {
Bill Wendlingad017fa2012-12-20 19:22:21 +00002170 const char * which = (Attributes & ObjCDeclSpec::DQ_PR_readwrite) ?
Ted Kremenek9d64c152010-03-12 00:38:38 +00002171 "readwrite" :
Bill Wendlingad017fa2012-12-20 19:22:21 +00002172 (Attributes & ObjCDeclSpec::DQ_PR_assign) ?
Ted Kremenek9d64c152010-03-12 00:38:38 +00002173 "assign" :
Bill Wendlingad017fa2012-12-20 19:22:21 +00002174 (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) ?
John McCallf85e1932011-06-15 23:02:42 +00002175 "unsafe_unretained" :
Bill Wendlingad017fa2012-12-20 19:22:21 +00002176 (Attributes & ObjCDeclSpec::DQ_PR_copy) ?
Ted Kremenek9d64c152010-03-12 00:38:38 +00002177 "copy" : "retain";
2178
Bill Wendlingad017fa2012-12-20 19:22:21 +00002179 Diag(Loc, (Attributes & (ObjCDeclSpec::DQ_PR_readwrite)) ?
Ted Kremenek9d64c152010-03-12 00:38:38 +00002180 diag::err_objc_property_attr_mutually_exclusive :
2181 diag::warn_objc_property_attr_mutually_exclusive)
2182 << "readonly" << which;
2183 }
2184
2185 // Check for copy or retain on non-object types.
Bill Wendlingad017fa2012-12-20 19:22:21 +00002186 if ((Attributes & (ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00002187 ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong)) &&
2188 !PropertyTy->isObjCRetainableType() &&
Fariborz Jahanian842f07b2010-03-30 22:40:11 +00002189 !PropertyDecl->getAttr<ObjCNSObjectAttr>()) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00002190 Diag(Loc, diag::err_objc_property_requires_object)
Bill Wendlingad017fa2012-12-20 19:22:21 +00002191 << (Attributes & ObjCDeclSpec::DQ_PR_weak ? "weak" :
2192 Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain (or strong)");
2193 Attributes &= ~(ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00002194 ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong);
John McCall977ea782012-02-21 21:48:05 +00002195 PropertyDecl->setInvalidDecl();
Ted Kremenek9d64c152010-03-12 00:38:38 +00002196 }
2197
2198 // Check for more than one of { assign, copy, retain }.
Bill Wendlingad017fa2012-12-20 19:22:21 +00002199 if (Attributes & ObjCDeclSpec::DQ_PR_assign) {
2200 if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00002201 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2202 << "assign" << "copy";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002203 Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
Ted Kremenek9d64c152010-03-12 00:38:38 +00002204 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002205 if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00002206 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2207 << "assign" << "retain";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002208 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
Ted Kremenek9d64c152010-03-12 00:38:38 +00002209 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002210 if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
John McCallf85e1932011-06-15 23:02:42 +00002211 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2212 << "assign" << "strong";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002213 Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
John McCallf85e1932011-06-15 23:02:42 +00002214 }
David Blaikie4e4d0842012-03-11 07:00:24 +00002215 if (getLangOpts().ObjCAutoRefCount &&
Bill Wendlingad017fa2012-12-20 19:22:21 +00002216 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
John McCallf85e1932011-06-15 23:02:42 +00002217 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2218 << "assign" << "weak";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002219 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
John McCallf85e1932011-06-15 23:02:42 +00002220 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002221 } else if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) {
2222 if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
John McCallf85e1932011-06-15 23:02:42 +00002223 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2224 << "unsafe_unretained" << "copy";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002225 Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
John McCallf85e1932011-06-15 23:02:42 +00002226 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002227 if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
John McCallf85e1932011-06-15 23:02:42 +00002228 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2229 << "unsafe_unretained" << "retain";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002230 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
John McCallf85e1932011-06-15 23:02:42 +00002231 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002232 if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
John McCallf85e1932011-06-15 23:02:42 +00002233 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2234 << "unsafe_unretained" << "strong";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002235 Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
John McCallf85e1932011-06-15 23:02:42 +00002236 }
David Blaikie4e4d0842012-03-11 07:00:24 +00002237 if (getLangOpts().ObjCAutoRefCount &&
Bill Wendlingad017fa2012-12-20 19:22:21 +00002238 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
John McCallf85e1932011-06-15 23:02:42 +00002239 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2240 << "unsafe_unretained" << "weak";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002241 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
John McCallf85e1932011-06-15 23:02:42 +00002242 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002243 } else if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
2244 if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
Ted Kremenek9d64c152010-03-12 00:38:38 +00002245 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2246 << "copy" << "retain";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002247 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
Ted Kremenek9d64c152010-03-12 00:38:38 +00002248 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002249 if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
John McCallf85e1932011-06-15 23:02:42 +00002250 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2251 << "copy" << "strong";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002252 Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
John McCallf85e1932011-06-15 23:02:42 +00002253 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002254 if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
John McCallf85e1932011-06-15 23:02:42 +00002255 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2256 << "copy" << "weak";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002257 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
John McCallf85e1932011-06-15 23:02:42 +00002258 }
2259 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002260 else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
2261 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
John McCallf85e1932011-06-15 23:02:42 +00002262 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2263 << "retain" << "weak";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002264 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
John McCallf85e1932011-06-15 23:02:42 +00002265 }
Bill Wendlingad017fa2012-12-20 19:22:21 +00002266 else if ((Attributes & ObjCDeclSpec::DQ_PR_strong) &&
2267 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
John McCallf85e1932011-06-15 23:02:42 +00002268 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2269 << "strong" << "weak";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002270 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
Ted Kremenek9d64c152010-03-12 00:38:38 +00002271 }
2272
Bill Wendlingad017fa2012-12-20 19:22:21 +00002273 if ((Attributes & ObjCDeclSpec::DQ_PR_atomic) &&
2274 (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)) {
Fariborz Jahanian9d1bbea2011-10-10 21:53:24 +00002275 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2276 << "atomic" << "nonatomic";
Bill Wendlingad017fa2012-12-20 19:22:21 +00002277 Attributes &= ~ObjCDeclSpec::DQ_PR_atomic;
Fariborz Jahanian9d1bbea2011-10-10 21:53:24 +00002278 }
2279
Ted Kremenek9d64c152010-03-12 00:38:38 +00002280 // Warn if user supplied no assignment attribute, property is
2281 // readwrite, and this is an object type.
Bill Wendlingad017fa2012-12-20 19:22:21 +00002282 if (!(Attributes & (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00002283 ObjCDeclSpec::DQ_PR_unsafe_unretained |
2284 ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong |
2285 ObjCDeclSpec::DQ_PR_weak)) &&
Ted Kremenek9d64c152010-03-12 00:38:38 +00002286 PropertyTy->isObjCObjectPointerType()) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002287 if (getLangOpts().ObjCAutoRefCount)
Fariborz Jahanianbc03aea2011-08-19 19:28:44 +00002288 // With arc, @property definitions should default to (strong) when
Fariborz Jahanianf21a92d2011-11-08 20:58:53 +00002289 // not specified; including when property is 'readonly'.
Fariborz Jahanianbc03aea2011-08-19 19:28:44 +00002290 PropertyDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
Bill Wendlingad017fa2012-12-20 19:22:21 +00002291 else if (!(Attributes & ObjCDeclSpec::DQ_PR_readonly)) {
Fariborz Jahanian9f37cd12012-01-04 00:31:53 +00002292 bool isAnyClassTy =
2293 (PropertyTy->isObjCClassType() ||
2294 PropertyTy->isObjCQualifiedClassType());
2295 // In non-gc, non-arc mode, 'Class' is treated as a 'void *' no need to
2296 // issue any warning.
David Blaikie4e4d0842012-03-11 07:00:24 +00002297 if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)
Fariborz Jahanian9f37cd12012-01-04 00:31:53 +00002298 ;
Fariborz Jahanianf224fb52012-09-17 23:57:35 +00002299 else if (propertyInPrimaryClass) {
2300 // Don't issue warning on property with no life time in class
2301 // extension as it is inherited from property in primary class.
Fariborz Jahanianbc03aea2011-08-19 19:28:44 +00002302 // Skip this warning in gc-only mode.
David Blaikie4e4d0842012-03-11 07:00:24 +00002303 if (getLangOpts().getGC() != LangOptions::GCOnly)
Fariborz Jahanianbc03aea2011-08-19 19:28:44 +00002304 Diag(Loc, diag::warn_objc_property_no_assignment_attribute);
Ted Kremenek9d64c152010-03-12 00:38:38 +00002305
Fariborz Jahanianbc03aea2011-08-19 19:28:44 +00002306 // If non-gc code warn that this is likely inappropriate.
David Blaikie4e4d0842012-03-11 07:00:24 +00002307 if (getLangOpts().getGC() == LangOptions::NonGC)
Fariborz Jahanianbc03aea2011-08-19 19:28:44 +00002308 Diag(Loc, diag::warn_objc_property_default_assign_on_object);
Fariborz Jahanian9f37cd12012-01-04 00:31:53 +00002309 }
Fariborz Jahanianbc03aea2011-08-19 19:28:44 +00002310 }
Ted Kremenek9d64c152010-03-12 00:38:38 +00002311
2312 // FIXME: Implement warning dependent on NSCopying being
2313 // implemented. See also:
2314 // <rdar://5168496&4855821&5607453&5096644&4947311&5698469&4947014&5168496>
2315 // (please trim this list while you are at it).
2316 }
2317
Bill Wendlingad017fa2012-12-20 19:22:21 +00002318 if (!(Attributes & ObjCDeclSpec::DQ_PR_copy)
2319 &&!(Attributes & ObjCDeclSpec::DQ_PR_readonly)
David Blaikie4e4d0842012-03-11 07:00:24 +00002320 && getLangOpts().getGC() == LangOptions::GCOnly
Ted Kremenek9d64c152010-03-12 00:38:38 +00002321 && PropertyTy->isBlockPointerType())
2322 Diag(Loc, diag::warn_objc_property_copy_missing_on_block);
Bill Wendlingad017fa2012-12-20 19:22:21 +00002323 else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
2324 !(Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2325 !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
Fariborz Jahanian528a4992011-09-14 18:03:46 +00002326 PropertyTy->isBlockPointerType())
2327 Diag(Loc, diag::warn_objc_property_retain_of_block);
Fariborz Jahanian48a98c72011-11-01 23:02:16 +00002328
Bill Wendlingad017fa2012-12-20 19:22:21 +00002329 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2330 (Attributes & ObjCDeclSpec::DQ_PR_setter))
Fariborz Jahanian48a98c72011-11-01 23:02:16 +00002331 Diag(Loc, diag::warn_objc_readonly_property_has_setter);
2332
Ted Kremenek9d64c152010-03-12 00:38:38 +00002333}