contrib/llvm/tools/clang/lib/Sema/SemaObjCProperty.cpp

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