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
26using 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.
38static 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.
64static 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
105static 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.
116static void
117CheckPropertyAgainstProtocol(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
138Decl *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
243static ObjCPropertyDecl::PropertyAttributeKind
244makePropertyAttributesAsWritten(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
274static 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
304static 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
313ObjCPropertyDecl *
314Sema::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
520ObjCPropertyDecl *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
642static 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'.
720static 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.
746static void
747DiagnosePropertyMismatchDeclInProtocols(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///
796Decl *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///
1300void
1301Sema::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
1377bool 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.
1421static 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.
1466static 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'.
1480bool
1481Sema::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
1501static 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.
1524void 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
1605void 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
1616static 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
1646void 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
1749void
1750Sema::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
1835void 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
1858void 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.
1887static 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.
1903void 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
2076void Sema::CheckObjCPropertyAttributes(Decl *PDecl,
2077                                       SourceLocation Loc,
2078                                       unsigned &Attributes,
2079                                       bool propertyInPrimaryClass) {
2080  // FIXME: Improve the reported location.
2081  if (!PDecl || PDecl->isInvalidDecl())
2082    return;
2083
2084  if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2085      (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
2086    Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2087    << "readonly" << "readwrite";
2088
2089  ObjCPropertyDecl *PropertyDecl = cast<ObjCPropertyDecl>(PDecl);
2090  QualType PropertyTy = PropertyDecl->getType();
2091  unsigned PropertyOwnership = getOwnershipRule(Attributes);
2092
2093  // 'readonly' property with no obvious lifetime.
2094  // its life time will be determined by its backing ivar.
2095  if (getLangOpts().ObjCAutoRefCount &&
2096      Attributes & ObjCDeclSpec::DQ_PR_readonly &&
2097      PropertyTy->isObjCRetainableType() &&
2098      !PropertyOwnership)
2099    return;
2100
2101  // Check for copy or retain on non-object types.
2102  if ((Attributes & (ObjCDeclSpec::DQ_PR_weak | ObjCDeclSpec::DQ_PR_copy |
2103                    ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong)) &&
2104      !PropertyTy->isObjCRetainableType() &&
2105      !PropertyDecl->hasAttr<ObjCNSObjectAttr>()) {
2106    Diag(Loc, diag::err_objc_property_requires_object)
2107      << (Attributes & ObjCDeclSpec::DQ_PR_weak ? "weak" :
2108          Attributes & ObjCDeclSpec::DQ_PR_copy ? "copy" : "retain (or strong)");
2109    Attributes &= ~(ObjCDeclSpec::DQ_PR_weak   | ObjCDeclSpec::DQ_PR_copy |
2110                    ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong);
2111    PropertyDecl->setInvalidDecl();
2112  }
2113
2114  // Check for more than one of { assign, copy, retain }.
2115  if (Attributes & ObjCDeclSpec::DQ_PR_assign) {
2116    if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
2117      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2118        << "assign" << "copy";
2119      Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
2120    }
2121    if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
2122      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2123        << "assign" << "retain";
2124      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2125    }
2126    if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
2127      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2128        << "assign" << "strong";
2129      Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
2130    }
2131    if (getLangOpts().ObjCAutoRefCount  &&
2132        (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2133      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2134        << "assign" << "weak";
2135      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2136    }
2137    if (PropertyDecl->hasAttr<IBOutletCollectionAttr>())
2138      Diag(Loc, diag::warn_iboutletcollection_property_assign);
2139  } else if (Attributes & ObjCDeclSpec::DQ_PR_unsafe_unretained) {
2140    if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
2141      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2142        << "unsafe_unretained" << "copy";
2143      Attributes &= ~ObjCDeclSpec::DQ_PR_copy;
2144    }
2145    if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
2146      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2147        << "unsafe_unretained" << "retain";
2148      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2149    }
2150    if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
2151      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2152        << "unsafe_unretained" << "strong";
2153      Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
2154    }
2155    if (getLangOpts().ObjCAutoRefCount  &&
2156        (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2157      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2158        << "unsafe_unretained" << "weak";
2159      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2160    }
2161  } else if (Attributes & ObjCDeclSpec::DQ_PR_copy) {
2162    if (Attributes & ObjCDeclSpec::DQ_PR_retain) {
2163      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2164        << "copy" << "retain";
2165      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2166    }
2167    if (Attributes & ObjCDeclSpec::DQ_PR_strong) {
2168      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2169        << "copy" << "strong";
2170      Attributes &= ~ObjCDeclSpec::DQ_PR_strong;
2171    }
2172    if (Attributes & ObjCDeclSpec::DQ_PR_weak) {
2173      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2174        << "copy" << "weak";
2175      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2176    }
2177  }
2178  else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
2179           (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2180      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2181        << "retain" << "weak";
2182      Attributes &= ~ObjCDeclSpec::DQ_PR_retain;
2183  }
2184  else if ((Attributes & ObjCDeclSpec::DQ_PR_strong) &&
2185           (Attributes & ObjCDeclSpec::DQ_PR_weak)) {
2186      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2187        << "strong" << "weak";
2188      Attributes &= ~ObjCDeclSpec::DQ_PR_weak;
2189  }
2190
2191  if ((Attributes & ObjCDeclSpec::DQ_PR_atomic) &&
2192      (Attributes & ObjCDeclSpec::DQ_PR_nonatomic)) {
2193      Diag(Loc, diag::err_objc_property_attr_mutually_exclusive)
2194        << "atomic" << "nonatomic";
2195      Attributes &= ~ObjCDeclSpec::DQ_PR_atomic;
2196  }
2197
2198  // Warn if user supplied no assignment attribute, property is
2199  // readwrite, and this is an object type.
2200  if (!(Attributes & (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_copy |
2201                      ObjCDeclSpec::DQ_PR_unsafe_unretained |
2202                      ObjCDeclSpec::DQ_PR_retain | ObjCDeclSpec::DQ_PR_strong |
2203                      ObjCDeclSpec::DQ_PR_weak)) &&
2204      PropertyTy->isObjCObjectPointerType()) {
2205      if (getLangOpts().ObjCAutoRefCount)
2206        // With arc,  @property definitions should default to (strong) when
2207        // not specified; including when property is 'readonly'.
2208        PropertyDecl->setPropertyAttributes(ObjCPropertyDecl::OBJC_PR_strong);
2209      else if (!(Attributes & ObjCDeclSpec::DQ_PR_readonly)) {
2210        bool isAnyClassTy =
2211          (PropertyTy->isObjCClassType() ||
2212           PropertyTy->isObjCQualifiedClassType());
2213        // In non-gc, non-arc mode, 'Class' is treated as a 'void *' no need to
2214        // issue any warning.
2215        if (isAnyClassTy && getLangOpts().getGC() == LangOptions::NonGC)
2216          ;
2217        else if (propertyInPrimaryClass) {
2218          // Don't issue warning on property with no life time in class
2219          // extension as it is inherited from property in primary class.
2220          // Skip this warning in gc-only mode.
2221          if (getLangOpts().getGC() != LangOptions::GCOnly)
2222            Diag(Loc, diag::warn_objc_property_no_assignment_attribute);
2223
2224          // If non-gc code warn that this is likely inappropriate.
2225          if (getLangOpts().getGC() == LangOptions::NonGC)
2226            Diag(Loc, diag::warn_objc_property_default_assign_on_object);
2227        }
2228      }
2229
2230    // FIXME: Implement warning dependent on NSCopying being
2231    // implemented. See also:
2232    // <rdar://5168496&4855821&5607453&5096644&4947311&5698469&4947014&5168496>
2233    // (please trim this list while you are at it).
2234  }
2235
2236  if (!(Attributes & ObjCDeclSpec::DQ_PR_copy)
2237      &&!(Attributes & ObjCDeclSpec::DQ_PR_readonly)
2238      && getLangOpts().getGC() == LangOptions::GCOnly
2239      && PropertyTy->isBlockPointerType())
2240    Diag(Loc, diag::warn_objc_property_copy_missing_on_block);
2241  else if ((Attributes & ObjCDeclSpec::DQ_PR_retain) &&
2242           !(Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2243           !(Attributes & ObjCDeclSpec::DQ_PR_strong) &&
2244           PropertyTy->isBlockPointerType())
2245      Diag(Loc, diag::warn_objc_property_retain_of_block);
2246
2247  if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
2248      (Attributes & ObjCDeclSpec::DQ_PR_setter))
2249    Diag(Loc, diag::warn_objc_readonly_property_has_setter);
2250
2251}
2252