1 //===--- 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
15 #include "clang/Sema/SemaInternal.h"
16 #include "clang/AST/ASTMutationListener.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/AST/ExprObjC.h"
20 #include "clang/Basic/SourceManager.h"
21 #include "clang/Lex/Lexer.h"
22 #include "clang/Sema/Initialization.h"
23 #include "llvm/ADT/DenseSet.h"
24 #include "llvm/ADT/SmallString.h"
25
26 using namespace clang;
27
28 //===----------------------------------------------------------------------===//
29 // Grammar actions.
30 //===----------------------------------------------------------------------===//
31
32 /// getImpliedARCOwnership - Given a set of property attributes and a
33 /// type, infer an expected lifetime. The type's ownership qualification
34 /// is not considered.
35 ///
36 /// Returns OCL_None if the attributes as stated do not imply an ownership.
37 /// Never returns OCL_Autoreleasing.
getImpliedARCOwnership(ObjCPropertyDecl::PropertyAttributeKind attrs,QualType type)38 static Qualifiers::ObjCLifetime getImpliedARCOwnership(
39 ObjCPropertyDecl::PropertyAttributeKind attrs,
40 QualType type) {
41 // retain, strong, copy, weak, and unsafe_unretained are only legal
42 // on properties of retainable pointer type.
43 if (attrs & (ObjCPropertyDecl::OBJC_PR_retain |
44 ObjCPropertyDecl::OBJC_PR_strong |
45 ObjCPropertyDecl::OBJC_PR_copy)) {
46 return Qualifiers::OCL_Strong;
47 } else if (attrs & ObjCPropertyDecl::OBJC_PR_weak) {
48 return Qualifiers::OCL_Weak;
49 } else if (attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained) {
50 return Qualifiers::OCL_ExplicitNone;
51 }
52
53 // assign can appear on other types, so we have to check the
54 // property type.
55 if (attrs & ObjCPropertyDecl::OBJC_PR_assign &&
56 type->isObjCRetainableType()) {
57 return Qualifiers::OCL_ExplicitNone;
58 }
59
60 return Qualifiers::OCL_None;
61 }
62
63 /// Check the internal consistency of a property declaration.
checkARCPropertyDecl(Sema & S,ObjCPropertyDecl * property)64 static void checkARCPropertyDecl(Sema &S, ObjCPropertyDecl *property) {
65 if (property->isInvalidDecl()) return;
66
67 ObjCPropertyDecl::PropertyAttributeKind propertyKind
68 = property->getPropertyAttributes();
69 Qualifiers::ObjCLifetime propertyLifetime
70 = property->getType().getObjCLifetime();
71
72 // Nothing to do if we don't have a lifetime.
73 if (propertyLifetime == Qualifiers::OCL_None) return;
74
75 Qualifiers::ObjCLifetime expectedLifetime
76 = getImpliedARCOwnership(propertyKind, property->getType());
77 if (!expectedLifetime) {
78 // We have a lifetime qualifier but no dominating property
79 // attribute. That's okay, but restore reasonable invariants by
80 // setting the property attribute according to the lifetime
81 // qualifier.
82 ObjCPropertyDecl::PropertyAttributeKind attr;
83 if (propertyLifetime == Qualifiers::OCL_Strong) {
84 attr = ObjCPropertyDecl::OBJC_PR_strong;
85 } else if (propertyLifetime == Qualifiers::OCL_Weak) {
86 attr = ObjCPropertyDecl::OBJC_PR_weak;
87 } else {
88 assert(propertyLifetime == Qualifiers::OCL_ExplicitNone);
89 attr = ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
90 }
91 property->setPropertyAttributes(attr);
92 return;
93 }
94
95 if (propertyLifetime == expectedLifetime) return;
96
97 property->setInvalidDecl();
98 S.Diag(property->getLocation(),
99 diag::err_arc_inconsistent_property_ownership)
100 << property->getDeclName()
101 << expectedLifetime
102 << propertyLifetime;
103 }
104
deduceWeakPropertyFromType(Sema & S,QualType T)105 static unsigned deduceWeakPropertyFromType(Sema &S, QualType T) {
106 if ((S.getLangOpts().getGC() != LangOptions::NonGC &&
107 T.isObjCGCWeak()) ||
108 (S.getLangOpts().ObjCAutoRefCount &&
109 T.getObjCLifetime() == Qualifiers::OCL_Weak))
110 return ObjCDeclSpec::DQ_PR_weak;
111 return 0;
112 }
113
114 /// \brief Check this Objective-C property against a property declared in the
115 /// given protocol.
116 static void
CheckPropertyAgainstProtocol(Sema & S,ObjCPropertyDecl * Prop,ObjCProtocolDecl * Proto,llvm::SmallPtrSet<ObjCProtocolDecl *,16> & Known)117 CheckPropertyAgainstProtocol(Sema &S, ObjCPropertyDecl *Prop,
118 ObjCProtocolDecl *Proto,
119 llvm::SmallPtrSet<ObjCProtocolDecl *, 16> &Known) {
120 // Have we seen this protocol before?
121 if (!Known.insert(Proto))
122 return;
123
124 // Look for a property with the same name.
125 DeclContext::lookup_result R = Proto->lookup(Prop->getDeclName());
126 for (unsigned I = 0, N = R.size(); I != N; ++I) {
127 if (ObjCPropertyDecl *ProtoProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
128 S.DiagnosePropertyMismatch(Prop, ProtoProp, Proto->getIdentifier(), true);
129 return;
130 }
131 }
132
133 // Check this property against any protocols we inherit.
134 for (auto *P : Proto->protocols())
135 CheckPropertyAgainstProtocol(S, Prop, P, Known);
136 }
137
ActOnProperty(Scope * S,SourceLocation AtLoc,SourceLocation LParenLoc,FieldDeclarator & FD,ObjCDeclSpec & ODS,Selector GetterSel,Selector SetterSel,bool * isOverridingProperty,tok::ObjCKeywordKind MethodImplKind,DeclContext * lexicalDC)138 Decl *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc,
139 SourceLocation LParenLoc,
140 FieldDeclarator &FD,
141 ObjCDeclSpec &ODS,
142 Selector GetterSel,
143 Selector SetterSel,
144 bool *isOverridingProperty,
145 tok::ObjCKeywordKind MethodImplKind,
146 DeclContext *lexicalDC) {
147 unsigned Attributes = ODS.getPropertyAttributes();
148 TypeSourceInfo *TSI = GetTypeForDeclarator(FD.D, S);
149 QualType T = TSI->getType();
150 Attributes |= deduceWeakPropertyFromType(*this, T);
151
152 bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) ||
153 // default is readwrite!
154 !(Attributes & ObjCDeclSpec::DQ_PR_readonly));
155 // property is defaulted to 'assign' if it is readwrite and is
156 // not retain or copy
157 bool isAssign = ((Attributes & ObjCDeclSpec::DQ_PR_assign) ||
158 (isReadWrite &&
159 !(Attributes & ObjCDeclSpec::DQ_PR_retain) &&
160 !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
161 !(Attributes & ObjCDeclSpec::DQ_PR_copy) &&
162 !(Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) &&
163 !(Attributes & ObjCDeclSpec::DQ_PR_weak)));
164
165 // Proceed with constructing the ObjCPropertyDecls.
166 ObjCContainerDecl *ClassDecl = cast<ObjCContainerDecl>(CurContext);
167 ObjCPropertyDecl *Res = nullptr;
168 if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
169 if (CDecl->IsClassExtension()) {
170 Res = HandlePropertyInClassExtension(S, AtLoc, LParenLoc,
171 FD, GetterSel, SetterSel,
172 isAssign, isReadWrite,
173 Attributes,
174 ODS.getPropertyAttributes(),
175 isOverridingProperty, TSI,
176 MethodImplKind);
177 if (!Res)
178 return nullptr;
179 }
180 }
181
182 if (!Res) {
183 Res = CreatePropertyDecl(S, ClassDecl, AtLoc, LParenLoc, FD,
184 GetterSel, SetterSel, isAssign, isReadWrite,
185 Attributes, ODS.getPropertyAttributes(),
186 TSI, MethodImplKind);
187 if (lexicalDC)
188 Res->setLexicalDeclContext(lexicalDC);
189 }
190
191 // Validate the attributes on the @property.
192 CheckObjCPropertyAttributes(Res, AtLoc, Attributes,
193 (isa<ObjCInterfaceDecl>(ClassDecl) ||
194 isa<ObjCProtocolDecl>(ClassDecl)));
195
196 if (getLangOpts().ObjCAutoRefCount)
197 checkARCPropertyDecl(*this, Res);
198
199 llvm::SmallPtrSet<ObjCProtocolDecl *, 16> KnownProtos;
200 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
201 // For a class, compare the property against a property in our superclass.
202 bool FoundInSuper = false;
203 ObjCInterfaceDecl *CurrentInterfaceDecl = IFace;
204 while (ObjCInterfaceDecl *Super = CurrentInterfaceDecl->getSuperClass()) {
205 DeclContext::lookup_result R = Super->lookup(Res->getDeclName());
206 for (unsigned I = 0, N = R.size(); I != N; ++I) {
207 if (ObjCPropertyDecl *SuperProp = dyn_cast<ObjCPropertyDecl>(R[I])) {
208 DiagnosePropertyMismatch(Res, SuperProp, Super->getIdentifier(), false);
209 FoundInSuper = true;
210 break;
211 }
212 }
213 if (FoundInSuper)
214 break;
215 else
216 CurrentInterfaceDecl = Super;
217 }
218
219 if (FoundInSuper) {
220 // Also compare the property against a property in our protocols.
221 for (auto *P : CurrentInterfaceDecl->protocols()) {
222 CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
223 }
224 } else {
225 // Slower path: look in all protocols we referenced.
226 for (auto *P : IFace->all_referenced_protocols()) {
227 CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
228 }
229 }
230 } else if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
231 for (auto *P : Cat->protocols())
232 CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
233 } else {
234 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(ClassDecl);
235 for (auto *P : Proto->protocols())
236 CheckPropertyAgainstProtocol(*this, Res, P, KnownProtos);
237 }
238
239 ActOnDocumentableDecl(Res);
240 return Res;
241 }
242
243 static ObjCPropertyDecl::PropertyAttributeKind
makePropertyAttributesAsWritten(unsigned Attributes)244 makePropertyAttributesAsWritten(unsigned Attributes) {
245 unsigned attributesAsWritten = 0;
246 if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
247 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readonly;
248 if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
249 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readwrite;
250 if (Attributes & ObjCDeclSpec::DQ_PR_getter)
251 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_getter;
252 if (Attributes & ObjCDeclSpec::DQ_PR_setter)
253 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_setter;
254 if (Attributes & ObjCDeclSpec::DQ_PR_assign)
255 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_assign;
256 if (Attributes & ObjCDeclSpec::DQ_PR_retain)
257 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_retain;
258 if (Attributes & ObjCDeclSpec::DQ_PR_strong)
259 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_strong;
260 if (Attributes & ObjCDeclSpec::DQ_PR_weak)
261 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_weak;
262 if (Attributes & ObjCDeclSpec::DQ_PR_copy)
263 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_copy;
264 if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
265 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
266 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
267 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_nonatomic;
268 if (Attributes & ObjCDeclSpec::DQ_PR_atomic)
269 attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_atomic;
270
271 return (ObjCPropertyDecl::PropertyAttributeKind)attributesAsWritten;
272 }
273
LocPropertyAttribute(ASTContext & Context,const char * attrName,SourceLocation LParenLoc,SourceLocation & Loc)274 static bool LocPropertyAttribute( ASTContext &Context, const char *attrName,
275 SourceLocation LParenLoc, SourceLocation &Loc) {
276 if (LParenLoc.isMacroID())
277 return false;
278
279 SourceManager &SM = Context.getSourceManager();
280 std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(LParenLoc);
281 // Try to load the file buffer.
282 bool invalidTemp = false;
283 StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
284 if (invalidTemp)
285 return false;
286 const char *tokenBegin = file.data() + locInfo.second;
287
288 // Lex from the start of the given location.
289 Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
290 Context.getLangOpts(),
291 file.begin(), tokenBegin, file.end());
292 Token Tok;
293 do {
294 lexer.LexFromRawLexer(Tok);
295 if (Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == attrName) {
296 Loc = Tok.getLocation();
297 return true;
298 }
299 } while (Tok.isNot(tok::r_paren));
300 return false;
301
302 }
303
getOwnershipRule(unsigned attr)304 static unsigned getOwnershipRule(unsigned attr) {
305 return attr & (ObjCPropertyDecl::OBJC_PR_assign |
306 ObjCPropertyDecl::OBJC_PR_retain |
307 ObjCPropertyDecl::OBJC_PR_copy |
308 ObjCPropertyDecl::OBJC_PR_weak |
309 ObjCPropertyDecl::OBJC_PR_strong |
310 ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
311 }
312
313 ObjCPropertyDecl *
HandlePropertyInClassExtension(Scope * S,SourceLocation AtLoc,SourceLocation LParenLoc,FieldDeclarator & FD,Selector GetterSel,Selector SetterSel,const bool isAssign,const bool isReadWrite,const unsigned Attributes,const unsigned AttributesAsWritten,bool * isOverridingProperty,TypeSourceInfo * T,tok::ObjCKeywordKind MethodImplKind)314 Sema::HandlePropertyInClassExtension(Scope *S,
315 SourceLocation AtLoc,
316 SourceLocation LParenLoc,
317 FieldDeclarator &FD,
318 Selector GetterSel, Selector SetterSel,
319 const bool isAssign,
320 const bool isReadWrite,
321 const unsigned Attributes,
322 const unsigned AttributesAsWritten,
323 bool *isOverridingProperty,
324 TypeSourceInfo *T,
325 tok::ObjCKeywordKind MethodImplKind) {
326 ObjCCategoryDecl *CDecl = cast<ObjCCategoryDecl>(CurContext);
327 // Diagnose if this property is already in continuation class.
328 DeclContext *DC = CurContext;
329 IdentifierInfo *PropertyId = FD.D.getIdentifier();
330 ObjCInterfaceDecl *CCPrimary = CDecl->getClassInterface();
331
332 if (CCPrimary) {
333 // Check for duplicate declaration of this property in current and
334 // other class extensions.
335 for (const auto *Ext : CCPrimary->known_extensions()) {
336 if (ObjCPropertyDecl *prevDecl
337 = ObjCPropertyDecl::findPropertyDecl(Ext, PropertyId)) {
338 Diag(AtLoc, diag::err_duplicate_property);
339 Diag(prevDecl->getLocation(), diag::note_property_declare);
340 return nullptr;
341 }
342 }
343 }
344
345 // Create a new ObjCPropertyDecl with the DeclContext being
346 // the class extension.
347 // FIXME. We should really be using CreatePropertyDecl for this.
348 ObjCPropertyDecl *PDecl =
349 ObjCPropertyDecl::Create(Context, DC, FD.D.getIdentifierLoc(),
350 PropertyId, AtLoc, LParenLoc, T);
351 PDecl->setPropertyAttributesAsWritten(
352 makePropertyAttributesAsWritten(AttributesAsWritten));
353 if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
354 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
355 if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
356 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
357 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
358 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
359 if (Attributes & ObjCDeclSpec::DQ_PR_atomic)
360 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic);
361 // Set setter/getter selector name. Needed later.
362 PDecl->setGetterName(GetterSel);
363 PDecl->setSetterName(SetterSel);
364 ProcessDeclAttributes(S, PDecl, FD.D);
365 DC->addDecl(PDecl);
366
367 // We need to look in the @interface to see if the @property was
368 // already declared.
369 if (!CCPrimary) {
370 Diag(CDecl->getLocation(), diag::err_continuation_class);
371 *isOverridingProperty = true;
372 return nullptr;
373 }
374
375 // Find the property in continuation class's primary class only.
376 ObjCPropertyDecl *PIDecl =
377 CCPrimary->FindPropertyVisibleInPrimaryClass(PropertyId);
378
379 if (!PIDecl) {
380 // No matching property found in the primary class. Just fall thru
381 // and add property to continuation class's primary class.
382 ObjCPropertyDecl *PrimaryPDecl =
383 CreatePropertyDecl(S, CCPrimary, AtLoc, LParenLoc,
384 FD, GetterSel, SetterSel, isAssign, isReadWrite,
385 Attributes,AttributesAsWritten, T, MethodImplKind, DC);
386
387 // A case of continuation class adding a new property in the class. This
388 // is not what it was meant for. However, gcc supports it and so should we.
389 // Make sure setter/getters are declared here.
390 ProcessPropertyDecl(PrimaryPDecl, CCPrimary,
391 /* redeclaredProperty = */ nullptr,
392 /* lexicalDC = */ CDecl);
393 PDecl->setGetterMethodDecl(PrimaryPDecl->getGetterMethodDecl());
394 PDecl->setSetterMethodDecl(PrimaryPDecl->getSetterMethodDecl());
395 if (ASTMutationListener *L = Context.getASTMutationListener())
396 L->AddedObjCPropertyInClassExtension(PrimaryPDecl, /*OrigProp=*/nullptr,
397 CDecl);
398 return PrimaryPDecl;
399 }
400 if (!Context.hasSameType(PIDecl->getType(), PDecl->getType())) {
401 bool IncompatibleObjC = false;
402 QualType ConvertedType;
403 // Relax the strict type matching for property type in continuation class.
404 // Allow property object type of continuation class to be different as long
405 // as it narrows the object type in its primary class property. Note that
406 // this conversion is safe only because the wider type is for a 'readonly'
407 // property in primary class and 'narrowed' type for a 'readwrite' property
408 // in continuation class.
409 if (!isa<ObjCObjectPointerType>(PIDecl->getType()) ||
410 !isa<ObjCObjectPointerType>(PDecl->getType()) ||
411 (!isObjCPointerConversion(PDecl->getType(), PIDecl->getType(),
412 ConvertedType, IncompatibleObjC))
413 || IncompatibleObjC) {
414 Diag(AtLoc,
415 diag::err_type_mismatch_continuation_class) << PDecl->getType();
416 Diag(PIDecl->getLocation(), diag::note_property_declare);
417 return nullptr;
418 }
419 }
420
421 // The property 'PIDecl's readonly attribute will be over-ridden
422 // with continuation class's readwrite property attribute!
423 unsigned PIkind = PIDecl->getPropertyAttributesAsWritten();
424 if (isReadWrite && (PIkind & ObjCPropertyDecl::OBJC_PR_readonly)) {
425 PIkind &= ~ObjCPropertyDecl::OBJC_PR_readonly;
426 PIkind |= ObjCPropertyDecl::OBJC_PR_readwrite;
427 PIkind |= deduceWeakPropertyFromType(*this, PIDecl->getType());
428 unsigned ClassExtensionMemoryModel = getOwnershipRule(Attributes);
429 unsigned PrimaryClassMemoryModel = getOwnershipRule(PIkind);
430 if (PrimaryClassMemoryModel && ClassExtensionMemoryModel &&
431 (PrimaryClassMemoryModel != ClassExtensionMemoryModel)) {
432 Diag(AtLoc, diag::warn_property_attr_mismatch);
433 Diag(PIDecl->getLocation(), diag::note_property_declare);
434 }
435 else if (getLangOpts().ObjCAutoRefCount) {
436 QualType PrimaryPropertyQT =
437 Context.getCanonicalType(PIDecl->getType()).getUnqualifiedType();
438 if (isa<ObjCObjectPointerType>(PrimaryPropertyQT)) {
439 bool PropertyIsWeak = ((PIkind & ObjCPropertyDecl::OBJC_PR_weak) != 0);
440 Qualifiers::ObjCLifetime PrimaryPropertyLifeTime =
441 PrimaryPropertyQT.getObjCLifetime();
442 if (PrimaryPropertyLifeTime == Qualifiers::OCL_None &&
443 (Attributes & ObjCDeclSpec::DQ_PR_weak) &&
444 !PropertyIsWeak) {
445 Diag(AtLoc, diag::warn_property_implicitly_mismatched);
446 Diag(PIDecl->getLocation(), diag::note_property_declare);
447 }
448 }
449 }
450
451 DeclContext *DC = cast<DeclContext>(CCPrimary);
452 if (!ObjCPropertyDecl::findPropertyDecl(DC,
453 PIDecl->getDeclName().getAsIdentifierInfo())) {
454 // In mrr mode, 'readwrite' property must have an explicit
455 // memory attribute. If none specified, select the default (assign).
456 if (!getLangOpts().ObjCAutoRefCount) {
457 if (!(PIkind & (ObjCDeclSpec::DQ_PR_assign |
458 ObjCDeclSpec::DQ_PR_retain |
459 ObjCDeclSpec::DQ_PR_strong |
460 ObjCDeclSpec::DQ_PR_copy |
461 ObjCDeclSpec::DQ_PR_unsafe_unretained |
462 ObjCDeclSpec::DQ_PR_weak)))
463 PIkind |= ObjCPropertyDecl::OBJC_PR_assign;
464 }
465
466 // Protocol is not in the primary class. Must build one for it.
467 ObjCDeclSpec ProtocolPropertyODS;
468 // FIXME. Assuming that ObjCDeclSpec::ObjCPropertyAttributeKind
469 // and ObjCPropertyDecl::PropertyAttributeKind have identical
470 // values. Should consolidate both into one enum type.
471 ProtocolPropertyODS.
472 setPropertyAttributes((ObjCDeclSpec::ObjCPropertyAttributeKind)
473 PIkind);
474 // Must re-establish the context from class extension to primary
475 // class context.
476 ContextRAII SavedContext(*this, CCPrimary);
477
478 Decl *ProtocolPtrTy =
479 ActOnProperty(S, AtLoc, LParenLoc, FD, ProtocolPropertyODS,
480 PIDecl->getGetterName(),
481 PIDecl->getSetterName(),
482 isOverridingProperty,
483 MethodImplKind,
484 /* lexicalDC = */ CDecl);
485 PIDecl = cast<ObjCPropertyDecl>(ProtocolPtrTy);
486 }
487 PIDecl->makeitReadWriteAttribute();
488 if (Attributes & ObjCDeclSpec::DQ_PR_retain)
489 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
490 if (Attributes & ObjCDeclSpec::DQ_PR_strong)
491 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
492 if (Attributes & ObjCDeclSpec::DQ_PR_copy)
493 PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
494 PIDecl->setSetterName(SetterSel);
495 } else {
496 // Tailor the diagnostics for the common case where a readwrite
497 // property is declared both in the @interface and the continuation.
498 // This is a common error where the user often intended the original
499 // declaration to be readonly.
500 unsigned diag =
501 (Attributes & ObjCDeclSpec::DQ_PR_readwrite) &&
502 (PIkind & ObjCPropertyDecl::OBJC_PR_readwrite)
503 ? diag::err_use_continuation_class_redeclaration_readwrite
504 : diag::err_use_continuation_class;
505 Diag(AtLoc, diag)
506 << CCPrimary->getDeclName();
507 Diag(PIDecl->getLocation(), diag::note_property_declare);
508 return nullptr;
509 }
510 *isOverridingProperty = true;
511 // Make sure setter decl is synthesized, and added to primary class's list.
512 ProcessPropertyDecl(PIDecl, CCPrimary, PDecl, CDecl);
513 PDecl->setGetterMethodDecl(PIDecl->getGetterMethodDecl());
514 PDecl->setSetterMethodDecl(PIDecl->getSetterMethodDecl());
515 if (ASTMutationListener *L = Context.getASTMutationListener())
516 L->AddedObjCPropertyInClassExtension(PDecl, PIDecl, CDecl);
517 return PDecl;
518 }
519
CreatePropertyDecl(Scope * S,ObjCContainerDecl * CDecl,SourceLocation AtLoc,SourceLocation LParenLoc,FieldDeclarator & FD,Selector GetterSel,Selector SetterSel,const bool isAssign,const bool isReadWrite,const unsigned Attributes,const unsigned AttributesAsWritten,TypeSourceInfo * TInfo,tok::ObjCKeywordKind MethodImplKind,DeclContext * lexicalDC)520 ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S,
521 ObjCContainerDecl *CDecl,
522 SourceLocation AtLoc,
523 SourceLocation LParenLoc,
524 FieldDeclarator &FD,
525 Selector GetterSel,
526 Selector SetterSel,
527 const bool isAssign,
528 const bool isReadWrite,
529 const unsigned Attributes,
530 const unsigned AttributesAsWritten,
531 TypeSourceInfo *TInfo,
532 tok::ObjCKeywordKind MethodImplKind,
533 DeclContext *lexicalDC){
534 IdentifierInfo *PropertyId = FD.D.getIdentifier();
535 QualType T = TInfo->getType();
536
537 // Issue a warning if property is 'assign' as default and its object, which is
538 // gc'able conforms to NSCopying protocol
539 if (getLangOpts().getGC() != LangOptions::NonGC &&
540 isAssign && !(Attributes & ObjCDeclSpec::DQ_PR_assign))
541 if (const ObjCObjectPointerType *ObjPtrTy =
542 T->getAs<ObjCObjectPointerType>()) {
543 ObjCInterfaceDecl *IDecl = ObjPtrTy->getObjectType()->getInterface();
544 if (IDecl)
545 if (ObjCProtocolDecl* PNSCopying =
546 LookupProtocol(&Context.Idents.get("NSCopying"), AtLoc))
547 if (IDecl->ClassImplementsProtocol(PNSCopying, true))
548 Diag(AtLoc, diag::warn_implements_nscopying) << PropertyId;
549 }
550
551 if (T->isObjCObjectType()) {
552 SourceLocation StarLoc = TInfo->getTypeLoc().getLocEnd();
553 StarLoc = getLocForEndOfToken(StarLoc);
554 Diag(FD.D.getIdentifierLoc(), diag::err_statically_allocated_object)
555 << FixItHint::CreateInsertion(StarLoc, "*");
556 T = Context.getObjCObjectPointerType(T);
557 SourceLocation TLoc = TInfo->getTypeLoc().getLocStart();
558 TInfo = Context.getTrivialTypeSourceInfo(T, TLoc);
559 }
560
561 DeclContext *DC = cast<DeclContext>(CDecl);
562 ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, DC,
563 FD.D.getIdentifierLoc(),
564 PropertyId, AtLoc, LParenLoc, TInfo);
565
566 if (ObjCPropertyDecl *prevDecl =
567 ObjCPropertyDecl::findPropertyDecl(DC, PropertyId)) {
568 Diag(PDecl->getLocation(), diag::err_duplicate_property);
569 Diag(prevDecl->getLocation(), diag::note_property_declare);
570 PDecl->setInvalidDecl();
571 }
572 else {
573 DC->addDecl(PDecl);
574 if (lexicalDC)
575 PDecl->setLexicalDeclContext(lexicalDC);
576 }
577
578 if (T->isArrayType() || T->isFunctionType()) {
579 Diag(AtLoc, diag::err_property_type) << T;
580 PDecl->setInvalidDecl();
581 }
582
583 ProcessDeclAttributes(S, PDecl, FD.D);
584
585 // Regardless of setter/getter attribute, we save the default getter/setter
586 // selector names in anticipation of declaration of setter/getter methods.
587 PDecl->setGetterName(GetterSel);
588 PDecl->setSetterName(SetterSel);
589 PDecl->setPropertyAttributesAsWritten(
590 makePropertyAttributesAsWritten(AttributesAsWritten));
591
592 if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
593 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
594
595 if (Attributes & ObjCDeclSpec::DQ_PR_getter)
596 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter);
597
598 if (Attributes & ObjCDeclSpec::DQ_PR_setter)
599 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter);
600
601 if (isReadWrite)
602 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
603
604 if (Attributes & ObjCDeclSpec::DQ_PR_retain)
605 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
606
607 if (Attributes & ObjCDeclSpec::DQ_PR_strong)
608 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
609
610 if (Attributes & ObjCDeclSpec::DQ_PR_weak)
611 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
612
613 if (Attributes & ObjCDeclSpec::DQ_PR_copy)
614 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
615
616 if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
617 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
618
619 if (isAssign)
620 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
621
622 // In the semantic attributes, one of nonatomic or atomic is always set.
623 if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
624 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
625 else
626 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic);
627
628 // 'unsafe_unretained' is alias for 'assign'.
629 if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
630 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
631 if (isAssign)
632 PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
633
634 if (MethodImplKind == tok::objc_required)
635 PDecl->setPropertyImplementation(ObjCPropertyDecl::Required);
636 else if (MethodImplKind == tok::objc_optional)
637 PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional);
638
639 return PDecl;
640 }
641
checkARCPropertyImpl(Sema & S,SourceLocation propertyImplLoc,ObjCPropertyDecl * property,ObjCIvarDecl * ivar)642 static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc,
643 ObjCPropertyDecl *property,
644 ObjCIvarDecl *ivar) {
645 if (property->isInvalidDecl() || ivar->isInvalidDecl()) return;
646
647 QualType ivarType = ivar->getType();
648 Qualifiers::ObjCLifetime ivarLifetime = ivarType.getObjCLifetime();
649
650 // The lifetime implied by the property's attributes.
651 Qualifiers::ObjCLifetime propertyLifetime =
652 getImpliedARCOwnership(property->getPropertyAttributes(),
653 property->getType());
654
655 // We're fine if they match.
656 if (propertyLifetime == ivarLifetime) return;
657
658 // These aren't valid lifetimes for object ivars; don't diagnose twice.
659 if (ivarLifetime == Qualifiers::OCL_None ||
660 ivarLifetime == Qualifiers::OCL_Autoreleasing)
661 return;
662
663 // If the ivar is private, and it's implicitly __unsafe_unretained
664 // becaues of its type, then pretend it was actually implicitly
665 // __strong. This is only sound because we're processing the
666 // property implementation before parsing any method bodies.
667 if (ivarLifetime == Qualifiers::OCL_ExplicitNone &&
668 propertyLifetime == Qualifiers::OCL_Strong &&
669 ivar->getAccessControl() == ObjCIvarDecl::Private) {
670 SplitQualType split = ivarType.split();
671 if (split.Quals.hasObjCLifetime()) {
672 assert(ivarType->isObjCARCImplicitlyUnretainedType());
673 split.Quals.setObjCLifetime(Qualifiers::OCL_Strong);
674 ivarType = S.Context.getQualifiedType(split);
675 ivar->setType(ivarType);
676 return;
677 }
678 }
679
680 switch (propertyLifetime) {
681 case Qualifiers::OCL_Strong:
682 S.Diag(ivar->getLocation(), diag::err_arc_strong_property_ownership)
683 << property->getDeclName()
684 << ivar->getDeclName()
685 << ivarLifetime;
686 break;
687
688 case Qualifiers::OCL_Weak:
689 S.Diag(ivar->getLocation(), diag::error_weak_property)
690 << property->getDeclName()
691 << ivar->getDeclName();
692 break;
693
694 case Qualifiers::OCL_ExplicitNone:
695 S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership)
696 << property->getDeclName()
697 << ivar->getDeclName()
698 << ((property->getPropertyAttributesAsWritten()
699 & ObjCPropertyDecl::OBJC_PR_assign) != 0);
700 break;
701
702 case Qualifiers::OCL_Autoreleasing:
703 llvm_unreachable("properties cannot be autoreleasing");
704
705 case Qualifiers::OCL_None:
706 // Any other property should be ignored.
707 return;
708 }
709
710 S.Diag(property->getLocation(), diag::note_property_declare);
711 if (propertyImplLoc.isValid())
712 S.Diag(propertyImplLoc, diag::note_property_synthesize);
713 }
714
715 /// setImpliedPropertyAttributeForReadOnlyProperty -
716 /// This routine evaludates life-time attributes for a 'readonly'
717 /// property with no known lifetime of its own, using backing
718 /// 'ivar's attribute, if any. If no backing 'ivar', property's
719 /// life-time is assumed 'strong'.
setImpliedPropertyAttributeForReadOnlyProperty(ObjCPropertyDecl * property,ObjCIvarDecl * ivar)720 static void setImpliedPropertyAttributeForReadOnlyProperty(
721 ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {
722 Qualifiers::ObjCLifetime propertyLifetime =
723 getImpliedARCOwnership(property->getPropertyAttributes(),
724 property->getType());
725 if (propertyLifetime != Qualifiers::OCL_None)
726 return;
727
728 if (!ivar) {
729 // if no backing ivar, make property 'strong'.
730 property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
731 return;
732 }
733 // property assumes owenership of backing ivar.
734 QualType ivarType = ivar->getType();
735 Qualifiers::ObjCLifetime ivarLifetime = ivarType.getObjCLifetime();
736 if (ivarLifetime == Qualifiers::OCL_Strong)
737 property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
738 else if (ivarLifetime == Qualifiers::OCL_Weak)
739 property->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
740 return;
741 }
742
743 /// DiagnosePropertyMismatchDeclInProtocols - diagnose properties declared
744 /// in inherited protocols with mismatched types. Since any of them can
745 /// be candidate for synthesis.
746 static void
DiagnosePropertyMismatchDeclInProtocols(Sema & S,SourceLocation AtLoc,ObjCInterfaceDecl * ClassDecl,ObjCPropertyDecl * Property)747 DiagnosePropertyMismatchDeclInProtocols(Sema &S, SourceLocation AtLoc,
748 ObjCInterfaceDecl *ClassDecl,
749 ObjCPropertyDecl *Property) {
750 ObjCInterfaceDecl::ProtocolPropertyMap PropMap;
751 for (const auto *PI : ClassDecl->all_referenced_protocols()) {
752 if (const ObjCProtocolDecl *PDecl = PI->getDefinition())
753 PDecl->collectInheritedProtocolProperties(Property, PropMap);
754 }
755 if (ObjCInterfaceDecl *SDecl = ClassDecl->getSuperClass())
756 while (SDecl) {
757 for (const auto *PI : SDecl->all_referenced_protocols()) {
758 if (const ObjCProtocolDecl *PDecl = PI->getDefinition())
759 PDecl->collectInheritedProtocolProperties(Property, PropMap);
760 }
761 SDecl = SDecl->getSuperClass();
762 }
763
764 if (PropMap.empty())
765 return;
766
767 QualType RHSType = S.Context.getCanonicalType(Property->getType());
768 bool FirsTime = true;
769 for (ObjCInterfaceDecl::ProtocolPropertyMap::iterator
770 I = PropMap.begin(), E = PropMap.end(); I != E; I++) {
771 ObjCPropertyDecl *Prop = I->second;
772 QualType LHSType = S.Context.getCanonicalType(Prop->getType());
773 if (!S.Context.propertyTypesAreCompatible(LHSType, RHSType)) {
774 bool IncompatibleObjC = false;
775 QualType ConvertedType;
776 if (!S.isObjCPointerConversion(RHSType, LHSType, ConvertedType, IncompatibleObjC)
777 || IncompatibleObjC) {
778 if (FirsTime) {
779 S.Diag(Property->getLocation(), diag::warn_protocol_property_mismatch)
780 << Property->getType();
781 FirsTime = false;
782 }
783 S.Diag(Prop->getLocation(), diag::note_protocol_property_declare)
784 << Prop->getType();
785 }
786 }
787 }
788 if (!FirsTime && AtLoc.isValid())
789 S.Diag(AtLoc, diag::note_property_synthesize);
790 }
791
792 /// ActOnPropertyImplDecl - This routine performs semantic checks and
793 /// builds the AST node for a property implementation declaration; declared
794 /// as \@synthesize or \@dynamic.
795 ///
ActOnPropertyImplDecl(Scope * S,SourceLocation AtLoc,SourceLocation PropertyLoc,bool Synthesize,IdentifierInfo * PropertyId,IdentifierInfo * PropertyIvar,SourceLocation PropertyIvarLoc)796 Decl *Sema::ActOnPropertyImplDecl(Scope *S,
797 SourceLocation AtLoc,
798 SourceLocation PropertyLoc,
799 bool Synthesize,
800 IdentifierInfo *PropertyId,
801 IdentifierInfo *PropertyIvar,
802 SourceLocation PropertyIvarLoc) {
803 ObjCContainerDecl *ClassImpDecl =
804 dyn_cast<ObjCContainerDecl>(CurContext);
805 // Make sure we have a context for the property implementation declaration.
806 if (!ClassImpDecl) {
807 Diag(AtLoc, diag::error_missing_property_context);
808 return nullptr;
809 }
810 if (PropertyIvarLoc.isInvalid())
811 PropertyIvarLoc = PropertyLoc;
812 SourceLocation PropertyDiagLoc = PropertyLoc;
813 if (PropertyDiagLoc.isInvalid())
814 PropertyDiagLoc = ClassImpDecl->getLocStart();
815 ObjCPropertyDecl *property = nullptr;
816 ObjCInterfaceDecl *IDecl = nullptr;
817 // Find the class or category class where this property must have
818 // a declaration.
819 ObjCImplementationDecl *IC = nullptr;
820 ObjCCategoryImplDecl *CatImplClass = nullptr;
821 if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {
822 IDecl = IC->getClassInterface();
823 // We always synthesize an interface for an implementation
824 // without an interface decl. So, IDecl is always non-zero.
825 assert(IDecl &&
826 "ActOnPropertyImplDecl - @implementation without @interface");
827
828 // Look for this property declaration in the @implementation's @interface
829 property = IDecl->FindPropertyDeclaration(PropertyId);
830 if (!property) {
831 Diag(PropertyLoc, diag::error_bad_property_decl) << IDecl->getDeclName();
832 return nullptr;
833 }
834 unsigned PIkind = property->getPropertyAttributesAsWritten();
835 if ((PIkind & (ObjCPropertyDecl::OBJC_PR_atomic |
836 ObjCPropertyDecl::OBJC_PR_nonatomic) ) == 0) {
837 if (AtLoc.isValid())
838 Diag(AtLoc, diag::warn_implicit_atomic_property);
839 else
840 Diag(IC->getLocation(), diag::warn_auto_implicit_atomic_property);
841 Diag(property->getLocation(), diag::note_property_declare);
842 }
843
844 if (const ObjCCategoryDecl *CD =
845 dyn_cast<ObjCCategoryDecl>(property->getDeclContext())) {
846 if (!CD->IsClassExtension()) {
847 Diag(PropertyLoc, diag::error_category_property) << CD->getDeclName();
848 Diag(property->getLocation(), diag::note_property_declare);
849 return nullptr;
850 }
851 }
852 if (Synthesize&&
853 (PIkind & ObjCPropertyDecl::OBJC_PR_readonly) &&
854 property->hasAttr<IBOutletAttr>() &&
855 !AtLoc.isValid()) {
856 bool ReadWriteProperty = false;
857 // Search into the class extensions and see if 'readonly property is
858 // redeclared 'readwrite', then no warning is to be issued.
859 for (auto *Ext : IDecl->known_extensions()) {
860 DeclContext::lookup_result R = Ext->lookup(property->getDeclName());
861 if (!R.empty())
862 if (ObjCPropertyDecl *ExtProp = dyn_cast<ObjCPropertyDecl>(R[0])) {
863 PIkind = ExtProp->getPropertyAttributesAsWritten();
864 if (PIkind & ObjCPropertyDecl::OBJC_PR_readwrite) {
865 ReadWriteProperty = true;
866 break;
867 }
868 }
869 }
870
871 if (!ReadWriteProperty) {
872 Diag(property->getLocation(), diag::warn_auto_readonly_iboutlet_property)
873 << property;
874 SourceLocation readonlyLoc;
875 if (LocPropertyAttribute(Context, "readonly",
876 property->getLParenLoc(), readonlyLoc)) {
877 SourceLocation endLoc =
878 readonlyLoc.getLocWithOffset(strlen("readonly")-1);
879 SourceRange ReadonlySourceRange(readonlyLoc, endLoc);
880 Diag(property->getLocation(),
881 diag::note_auto_readonly_iboutlet_fixup_suggest) <<
882 FixItHint::CreateReplacement(ReadonlySourceRange, "readwrite");
883 }
884 }
885 }
886 if (Synthesize && isa<ObjCProtocolDecl>(property->getDeclContext()))
887 DiagnosePropertyMismatchDeclInProtocols(*this, AtLoc, IDecl, property);
888
889 } else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) {
890 if (Synthesize) {
891 Diag(AtLoc, diag::error_synthesize_category_decl);
892 return nullptr;
893 }
894 IDecl = CatImplClass->getClassInterface();
895 if (!IDecl) {
896 Diag(AtLoc, diag::error_missing_property_interface);
897 return nullptr;
898 }
899 ObjCCategoryDecl *Category =
900 IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier());
901
902 // If category for this implementation not found, it is an error which
903 // has already been reported eralier.
904 if (!Category)
905 return nullptr;
906 // Look for this property declaration in @implementation's category
907 property = Category->FindPropertyDeclaration(PropertyId);
908 if (!property) {
909 Diag(PropertyLoc, diag::error_bad_category_property_decl)
910 << Category->getDeclName();
911 return nullptr;
912 }
913 } else {
914 Diag(AtLoc, diag::error_bad_property_context);
915 return nullptr;
916 }
917 ObjCIvarDecl *Ivar = nullptr;
918 bool CompleteTypeErr = false;
919 bool compat = true;
920 // Check that we have a valid, previously declared ivar for @synthesize
921 if (Synthesize) {
922 // @synthesize
923 if (!PropertyIvar)
924 PropertyIvar = PropertyId;
925 // Check that this is a previously declared 'ivar' in 'IDecl' interface
926 ObjCInterfaceDecl *ClassDeclared;
927 Ivar = IDecl->lookupInstanceVariable(PropertyIvar, ClassDeclared);
928 QualType PropType = property->getType();
929 QualType PropertyIvarType = PropType.getNonReferenceType();
930
931 if (RequireCompleteType(PropertyDiagLoc, PropertyIvarType,
932 diag::err_incomplete_synthesized_property,
933 property->getDeclName())) {
934 Diag(property->getLocation(), diag::note_property_declare);
935 CompleteTypeErr = true;
936 }
937
938 if (getLangOpts().ObjCAutoRefCount &&
939 (property->getPropertyAttributesAsWritten() &
940 ObjCPropertyDecl::OBJC_PR_readonly) &&
941 PropertyIvarType->isObjCRetainableType()) {
942 setImpliedPropertyAttributeForReadOnlyProperty(property, Ivar);
943 }
944
945 ObjCPropertyDecl::PropertyAttributeKind kind
946 = property->getPropertyAttributes();
947
948 // Add GC __weak to the ivar type if the property is weak.
949 if ((kind & ObjCPropertyDecl::OBJC_PR_weak) &&
950 getLangOpts().getGC() != LangOptions::NonGC) {
951 assert(!getLangOpts().ObjCAutoRefCount);
952 if (PropertyIvarType.isObjCGCStrong()) {
953 Diag(PropertyDiagLoc, diag::err_gc_weak_property_strong_type);
954 Diag(property->getLocation(), diag::note_property_declare);
955 } else {
956 PropertyIvarType =
957 Context.getObjCGCQualType(PropertyIvarType, Qualifiers::Weak);
958 }
959 }
960 if (AtLoc.isInvalid()) {
961 // Check when default synthesizing a property that there is
962 // an ivar matching property name and issue warning; since this
963 // is the most common case of not using an ivar used for backing
964 // property in non-default synthesis case.
965 ObjCInterfaceDecl *ClassDeclared=nullptr;
966 ObjCIvarDecl *originalIvar =
967 IDecl->lookupInstanceVariable(property->getIdentifier(),
968 ClassDeclared);
969 if (originalIvar) {
970 Diag(PropertyDiagLoc,
971 diag::warn_autosynthesis_property_ivar_match)
972 << PropertyId << (Ivar == nullptr) << PropertyIvar
973 << originalIvar->getIdentifier();
974 Diag(property->getLocation(), diag::note_property_declare);
975 Diag(originalIvar->getLocation(), diag::note_ivar_decl);
976 }
977 }
978
979 if (!Ivar) {
980 // In ARC, give the ivar a lifetime qualifier based on the
981 // property attributes.
982 if (getLangOpts().ObjCAutoRefCount &&
983 !PropertyIvarType.getObjCLifetime() &&
984 PropertyIvarType->isObjCRetainableType()) {
985
986 // It's an error if we have to do this and the user didn't
987 // explicitly write an ownership attribute on the property.
988 if (!property->hasWrittenStorageAttribute() &&
989 !(kind & ObjCPropertyDecl::OBJC_PR_strong)) {
990 Diag(PropertyDiagLoc,
991 diag::err_arc_objc_property_default_assign_on_object);
992 Diag(property->getLocation(), diag::note_property_declare);
993 } else {
994 Qualifiers::ObjCLifetime lifetime =
995 getImpliedARCOwnership(kind, PropertyIvarType);
996 assert(lifetime && "no lifetime for property?");
997 if (lifetime == Qualifiers::OCL_Weak) {
998 bool err = false;
999 if (const ObjCObjectPointerType *ObjT =
1000 PropertyIvarType->getAs<ObjCObjectPointerType>()) {
1001 const ObjCInterfaceDecl *ObjI = ObjT->getInterfaceDecl();
1002 if (ObjI && ObjI->isArcWeakrefUnavailable()) {
1003 Diag(property->getLocation(),
1004 diag::err_arc_weak_unavailable_property) << PropertyIvarType;
1005 Diag(ClassImpDecl->getLocation(), diag::note_implemented_by_class)
1006 << ClassImpDecl->getName();
1007 err = true;
1008 }
1009 }
1010 if (!err && !getLangOpts().ObjCARCWeak) {
1011 Diag(PropertyDiagLoc, diag::err_arc_weak_no_runtime);
1012 Diag(property->getLocation(), diag::note_property_declare);
1013 }
1014 }
1015
1016 Qualifiers qs;
1017 qs.addObjCLifetime(lifetime);
1018 PropertyIvarType = Context.getQualifiedType(PropertyIvarType, qs);
1019 }
1020 }
1021
1022 if (kind & ObjCPropertyDecl::OBJC_PR_weak &&
1023 !getLangOpts().ObjCAutoRefCount &&
1024 getLangOpts().getGC() == LangOptions::NonGC) {
1025 Diag(PropertyDiagLoc, diag::error_synthesize_weak_non_arc_or_gc);
1026 Diag(property->getLocation(), diag::note_property_declare);
1027 }
1028
1029 Ivar = ObjCIvarDecl::Create(Context, ClassImpDecl,
1030 PropertyIvarLoc,PropertyIvarLoc, PropertyIvar,
1031 PropertyIvarType, /*Dinfo=*/nullptr,
1032 ObjCIvarDecl::Private,
1033 (Expr *)nullptr, true);
1034 if (RequireNonAbstractType(PropertyIvarLoc,
1035 PropertyIvarType,
1036 diag::err_abstract_type_in_decl,
1037 AbstractSynthesizedIvarType)) {
1038 Diag(property->getLocation(), diag::note_property_declare);
1039 Ivar->setInvalidDecl();
1040 } else if (CompleteTypeErr)
1041 Ivar->setInvalidDecl();
1042 ClassImpDecl->addDecl(Ivar);
1043 IDecl->makeDeclVisibleInContext(Ivar);
1044
1045 if (getLangOpts().ObjCRuntime.isFragile())
1046 Diag(PropertyDiagLoc, diag::error_missing_property_ivar_decl)
1047 << PropertyId;
1048 // Note! I deliberately want it to fall thru so, we have a
1049 // a property implementation and to avoid future warnings.
1050 } else if (getLangOpts().ObjCRuntime.isNonFragile() &&
1051 !declaresSameEntity(ClassDeclared, IDecl)) {
1052 Diag(PropertyDiagLoc, diag::error_ivar_in_superclass_use)
1053 << property->getDeclName() << Ivar->getDeclName()
1054 << ClassDeclared->getDeclName();
1055 Diag(Ivar->getLocation(), diag::note_previous_access_declaration)
1056 << Ivar << Ivar->getName();
1057 // Note! I deliberately want it to fall thru so more errors are caught.
1058 }
1059 property->setPropertyIvarDecl(Ivar);
1060
1061 QualType IvarType = Context.getCanonicalType(Ivar->getType());
1062
1063 // Check that type of property and its ivar are type compatible.
1064 if (!Context.hasSameType(PropertyIvarType, IvarType)) {
1065 if (isa<ObjCObjectPointerType>(PropertyIvarType)
1066 && isa<ObjCObjectPointerType>(IvarType))
1067 compat =
1068 Context.canAssignObjCInterfaces(
1069 PropertyIvarType->getAs<ObjCObjectPointerType>(),
1070 IvarType->getAs<ObjCObjectPointerType>());
1071 else {
1072 compat = (CheckAssignmentConstraints(PropertyIvarLoc, PropertyIvarType,
1073 IvarType)
1074 == Compatible);
1075 }
1076 if (!compat) {
1077 Diag(PropertyDiagLoc, diag::error_property_ivar_type)
1078 << property->getDeclName() << PropType
1079 << Ivar->getDeclName() << IvarType;
1080 Diag(Ivar->getLocation(), diag::note_ivar_decl);
1081 // Note! I deliberately want it to fall thru so, we have a
1082 // a property implementation and to avoid future warnings.
1083 }
1084 else {
1085 // FIXME! Rules for properties are somewhat different that those
1086 // for assignments. Use a new routine to consolidate all cases;
1087 // specifically for property redeclarations as well as for ivars.
1088 QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
1089 QualType rhsType =Context.getCanonicalType(IvarType).getUnqualifiedType();
1090 if (lhsType != rhsType &&
1091 lhsType->isArithmeticType()) {
1092 Diag(PropertyDiagLoc, diag::error_property_ivar_type)
1093 << property->getDeclName() << PropType
1094 << Ivar->getDeclName() << IvarType;
1095 Diag(Ivar->getLocation(), diag::note_ivar_decl);
1096 // Fall thru - see previous comment
1097 }
1098 }
1099 // __weak is explicit. So it works on Canonical type.
1100 if ((PropType.isObjCGCWeak() && !IvarType.isObjCGCWeak() &&
1101 getLangOpts().getGC() != LangOptions::NonGC)) {
1102 Diag(PropertyDiagLoc, diag::error_weak_property)
1103 << property->getDeclName() << Ivar->getDeclName();
1104 Diag(Ivar->getLocation(), diag::note_ivar_decl);
1105 // Fall thru - see previous comment
1106 }
1107 // Fall thru - see previous comment
1108 if ((property->getType()->isObjCObjectPointerType() ||
1109 PropType.isObjCGCStrong()) && IvarType.isObjCGCWeak() &&
1110 getLangOpts().getGC() != LangOptions::NonGC) {
1111 Diag(PropertyDiagLoc, diag::error_strong_property)
1112 << property->getDeclName() << Ivar->getDeclName();
1113 // Fall thru - see previous comment
1114 }
1115 }
1116 if (getLangOpts().ObjCAutoRefCount)
1117 checkARCPropertyImpl(*this, PropertyLoc, property, Ivar);
1118 } else if (PropertyIvar)
1119 // @dynamic
1120 Diag(PropertyDiagLoc, diag::error_dynamic_property_ivar_decl);
1121
1122 assert (property && "ActOnPropertyImplDecl - property declaration missing");
1123 ObjCPropertyImplDecl *PIDecl =
1124 ObjCPropertyImplDecl::Create(Context, CurContext, AtLoc, PropertyLoc,
1125 property,
1126 (Synthesize ?
1127 ObjCPropertyImplDecl::Synthesize
1128 : ObjCPropertyImplDecl::Dynamic),
1129 Ivar, PropertyIvarLoc);
1130
1131 if (CompleteTypeErr || !compat)
1132 PIDecl->setInvalidDecl();
1133
1134 if (ObjCMethodDecl *getterMethod = property->getGetterMethodDecl()) {
1135 getterMethod->createImplicitParams(Context, IDecl);
1136 if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
1137 Ivar->getType()->isRecordType()) {
1138 // For Objective-C++, need to synthesize the AST for the IVAR object to be
1139 // returned by the getter as it must conform to C++'s copy-return rules.
1140 // FIXME. Eventually we want to do this for Objective-C as well.
1141 SynthesizedFunctionScope Scope(*this, getterMethod);
1142 ImplicitParamDecl *SelfDecl = getterMethod->getSelfDecl();
1143 DeclRefExpr *SelfExpr =
1144 new (Context) DeclRefExpr(SelfDecl, false, SelfDecl->getType(),
1145 VK_LValue, PropertyDiagLoc);
1146 MarkDeclRefReferenced(SelfExpr);
1147 Expr *LoadSelfExpr =
1148 ImplicitCastExpr::Create(Context, SelfDecl->getType(),
1149 CK_LValueToRValue, SelfExpr, nullptr,
1150 VK_RValue);
1151 Expr *IvarRefExpr =
1152 new (Context) ObjCIvarRefExpr(Ivar, Ivar->getType(), PropertyDiagLoc,
1153 Ivar->getLocation(),
1154 LoadSelfExpr, true, true);
1155 ExprResult Res = PerformCopyInitialization(
1156 InitializedEntity::InitializeResult(PropertyDiagLoc,
1157 getterMethod->getReturnType(),
1158 /*NRVO=*/false),
1159 PropertyDiagLoc, IvarRefExpr);
1160 if (!Res.isInvalid()) {
1161 Expr *ResExpr = Res.getAs<Expr>();
1162 if (ResExpr)
1163 ResExpr = MaybeCreateExprWithCleanups(ResExpr);
1164 PIDecl->setGetterCXXConstructor(ResExpr);
1165 }
1166 }
1167 if (property->hasAttr<NSReturnsNotRetainedAttr>() &&
1168 !getterMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
1169 Diag(getterMethod->getLocation(),
1170 diag::warn_property_getter_owning_mismatch);
1171 Diag(property->getLocation(), diag::note_property_declare);
1172 }
1173 if (getLangOpts().ObjCAutoRefCount && Synthesize)
1174 switch (getterMethod->getMethodFamily()) {
1175 case OMF_retain:
1176 case OMF_retainCount:
1177 case OMF_release:
1178 case OMF_autorelease:
1179 Diag(getterMethod->getLocation(), diag::err_arc_illegal_method_def)
1180 << 1 << getterMethod->getSelector();
1181 break;
1182 default:
1183 break;
1184 }
1185 }
1186 if (ObjCMethodDecl *setterMethod = property->getSetterMethodDecl()) {
1187 setterMethod->createImplicitParams(Context, IDecl);
1188 if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
1189 Ivar->getType()->isRecordType()) {
1190 // FIXME. Eventually we want to do this for Objective-C as well.
1191 SynthesizedFunctionScope Scope(*this, setterMethod);
1192 ImplicitParamDecl *SelfDecl = setterMethod->getSelfDecl();
1193 DeclRefExpr *SelfExpr =
1194 new (Context) DeclRefExpr(SelfDecl, false, SelfDecl->getType(),
1195 VK_LValue, PropertyDiagLoc);
1196 MarkDeclRefReferenced(SelfExpr);
1197 Expr *LoadSelfExpr =
1198 ImplicitCastExpr::Create(Context, SelfDecl->getType(),
1199 CK_LValueToRValue, SelfExpr, nullptr,
1200 VK_RValue);
1201 Expr *lhs =
1202 new (Context) ObjCIvarRefExpr(Ivar, Ivar->getType(), PropertyDiagLoc,
1203 Ivar->getLocation(),
1204 LoadSelfExpr, true, true);
1205 ObjCMethodDecl::param_iterator P = setterMethod->param_begin();
1206 ParmVarDecl *Param = (*P);
1207 QualType T = Param->getType().getNonReferenceType();
1208 DeclRefExpr *rhs = new (Context) DeclRefExpr(Param, false, T,
1209 VK_LValue, PropertyDiagLoc);
1210 MarkDeclRefReferenced(rhs);
1211 ExprResult Res = BuildBinOp(S, PropertyDiagLoc,
1212 BO_Assign, lhs, rhs);
1213 if (property->getPropertyAttributes() &
1214 ObjCPropertyDecl::OBJC_PR_atomic) {
1215 Expr *callExpr = Res.getAs<Expr>();
1216 if (const CXXOperatorCallExpr *CXXCE =
1217 dyn_cast_or_null<CXXOperatorCallExpr>(callExpr))
1218 if (const FunctionDecl *FuncDecl = CXXCE->getDirectCallee())
1219 if (!FuncDecl->isTrivial())
1220 if (property->getType()->isReferenceType()) {
1221 Diag(PropertyDiagLoc,
1222 diag::err_atomic_property_nontrivial_assign_op)
1223 << property->getType();
1224 Diag(FuncDecl->getLocStart(),
1225 diag::note_callee_decl) << FuncDecl;
1226 }
1227 }
1228 PIDecl->setSetterCXXAssignment(Res.getAs<Expr>());
1229 }
1230 }
1231
1232 if (IC) {
1233 if (Synthesize)
1234 if (ObjCPropertyImplDecl *PPIDecl =
1235 IC->FindPropertyImplIvarDecl(PropertyIvar)) {
1236 Diag(PropertyLoc, diag::error_duplicate_ivar_use)
1237 << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
1238 << PropertyIvar;
1239 Diag(PPIDecl->getLocation(), diag::note_previous_use);
1240 }
1241
1242 if (ObjCPropertyImplDecl *PPIDecl
1243 = IC->FindPropertyImplDecl(PropertyId)) {
1244 Diag(PropertyLoc, diag::error_property_implemented) << PropertyId;
1245 Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
1246 return nullptr;
1247 }
1248 IC->addPropertyImplementation(PIDecl);
1249 if (getLangOpts().ObjCDefaultSynthProperties &&
1250 getLangOpts().ObjCRuntime.isNonFragile() &&
1251 !IDecl->isObjCRequiresPropertyDefs()) {
1252 // Diagnose if an ivar was lazily synthesdized due to a previous
1253 // use and if 1) property is @dynamic or 2) property is synthesized
1254 // but it requires an ivar of different name.
1255 ObjCInterfaceDecl *ClassDeclared=nullptr;
1256 ObjCIvarDecl *Ivar = nullptr;
1257 if (!Synthesize)
1258 Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
1259 else {
1260 if (PropertyIvar && PropertyIvar != PropertyId)
1261 Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
1262 }
1263 // Issue diagnostics only if Ivar belongs to current class.
1264 if (Ivar && Ivar->getSynthesize() &&
1265 declaresSameEntity(IC->getClassInterface(), ClassDeclared)) {
1266 Diag(Ivar->getLocation(), diag::err_undeclared_var_use)
1267 << PropertyId;
1268 Ivar->setInvalidDecl();
1269 }
1270 }
1271 } else {
1272 if (Synthesize)
1273 if (ObjCPropertyImplDecl *PPIDecl =
1274 CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) {
1275 Diag(PropertyDiagLoc, 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 CatImplClass->FindPropertyImplDecl(PropertyId)) {
1283 Diag(PropertyDiagLoc, diag::error_property_implemented) << PropertyId;
1284 Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
1285 return nullptr;
1286 }
1287 CatImplClass->addPropertyImplementation(PIDecl);
1288 }
1289
1290 return PIDecl;
1291 }
1292
1293 //===----------------------------------------------------------------------===//
1294 // Helper methods.
1295 //===----------------------------------------------------------------------===//
1296
1297 /// DiagnosePropertyMismatch - Compares two properties for their
1298 /// attributes and types and warns on a variety of inconsistencies.
1299 ///
1300 void
DiagnosePropertyMismatch(ObjCPropertyDecl * Property,ObjCPropertyDecl * SuperProperty,const IdentifierInfo * inheritedName,bool OverridingProtocolProperty)1301 Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
1302 ObjCPropertyDecl *SuperProperty,
1303 const IdentifierInfo *inheritedName,
1304 bool OverridingProtocolProperty) {
1305 ObjCPropertyDecl::PropertyAttributeKind CAttr =
1306 Property->getPropertyAttributes();
1307 ObjCPropertyDecl::PropertyAttributeKind SAttr =
1308 SuperProperty->getPropertyAttributes();
1309
1310 // We allow readonly properties without an explicit ownership
1311 // (assign/unsafe_unretained/weak/retain/strong/copy) in super class
1312 // to be overridden by a property with any explicit ownership in the subclass.
1313 if (!OverridingProtocolProperty &&
1314 !getOwnershipRule(SAttr) && getOwnershipRule(CAttr))
1315 ;
1316 else {
1317 if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly)
1318 && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite))
1319 Diag(Property->getLocation(), diag::warn_readonly_property)
1320 << Property->getDeclName() << inheritedName;
1321 if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy)
1322 != (SAttr & ObjCPropertyDecl::OBJC_PR_copy))
1323 Diag(Property->getLocation(), diag::warn_property_attribute)
1324 << Property->getDeclName() << "copy" << inheritedName;
1325 else if (!(SAttr & ObjCPropertyDecl::OBJC_PR_readonly)){
1326 unsigned CAttrRetain =
1327 (CAttr &
1328 (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
1329 unsigned SAttrRetain =
1330 (SAttr &
1331 (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
1332 bool CStrong = (CAttrRetain != 0);
1333 bool SStrong = (SAttrRetain != 0);
1334 if (CStrong != SStrong)
1335 Diag(Property->getLocation(), diag::warn_property_attribute)
1336 << Property->getDeclName() << "retain (or strong)" << inheritedName;
1337 }
1338 }
1339
1340 if ((CAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)
1341 != (SAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
1342 Diag(Property->getLocation(), diag::warn_property_attribute)
1343 << Property->getDeclName() << "atomic" << inheritedName;
1344 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1345 }
1346 if (Property->getSetterName() != SuperProperty->getSetterName()) {
1347 Diag(Property->getLocation(), diag::warn_property_attribute)
1348 << Property->getDeclName() << "setter" << inheritedName;
1349 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1350 }
1351 if (Property->getGetterName() != SuperProperty->getGetterName()) {
1352 Diag(Property->getLocation(), diag::warn_property_attribute)
1353 << Property->getDeclName() << "getter" << inheritedName;
1354 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1355 }
1356
1357 QualType LHSType =
1358 Context.getCanonicalType(SuperProperty->getType());
1359 QualType RHSType =
1360 Context.getCanonicalType(Property->getType());
1361
1362 if (!Context.propertyTypesAreCompatible(LHSType, RHSType)) {
1363 // Do cases not handled in above.
1364 // FIXME. For future support of covariant property types, revisit this.
1365 bool IncompatibleObjC = false;
1366 QualType ConvertedType;
1367 if (!isObjCPointerConversion(RHSType, LHSType,
1368 ConvertedType, IncompatibleObjC) ||
1369 IncompatibleObjC) {
1370 Diag(Property->getLocation(), diag::warn_property_types_are_incompatible)
1371 << Property->getType() << SuperProperty->getType() << inheritedName;
1372 Diag(SuperProperty->getLocation(), diag::note_property_declare);
1373 }
1374 }
1375 }
1376
DiagnosePropertyAccessorMismatch(ObjCPropertyDecl * property,ObjCMethodDecl * GetterMethod,SourceLocation Loc)1377 bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property,
1378 ObjCMethodDecl *GetterMethod,
1379 SourceLocation Loc) {
1380 if (!GetterMethod)
1381 return false;
1382 QualType GetterType = GetterMethod->getReturnType().getNonReferenceType();
1383 QualType PropertyIvarType = property->getType().getNonReferenceType();
1384 bool compat = Context.hasSameType(PropertyIvarType, GetterType);
1385 if (!compat) {
1386 if (isa<ObjCObjectPointerType>(PropertyIvarType) &&
1387 isa<ObjCObjectPointerType>(GetterType))
1388 compat =
1389 Context.canAssignObjCInterfaces(
1390 GetterType->getAs<ObjCObjectPointerType>(),
1391 PropertyIvarType->getAs<ObjCObjectPointerType>());
1392 else if (CheckAssignmentConstraints(Loc, GetterType, PropertyIvarType)
1393 != Compatible) {
1394 Diag(Loc, diag::error_property_accessor_type)
1395 << property->getDeclName() << PropertyIvarType
1396 << GetterMethod->getSelector() << GetterType;
1397 Diag(GetterMethod->getLocation(), diag::note_declared_at);
1398 return true;
1399 } else {
1400 compat = true;
1401 QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
1402 QualType rhsType =Context.getCanonicalType(GetterType).getUnqualifiedType();
1403 if (lhsType != rhsType && lhsType->isArithmeticType())
1404 compat = false;
1405 }
1406 }
1407
1408 if (!compat) {
1409 Diag(Loc, diag::warn_accessor_property_type_mismatch)
1410 << property->getDeclName()
1411 << GetterMethod->getSelector();
1412 Diag(GetterMethod->getLocation(), diag::note_declared_at);
1413 return true;
1414 }
1415
1416 return false;
1417 }
1418
1419 /// CollectImmediateProperties - This routine collects all properties in
1420 /// the class and its conforming protocols; but not those in its super class.
CollectImmediateProperties(ObjCContainerDecl * CDecl,ObjCContainerDecl::PropertyMap & PropMap,ObjCContainerDecl::PropertyMap & SuperPropMap,bool IncludeProtocols=true)1421 static void CollectImmediateProperties(ObjCContainerDecl *CDecl,
1422 ObjCContainerDecl::PropertyMap &PropMap,
1423 ObjCContainerDecl::PropertyMap &SuperPropMap,
1424 bool IncludeProtocols = true) {
1425
1426 if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
1427 for (auto *Prop : IDecl->properties())
1428 PropMap[Prop->getIdentifier()] = Prop;
1429 if (IncludeProtocols) {
1430 // Scan through class's protocols.
1431 for (auto *PI : IDecl->all_referenced_protocols())
1432 CollectImmediateProperties(PI, PropMap, SuperPropMap);
1433 }
1434 }
1435 if (ObjCCategoryDecl *CATDecl = dyn_cast<ObjCCategoryDecl>(CDecl)) {
1436 if (!CATDecl->IsClassExtension())
1437 for (auto *Prop : CATDecl->properties())
1438 PropMap[Prop->getIdentifier()] = Prop;
1439 if (IncludeProtocols) {
1440 // Scan through class's protocols.
1441 for (auto *PI : CATDecl->protocols())
1442 CollectImmediateProperties(PI, PropMap, SuperPropMap);
1443 }
1444 }
1445 else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(CDecl)) {
1446 for (auto *Prop : PDecl->properties()) {
1447 ObjCPropertyDecl *PropertyFromSuper = SuperPropMap[Prop->getIdentifier()];
1448 // Exclude property for protocols which conform to class's super-class,
1449 // as super-class has to implement the property.
1450 if (!PropertyFromSuper ||
1451 PropertyFromSuper->getIdentifier() != Prop->getIdentifier()) {
1452 ObjCPropertyDecl *&PropEntry = PropMap[Prop->getIdentifier()];
1453 if (!PropEntry)
1454 PropEntry = Prop;
1455 }
1456 }
1457 // scan through protocol's protocols.
1458 for (auto *PI : PDecl->protocols())
1459 CollectImmediateProperties(PI, PropMap, SuperPropMap);
1460 }
1461 }
1462
1463 /// CollectSuperClassPropertyImplementations - This routine collects list of
1464 /// properties to be implemented in super class(s) and also coming from their
1465 /// conforming protocols.
CollectSuperClassPropertyImplementations(ObjCInterfaceDecl * CDecl,ObjCInterfaceDecl::PropertyMap & PropMap)1466 static void CollectSuperClassPropertyImplementations(ObjCInterfaceDecl *CDecl,
1467 ObjCInterfaceDecl::PropertyMap &PropMap) {
1468 if (ObjCInterfaceDecl *SDecl = CDecl->getSuperClass()) {
1469 ObjCInterfaceDecl::PropertyDeclOrder PO;
1470 while (SDecl) {
1471 SDecl->collectPropertiesToImplement(PropMap, PO);
1472 SDecl = SDecl->getSuperClass();
1473 }
1474 }
1475 }
1476
1477 /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
1478 /// an ivar synthesized for 'Method' and 'Method' is a property accessor
1479 /// declared in class 'IFace'.
1480 bool
IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl * IFace,ObjCMethodDecl * Method,ObjCIvarDecl * IV)1481 Sema::IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
1482 ObjCMethodDecl *Method, ObjCIvarDecl *IV) {
1483 if (!IV->getSynthesize())
1484 return false;
1485 ObjCMethodDecl *IMD = IFace->lookupMethod(Method->getSelector(),
1486 Method->isInstanceMethod());
1487 if (!IMD || !IMD->isPropertyAccessor())
1488 return false;
1489
1490 // look up a property declaration whose one of its accessors is implemented
1491 // by this method.
1492 for (const auto *Property : IFace->properties()) {
1493 if ((Property->getGetterName() == IMD->getSelector() ||
1494 Property->getSetterName() == IMD->getSelector()) &&
1495 (Property->getPropertyIvarDecl() == IV))
1496 return true;
1497 }
1498 return false;
1499 }
1500
SuperClassImplementsProperty(ObjCInterfaceDecl * IDecl,ObjCPropertyDecl * Prop)1501 static bool SuperClassImplementsProperty(ObjCInterfaceDecl *IDecl,
1502 ObjCPropertyDecl *Prop) {
1503 bool SuperClassImplementsGetter = false;
1504 bool SuperClassImplementsSetter = false;
1505 if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
1506 SuperClassImplementsSetter = true;
1507
1508 while (IDecl->getSuperClass()) {
1509 ObjCInterfaceDecl *SDecl = IDecl->getSuperClass();
1510 if (!SuperClassImplementsGetter && SDecl->getInstanceMethod(Prop->getGetterName()))
1511 SuperClassImplementsGetter = true;
1512
1513 if (!SuperClassImplementsSetter && SDecl->getInstanceMethod(Prop->getSetterName()))
1514 SuperClassImplementsSetter = true;
1515 if (SuperClassImplementsGetter && SuperClassImplementsSetter)
1516 return true;
1517 IDecl = IDecl->getSuperClass();
1518 }
1519 return false;
1520 }
1521
1522 /// \brief Default synthesizes all properties which must be synthesized
1523 /// in class's \@implementation.
DefaultSynthesizeProperties(Scope * S,ObjCImplDecl * IMPDecl,ObjCInterfaceDecl * IDecl)1524 void Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl* IMPDecl,
1525 ObjCInterfaceDecl *IDecl) {
1526
1527 ObjCInterfaceDecl::PropertyMap PropMap;
1528 ObjCInterfaceDecl::PropertyDeclOrder PropertyOrder;
1529 IDecl->collectPropertiesToImplement(PropMap, PropertyOrder);
1530 if (PropMap.empty())
1531 return;
1532 ObjCInterfaceDecl::PropertyMap SuperPropMap;
1533 CollectSuperClassPropertyImplementations(IDecl, SuperPropMap);
1534
1535 for (unsigned i = 0, e = PropertyOrder.size(); i != e; i++) {
1536 ObjCPropertyDecl *Prop = PropertyOrder[i];
1537 // Is there a matching property synthesize/dynamic?
1538 if (Prop->isInvalidDecl() ||
1539 Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1540 continue;
1541 // Property may have been synthesized by user.
1542 if (IMPDecl->FindPropertyImplDecl(Prop->getIdentifier()))
1543 continue;
1544 if (IMPDecl->getInstanceMethod(Prop->getGetterName())) {
1545 if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
1546 continue;
1547 if (IMPDecl->getInstanceMethod(Prop->getSetterName()))
1548 continue;
1549 }
1550 // If property to be implemented in the super class, ignore.
1551 if (SuperPropMap[Prop->getIdentifier()]) {
1552 ObjCPropertyDecl *PropInSuperClass = SuperPropMap[Prop->getIdentifier()];
1553 if ((Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readwrite) &&
1554 (PropInSuperClass->getPropertyAttributes() &
1555 ObjCPropertyDecl::OBJC_PR_readonly) &&
1556 !IMPDecl->getInstanceMethod(Prop->getSetterName()) &&
1557 !IDecl->HasUserDeclaredSetterMethod(Prop)) {
1558 Diag(Prop->getLocation(), diag::warn_no_autosynthesis_property)
1559 << Prop->getIdentifier();
1560 Diag(PropInSuperClass->getLocation(), diag::note_property_declare);
1561 }
1562 continue;
1563 }
1564 if (ObjCPropertyImplDecl *PID =
1565 IMPDecl->FindPropertyImplIvarDecl(Prop->getIdentifier())) {
1566 if (PID->getPropertyDecl() != Prop) {
1567 Diag(Prop->getLocation(), diag::warn_no_autosynthesis_shared_ivar_property)
1568 << Prop->getIdentifier();
1569 if (!PID->getLocation().isInvalid())
1570 Diag(PID->getLocation(), diag::note_property_synthesize);
1571 }
1572 continue;
1573 }
1574 if (ObjCProtocolDecl *Proto =
1575 dyn_cast<ObjCProtocolDecl>(Prop->getDeclContext())) {
1576 // We won't auto-synthesize properties declared in protocols.
1577 // Suppress the warning if class's superclass implements property's
1578 // getter and implements property's setter (if readwrite property).
1579 if (!SuperClassImplementsProperty(IDecl, Prop)) {
1580 Diag(IMPDecl->getLocation(),
1581 diag::warn_auto_synthesizing_protocol_property)
1582 << Prop << Proto;
1583 Diag(Prop->getLocation(), diag::note_property_declare);
1584 }
1585 continue;
1586 }
1587
1588 // We use invalid SourceLocations for the synthesized ivars since they
1589 // aren't really synthesized at a particular location; they just exist.
1590 // Saying that they are located at the @implementation isn't really going
1591 // to help users.
1592 ObjCPropertyImplDecl *PIDecl = dyn_cast_or_null<ObjCPropertyImplDecl>(
1593 ActOnPropertyImplDecl(S, SourceLocation(), SourceLocation(),
1594 true,
1595 /* property = */ Prop->getIdentifier(),
1596 /* ivar = */ Prop->getDefaultSynthIvarName(Context),
1597 Prop->getLocation()));
1598 if (PIDecl) {
1599 Diag(Prop->getLocation(), diag::warn_missing_explicit_synthesis);
1600 Diag(IMPDecl->getLocation(), diag::note_while_in_implementation);
1601 }
1602 }
1603 }
1604
DefaultSynthesizeProperties(Scope * S,Decl * D)1605 void Sema::DefaultSynthesizeProperties(Scope *S, Decl *D) {
1606 if (!LangOpts.ObjCDefaultSynthProperties || LangOpts.ObjCRuntime.isFragile())
1607 return;
1608 ObjCImplementationDecl *IC=dyn_cast_or_null<ObjCImplementationDecl>(D);
1609 if (!IC)
1610 return;
1611 if (ObjCInterfaceDecl* IDecl = IC->getClassInterface())
1612 if (!IDecl->isObjCRequiresPropertyDefs())
1613 DefaultSynthesizeProperties(S, IC, IDecl);
1614 }
1615
DiagnoseUnimplementedAccessor(Sema & S,ObjCInterfaceDecl * PrimaryClass,Selector Method,ObjCImplDecl * IMPDecl,ObjCContainerDecl * CDecl,ObjCCategoryDecl * C,ObjCPropertyDecl * Prop,Sema::SelectorSet & SMap)1616 static void DiagnoseUnimplementedAccessor(Sema &S,
1617 ObjCInterfaceDecl *PrimaryClass,
1618 Selector Method,
1619 ObjCImplDecl* IMPDecl,
1620 ObjCContainerDecl *CDecl,
1621 ObjCCategoryDecl *C,
1622 ObjCPropertyDecl *Prop,
1623 Sema::SelectorSet &SMap) {
1624 // When reporting on missing property setter/getter implementation in
1625 // categories, do not report when they are declared in primary class,
1626 // class's protocol, or one of it super classes. This is because,
1627 // the class is going to implement them.
1628 if (!SMap.count(Method) &&
1629 (PrimaryClass == nullptr ||
1630 !PrimaryClass->lookupPropertyAccessor(Method, C))) {
1631 S.Diag(IMPDecl->getLocation(),
1632 isa<ObjCCategoryDecl>(CDecl) ?
1633 diag::warn_setter_getter_impl_required_in_category :
1634 diag::warn_setter_getter_impl_required)
1635 << Prop->getDeclName() << Method;
1636 S.Diag(Prop->getLocation(),
1637 diag::note_property_declare);
1638 if (S.LangOpts.ObjCDefaultSynthProperties &&
1639 S.LangOpts.ObjCRuntime.isNonFragile())
1640 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CDecl))
1641 if (const ObjCInterfaceDecl *RID = ID->isObjCRequiresPropertyDefs())
1642 S.Diag(RID->getLocation(), diag::note_suppressed_class_declare);
1643 }
1644 }
1645
DiagnoseUnimplementedProperties(Scope * S,ObjCImplDecl * IMPDecl,ObjCContainerDecl * CDecl,bool SynthesizeProperties)1646 void Sema::DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
1647 ObjCContainerDecl *CDecl,
1648 bool SynthesizeProperties) {
1649 ObjCContainerDecl::PropertyMap PropMap;
1650 ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl);
1651
1652 if (!SynthesizeProperties) {
1653 ObjCContainerDecl::PropertyMap NoNeedToImplPropMap;
1654 // Gather properties which need not be implemented in this class
1655 // or category.
1656 if (!IDecl)
1657 if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
1658 // For categories, no need to implement properties declared in
1659 // its primary class (and its super classes) if property is
1660 // declared in one of those containers.
1661 if ((IDecl = C->getClassInterface())) {
1662 ObjCInterfaceDecl::PropertyDeclOrder PO;
1663 IDecl->collectPropertiesToImplement(NoNeedToImplPropMap, PO);
1664 }
1665 }
1666 if (IDecl)
1667 CollectSuperClassPropertyImplementations(IDecl, NoNeedToImplPropMap);
1668
1669 CollectImmediateProperties(CDecl, PropMap, NoNeedToImplPropMap);
1670 }
1671
1672 // Scan the @interface to see if any of the protocols it adopts
1673 // require an explicit implementation, via attribute
1674 // 'objc_protocol_requires_explicit_implementation'.
1675 if (IDecl) {
1676 std::unique_ptr<ObjCContainerDecl::PropertyMap> LazyMap;
1677
1678 for (auto *PDecl : IDecl->all_referenced_protocols()) {
1679 if (!PDecl->hasAttr<ObjCExplicitProtocolImplAttr>())
1680 continue;
1681 // Lazily construct a set of all the properties in the @interface
1682 // of the class, without looking at the superclass. We cannot
1683 // use the call to CollectImmediateProperties() above as that
1684 // utilizes information from the super class's properties as well
1685 // as scans the adopted protocols. This work only triggers for protocols
1686 // with the attribute, which is very rare, and only occurs when
1687 // analyzing the @implementation.
1688 if (!LazyMap) {
1689 ObjCContainerDecl::PropertyMap NoNeedToImplPropMap;
1690 LazyMap.reset(new ObjCContainerDecl::PropertyMap());
1691 CollectImmediateProperties(CDecl, *LazyMap, NoNeedToImplPropMap,
1692 /* IncludeProtocols */ false);
1693 }
1694 // Add the properties of 'PDecl' to the list of properties that
1695 // need to be implemented.
1696 for (auto *PropDecl : PDecl->properties()) {
1697 if ((*LazyMap)[PropDecl->getIdentifier()])
1698 continue;
1699 PropMap[PropDecl->getIdentifier()] = PropDecl;
1700 }
1701 }
1702 }
1703
1704 if (PropMap.empty())
1705 return;
1706
1707 llvm::DenseSet<ObjCPropertyDecl *> PropImplMap;
1708 for (const auto *I : IMPDecl->property_impls())
1709 PropImplMap.insert(I->getPropertyDecl());
1710
1711 SelectorSet InsMap;
1712 // Collect property accessors implemented in current implementation.
1713 for (const auto *I : IMPDecl->instance_methods())
1714 InsMap.insert(I->getSelector());
1715
1716 ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
1717 ObjCInterfaceDecl *PrimaryClass = nullptr;
1718 if (C && !C->IsClassExtension())
1719 if ((PrimaryClass = C->getClassInterface()))
1720 // Report unimplemented properties in the category as well.
1721 if (ObjCImplDecl *IMP = PrimaryClass->getImplementation()) {
1722 // When reporting on missing setter/getters, do not report when
1723 // setter/getter is implemented in category's primary class
1724 // implementation.
1725 for (const auto *I : IMP->instance_methods())
1726 InsMap.insert(I->getSelector());
1727 }
1728
1729 for (ObjCContainerDecl::PropertyMap::iterator
1730 P = PropMap.begin(), E = PropMap.end(); P != E; ++P) {
1731 ObjCPropertyDecl *Prop = P->second;
1732 // Is there a matching propery synthesize/dynamic?
1733 if (Prop->isInvalidDecl() ||
1734 Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional ||
1735 PropImplMap.count(Prop) ||
1736 Prop->getAvailability() == AR_Unavailable)
1737 continue;
1738
1739 // Diagnose unimplemented getters and setters.
1740 DiagnoseUnimplementedAccessor(*this,
1741 PrimaryClass, Prop->getGetterName(), IMPDecl, CDecl, C, Prop, InsMap);
1742 if (!Prop->isReadOnly())
1743 DiagnoseUnimplementedAccessor(*this,
1744 PrimaryClass, Prop->getSetterName(),
1745 IMPDecl, CDecl, C, Prop, InsMap);
1746 }
1747 }
1748
1749 void
AtomicPropertySetterGetterRules(ObjCImplDecl * IMPDecl,ObjCContainerDecl * IDecl)1750 Sema::AtomicPropertySetterGetterRules (ObjCImplDecl* IMPDecl,
1751 ObjCContainerDecl* IDecl) {
1752 // Rules apply in non-GC mode only
1753 if (getLangOpts().getGC() != LangOptions::NonGC)
1754 return;
1755 for (const auto *Property : IDecl->properties()) {
1756 ObjCMethodDecl *GetterMethod = nullptr;
1757 ObjCMethodDecl *SetterMethod = nullptr;
1758 bool LookedUpGetterSetter = false;
1759
1760 unsigned Attributes = Property->getPropertyAttributes();
1761 unsigned AttributesAsWritten = Property->getPropertyAttributesAsWritten();
1762
1763 if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic) &&
1764 !(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
1765 GetterMethod = IMPDecl->getInstanceMethod(Property->getGetterName());
1766 SetterMethod = IMPDecl->getInstanceMethod(Property->getSetterName());
1767 LookedUpGetterSetter = true;
1768 if (GetterMethod) {
1769 Diag(GetterMethod->getLocation(),
1770 diag::warn_default_atomic_custom_getter_setter)
1771 << Property->getIdentifier() << 0;
1772 Diag(Property->getLocation(), diag::note_property_declare);
1773 }
1774 if (SetterMethod) {
1775 Diag(SetterMethod->getLocation(),
1776 diag::warn_default_atomic_custom_getter_setter)
1777 << Property->getIdentifier() << 1;
1778 Diag(Property->getLocation(), diag::note_property_declare);
1779 }
1780 }
1781
1782 // We only care about readwrite atomic property.
1783 if ((Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) ||
1784 !(Attributes & ObjCPropertyDecl::OBJC_PR_readwrite))
1785 continue;
1786 if (const ObjCPropertyImplDecl *PIDecl
1787 = IMPDecl->FindPropertyImplDecl(Property->getIdentifier())) {
1788 if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
1789 continue;
1790 if (!LookedUpGetterSetter) {
1791 GetterMethod = IMPDecl->getInstanceMethod(Property->getGetterName());
1792 SetterMethod = IMPDecl->getInstanceMethod(Property->getSetterName());
1793 }
1794 if ((GetterMethod && !SetterMethod) || (!GetterMethod && SetterMethod)) {
1795 SourceLocation MethodLoc =
1796 (GetterMethod ? GetterMethod->getLocation()
1797 : SetterMethod->getLocation());
1798 Diag(MethodLoc, diag::warn_atomic_property_rule)
1799 << Property->getIdentifier() << (GetterMethod != nullptr)
1800 << (SetterMethod != nullptr);
1801 // fixit stuff.
1802 if (!AttributesAsWritten) {
1803 if (Property->getLParenLoc().isValid()) {
1804 // @property () ... case.
1805 SourceRange PropSourceRange(Property->getAtLoc(),
1806 Property->getLParenLoc());
1807 Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) <<
1808 FixItHint::CreateReplacement(PropSourceRange, "@property (nonatomic");
1809 }
1810 else {
1811 //@property id etc.
1812 SourceLocation endLoc =
1813 Property->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
1814 endLoc = endLoc.getLocWithOffset(-1);
1815 SourceRange PropSourceRange(Property->getAtLoc(), endLoc);
1816 Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) <<
1817 FixItHint::CreateReplacement(PropSourceRange, "@property (nonatomic) ");
1818 }
1819 }
1820 else if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic)) {
1821 // @property () ... case.
1822 SourceLocation endLoc = Property->getLParenLoc();
1823 SourceRange PropSourceRange(Property->getAtLoc(), endLoc);
1824 Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) <<
1825 FixItHint::CreateReplacement(PropSourceRange, "@property (nonatomic, ");
1826 }
1827 else
1828 Diag(MethodLoc, diag::note_atomic_property_fixup_suggest);
1829 Diag(Property->getLocation(), diag::note_property_declare);
1830 }
1831 }
1832 }
1833 }
1834
DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl * D)1835 void Sema::DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D) {
1836 if (getLangOpts().getGC() == LangOptions::GCOnly)
1837 return;
1838
1839 for (const auto *PID : D->property_impls()) {
1840 const ObjCPropertyDecl *PD = PID->getPropertyDecl();
1841 if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() &&
1842 !D->getInstanceMethod(PD->getGetterName())) {
1843 ObjCMethodDecl *method = PD->getGetterMethodDecl();
1844 if (!method)
1845 continue;
1846 ObjCMethodFamily family = method->getMethodFamily();
1847 if (family == OMF_alloc || family == OMF_copy ||
1848 family == OMF_mutableCopy || family == OMF_new) {
1849 if (getLangOpts().ObjCAutoRefCount)
1850 Diag(PD->getLocation(), diag::err_cocoa_naming_owned_rule);
1851 else
1852 Diag(PD->getLocation(), diag::warn_cocoa_naming_owned_rule);
1853 }
1854 }
1855 }
1856 }
1857
DiagnoseMissingDesignatedInitOverrides(const ObjCImplementationDecl * ImplD,const ObjCInterfaceDecl * IFD)1858 void Sema::DiagnoseMissingDesignatedInitOverrides(
1859 const ObjCImplementationDecl *ImplD,
1860 const ObjCInterfaceDecl *IFD) {
1861 assert(IFD->hasDesignatedInitializers());
1862 const ObjCInterfaceDecl *SuperD = IFD->getSuperClass();
1863 if (!SuperD)
1864 return;
1865
1866 SelectorSet InitSelSet;
1867 for (const auto *I : ImplD->instance_methods())
1868 if (I->getMethodFamily() == OMF_init)
1869 InitSelSet.insert(I->getSelector());
1870
1871 SmallVector<const ObjCMethodDecl *, 8> DesignatedInits;
1872 SuperD->getDesignatedInitializers(DesignatedInits);
1873 for (SmallVector<const ObjCMethodDecl *, 8>::iterator
1874 I = DesignatedInits.begin(), E = DesignatedInits.end(); I != E; ++I) {
1875 const ObjCMethodDecl *MD = *I;
1876 if (!InitSelSet.count(MD->getSelector())) {
1877 Diag(ImplD->getLocation(),
1878 diag::warn_objc_implementation_missing_designated_init_override)
1879 << MD->getSelector();
1880 Diag(MD->getLocation(), diag::note_objc_designated_init_marked_here);
1881 }
1882 }
1883 }
1884
1885 /// AddPropertyAttrs - Propagates attributes from a property to the
1886 /// implicitly-declared getter or setter for that property.
AddPropertyAttrs(Sema & S,ObjCMethodDecl * PropertyMethod,ObjCPropertyDecl * Property)1887 static void AddPropertyAttrs(Sema &S, ObjCMethodDecl *PropertyMethod,
1888 ObjCPropertyDecl *Property) {
1889 // Should we just clone all attributes over?
1890 for (const auto *A : Property->attrs()) {
1891 if (isa<DeprecatedAttr>(A) ||
1892 isa<UnavailableAttr>(A) ||
1893 isa<AvailabilityAttr>(A))
1894 PropertyMethod->addAttr(A->clone(S.Context));
1895 }
1896 }
1897
1898 /// ProcessPropertyDecl - Make sure that any user-defined setter/getter methods
1899 /// have the property type and issue diagnostics if they don't.
1900 /// Also synthesize a getter/setter method if none exist (and update the
1901 /// appropriate lookup tables. FIXME: Should reconsider if adding synthesized
1902 /// methods is the "right" thing to do.
ProcessPropertyDecl(ObjCPropertyDecl * property,ObjCContainerDecl * CD,ObjCPropertyDecl * redeclaredProperty,ObjCContainerDecl * lexicalDC)1903 void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property,
1904 ObjCContainerDecl *CD,
1905 ObjCPropertyDecl *redeclaredProperty,
1906 ObjCContainerDecl *lexicalDC) {
1907
1908 ObjCMethodDecl *GetterMethod, *SetterMethod;
1909
1910 if (CD->isInvalidDecl())
1911 return;
1912
1913 GetterMethod = CD->getInstanceMethod(property->getGetterName());
1914 SetterMethod = CD->getInstanceMethod(property->getSetterName());
1915 DiagnosePropertyAccessorMismatch(property, GetterMethod,
1916 property->getLocation());
1917
1918 if (SetterMethod) {
1919 ObjCPropertyDecl::PropertyAttributeKind CAttr =
1920 property->getPropertyAttributes();
1921 if ((!(CAttr & ObjCPropertyDecl::OBJC_PR_readonly)) &&
1922 Context.getCanonicalType(SetterMethod->getReturnType()) !=
1923 Context.VoidTy)
1924 Diag(SetterMethod->getLocation(), diag::err_setter_type_void);
1925 if (SetterMethod->param_size() != 1 ||
1926 !Context.hasSameUnqualifiedType(
1927 (*SetterMethod->param_begin())->getType().getNonReferenceType(),
1928 property->getType().getNonReferenceType())) {
1929 Diag(property->getLocation(),
1930 diag::warn_accessor_property_type_mismatch)
1931 << property->getDeclName()
1932 << SetterMethod->getSelector();
1933 Diag(SetterMethod->getLocation(), diag::note_declared_at);
1934 }
1935 }
1936
1937 // Synthesize getter/setter methods if none exist.
1938 // Find the default getter and if one not found, add one.
1939 // FIXME: The synthesized property we set here is misleading. We almost always
1940 // synthesize these methods unless the user explicitly provided prototypes
1941 // (which is odd, but allowed). Sema should be typechecking that the
1942 // declarations jive in that situation (which it is not currently).
1943 if (!GetterMethod) {
1944 // No instance method of same name as property getter name was found.
1945 // Declare a getter method and add it to the list of methods
1946 // for this class.
1947 SourceLocation Loc = redeclaredProperty ?
1948 redeclaredProperty->getLocation() :
1949 property->getLocation();
1950
1951 GetterMethod = ObjCMethodDecl::Create(Context, Loc, Loc,
1952 property->getGetterName(),
1953 property->getType(), nullptr, CD,
1954 /*isInstance=*/true, /*isVariadic=*/false,
1955 /*isPropertyAccessor=*/true,
1956 /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1957 (property->getPropertyImplementation() ==
1958 ObjCPropertyDecl::Optional) ?
1959 ObjCMethodDecl::Optional :
1960 ObjCMethodDecl::Required);
1961 CD->addDecl(GetterMethod);
1962
1963 AddPropertyAttrs(*this, GetterMethod, property);
1964
1965 // FIXME: Eventually this shouldn't be needed, as the lexical context
1966 // and the real context should be the same.
1967 if (lexicalDC)
1968 GetterMethod->setLexicalDeclContext(lexicalDC);
1969 if (property->hasAttr<NSReturnsNotRetainedAttr>())
1970 GetterMethod->addAttr(NSReturnsNotRetainedAttr::CreateImplicit(Context,
1971 Loc));
1972
1973 if (property->hasAttr<ObjCReturnsInnerPointerAttr>())
1974 GetterMethod->addAttr(
1975 ObjCReturnsInnerPointerAttr::CreateImplicit(Context, Loc));
1976
1977 if (const SectionAttr *SA = property->getAttr<SectionAttr>())
1978 GetterMethod->addAttr(
1979 SectionAttr::CreateImplicit(Context, SectionAttr::GNU_section,
1980 SA->getName(), Loc));
1981
1982 if (getLangOpts().ObjCAutoRefCount)
1983 CheckARCMethodDecl(GetterMethod);
1984 } else
1985 // A user declared getter will be synthesize when @synthesize of
1986 // the property with the same name is seen in the @implementation
1987 GetterMethod->setPropertyAccessor(true);
1988 property->setGetterMethodDecl(GetterMethod);
1989
1990 // Skip setter if property is read-only.
1991 if (!property->isReadOnly()) {
1992 // Find the default setter and if one not found, add one.
1993 if (!SetterMethod) {
1994 // No instance method of same name as property setter name was found.
1995 // Declare a setter method and add it to the list of methods
1996 // for this class.
1997 SourceLocation Loc = redeclaredProperty ?
1998 redeclaredProperty->getLocation() :
1999 property->getLocation();
2000
2001 SetterMethod =
2002 ObjCMethodDecl::Create(Context, Loc, Loc,
2003 property->getSetterName(), Context.VoidTy,
2004 nullptr, CD, /*isInstance=*/true,
2005 /*isVariadic=*/false,
2006 /*isPropertyAccessor=*/true,
2007 /*isImplicitlyDeclared=*/true,
2008 /*isDefined=*/false,
2009 (property->getPropertyImplementation() ==
2010 ObjCPropertyDecl::Optional) ?
2011 ObjCMethodDecl::Optional :
2012 ObjCMethodDecl::Required);
2013
2014 // Invent the arguments for the setter. We don't bother making a
2015 // nice name for the argument.
2016 ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterMethod,
2017 Loc, Loc,
2018 property->getIdentifier(),
2019 property->getType().getUnqualifiedType(),
2020 /*TInfo=*/nullptr,
2021 SC_None,
2022 nullptr);
2023 SetterMethod->setMethodParams(Context, Argument, None);
2024
2025 AddPropertyAttrs(*this, SetterMethod, property);
2026
2027 CD->addDecl(SetterMethod);
2028 // FIXME: Eventually this shouldn't be needed, as the lexical context
2029 // and the real context should be the same.
2030 if (lexicalDC)
2031 SetterMethod->setLexicalDeclContext(lexicalDC);
2032 if (const SectionAttr *SA = property->getAttr<SectionAttr>())
2033 SetterMethod->addAttr(
2034 SectionAttr::CreateImplicit(Context, SectionAttr::GNU_section,
2035 SA->getName(), Loc));
2036 // It's possible for the user to have set a very odd custom
2037 // setter selector that causes it to have a method family.
2038 if (getLangOpts().ObjCAutoRefCount)
2039 CheckARCMethodDecl(SetterMethod);
2040 } else
2041 // A user declared setter will be synthesize when @synthesize of
2042 // the property with the same name is seen in the @implementation
2043 SetterMethod->setPropertyAccessor(true);
2044 property->setSetterMethodDecl(SetterMethod);
2045 }
2046 // Add any synthesized methods to the global pool. This allows us to
2047 // handle the following, which is supported by GCC (and part of the design).
2048 //
2049 // @interface Foo
2050 // @property double bar;
2051 // @end
2052 //
2053 // void thisIsUnfortunate() {
2054 // id foo;
2055 // double bar = [foo bar];
2056 // }
2057 //
2058 if (GetterMethod)
2059 AddInstanceMethodToGlobalPool(GetterMethod);
2060 if (SetterMethod)
2061 AddInstanceMethodToGlobalPool(SetterMethod);
2062
2063 ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(CD);
2064 if (!CurrentClass) {
2065 if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(CD))
2066 CurrentClass = Cat->getClassInterface();
2067 else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(CD))
2068 CurrentClass = Impl->getClassInterface();
2069 }
2070 if (GetterMethod)
2071 CheckObjCMethodOverrides(GetterMethod, CurrentClass, Sema::RTC_Unknown);
2072 if (SetterMethod)
2073 CheckObjCMethodOverrides(SetterMethod, CurrentClass, Sema::RTC_Unknown);
2074 }
2075
CheckObjCPropertyAttributes(Decl * PDecl,SourceLocation Loc,unsigned & Attributes,bool propertyInPrimaryClass)2076 void Sema::CheckObjCPropertyAttributes(Decl *PDecl,
2077 SourceLocation Loc,
2078 unsigned &Attributes,
2079 bool propertyInPrimaryClass) {
2080 // FIXME: Improve the reported location.
2081 if (!PDecl || PDecl->isInvalidDecl())
2082 return;
2083
2084 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2085 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
2086 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2087 << "readonly" << "readwrite";
2088
2089 ObjCPropertyDecl *PropertyDecl = cast<ObjCPropertyDecl>(PDecl);
2090 QualType PropertyTy = PropertyDecl->getType();
2091 unsigned PropertyOwnership = getOwnershipRule(Attributes);
2092
2093 // 'readonly' property with no obvious lifetime.
2094 // its life time will be determined by its backing ivar.
2095 if (getLangOpts().ObjCAutoRefCount &&
2096 Attributes & ObjCDeclSpec::DQ_PR_readonly &&
2097 PropertyTy->isObjCRetainableType() &&
2098 !PropertyOwnership)
2099 return;
2100
2101 // Check for copy or retain on non-object types.
2102 if ((Attributes & (ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
2103 ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong)) &&
2104 !PropertyTy->isObjCRetainableType() &&
2105 !PropertyDecl->hasAttr<ObjCNSObjectAttr>()) {
2106 Diag(Loc, diag::err_objc_property_requires_object)
2107 << (Attributes & ObjCDeclSpec::DQ_PR_weak ? "weak" :
2108 Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain (or strong)");
2109 Attributes &= ~(ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
2110 ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong);
2111 PropertyDecl->setInvalidDecl();
2112 }
2113
2114 // Check for more than one of { assign, copy, retain }.
2115 if (Attributes & ObjCDeclSpec::DQ_PR_assign) {
2116 if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
2117 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2118 << "assign" << "copy";
2119 Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
2120 }
2121 if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
2122 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2123 << "assign" << "retain";
2124 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2125 }
2126 if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
2127 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2128 << "assign" << "strong";
2129 Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
2130 }
2131 if (getLangOpts().ObjCAutoRefCount &&
2132 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2133 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2134 << "assign" << "weak";
2135 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2136 }
2137 if (PropertyDecl->hasAttr<IBOutletCollectionAttr>())
2138 Diag(Loc, diag::warn_iboutletcollection_property_assign);
2139 } else if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) {
2140 if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
2141 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2142 << "unsafe_unretained" << "copy";
2143 Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
2144 }
2145 if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
2146 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2147 << "unsafe_unretained" << "retain";
2148 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2149 }
2150 if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
2151 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2152 << "unsafe_unretained" << "strong";
2153 Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
2154 }
2155 if (getLangOpts().ObjCAutoRefCount &&
2156 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2157 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2158 << "unsafe_unretained" << "weak";
2159 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2160 }
2161 } else if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
2162 if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
2163 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2164 << "copy" << "retain";
2165 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2166 }
2167 if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
2168 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2169 << "copy" << "strong";
2170 Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
2171 }
2172 if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
2173 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2174 << "copy" << "weak";
2175 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2176 }
2177 }
2178 else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
2179 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2180 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2181 << "retain" << "weak";
2182 Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2183 }
2184 else if ((Attributes & ObjCDeclSpec::DQ_PR_strong) &&
2185 (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2186 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2187 << "strong" << "weak";
2188 Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2189 }
2190
2191 if ((Attributes & ObjCDeclSpec::DQ_PR_atomic) &&
2192 (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)) {
2193 Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2194 << "atomic" << "nonatomic";
2195 Attributes &= ~ObjCDeclSpec::DQ_PR_atomic;
2196 }
2197
2198 // Warn if user supplied no assignment attribute, property is
2199 // readwrite, and this is an object type.
2200 if (!(Attributes & (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_copy |
2201 ObjCDeclSpec::DQ_PR_unsafe_unretained |
2202 ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong |
2203 ObjCDeclSpec::DQ_PR_weak)) &&
2204 PropertyTy->isObjCObjectPointerType()) {
2205 if (getLangOpts().ObjCAutoRefCount)
2206 // With arc, @property definitions should default to (strong) when
2207 // not specified; including when property is 'readonly'.
2208 PropertyDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
2209 else if (!(Attributes & ObjCDeclSpec::DQ_PR_readonly)) {
2210 bool isAnyClassTy =
2211 (PropertyTy->isObjCClassType() ||
2212 PropertyTy->isObjCQualifiedClassType());
2213 // In non-gc, non-arc mode, 'Class' is treated as a 'void *' no need to
2214 // issue any warning.
2215 if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)
2216 ;
2217 else if (propertyInPrimaryClass) {
2218 // Don't issue warning on property with no life time in class
2219 // extension as it is inherited from property in primary class.
2220 // Skip this warning in gc-only mode.
2221 if (getLangOpts().getGC() != LangOptions::GCOnly)
2222 Diag(Loc, diag::warn_objc_property_no_assignment_attribute);
2223
2224 // If non-gc code warn that this is likely inappropriate.
2225 if (getLangOpts().getGC() == LangOptions::NonGC)
2226 Diag(Loc, diag::warn_objc_property_default_assign_on_object);
2227 }
2228 }
2229
2230 // FIXME: Implement warning dependent on NSCopying being
2231 // implemented. See also:
2232 // <rdar://5168496&4855821&5607453&5096644&4947311&5698469&4947014&5168496>
2233 // (please trim this list while you are at it).
2234 }
2235
2236 if (!(Attributes & ObjCDeclSpec::DQ_PR_copy)
2237 &&!(Attributes & ObjCDeclSpec::DQ_PR_readonly)
2238 && getLangOpts().getGC() == LangOptions::GCOnly
2239 && PropertyTy->isBlockPointerType())
2240 Diag(Loc, diag::warn_objc_property_copy_missing_on_block);
2241 else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
2242 !(Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2243 !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
2244 PropertyTy->isBlockPointerType())
2245 Diag(Loc, diag::warn_objc_property_retain_of_block);
2246
2247 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2248 (Attributes & ObjCDeclSpec::DQ_PR_setter))
2249 Diag(Loc, diag::warn_objc_readonly_property_has_setter);
2250
2251 }
2252