SemaObjCProperty.cpp revision 327a50f46449c946c42d50d97689bcb30e2af7d9 
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/Sema/Initialization.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/ExprObjC.h"
19#include "clang/AST/ExprCXX.h"
20#include "llvm/ADT/DenseSet.h"
21
22using namespace clang;
23
24//===----------------------------------------------------------------------===//
25// Grammar actions.
26//===----------------------------------------------------------------------===//
27
28/// getImpliedARCOwnership - Given a set of property attributes and a
29/// type, infer an expected lifetime.  The type's ownership qualification
30/// is not considered.
31///
32/// Returns OCL_None if the attributes as stated do not imply an ownership.
33/// Never returns OCL_Autoreleasing.
34static Qualifiers::ObjCLifetime getImpliedARCOwnership(
35                               ObjCPropertyDecl::PropertyAttributeKind attrs,
36                                                QualType type) {
37  // retain, strong, copy, weak, and unsafe_unretained are only legal
38  // on properties of retainable pointer type.
39  if (attrs & (ObjCPropertyDecl::OBJC_PR_retain |
40               ObjCPropertyDecl::OBJC_PR_strong |
41               ObjCPropertyDecl::OBJC_PR_copy)) {
42    return type->getObjCARCImplicitLifetime();
43  } else if (attrs & ObjCPropertyDecl::OBJC_PR_weak) {
44    return Qualifiers::OCL_Weak;
45  } else if (attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained) {
46    return Qualifiers::OCL_ExplicitNone;
47  }
48
49  // assign can appear on other types, so we have to check the
50  // property type.
51  if (attrs & ObjCPropertyDecl::OBJC_PR_assign &&
52      type->isObjCRetainableType()) {
53    return Qualifiers::OCL_ExplicitNone;
54  }
55
56  return Qualifiers::OCL_None;
57}
58
59/// Check the internal consistency of a property declaration.
60static void checkARCPropertyDecl(Sema &S, ObjCPropertyDecl *property) {
61  if (property->isInvalidDecl()) return;
62
63  ObjCPropertyDecl::PropertyAttributeKind propertyKind
64    = property->getPropertyAttributes();
65  Qualifiers::ObjCLifetime propertyLifetime
66    = property->getType().getObjCLifetime();
67
68  // Nothing to do if we don't have a lifetime.
69  if (propertyLifetime == Qualifiers::OCL_None) return;
70
71  Qualifiers::ObjCLifetime expectedLifetime
72    = getImpliedARCOwnership(propertyKind, property->getType());
73  if (!expectedLifetime) {
74    // We have a lifetime qualifier but no dominating property
75    // attribute.  That's okay, but restore reasonable invariants by
76    // setting the property attribute according to the lifetime
77    // qualifier.
78    ObjCPropertyDecl::PropertyAttributeKind attr;
79    if (propertyLifetime == Qualifiers::OCL_Strong) {
80      attr = ObjCPropertyDecl::OBJC_PR_strong;
81    } else if (propertyLifetime == Qualifiers::OCL_Weak) {
82      attr = ObjCPropertyDecl::OBJC_PR_weak;
83    } else {
84      assert(propertyLifetime == Qualifiers::OCL_ExplicitNone);
85      attr = ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
86    }
87    property->setPropertyAttributes(attr);
88    return;
89  }
90
91  if (propertyLifetime == expectedLifetime) return;
92
93  property->setInvalidDecl();
94  S.Diag(property->getLocation(),
95         diag::err_arc_inconsistent_property_ownership)
96    << property->getDeclName()
97    << expectedLifetime
98    << propertyLifetime;
99}
100
101Decl *Sema::ActOnProperty(Scope *S, SourceLocation AtLoc,
102                          FieldDeclarator &FD,
103                          ObjCDeclSpec &ODS,
104                          Selector GetterSel,
105                          Selector SetterSel,
106                          bool *isOverridingProperty,
107                          tok::ObjCKeywordKind MethodImplKind,
108                          DeclContext *lexicalDC) {
109  unsigned Attributes = ODS.getPropertyAttributes();
110  TypeSourceInfo *TSI = GetTypeForDeclarator(FD.D, S);
111  QualType T = TSI->getType();
112  if ((getLangOptions().getGC() != LangOptions::NonGC &&
113       T.isObjCGCWeak()) ||
114      (getLangOptions().ObjCAutoRefCount &&
115       T.getObjCLifetime() == Qualifiers::OCL_Weak))
116    Attributes |= ObjCDeclSpec::DQ_PR_weak;
117
118  bool isReadWrite = ((Attributes & ObjCDeclSpec::DQ_PR_readwrite) ||
119                      // default is readwrite!
120                      !(Attributes & ObjCDeclSpec::DQ_PR_readonly));
121  // property is defaulted to 'assign' if it is readwrite and is
122  // not retain or copy
123  bool isAssign = ((Attributes & ObjCDeclSpec::DQ_PR_assign) ||
124                   (isReadWrite &&
125                    !(Attributes & ObjCDeclSpec::DQ_PR_retain) &&
126                    !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
127                    !(Attributes & ObjCDeclSpec::DQ_PR_copy) &&
128                    !(Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) &&
129                    !(Attributes & ObjCDeclSpec::DQ_PR_weak)));
130
131  // Proceed with constructing the ObjCPropertDecls.
132  ObjCContainerDecl *ClassDecl = cast<ObjCContainerDecl>(CurContext);
133
134  if (ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl))
135    if (CDecl->IsClassExtension()) {
136      Decl *Res = HandlePropertyInClassExtension(S, AtLoc,
137                                           FD, GetterSel, SetterSel,
138                                           isAssign, isReadWrite,
139                                           Attributes,
140                                           isOverridingProperty, TSI,
141                                           MethodImplKind);
142      if (Res) {
143        CheckObjCPropertyAttributes(Res, AtLoc, Attributes);
144        if (getLangOptions().ObjCAutoRefCount)
145          checkARCPropertyDecl(*this, cast<ObjCPropertyDecl>(Res));
146      }
147      return Res;
148    }
149
150  ObjCPropertyDecl *Res = CreatePropertyDecl(S, ClassDecl, AtLoc, FD,
151                                             GetterSel, SetterSel,
152                                             isAssign, isReadWrite,
153                                             Attributes, TSI, MethodImplKind);
154  if (lexicalDC)
155    Res->setLexicalDeclContext(lexicalDC);
156
157  // Validate the attributes on the @property.
158  CheckObjCPropertyAttributes(Res, AtLoc, Attributes);
159
160  if (getLangOptions().ObjCAutoRefCount)
161    checkARCPropertyDecl(*this, Res);
162
163  return Res;
164}
165
166static ObjCPropertyDecl::PropertyAttributeKind
167makePropertyAttributesAsWritten(unsigned Attributes) {
168  unsigned attributesAsWritten = 0;
169  if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
170    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readonly;
171  if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
172    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_readwrite;
173  if (Attributes & ObjCDeclSpec::DQ_PR_getter)
174    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_getter;
175  if (Attributes & ObjCDeclSpec::DQ_PR_setter)
176    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_setter;
177  if (Attributes & ObjCDeclSpec::DQ_PR_assign)
178    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_assign;
179  if (Attributes & ObjCDeclSpec::DQ_PR_retain)
180    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_retain;
181  if (Attributes & ObjCDeclSpec::DQ_PR_strong)
182    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_strong;
183  if (Attributes & ObjCDeclSpec::DQ_PR_weak)
184    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_weak;
185  if (Attributes & ObjCDeclSpec::DQ_PR_copy)
186    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_copy;
187  if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
188    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_unsafe_unretained;
189  if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
190    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_nonatomic;
191  if (Attributes & ObjCDeclSpec::DQ_PR_atomic)
192    attributesAsWritten |= ObjCPropertyDecl::OBJC_PR_atomic;
193
194  return (ObjCPropertyDecl::PropertyAttributeKind)attributesAsWritten;
195}
196
197Decl *
198Sema::HandlePropertyInClassExtension(Scope *S,
199                                     SourceLocation AtLoc, FieldDeclarator &FD,
200                                     Selector GetterSel, Selector SetterSel,
201                                     const bool isAssign,
202                                     const bool isReadWrite,
203                                     const unsigned Attributes,
204                                     bool *isOverridingProperty,
205                                     TypeSourceInfo *T,
206                                     tok::ObjCKeywordKind MethodImplKind) {
207  ObjCCategoryDecl *CDecl = cast<ObjCCategoryDecl>(CurContext);
208  // Diagnose if this property is already in continuation class.
209  DeclContext *DC = CurContext;
210  IdentifierInfo *PropertyId = FD.D.getIdentifier();
211  ObjCInterfaceDecl *CCPrimary = CDecl->getClassInterface();
212
213  if (CCPrimary)
214    // Check for duplicate declaration of this property in current and
215    // other class extensions.
216    for (const ObjCCategoryDecl *ClsExtDecl =
217         CCPrimary->getFirstClassExtension();
218         ClsExtDecl; ClsExtDecl = ClsExtDecl->getNextClassExtension()) {
219      if (ObjCPropertyDecl *prevDecl =
220          ObjCPropertyDecl::findPropertyDecl(ClsExtDecl, PropertyId)) {
221        Diag(AtLoc, diag::err_duplicate_property);
222        Diag(prevDecl->getLocation(), diag::note_property_declare);
223        return 0;
224      }
225    }
226
227  // Create a new ObjCPropertyDecl with the DeclContext being
228  // the class extension.
229  // FIXME. We should really be using CreatePropertyDecl for this.
230  ObjCPropertyDecl *PDecl =
231    ObjCPropertyDecl::Create(Context, DC, FD.D.getIdentifierLoc(),
232                             PropertyId, AtLoc, T);
233  PDecl->setPropertyAttributesAsWritten(
234                                   makePropertyAttributesAsWritten(Attributes));
235  if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
236    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
237  if (Attributes & ObjCDeclSpec::DQ_PR_readwrite)
238    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
239  // Set setter/getter selector name. Needed later.
240  PDecl->setGetterName(GetterSel);
241  PDecl->setSetterName(SetterSel);
242  ProcessDeclAttributes(S, PDecl, FD.D);
243  DC->addDecl(PDecl);
244
245  // We need to look in the @interface to see if the @property was
246  // already declared.
247  if (!CCPrimary) {
248    Diag(CDecl->getLocation(), diag::err_continuation_class);
249    *isOverridingProperty = true;
250    return 0;
251  }
252
253  // Find the property in continuation class's primary class only.
254  ObjCPropertyDecl *PIDecl =
255    CCPrimary->FindPropertyVisibleInPrimaryClass(PropertyId);
256
257  if (!PIDecl) {
258    // No matching property found in the primary class. Just fall thru
259    // and add property to continuation class's primary class.
260    ObjCPropertyDecl *PDecl =
261      CreatePropertyDecl(S, CCPrimary, AtLoc,
262                         FD, GetterSel, SetterSel, isAssign, isReadWrite,
263                         Attributes, T, MethodImplKind, DC);
264
265    // A case of continuation class adding a new property in the class. This
266    // is not what it was meant for. However, gcc supports it and so should we.
267    // Make sure setter/getters are declared here.
268    ProcessPropertyDecl(PDecl, CCPrimary, /* redeclaredProperty = */ 0,
269                        /* lexicalDC = */ CDecl);
270    return PDecl;
271  }
272  if (PIDecl->getType().getCanonicalType()
273      != PDecl->getType().getCanonicalType()) {
274    Diag(AtLoc,
275         diag::warn_type_mismatch_continuation_class) << PDecl->getType();
276    Diag(PIDecl->getLocation(), diag::note_property_declare);
277  }
278
279  // The property 'PIDecl's readonly attribute will be over-ridden
280  // with continuation class's readwrite property attribute!
281  unsigned PIkind = PIDecl->getPropertyAttributesAsWritten();
282  if (isReadWrite && (PIkind & ObjCPropertyDecl::OBJC_PR_readonly)) {
283    unsigned retainCopyNonatomic =
284    (ObjCPropertyDecl::OBJC_PR_retain |
285     ObjCPropertyDecl::OBJC_PR_strong |
286     ObjCPropertyDecl::OBJC_PR_copy |
287     ObjCPropertyDecl::OBJC_PR_nonatomic);
288    if ((Attributes & retainCopyNonatomic) !=
289        (PIkind & retainCopyNonatomic)) {
290      Diag(AtLoc, diag::warn_property_attr_mismatch);
291      Diag(PIDecl->getLocation(), diag::note_property_declare);
292    }
293    DeclContext *DC = cast<DeclContext>(CCPrimary);
294    if (!ObjCPropertyDecl::findPropertyDecl(DC,
295                                 PIDecl->getDeclName().getAsIdentifierInfo())) {
296      // Protocol is not in the primary class. Must build one for it.
297      ObjCDeclSpec ProtocolPropertyODS;
298      // FIXME. Assuming that ObjCDeclSpec::ObjCPropertyAttributeKind
299      // and ObjCPropertyDecl::PropertyAttributeKind have identical
300      // values.  Should consolidate both into one enum type.
301      ProtocolPropertyODS.
302      setPropertyAttributes((ObjCDeclSpec::ObjCPropertyAttributeKind)
303                            PIkind);
304      // Must re-establish the context from class extension to primary
305      // class context.
306      ContextRAII SavedContext(*this, CCPrimary);
307
308      Decl *ProtocolPtrTy =
309        ActOnProperty(S, AtLoc, FD, ProtocolPropertyODS,
310                      PIDecl->getGetterName(),
311                      PIDecl->getSetterName(),
312                      isOverridingProperty,
313                      MethodImplKind,
314                      /* lexicalDC = */ CDecl);
315      PIDecl = cast<ObjCPropertyDecl>(ProtocolPtrTy);
316    }
317    PIDecl->makeitReadWriteAttribute();
318    if (Attributes & ObjCDeclSpec::DQ_PR_retain)
319      PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
320    if (Attributes & ObjCDeclSpec::DQ_PR_strong)
321      PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
322    if (Attributes & ObjCDeclSpec::DQ_PR_copy)
323      PIDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
324    PIDecl->setSetterName(SetterSel);
325  } else {
326    // Tailor the diagnostics for the common case where a readwrite
327    // property is declared both in the @interface and the continuation.
328    // This is a common error where the user often intended the original
329    // declaration to be readonly.
330    unsigned diag =
331      (Attributes & ObjCDeclSpec::DQ_PR_readwrite) &&
332      (PIkind & ObjCPropertyDecl::OBJC_PR_readwrite)
333      ? diag::err_use_continuation_class_redeclaration_readwrite
334      : diag::err_use_continuation_class;
335    Diag(AtLoc, diag)
336      << CCPrimary->getDeclName();
337    Diag(PIDecl->getLocation(), diag::note_property_declare);
338  }
339  *isOverridingProperty = true;
340  // Make sure setter decl is synthesized, and added to primary class's list.
341  ProcessPropertyDecl(PIDecl, CCPrimary, PDecl, CDecl);
342  return 0;
343}
344
345ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S,
346                                           ObjCContainerDecl *CDecl,
347                                           SourceLocation AtLoc,
348                                           FieldDeclarator &FD,
349                                           Selector GetterSel,
350                                           Selector SetterSel,
351                                           const bool isAssign,
352                                           const bool isReadWrite,
353                                           const unsigned Attributes,
354                                           TypeSourceInfo *TInfo,
355                                           tok::ObjCKeywordKind MethodImplKind,
356                                           DeclContext *lexicalDC){
357  IdentifierInfo *PropertyId = FD.D.getIdentifier();
358  QualType T = TInfo->getType();
359
360  // Issue a warning if property is 'assign' as default and its object, which is
361  // gc'able conforms to NSCopying protocol
362  if (getLangOptions().getGC() != LangOptions::NonGC &&
363      isAssign && !(Attributes & ObjCDeclSpec::DQ_PR_assign))
364    if (const ObjCObjectPointerType *ObjPtrTy =
365          T->getAs<ObjCObjectPointerType>()) {
366      ObjCInterfaceDecl *IDecl = ObjPtrTy->getObjectType()->getInterface();
367      if (IDecl)
368        if (ObjCProtocolDecl* PNSCopying =
369            LookupProtocol(&Context.Idents.get("NSCopying"), AtLoc))
370          if (IDecl->ClassImplementsProtocol(PNSCopying, true))
371            Diag(AtLoc, diag::warn_implements_nscopying) << PropertyId;
372    }
373  if (T->isObjCObjectType())
374    Diag(FD.D.getIdentifierLoc(), diag::err_statically_allocated_object);
375
376  DeclContext *DC = cast<DeclContext>(CDecl);
377  ObjCPropertyDecl *PDecl = ObjCPropertyDecl::Create(Context, DC,
378                                                     FD.D.getIdentifierLoc(),
379                                                     PropertyId, AtLoc, TInfo);
380
381  if (ObjCPropertyDecl *prevDecl =
382        ObjCPropertyDecl::findPropertyDecl(DC, PropertyId)) {
383    Diag(PDecl->getLocation(), diag::err_duplicate_property);
384    Diag(prevDecl->getLocation(), diag::note_property_declare);
385    PDecl->setInvalidDecl();
386  }
387  else {
388    DC->addDecl(PDecl);
389    if (lexicalDC)
390      PDecl->setLexicalDeclContext(lexicalDC);
391  }
392
393  if (T->isArrayType() || T->isFunctionType()) {
394    Diag(AtLoc, diag::err_property_type) << T;
395    PDecl->setInvalidDecl();
396  }
397
398  ProcessDeclAttributes(S, PDecl, FD.D);
399
400  // Regardless of setter/getter attribute, we save the default getter/setter
401  // selector names in anticipation of declaration of setter/getter methods.
402  PDecl->setGetterName(GetterSel);
403  PDecl->setSetterName(SetterSel);
404  PDecl->setPropertyAttributesAsWritten(
405                                   makePropertyAttributesAsWritten(Attributes));
406
407  if (Attributes & ObjCDeclSpec::DQ_PR_readonly)
408    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readonly);
409
410  if (Attributes & ObjCDeclSpec::DQ_PR_getter)
411    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_getter);
412
413  if (Attributes & ObjCDeclSpec::DQ_PR_setter)
414    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_setter);
415
416  if (isReadWrite)
417    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_readwrite);
418
419  if (Attributes & ObjCDeclSpec::DQ_PR_retain)
420    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_retain);
421
422  if (Attributes & ObjCDeclSpec::DQ_PR_strong)
423    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
424
425  if (Attributes & ObjCDeclSpec::DQ_PR_weak)
426    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_weak);
427
428  if (Attributes & ObjCDeclSpec::DQ_PR_copy)
429    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_copy);
430
431  if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
432    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
433
434  if (isAssign)
435    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
436
437  // In the semantic attributes, one of nonatomic or atomic is always set.
438  if (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)
439    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_nonatomic);
440  else
441    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_atomic);
442
443  // 'unsafe_unretained' is alias for 'assign'.
444  if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained)
445    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_assign);
446  if (isAssign)
447    PDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_unsafe_unretained);
448
449  if (MethodImplKind == tok::objc_required)
450    PDecl->setPropertyImplementation(ObjCPropertyDecl::Required);
451  else if (MethodImplKind == tok::objc_optional)
452    PDecl->setPropertyImplementation(ObjCPropertyDecl::Optional);
453
454  return PDecl;
455}
456
457static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc,
458                                 ObjCPropertyDecl *property,
459                                 ObjCIvarDecl *ivar) {
460  if (property->isInvalidDecl() || ivar->isInvalidDecl()) return;
461
462  QualType ivarType = ivar->getType();
463  Qualifiers::ObjCLifetime ivarLifetime = ivarType.getObjCLifetime();
464
465  // The lifetime implied by the property's attributes.
466  Qualifiers::ObjCLifetime propertyLifetime =
467    getImpliedARCOwnership(property->getPropertyAttributes(),
468                           property->getType());
469
470  // We're fine if they match.
471  if (propertyLifetime == ivarLifetime) return;
472
473  // These aren't valid lifetimes for object ivars;  don't diagnose twice.
474  if (ivarLifetime == Qualifiers::OCL_None ||
475      ivarLifetime == Qualifiers::OCL_Autoreleasing)
476    return;
477
478  switch (propertyLifetime) {
479  case Qualifiers::OCL_Strong:
480    S.Diag(propertyImplLoc, diag::err_arc_strong_property_ownership)
481      << property->getDeclName()
482      << ivar->getDeclName()
483      << ivarLifetime;
484    break;
485
486  case Qualifiers::OCL_Weak:
487    S.Diag(propertyImplLoc, diag::error_weak_property)
488      << property->getDeclName()
489      << ivar->getDeclName();
490    break;
491
492  case Qualifiers::OCL_ExplicitNone:
493    S.Diag(propertyImplLoc, diag::err_arc_assign_property_ownership)
494      << property->getDeclName()
495      << ivar->getDeclName()
496      << ((property->getPropertyAttributesAsWritten()
497           & ObjCPropertyDecl::OBJC_PR_assign) != 0);
498    break;
499
500  case Qualifiers::OCL_Autoreleasing:
501    llvm_unreachable("properties cannot be autoreleasing");
502
503  case Qualifiers::OCL_None:
504    // Any other property should be ignored.
505    return;
506  }
507
508  S.Diag(property->getLocation(), diag::note_property_declare);
509}
510
511
512/// ActOnPropertyImplDecl - This routine performs semantic checks and
513/// builds the AST node for a property implementation declaration; declared
514/// as @synthesize or @dynamic.
515///
516Decl *Sema::ActOnPropertyImplDecl(Scope *S,
517                                  SourceLocation AtLoc,
518                                  SourceLocation PropertyLoc,
519                                  bool Synthesize,
520                                  IdentifierInfo *PropertyId,
521                                  IdentifierInfo *PropertyIvar,
522                                  SourceLocation PropertyIvarLoc) {
523  ObjCContainerDecl *ClassImpDecl =
524    dyn_cast<ObjCContainerDecl>(CurContext);
525  // Make sure we have a context for the property implementation declaration.
526  if (!ClassImpDecl) {
527    Diag(AtLoc, diag::error_missing_property_context);
528    return 0;
529  }
530  ObjCPropertyDecl *property = 0;
531  ObjCInterfaceDecl* IDecl = 0;
532  // Find the class or category class where this property must have
533  // a declaration.
534  ObjCImplementationDecl *IC = 0;
535  ObjCCategoryImplDecl* CatImplClass = 0;
536  if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {
537    IDecl = IC->getClassInterface();
538    // We always synthesize an interface for an implementation
539    // without an interface decl. So, IDecl is always non-zero.
540    assert(IDecl &&
541           "ActOnPropertyImplDecl - @implementation without @interface");
542
543    // Look for this property declaration in the @implementation's @interface
544    property = IDecl->FindPropertyDeclaration(PropertyId);
545    if (!property) {
546      Diag(PropertyLoc, diag::error_bad_property_decl) << IDecl->getDeclName();
547      return 0;
548    }
549    unsigned PIkind = property->getPropertyAttributesAsWritten();
550    if ((PIkind & (ObjCPropertyDecl::OBJC_PR_atomic |
551                   ObjCPropertyDecl::OBJC_PR_nonatomic) ) == 0) {
552      if (AtLoc.isValid())
553        Diag(AtLoc, diag::warn_implicit_atomic_property);
554      else
555        Diag(IC->getLocation(), diag::warn_auto_implicit_atomic_property);
556      Diag(property->getLocation(), diag::note_property_declare);
557    }
558
559    if (const ObjCCategoryDecl *CD =
560        dyn_cast<ObjCCategoryDecl>(property->getDeclContext())) {
561      if (!CD->IsClassExtension()) {
562        Diag(PropertyLoc, diag::error_category_property) << CD->getDeclName();
563        Diag(property->getLocation(), diag::note_property_declare);
564        return 0;
565      }
566    }
567  } else if ((CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassImpDecl))) {
568    if (Synthesize) {
569      Diag(AtLoc, diag::error_synthesize_category_decl);
570      return 0;
571    }
572    IDecl = CatImplClass->getClassInterface();
573    if (!IDecl) {
574      Diag(AtLoc, diag::error_missing_property_interface);
575      return 0;
576    }
577    ObjCCategoryDecl *Category =
578    IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier());
579
580    // If category for this implementation not found, it is an error which
581    // has already been reported eralier.
582    if (!Category)
583      return 0;
584    // Look for this property declaration in @implementation's category
585    property = Category->FindPropertyDeclaration(PropertyId);
586    if (!property) {
587      Diag(PropertyLoc, diag::error_bad_category_property_decl)
588      << Category->getDeclName();
589      return 0;
590    }
591  } else {
592    Diag(AtLoc, diag::error_bad_property_context);
593    return 0;
594  }
595  ObjCIvarDecl *Ivar = 0;
596  // Check that we have a valid, previously declared ivar for @synthesize
597  if (Synthesize) {
598    // @synthesize
599    if (!PropertyIvar)
600      PropertyIvar = PropertyId;
601    ObjCPropertyDecl::PropertyAttributeKind kind
602      = property->getPropertyAttributes();
603    QualType PropType = property->getType();
604
605    QualType PropertyIvarType = PropType.getNonReferenceType();
606
607    // Add GC __weak to the ivar type if the property is weak.
608    if ((kind & ObjCPropertyDecl::OBJC_PR_weak) &&
609        getLangOptions().getGC() != LangOptions::NonGC) {
610      assert(!getLangOptions().ObjCAutoRefCount);
611      if (PropertyIvarType.isObjCGCStrong()) {
612        Diag(PropertyLoc, diag::err_gc_weak_property_strong_type);
613        Diag(property->getLocation(), diag::note_property_declare);
614      } else {
615        PropertyIvarType =
616          Context.getObjCGCQualType(PropertyIvarType, Qualifiers::Weak);
617      }
618    }
619
620    // Check that this is a previously declared 'ivar' in 'IDecl' interface
621    ObjCInterfaceDecl *ClassDeclared;
622    Ivar = IDecl->lookupInstanceVariable(PropertyIvar, ClassDeclared);
623    if (!Ivar) {
624      // In ARC, give the ivar a lifetime qualifier based on the
625      // property attributes.
626      if (getLangOptions().ObjCAutoRefCount &&
627          !PropertyIvarType.getObjCLifetime() &&
628          PropertyIvarType->isObjCRetainableType()) {
629
630        // It's an error if we have to do this and the user didn't
631        // explicitly write an ownership attribute on the property.
632        if (!property->hasWrittenStorageAttribute() &&
633            !(kind & ObjCPropertyDecl::OBJC_PR_strong)) {
634          Diag(PropertyLoc,
635               diag::err_arc_objc_property_default_assign_on_object);
636          Diag(property->getLocation(), diag::note_property_declare);
637        } else {
638          Qualifiers::ObjCLifetime lifetime =
639            getImpliedARCOwnership(kind, PropertyIvarType);
640          assert(lifetime && "no lifetime for property?");
641
642          if (lifetime == Qualifiers::OCL_Weak &&
643              !getLangOptions().ObjCRuntimeHasWeak) {
644            Diag(PropertyLoc, diag::err_arc_weak_no_runtime);
645            Diag(property->getLocation(), diag::note_property_declare);
646          }
647
648          Qualifiers qs;
649          qs.addObjCLifetime(lifetime);
650          PropertyIvarType = Context.getQualifiedType(PropertyIvarType, qs);
651        }
652      }
653
654      if (kind & ObjCPropertyDecl::OBJC_PR_weak &&
655          !getLangOptions().ObjCAutoRefCount &&
656          getLangOptions().getGC() == LangOptions::NonGC) {
657        Diag(PropertyLoc, diag::error_synthesize_weak_non_arc_or_gc);
658        Diag(property->getLocation(), diag::note_property_declare);
659      }
660
661      Ivar = ObjCIvarDecl::Create(Context, ClassImpDecl,
662                                  PropertyLoc, PropertyLoc, PropertyIvar,
663                                  PropertyIvarType, /*Dinfo=*/0,
664                                  ObjCIvarDecl::Private,
665                                  (Expr *)0, true);
666      ClassImpDecl->addDecl(Ivar);
667      IDecl->makeDeclVisibleInContext(Ivar, false);
668      property->setPropertyIvarDecl(Ivar);
669
670      if (!getLangOptions().ObjCNonFragileABI)
671        Diag(PropertyLoc, diag::error_missing_property_ivar_decl) << PropertyId;
672      // Note! I deliberately want it to fall thru so, we have a
673      // a property implementation and to avoid future warnings.
674    } else if (getLangOptions().ObjCNonFragileABI &&
675               ClassDeclared != IDecl) {
676      Diag(PropertyLoc, diag::error_ivar_in_superclass_use)
677      << property->getDeclName() << Ivar->getDeclName()
678      << ClassDeclared->getDeclName();
679      Diag(Ivar->getLocation(), diag::note_previous_access_declaration)
680      << Ivar << Ivar->getName();
681      // Note! I deliberately want it to fall thru so more errors are caught.
682    }
683    QualType IvarType = Context.getCanonicalType(Ivar->getType());
684
685    // Check that type of property and its ivar are type compatible.
686    if (Context.getCanonicalType(PropertyIvarType) != IvarType) {
687      bool compat = false;
688      if (isa<ObjCObjectPointerType>(PropertyIvarType)
689          && isa<ObjCObjectPointerType>(IvarType))
690        compat =
691          Context.canAssignObjCInterfaces(
692                                  PropertyIvarType->getAs<ObjCObjectPointerType>(),
693                                  IvarType->getAs<ObjCObjectPointerType>());
694      else {
695        SourceLocation Loc = PropertyIvarLoc;
696        if (Loc.isInvalid())
697          Loc = PropertyLoc;
698        compat = (CheckAssignmentConstraints(Loc, PropertyIvarType, IvarType)
699                    == Compatible);
700      }
701      if (!compat) {
702        Diag(PropertyLoc, diag::error_property_ivar_type)
703          << property->getDeclName() << PropType
704          << Ivar->getDeclName() << IvarType;
705        Diag(Ivar->getLocation(), diag::note_ivar_decl);
706        // Note! I deliberately want it to fall thru so, we have a
707        // a property implementation and to avoid future warnings.
708      }
709
710      // FIXME! Rules for properties are somewhat different that those
711      // for assignments. Use a new routine to consolidate all cases;
712      // specifically for property redeclarations as well as for ivars.
713      QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
714      QualType rhsType =Context.getCanonicalType(IvarType).getUnqualifiedType();
715      if (lhsType != rhsType &&
716          lhsType->isArithmeticType()) {
717        Diag(PropertyLoc, diag::error_property_ivar_type)
718          << property->getDeclName() << PropType
719          << Ivar->getDeclName() << IvarType;
720        Diag(Ivar->getLocation(), diag::note_ivar_decl);
721        // Fall thru - see previous comment
722      }
723      // __weak is explicit. So it works on Canonical type.
724      if ((PropType.isObjCGCWeak() && !IvarType.isObjCGCWeak() &&
725           getLangOptions().getGC() != LangOptions::NonGC)) {
726        Diag(PropertyLoc, diag::error_weak_property)
727        << property->getDeclName() << Ivar->getDeclName();
728        Diag(Ivar->getLocation(), diag::note_ivar_decl);
729        // Fall thru - see previous comment
730      }
731      // Fall thru - see previous comment
732      if ((property->getType()->isObjCObjectPointerType() ||
733           PropType.isObjCGCStrong()) && IvarType.isObjCGCWeak() &&
734          getLangOptions().getGC() != LangOptions::NonGC) {
735        Diag(PropertyLoc, diag::error_strong_property)
736        << property->getDeclName() << Ivar->getDeclName();
737        // Fall thru - see previous comment
738      }
739    }
740    if (getLangOptions().ObjCAutoRefCount)
741      checkARCPropertyImpl(*this, PropertyLoc, property, Ivar);
742  } else if (PropertyIvar)
743    // @dynamic
744    Diag(PropertyLoc, diag::error_dynamic_property_ivar_decl);
745
746  assert (property && "ActOnPropertyImplDecl - property declaration missing");
747  ObjCPropertyImplDecl *PIDecl =
748  ObjCPropertyImplDecl::Create(Context, CurContext, AtLoc, PropertyLoc,
749                               property,
750                               (Synthesize ?
751                                ObjCPropertyImplDecl::Synthesize
752                                : ObjCPropertyImplDecl::Dynamic),
753                               Ivar, PropertyIvarLoc);
754  if (ObjCMethodDecl *getterMethod = property->getGetterMethodDecl()) {
755    getterMethod->createImplicitParams(Context, IDecl);
756    if (getLangOptions().CPlusPlus && Synthesize &&
757        Ivar->getType()->isRecordType()) {
758      // For Objective-C++, need to synthesize the AST for the IVAR object to be
759      // returned by the getter as it must conform to C++'s copy-return rules.
760      // FIXME. Eventually we want to do this for Objective-C as well.
761      ImplicitParamDecl *SelfDecl = getterMethod->getSelfDecl();
762      DeclRefExpr *SelfExpr =
763        new (Context) DeclRefExpr(SelfDecl, SelfDecl->getType(),
764                                  VK_RValue, SourceLocation());
765      Expr *IvarRefExpr =
766        new (Context) ObjCIvarRefExpr(Ivar, Ivar->getType(), AtLoc,
767                                      SelfExpr, true, true);
768      ExprResult Res =
769        PerformCopyInitialization(InitializedEntity::InitializeResult(
770                                    SourceLocation(),
771                                    getterMethod->getResultType(),
772                                    /*NRVO=*/false),
773                                  SourceLocation(),
774                                  Owned(IvarRefExpr));
775      if (!Res.isInvalid()) {
776        Expr *ResExpr = Res.takeAs<Expr>();
777        if (ResExpr)
778          ResExpr = MaybeCreateExprWithCleanups(ResExpr);
779        PIDecl->setGetterCXXConstructor(ResExpr);
780      }
781    }
782    if (property->hasAttr<NSReturnsNotRetainedAttr>() &&
783        !getterMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
784      Diag(getterMethod->getLocation(),
785           diag::warn_property_getter_owning_mismatch);
786      Diag(property->getLocation(), diag::note_property_declare);
787    }
788  }
789  if (ObjCMethodDecl *setterMethod = property->getSetterMethodDecl()) {
790    setterMethod->createImplicitParams(Context, IDecl);
791    if (getLangOptions().CPlusPlus && Synthesize
792        && Ivar->getType()->isRecordType()) {
793      // FIXME. Eventually we want to do this for Objective-C as well.
794      ImplicitParamDecl *SelfDecl = setterMethod->getSelfDecl();
795      DeclRefExpr *SelfExpr =
796        new (Context) DeclRefExpr(SelfDecl, SelfDecl->getType(),
797                                  VK_RValue, SourceLocation());
798      Expr *lhs =
799        new (Context) ObjCIvarRefExpr(Ivar, Ivar->getType(), AtLoc,
800                                      SelfExpr, true, true);
801      ObjCMethodDecl::param_iterator P = setterMethod->param_begin();
802      ParmVarDecl *Param = (*P);
803      QualType T = Param->getType();
804      if (T->isReferenceType())
805        T = T->getAs<ReferenceType>()->getPointeeType();
806      Expr *rhs = new (Context) DeclRefExpr(Param, T,
807                                            VK_LValue, SourceLocation());
808      ExprResult Res = BuildBinOp(S, lhs->getLocEnd(),
809                                  BO_Assign, lhs, rhs);
810      if (property->getPropertyAttributes() &
811          ObjCPropertyDecl::OBJC_PR_atomic) {
812        Expr *callExpr = Res.takeAs<Expr>();
813        if (const CXXOperatorCallExpr *CXXCE =
814              dyn_cast_or_null<CXXOperatorCallExpr>(callExpr))
815          if (const FunctionDecl *FuncDecl = CXXCE->getDirectCallee())
816            if (!FuncDecl->isTrivial())
817              Diag(PropertyLoc,
818                   diag::warn_atomic_property_nontrivial_assign_op)
819                    << property->getType();
820      }
821      PIDecl->setSetterCXXAssignment(Res.takeAs<Expr>());
822    }
823  }
824
825  if (IC) {
826    if (Synthesize)
827      if (ObjCPropertyImplDecl *PPIDecl =
828          IC->FindPropertyImplIvarDecl(PropertyIvar)) {
829        Diag(PropertyLoc, diag::error_duplicate_ivar_use)
830        << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
831        << PropertyIvar;
832        Diag(PPIDecl->getLocation(), diag::note_previous_use);
833      }
834
835    if (ObjCPropertyImplDecl *PPIDecl
836        = IC->FindPropertyImplDecl(PropertyId)) {
837      Diag(PropertyLoc, diag::error_property_implemented) << PropertyId;
838      Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
839      return 0;
840    }
841    IC->addPropertyImplementation(PIDecl);
842    if (getLangOptions().ObjCDefaultSynthProperties &&
843        getLangOptions().ObjCNonFragileABI2) {
844      // Diagnose if an ivar was lazily synthesdized due to a previous
845      // use and if 1) property is @dynamic or 2) property is synthesized
846      // but it requires an ivar of different name.
847      ObjCInterfaceDecl *ClassDeclared=0;
848      ObjCIvarDecl *Ivar = 0;
849      if (!Synthesize)
850        Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
851      else {
852        if (PropertyIvar && PropertyIvar != PropertyId)
853          Ivar = IDecl->lookupInstanceVariable(PropertyId, ClassDeclared);
854      }
855      // Issue diagnostics only if Ivar belongs to current class.
856      if (Ivar && Ivar->getSynthesize() &&
857          IC->getClassInterface() == ClassDeclared) {
858        Diag(Ivar->getLocation(), diag::err_undeclared_var_use)
859        << PropertyId;
860        Ivar->setInvalidDecl();
861      }
862    }
863  } else {
864    if (Synthesize)
865      if (ObjCPropertyImplDecl *PPIDecl =
866          CatImplClass->FindPropertyImplIvarDecl(PropertyIvar)) {
867        Diag(PropertyLoc, diag::error_duplicate_ivar_use)
868        << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
869        << PropertyIvar;
870        Diag(PPIDecl->getLocation(), diag::note_previous_use);
871      }
872
873    if (ObjCPropertyImplDecl *PPIDecl =
874        CatImplClass->FindPropertyImplDecl(PropertyId)) {
875      Diag(PropertyLoc, diag::error_property_implemented) << PropertyId;
876      Diag(PPIDecl->getLocation(), diag::note_previous_declaration);
877      return 0;
878    }
879    CatImplClass->addPropertyImplementation(PIDecl);
880  }
881
882  return PIDecl;
883}
884
885//===----------------------------------------------------------------------===//
886// Helper methods.
887//===----------------------------------------------------------------------===//
888
889/// DiagnosePropertyMismatch - Compares two properties for their
890/// attributes and types and warns on a variety of inconsistencies.
891///
892void
893Sema::DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
894                               ObjCPropertyDecl *SuperProperty,
895                               const IdentifierInfo *inheritedName) {
896  ObjCPropertyDecl::PropertyAttributeKind CAttr =
897  Property->getPropertyAttributes();
898  ObjCPropertyDecl::PropertyAttributeKind SAttr =
899  SuperProperty->getPropertyAttributes();
900  if ((CAttr & ObjCPropertyDecl::OBJC_PR_readonly)
901      && (SAttr & ObjCPropertyDecl::OBJC_PR_readwrite))
902    Diag(Property->getLocation(), diag::warn_readonly_property)
903      << Property->getDeclName() << inheritedName;
904  if ((CAttr & ObjCPropertyDecl::OBJC_PR_copy)
905      != (SAttr & ObjCPropertyDecl::OBJC_PR_copy))
906    Diag(Property->getLocation(), diag::warn_property_attribute)
907      << Property->getDeclName() << "copy" << inheritedName;
908  else if (!(SAttr & ObjCPropertyDecl::OBJC_PR_readonly)){
909    unsigned CAttrRetain =
910      (CAttr &
911       (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
912    unsigned SAttrRetain =
913      (SAttr &
914       (ObjCPropertyDecl::OBJC_PR_retain | ObjCPropertyDecl::OBJC_PR_strong));
915    bool CStrong = (CAttrRetain != 0);
916    bool SStrong = (SAttrRetain != 0);
917    if (CStrong != SStrong)
918      Diag(Property->getLocation(), diag::warn_property_attribute)
919        << Property->getDeclName() << "retain (or strong)" << inheritedName;
920  }
921
922  if ((CAttr & ObjCPropertyDecl::OBJC_PR_nonatomic)
923      != (SAttr & ObjCPropertyDecl::OBJC_PR_nonatomic))
924    Diag(Property->getLocation(), diag::warn_property_attribute)
925      << Property->getDeclName() << "atomic" << inheritedName;
926  if (Property->getSetterName() != SuperProperty->getSetterName())
927    Diag(Property->getLocation(), diag::warn_property_attribute)
928      << Property->getDeclName() << "setter" << inheritedName;
929  if (Property->getGetterName() != SuperProperty->getGetterName())
930    Diag(Property->getLocation(), diag::warn_property_attribute)
931      << Property->getDeclName() << "getter" << inheritedName;
932
933  QualType LHSType =
934    Context.getCanonicalType(SuperProperty->getType());
935  QualType RHSType =
936    Context.getCanonicalType(Property->getType());
937
938  if (!Context.propertyTypesAreCompatible(LHSType, RHSType)) {
939    // Do cases not handled in above.
940    // FIXME. For future support of covariant property types, revisit this.
941    bool IncompatibleObjC = false;
942    QualType ConvertedType;
943    if (!isObjCPointerConversion(RHSType, LHSType,
944                                 ConvertedType, IncompatibleObjC) ||
945        IncompatibleObjC) {
946        Diag(Property->getLocation(), diag::warn_property_types_are_incompatible)
947        << Property->getType() << SuperProperty->getType() << inheritedName;
948      Diag(SuperProperty->getLocation(), diag::note_property_declare);
949    }
950  }
951}
952
953bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property,
954                                            ObjCMethodDecl *GetterMethod,
955                                            SourceLocation Loc) {
956  if (GetterMethod &&
957      GetterMethod->getResultType().getNonReferenceType()
958      != property->getType().getNonReferenceType()) {
959    AssignConvertType result = Incompatible;
960    if (property->getType()->isObjCObjectPointerType())
961      result = CheckAssignmentConstraints(Loc, GetterMethod->getResultType(),
962                                          property->getType());
963    if (result != Compatible) {
964      Diag(Loc, diag::warn_accessor_property_type_mismatch)
965      << property->getDeclName()
966      << GetterMethod->getSelector();
967      Diag(GetterMethod->getLocation(), diag::note_declared_at);
968      return true;
969    }
970  }
971  return false;
972}
973
974/// ComparePropertiesInBaseAndSuper - This routine compares property
975/// declarations in base and its super class, if any, and issues
976/// diagnostics in a variety of inconsistent situations.
977///
978void Sema::ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl) {
979  ObjCInterfaceDecl *SDecl = IDecl->getSuperClass();
980  if (!SDecl)
981    return;
982  // FIXME: O(N^2)
983  for (ObjCInterfaceDecl::prop_iterator S = SDecl->prop_begin(),
984       E = SDecl->prop_end(); S != E; ++S) {
985    ObjCPropertyDecl *SuperPDecl = (*S);
986    // Does property in super class has declaration in current class?
987    for (ObjCInterfaceDecl::prop_iterator I = IDecl->prop_begin(),
988         E = IDecl->prop_end(); I != E; ++I) {
989      ObjCPropertyDecl *PDecl = (*I);
990      if (SuperPDecl->getIdentifier() == PDecl->getIdentifier())
991          DiagnosePropertyMismatch(PDecl, SuperPDecl,
992                                   SDecl->getIdentifier());
993    }
994  }
995}
996
997/// MatchOneProtocolPropertiesInClass - This routine goes thru the list
998/// of properties declared in a protocol and compares their attribute against
999/// the same property declared in the class or category.
1000void
1001Sema::MatchOneProtocolPropertiesInClass(Decl *CDecl,
1002                                          ObjCProtocolDecl *PDecl) {
1003  ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDecl);
1004  if (!IDecl) {
1005    // Category
1006    ObjCCategoryDecl *CatDecl = static_cast<ObjCCategoryDecl*>(CDecl);
1007    assert (CatDecl && "MatchOneProtocolPropertiesInClass");
1008    if (!CatDecl->IsClassExtension())
1009      for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1010           E = PDecl->prop_end(); P != E; ++P) {
1011        ObjCPropertyDecl *Pr = (*P);
1012        ObjCCategoryDecl::prop_iterator CP, CE;
1013        // Is this property already in  category's list of properties?
1014        for (CP = CatDecl->prop_begin(), CE = CatDecl->prop_end(); CP!=CE; ++CP)
1015          if ((*CP)->getIdentifier() == Pr->getIdentifier())
1016            break;
1017        if (CP != CE)
1018          // Property protocol already exist in class. Diagnose any mismatch.
1019          DiagnosePropertyMismatch((*CP), Pr, PDecl->getIdentifier());
1020      }
1021    return;
1022  }
1023  for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1024       E = PDecl->prop_end(); P != E; ++P) {
1025    ObjCPropertyDecl *Pr = (*P);
1026    ObjCInterfaceDecl::prop_iterator CP, CE;
1027    // Is this property already in  class's list of properties?
1028    for (CP = IDecl->prop_begin(), CE = IDecl->prop_end(); CP != CE; ++CP)
1029      if ((*CP)->getIdentifier() == Pr->getIdentifier())
1030        break;
1031    if (CP != CE)
1032      // Property protocol already exist in class. Diagnose any mismatch.
1033      DiagnosePropertyMismatch((*CP), Pr, PDecl->getIdentifier());
1034    }
1035}
1036
1037/// CompareProperties - This routine compares properties
1038/// declared in 'ClassOrProtocol' objects (which can be a class or an
1039/// inherited protocol with the list of properties for class/category 'CDecl'
1040///
1041void Sema::CompareProperties(Decl *CDecl, Decl *ClassOrProtocol) {
1042  Decl *ClassDecl = ClassOrProtocol;
1043  ObjCInterfaceDecl *IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDecl);
1044
1045  if (!IDecl) {
1046    // Category
1047    ObjCCategoryDecl *CatDecl = static_cast<ObjCCategoryDecl*>(CDecl);
1048    assert (CatDecl && "CompareProperties");
1049    if (ObjCCategoryDecl *MDecl = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
1050      for (ObjCCategoryDecl::protocol_iterator P = MDecl->protocol_begin(),
1051           E = MDecl->protocol_end(); P != E; ++P)
1052      // Match properties of category with those of protocol (*P)
1053      MatchOneProtocolPropertiesInClass(CatDecl, *P);
1054
1055      // Go thru the list of protocols for this category and recursively match
1056      // their properties with those in the category.
1057      for (ObjCCategoryDecl::protocol_iterator P = CatDecl->protocol_begin(),
1058           E = CatDecl->protocol_end(); P != E; ++P)
1059        CompareProperties(CatDecl, *P);
1060    } else {
1061      ObjCProtocolDecl *MD = cast<ObjCProtocolDecl>(ClassDecl);
1062      for (ObjCProtocolDecl::protocol_iterator P = MD->protocol_begin(),
1063           E = MD->protocol_end(); P != E; ++P)
1064        MatchOneProtocolPropertiesInClass(CatDecl, *P);
1065    }
1066    return;
1067  }
1068
1069  if (ObjCInterfaceDecl *MDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
1070    for (ObjCInterfaceDecl::all_protocol_iterator
1071          P = MDecl->all_referenced_protocol_begin(),
1072          E = MDecl->all_referenced_protocol_end(); P != E; ++P)
1073      // Match properties of class IDecl with those of protocol (*P).
1074      MatchOneProtocolPropertiesInClass(IDecl, *P);
1075
1076    // Go thru the list of protocols for this class and recursively match
1077    // their properties with those declared in the class.
1078    for (ObjCInterfaceDecl::all_protocol_iterator
1079          P = IDecl->all_referenced_protocol_begin(),
1080          E = IDecl->all_referenced_protocol_end(); P != E; ++P)
1081      CompareProperties(IDecl, *P);
1082  } else {
1083    ObjCProtocolDecl *MD = cast<ObjCProtocolDecl>(ClassDecl);
1084    for (ObjCProtocolDecl::protocol_iterator P = MD->protocol_begin(),
1085         E = MD->protocol_end(); P != E; ++P)
1086      MatchOneProtocolPropertiesInClass(IDecl, *P);
1087  }
1088}
1089
1090/// isPropertyReadonly - Return true if property is readonly, by searching
1091/// for the property in the class and in its categories and implementations
1092///
1093bool Sema::isPropertyReadonly(ObjCPropertyDecl *PDecl,
1094                              ObjCInterfaceDecl *IDecl) {
1095  // by far the most common case.
1096  if (!PDecl->isReadOnly())
1097    return false;
1098  // Even if property is ready only, if interface has a user defined setter,
1099  // it is not considered read only.
1100  if (IDecl->getInstanceMethod(PDecl->getSetterName()))
1101    return false;
1102
1103  // Main class has the property as 'readonly'. Must search
1104  // through the category list to see if the property's
1105  // attribute has been over-ridden to 'readwrite'.
1106  for (ObjCCategoryDecl *Category = IDecl->getCategoryList();
1107       Category; Category = Category->getNextClassCategory()) {
1108    // Even if property is ready only, if a category has a user defined setter,
1109    // it is not considered read only.
1110    if (Category->getInstanceMethod(PDecl->getSetterName()))
1111      return false;
1112    ObjCPropertyDecl *P =
1113      Category->FindPropertyDeclaration(PDecl->getIdentifier());
1114    if (P && !P->isReadOnly())
1115      return false;
1116  }
1117
1118  // Also, check for definition of a setter method in the implementation if
1119  // all else failed.
1120  if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurContext)) {
1121    if (ObjCImplementationDecl *IMD =
1122        dyn_cast<ObjCImplementationDecl>(OMD->getDeclContext())) {
1123      if (IMD->getInstanceMethod(PDecl->getSetterName()))
1124        return false;
1125    } else if (ObjCCategoryImplDecl *CIMD =
1126               dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) {
1127      if (CIMD->getInstanceMethod(PDecl->getSetterName()))
1128        return false;
1129    }
1130  }
1131  // Lastly, look through the implementation (if one is in scope).
1132  if (ObjCImplementationDecl *ImpDecl = IDecl->getImplementation())
1133    if (ImpDecl->getInstanceMethod(PDecl->getSetterName()))
1134      return false;
1135  // If all fails, look at the super class.
1136  if (ObjCInterfaceDecl *SIDecl = IDecl->getSuperClass())
1137    return isPropertyReadonly(PDecl, SIDecl);
1138  return true;
1139}
1140
1141/// CollectImmediateProperties - This routine collects all properties in
1142/// the class and its conforming protocols; but not those it its super class.
1143void Sema::CollectImmediateProperties(ObjCContainerDecl *CDecl,
1144            llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& PropMap,
1145            llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& SuperPropMap) {
1146  if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
1147    for (ObjCContainerDecl::prop_iterator P = IDecl->prop_begin(),
1148         E = IDecl->prop_end(); P != E; ++P) {
1149      ObjCPropertyDecl *Prop = (*P);
1150      PropMap[Prop->getIdentifier()] = Prop;
1151    }
1152    // scan through class's protocols.
1153    for (ObjCInterfaceDecl::all_protocol_iterator
1154         PI = IDecl->all_referenced_protocol_begin(),
1155         E = IDecl->all_referenced_protocol_end(); PI != E; ++PI)
1156        CollectImmediateProperties((*PI), PropMap, SuperPropMap);
1157  }
1158  if (ObjCCategoryDecl *CATDecl = dyn_cast<ObjCCategoryDecl>(CDecl)) {
1159    if (!CATDecl->IsClassExtension())
1160      for (ObjCContainerDecl::prop_iterator P = CATDecl->prop_begin(),
1161           E = CATDecl->prop_end(); P != E; ++P) {
1162        ObjCPropertyDecl *Prop = (*P);
1163        PropMap[Prop->getIdentifier()] = Prop;
1164      }
1165    // scan through class's protocols.
1166    for (ObjCCategoryDecl::protocol_iterator PI = CATDecl->protocol_begin(),
1167         E = CATDecl->protocol_end(); PI != E; ++PI)
1168      CollectImmediateProperties((*PI), PropMap, SuperPropMap);
1169  }
1170  else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(CDecl)) {
1171    for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1172         E = PDecl->prop_end(); P != E; ++P) {
1173      ObjCPropertyDecl *Prop = (*P);
1174      ObjCPropertyDecl *PropertyFromSuper = SuperPropMap[Prop->getIdentifier()];
1175      // Exclude property for protocols which conform to class's super-class,
1176      // as super-class has to implement the property.
1177      if (!PropertyFromSuper ||
1178          PropertyFromSuper->getIdentifier() != Prop->getIdentifier()) {
1179        ObjCPropertyDecl *&PropEntry = PropMap[Prop->getIdentifier()];
1180        if (!PropEntry)
1181          PropEntry = Prop;
1182      }
1183    }
1184    // scan through protocol's protocols.
1185    for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1186         E = PDecl->protocol_end(); PI != E; ++PI)
1187      CollectImmediateProperties((*PI), PropMap, SuperPropMap);
1188  }
1189}
1190
1191/// CollectClassPropertyImplementations - This routine collects list of
1192/// properties to be implemented in the class. This includes, class's
1193/// and its conforming protocols' properties.
1194static void CollectClassPropertyImplementations(ObjCContainerDecl *CDecl,
1195                llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& PropMap) {
1196  if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
1197    for (ObjCContainerDecl::prop_iterator P = IDecl->prop_begin(),
1198         E = IDecl->prop_end(); P != E; ++P) {
1199      ObjCPropertyDecl *Prop = (*P);
1200      PropMap[Prop->getIdentifier()] = Prop;
1201    }
1202    for (ObjCInterfaceDecl::all_protocol_iterator
1203         PI = IDecl->all_referenced_protocol_begin(),
1204         E = IDecl->all_referenced_protocol_end(); PI != E; ++PI)
1205      CollectClassPropertyImplementations((*PI), PropMap);
1206  }
1207  else if (ObjCProtocolDecl *PDecl = dyn_cast<ObjCProtocolDecl>(CDecl)) {
1208    for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1209         E = PDecl->prop_end(); P != E; ++P) {
1210      ObjCPropertyDecl *Prop = (*P);
1211      PropMap[Prop->getIdentifier()] = Prop;
1212    }
1213    // scan through protocol's protocols.
1214    for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1215         E = PDecl->protocol_end(); PI != E; ++PI)
1216      CollectClassPropertyImplementations((*PI), PropMap);
1217  }
1218}
1219
1220/// CollectSuperClassPropertyImplementations - This routine collects list of
1221/// properties to be implemented in super class(s) and also coming from their
1222/// conforming protocols.
1223static void CollectSuperClassPropertyImplementations(ObjCInterfaceDecl *CDecl,
1224                llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& PropMap) {
1225  if (ObjCInterfaceDecl *SDecl = CDecl->getSuperClass()) {
1226    while (SDecl) {
1227      CollectClassPropertyImplementations(SDecl, PropMap);
1228      SDecl = SDecl->getSuperClass();
1229    }
1230  }
1231}
1232
1233/// LookupPropertyDecl - Looks up a property in the current class and all
1234/// its protocols.
1235ObjCPropertyDecl *Sema::LookupPropertyDecl(const ObjCContainerDecl *CDecl,
1236                                     IdentifierInfo *II) {
1237  if (const ObjCInterfaceDecl *IDecl =
1238        dyn_cast<ObjCInterfaceDecl>(CDecl)) {
1239    for (ObjCContainerDecl::prop_iterator P = IDecl->prop_begin(),
1240         E = IDecl->prop_end(); P != E; ++P) {
1241      ObjCPropertyDecl *Prop = (*P);
1242      if (Prop->getIdentifier() == II)
1243        return Prop;
1244    }
1245    // scan through class's protocols.
1246    for (ObjCInterfaceDecl::all_protocol_iterator
1247         PI = IDecl->all_referenced_protocol_begin(),
1248         E = IDecl->all_referenced_protocol_end(); PI != E; ++PI) {
1249      ObjCPropertyDecl *Prop = LookupPropertyDecl((*PI), II);
1250      if (Prop)
1251        return Prop;
1252    }
1253  }
1254  else if (const ObjCProtocolDecl *PDecl =
1255            dyn_cast<ObjCProtocolDecl>(CDecl)) {
1256    for (ObjCProtocolDecl::prop_iterator P = PDecl->prop_begin(),
1257         E = PDecl->prop_end(); P != E; ++P) {
1258      ObjCPropertyDecl *Prop = (*P);
1259      if (Prop->getIdentifier() == II)
1260        return Prop;
1261    }
1262    // scan through protocol's protocols.
1263    for (ObjCProtocolDecl::protocol_iterator PI = PDecl->protocol_begin(),
1264         E = PDecl->protocol_end(); PI != E; ++PI) {
1265      ObjCPropertyDecl *Prop = LookupPropertyDecl((*PI), II);
1266      if (Prop)
1267        return Prop;
1268    }
1269  }
1270  return 0;
1271}
1272
1273static IdentifierInfo * getDefaultSynthIvarName(ObjCPropertyDecl *Prop,
1274                                                ASTContext &Ctx) {
1275  llvm::SmallString<128> ivarName;
1276  {
1277    llvm::raw_svector_ostream os(ivarName);
1278    os << '_' << Prop->getIdentifier()->getName();
1279  }
1280  return &Ctx.Idents.get(ivarName.str());
1281}
1282
1283/// DefaultSynthesizeProperties - This routine default synthesizes all
1284/// properties which must be synthesized in class's @implementation.
1285void Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl* IMPDecl,
1286                                       ObjCInterfaceDecl *IDecl) {
1287
1288  llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*> PropMap;
1289  CollectClassPropertyImplementations(IDecl, PropMap);
1290  if (PropMap.empty())
1291    return;
1292  llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*> SuperPropMap;
1293  CollectSuperClassPropertyImplementations(IDecl, SuperPropMap);
1294
1295  for (llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>::iterator
1296       P = PropMap.begin(), E = PropMap.end(); P != E; ++P) {
1297    ObjCPropertyDecl *Prop = P->second;
1298    // If property to be implemented in the super class, ignore.
1299    if (SuperPropMap[Prop->getIdentifier()])
1300      continue;
1301    // Is there a matching propery synthesize/dynamic?
1302    if (Prop->isInvalidDecl() ||
1303        Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional ||
1304        IMPDecl->FindPropertyImplIvarDecl(Prop->getIdentifier()))
1305      continue;
1306    // Property may have been synthesized by user.
1307    if (IMPDecl->FindPropertyImplDecl(Prop->getIdentifier()))
1308      continue;
1309    if (IMPDecl->getInstanceMethod(Prop->getGetterName())) {
1310      if (Prop->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_readonly)
1311        continue;
1312      if (IMPDecl->getInstanceMethod(Prop->getSetterName()))
1313        continue;
1314    }
1315
1316
1317    // We use invalid SourceLocations for the synthesized ivars since they
1318    // aren't really synthesized at a particular location; they just exist.
1319    // Saying that they are located at the @implementation isn't really going
1320    // to help users.
1321    ActOnPropertyImplDecl(S, SourceLocation(), SourceLocation(),
1322                          true,
1323                          /* property = */ Prop->getIdentifier(),
1324                          /* ivar = */ getDefaultSynthIvarName(Prop, Context),
1325                          SourceLocation());
1326  }
1327}
1328
1329void Sema::DefaultSynthesizeProperties(Scope *S, Decl *D) {
1330  if (!LangOpts.ObjCDefaultSynthProperties || !LangOpts.ObjCNonFragileABI2)
1331    return;
1332  ObjCImplementationDecl *IC=dyn_cast_or_null<ObjCImplementationDecl>(D);
1333  if (!IC)
1334    return;
1335  if (ObjCInterfaceDecl* IDecl = IC->getClassInterface())
1336    DefaultSynthesizeProperties(S, IC, IDecl);
1337}
1338
1339void Sema::DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
1340                                      ObjCContainerDecl *CDecl,
1341                                      const llvm::DenseSet<Selector>& InsMap) {
1342  llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*> SuperPropMap;
1343  if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl))
1344    CollectSuperClassPropertyImplementations(IDecl, SuperPropMap);
1345
1346  llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*> PropMap;
1347  CollectImmediateProperties(CDecl, PropMap, SuperPropMap);
1348  if (PropMap.empty())
1349    return;
1350
1351  llvm::DenseSet<ObjCPropertyDecl *> PropImplMap;
1352  for (ObjCImplDecl::propimpl_iterator
1353       I = IMPDecl->propimpl_begin(),
1354       EI = IMPDecl->propimpl_end(); I != EI; ++I)
1355    PropImplMap.insert((*I)->getPropertyDecl());
1356
1357  for (llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>::iterator
1358       P = PropMap.begin(), E = PropMap.end(); P != E; ++P) {
1359    ObjCPropertyDecl *Prop = P->second;
1360    // Is there a matching propery synthesize/dynamic?
1361    if (Prop->isInvalidDecl() ||
1362        Prop->getPropertyImplementation() == ObjCPropertyDecl::Optional ||
1363        PropImplMap.count(Prop) || Prop->hasAttr<UnavailableAttr>())
1364      continue;
1365    if (!InsMap.count(Prop->getGetterName())) {
1366      Diag(IMPDecl->getLocation(),
1367           isa<ObjCCategoryDecl>(CDecl) ?
1368            diag::warn_setter_getter_impl_required_in_category :
1369            diag::warn_setter_getter_impl_required)
1370      << Prop->getDeclName() << Prop->getGetterName();
1371      Diag(Prop->getLocation(),
1372           diag::note_property_declare);
1373    }
1374
1375    if (!Prop->isReadOnly() && !InsMap.count(Prop->getSetterName())) {
1376      Diag(IMPDecl->getLocation(),
1377           isa<ObjCCategoryDecl>(CDecl) ?
1378           diag::warn_setter_getter_impl_required_in_category :
1379           diag::warn_setter_getter_impl_required)
1380      << Prop->getDeclName() << Prop->getSetterName();
1381      Diag(Prop->getLocation(),
1382           diag::note_property_declare);
1383    }
1384  }
1385}
1386
1387void
1388Sema::AtomicPropertySetterGetterRules (ObjCImplDecl* IMPDecl,
1389                                       ObjCContainerDecl* IDecl) {
1390  // Rules apply in non-GC mode only
1391  if (getLangOptions().getGC() != LangOptions::NonGC)
1392    return;
1393  for (ObjCContainerDecl::prop_iterator I = IDecl->prop_begin(),
1394       E = IDecl->prop_end();
1395       I != E; ++I) {
1396    ObjCPropertyDecl *Property = (*I);
1397    ObjCMethodDecl *GetterMethod = 0;
1398    ObjCMethodDecl *SetterMethod = 0;
1399    bool LookedUpGetterSetter = false;
1400
1401    unsigned Attributes = Property->getPropertyAttributes();
1402    unsigned AttributesAsWritten = Property->getPropertyAttributesAsWritten();
1403
1404    if (!(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_atomic) &&
1405        !(AttributesAsWritten & ObjCPropertyDecl::OBJC_PR_nonatomic)) {
1406      GetterMethod = IMPDecl->getInstanceMethod(Property->getGetterName());
1407      SetterMethod = IMPDecl->getInstanceMethod(Property->getSetterName());
1408      LookedUpGetterSetter = true;
1409      if (GetterMethod) {
1410        Diag(GetterMethod->getLocation(),
1411             diag::warn_default_atomic_custom_getter_setter)
1412          << Property->getIdentifier() << 0;
1413        Diag(Property->getLocation(), diag::note_property_declare);
1414      }
1415      if (SetterMethod) {
1416        Diag(SetterMethod->getLocation(),
1417             diag::warn_default_atomic_custom_getter_setter)
1418          << Property->getIdentifier() << 1;
1419        Diag(Property->getLocation(), diag::note_property_declare);
1420      }
1421    }
1422
1423    // We only care about readwrite atomic property.
1424    if ((Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) ||
1425        !(Attributes & ObjCPropertyDecl::OBJC_PR_readwrite))
1426      continue;
1427    if (const ObjCPropertyImplDecl *PIDecl
1428         = IMPDecl->FindPropertyImplDecl(Property->getIdentifier())) {
1429      if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
1430        continue;
1431      if (!LookedUpGetterSetter) {
1432        GetterMethod = IMPDecl->getInstanceMethod(Property->getGetterName());
1433        SetterMethod = IMPDecl->getInstanceMethod(Property->getSetterName());
1434        LookedUpGetterSetter = true;
1435      }
1436      if ((GetterMethod && !SetterMethod) || (!GetterMethod && SetterMethod)) {
1437        SourceLocation MethodLoc =
1438          (GetterMethod ? GetterMethod->getLocation()
1439                        : SetterMethod->getLocation());
1440        Diag(MethodLoc, diag::warn_atomic_property_rule)
1441          << Property->getIdentifier() << (GetterMethod != 0)
1442          << (SetterMethod != 0);
1443        Diag(MethodLoc, diag::note_atomic_property_fixup_suggest);
1444        Diag(Property->getLocation(), diag::note_property_declare);
1445      }
1446    }
1447  }
1448}
1449
1450void Sema::DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D) {
1451  if (getLangOptions().getGC() == LangOptions::GCOnly)
1452    return;
1453
1454  for (ObjCImplementationDecl::propimpl_iterator
1455         i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
1456    ObjCPropertyImplDecl *PID = *i;
1457    if (PID->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
1458      continue;
1459
1460    const ObjCPropertyDecl *PD = PID->getPropertyDecl();
1461    if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() &&
1462        !D->getInstanceMethod(PD->getGetterName())) {
1463      ObjCMethodDecl *method = PD->getGetterMethodDecl();
1464      if (!method)
1465        continue;
1466      ObjCMethodFamily family = method->getMethodFamily();
1467      if (family == OMF_alloc || family == OMF_copy ||
1468          family == OMF_mutableCopy || family == OMF_new) {
1469        if (getLangOptions().ObjCAutoRefCount)
1470          Diag(PID->getLocation(), diag::err_ownin_getter_rule);
1471        else
1472          Diag(PID->getLocation(), diag::warn_owning_getter_rule);
1473        Diag(PD->getLocation(), diag::note_property_declare);
1474      }
1475    }
1476  }
1477}
1478
1479/// AddPropertyAttrs - Propagates attributes from a property to the
1480/// implicitly-declared getter or setter for that property.
1481static void AddPropertyAttrs(Sema &S, ObjCMethodDecl *PropertyMethod,
1482                             ObjCPropertyDecl *Property) {
1483  // Should we just clone all attributes over?
1484  for (Decl::attr_iterator A = Property->attr_begin(),
1485                        AEnd = Property->attr_end();
1486       A != AEnd; ++A) {
1487    if (isa<DeprecatedAttr>(*A) ||
1488        isa<UnavailableAttr>(*A) ||
1489        isa<AvailabilityAttr>(*A))
1490      PropertyMethod->addAttr((*A)->clone(S.Context));
1491  }
1492}
1493
1494/// ProcessPropertyDecl - Make sure that any user-defined setter/getter methods
1495/// have the property type and issue diagnostics if they don't.
1496/// Also synthesize a getter/setter method if none exist (and update the
1497/// appropriate lookup tables. FIXME: Should reconsider if adding synthesized
1498/// methods is the "right" thing to do.
1499void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property,
1500                               ObjCContainerDecl *CD,
1501                               ObjCPropertyDecl *redeclaredProperty,
1502                               ObjCContainerDecl *lexicalDC) {
1503
1504  ObjCMethodDecl *GetterMethod, *SetterMethod;
1505
1506  GetterMethod = CD->getInstanceMethod(property->getGetterName());
1507  SetterMethod = CD->getInstanceMethod(property->getSetterName());
1508  DiagnosePropertyAccessorMismatch(property, GetterMethod,
1509                                   property->getLocation());
1510
1511  if (SetterMethod) {
1512    ObjCPropertyDecl::PropertyAttributeKind CAttr =
1513      property->getPropertyAttributes();
1514    if ((!(CAttr & ObjCPropertyDecl::OBJC_PR_readonly)) &&
1515        Context.getCanonicalType(SetterMethod->getResultType()) !=
1516          Context.VoidTy)
1517      Diag(SetterMethod->getLocation(), diag::err_setter_type_void);
1518    if (SetterMethod->param_size() != 1 ||
1519        !Context.hasSameUnqualifiedType(
1520          (*SetterMethod->param_begin())->getType().getNonReferenceType(),
1521          property->getType().getNonReferenceType())) {
1522      Diag(property->getLocation(),
1523           diag::warn_accessor_property_type_mismatch)
1524        << property->getDeclName()
1525        << SetterMethod->getSelector();
1526      Diag(SetterMethod->getLocation(), diag::note_declared_at);
1527    }
1528  }
1529
1530  // Synthesize getter/setter methods if none exist.
1531  // Find the default getter and if one not found, add one.
1532  // FIXME: The synthesized property we set here is misleading. We almost always
1533  // synthesize these methods unless the user explicitly provided prototypes
1534  // (which is odd, but allowed). Sema should be typechecking that the
1535  // declarations jive in that situation (which it is not currently).
1536  if (!GetterMethod) {
1537    // No instance method of same name as property getter name was found.
1538    // Declare a getter method and add it to the list of methods
1539    // for this class.
1540    SourceLocation Loc = redeclaredProperty ?
1541      redeclaredProperty->getLocation() :
1542      property->getLocation();
1543
1544    GetterMethod = ObjCMethodDecl::Create(Context, Loc, Loc,
1545                             property->getGetterName(),
1546                             property->getType(), 0, CD, /*isInstance=*/true,
1547                             /*isVariadic=*/false, /*isSynthesized=*/true,
1548                             /*isImplicitlyDeclared=*/true, /*isDefined=*/false,
1549                             (property->getPropertyImplementation() ==
1550                              ObjCPropertyDecl::Optional) ?
1551                             ObjCMethodDecl::Optional :
1552                             ObjCMethodDecl::Required);
1553    CD->addDecl(GetterMethod);
1554
1555    AddPropertyAttrs(*this, GetterMethod, property);
1556
1557    // FIXME: Eventually this shouldn't be needed, as the lexical context
1558    // and the real context should be the same.
1559    if (lexicalDC)
1560      GetterMethod->setLexicalDeclContext(lexicalDC);
1561    if (property->hasAttr<NSReturnsNotRetainedAttr>())
1562      GetterMethod->addAttr(
1563        ::new (Context) NSReturnsNotRetainedAttr(Loc, Context));
1564  } else
1565    // A user declared getter will be synthesize when @synthesize of
1566    // the property with the same name is seen in the @implementation
1567    GetterMethod->setSynthesized(true);
1568  property->setGetterMethodDecl(GetterMethod);
1569
1570  // Skip setter if property is read-only.
1571  if (!property->isReadOnly()) {
1572    // Find the default setter and if one not found, add one.
1573    if (!SetterMethod) {
1574      // No instance method of same name as property setter name was found.
1575      // Declare a setter method and add it to the list of methods
1576      // for this class.
1577      SourceLocation Loc = redeclaredProperty ?
1578        redeclaredProperty->getLocation() :
1579        property->getLocation();
1580
1581      SetterMethod =
1582        ObjCMethodDecl::Create(Context, Loc, Loc,
1583                               property->getSetterName(), Context.VoidTy, 0,
1584                               CD, /*isInstance=*/true, /*isVariadic=*/false,
1585                               /*isSynthesized=*/true,
1586                               /*isImplicitlyDeclared=*/true,
1587                               /*isDefined=*/false,
1588                               (property->getPropertyImplementation() ==
1589                                ObjCPropertyDecl::Optional) ?
1590                                ObjCMethodDecl::Optional :
1591                                ObjCMethodDecl::Required);
1592
1593      // Invent the arguments for the setter. We don't bother making a
1594      // nice name for the argument.
1595      ParmVarDecl *Argument = ParmVarDecl::Create(Context, SetterMethod,
1596                                                  Loc, Loc,
1597                                                  property->getIdentifier(),
1598                                    property->getType().getUnqualifiedType(),
1599                                                  /*TInfo=*/0,
1600                                                  SC_None,
1601                                                  SC_None,
1602                                                  0);
1603      SetterMethod->setMethodParams(Context, Argument,
1604                                    ArrayRef<SourceLocation>());
1605
1606      AddPropertyAttrs(*this, SetterMethod, property);
1607
1608      CD->addDecl(SetterMethod);
1609      // FIXME: Eventually this shouldn't be needed, as the lexical context
1610      // and the real context should be the same.
1611      if (lexicalDC)
1612        SetterMethod->setLexicalDeclContext(lexicalDC);
1613    } else
1614      // A user declared setter will be synthesize when @synthesize of
1615      // the property with the same name is seen in the @implementation
1616      SetterMethod->setSynthesized(true);
1617    property->setSetterMethodDecl(SetterMethod);
1618  }
1619  // Add any synthesized methods to the global pool. This allows us to
1620  // handle the following, which is supported by GCC (and part of the design).
1621  //
1622  // @interface Foo
1623  // @property double bar;
1624  // @end
1625  //
1626  // void thisIsUnfortunate() {
1627  //   id foo;
1628  //   double bar = [foo bar];
1629  // }
1630  //
1631  if (GetterMethod)
1632    AddInstanceMethodToGlobalPool(GetterMethod);
1633  if (SetterMethod)
1634    AddInstanceMethodToGlobalPool(SetterMethod);
1635}
1636
1637void Sema::CheckObjCPropertyAttributes(Decl *PDecl,
1638                                       SourceLocation Loc,
1639                                       unsigned &Attributes) {
1640  // FIXME: Improve the reported location.
1641  if (!PDecl || PDecl->isInvalidDecl())
1642    return;
1643
1644  ObjCPropertyDecl *PropertyDecl = cast<ObjCPropertyDecl>(PDecl);
1645  QualType PropertyTy = PropertyDecl->getType();
1646
1647  // readonly and readwrite/assign/retain/copy conflict.
1648  if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
1649      (Attributes & (ObjCDeclSpec::DQ_PR_readwrite |
1650                     ObjCDeclSpec::DQ_PR_assign |
1651                     ObjCDeclSpec::DQ_PR_unsafe_unretained |
1652                     ObjCDeclSpec::DQ_PR_copy |
1653                     ObjCDeclSpec::DQ_PR_retain |
1654                     ObjCDeclSpec::DQ_PR_strong))) {
1655    const char * which = (Attributes & ObjCDeclSpec::DQ_PR_readwrite) ?
1656                          "readwrite" :
1657                         (Attributes & ObjCDeclSpec::DQ_PR_assign) ?
1658                          "assign" :
1659                         (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) ?
1660                          "unsafe_unretained" :
1661                         (Attributes & ObjCDeclSpec::DQ_PR_copy) ?
1662                          "copy" : "retain";
1663
1664    Diag(Loc, (Attributes & (ObjCDeclSpec::DQ_PR_readwrite)) ?
1665                 diag::err_objc_property_attr_mutually_exclusive :
1666                 diag::warn_objc_property_attr_mutually_exclusive)
1667      << "readonly" << which;
1668  }
1669
1670  // Check for copy or retain on non-object types.
1671  if ((Attributes & (ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
1672                    ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong)) &&
1673      !PropertyTy->isObjCRetainableType() &&
1674      !PropertyDecl->getAttr<ObjCNSObjectAttr>()) {
1675    Diag(Loc, diag::err_objc_property_requires_object)
1676      << (Attributes & ObjCDeclSpec::DQ_PR_weak ? "weak" :
1677          Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain (or strong)");
1678    Attributes &= ~(ObjCDeclSpec::DQ_PR_weak   | ObjCDeclSpec::DQ_PR_copy |
1679                    ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong);
1680  }
1681
1682  // Check for more than one of { assign, copy, retain }.
1683  if (Attributes & ObjCDeclSpec::DQ_PR_assign) {
1684    if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
1685      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1686        << "assign" << "copy";
1687      Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
1688    }
1689    if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
1690      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1691        << "assign" << "retain";
1692      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
1693    }
1694    if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
1695      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1696        << "assign" << "strong";
1697      Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
1698    }
1699    if (getLangOptions().ObjCAutoRefCount  &&
1700        (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
1701      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1702        << "assign" << "weak";
1703      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
1704    }
1705  } else if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) {
1706    if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
1707      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1708        << "unsafe_unretained" << "copy";
1709      Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
1710    }
1711    if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
1712      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1713        << "unsafe_unretained" << "retain";
1714      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
1715    }
1716    if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
1717      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1718        << "unsafe_unretained" << "strong";
1719      Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
1720    }
1721    if (getLangOptions().ObjCAutoRefCount  &&
1722        (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
1723      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1724        << "unsafe_unretained" << "weak";
1725      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
1726    }
1727  } else if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
1728    if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
1729      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1730        << "copy" << "retain";
1731      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
1732    }
1733    if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
1734      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1735        << "copy" << "strong";
1736      Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
1737    }
1738    if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
1739      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1740        << "copy" << "weak";
1741      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
1742    }
1743  }
1744  else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
1745           (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
1746      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1747        << "retain" << "weak";
1748      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
1749  }
1750  else if ((Attributes & ObjCDeclSpec::DQ_PR_strong) &&
1751           (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
1752      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1753        << "strong" << "weak";
1754      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
1755  }
1756
1757  if ((Attributes & ObjCDeclSpec::DQ_PR_atomic) &&
1758      (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)) {
1759      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
1760        << "atomic" << "nonatomic";
1761      Attributes &= ~ObjCDeclSpec::DQ_PR_atomic;
1762  }
1763
1764  // Warn if user supplied no assignment attribute, property is
1765  // readwrite, and this is an object type.
1766  if (!(Attributes & (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_copy |
1767                      ObjCDeclSpec::DQ_PR_unsafe_unretained |
1768                      ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong |
1769                      ObjCDeclSpec::DQ_PR_weak)) &&
1770      !(Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
1771      PropertyTy->isObjCObjectPointerType()) {
1772      if (getLangOptions().ObjCAutoRefCount)
1773        // With arc,  @property definitions should default to (strong) when
1774        // not specified
1775        PropertyDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
1776      else {
1777          // Skip this warning in gc-only mode.
1778          if (getLangOptions().getGC() != LangOptions::GCOnly)
1779            Diag(Loc, diag::warn_objc_property_no_assignment_attribute);
1780
1781          // If non-gc code warn that this is likely inappropriate.
1782          if (getLangOptions().getGC() == LangOptions::NonGC)
1783            Diag(Loc, diag::warn_objc_property_default_assign_on_object);
1784      }
1785
1786    // FIXME: Implement warning dependent on NSCopying being
1787    // implemented. See also:
1788    // <rdar://5168496&4855821&5607453&5096644&4947311&5698469&4947014&5168496>
1789    // (please trim this list while you are at it).
1790  }
1791
1792  if (!(Attributes & ObjCDeclSpec::DQ_PR_copy)
1793      &&!(Attributes & ObjCDeclSpec::DQ_PR_readonly)
1794      && getLangOptions().getGC() == LangOptions::GCOnly
1795      && PropertyTy->isBlockPointerType())
1796    Diag(Loc, diag::warn_objc_property_copy_missing_on_block);
1797  else if (getLangOptions().ObjCAutoRefCount &&
1798           (Attributes & ObjCDeclSpec::DQ_PR_retain) &&
1799           !(Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
1800           !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
1801           PropertyTy->isBlockPointerType())
1802      Diag(Loc, diag::warn_objc_property_retain_of_block);
1803}
1804