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