Home | History | Annotate | Download | only in ARCMigrate 
      1 //===--- TransProperties.cpp - Tranformations to ARC mode -----------------===//
      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 // rewriteProperties:
     11 //
     12 // - Adds strong/weak/unsafe_unretained ownership specifier to properties that
     13 //   are missing one.
     14 // - Migrates properties from (retain) to (strong) and (assign) to
     15 //   (unsafe_unretained/weak).
     16 // - If a property is synthesized, adds the ownership specifier in the ivar
     17 //   backing the property.
     18 //
     19 //  @interface Foo : NSObject {
     20 //      NSObject *x;
     21 //  }
     22 //  @property (assign) id x;
     23 //  @end
     24 // ---->
     25 //  @interface Foo : NSObject {
     26 //      NSObject *__weak x;
     27 //  }
     28 //  @property (weak) id x;
     29 //  @end
     30 //
     31 //===----------------------------------------------------------------------===//
     32 
     33 #include "Transforms.h"
     34 #include "Internals.h"
     35 #include "clang/Sema/SemaDiagnostic.h"
     36 #include "clang/Basic/SourceManager.h"
     37 #include "clang/Lex/Lexer.h"
     38 #include <map>
     39 
     40 using namespace clang;
     41 using namespace arcmt;
     42 using namespace trans;
     43 
     44 namespace {
     45 
     46 class PropertiesRewriter {
     47   MigrationContext &MigrateCtx;
     48   MigrationPass &Pass;
     49   ObjCImplementationDecl *CurImplD;
     50 
     51   enum PropActionKind {
     52     PropAction_None,
     53     PropAction_RetainReplacedWithStrong,
     54     PropAction_AssignRemoved,
     55     PropAction_AssignRewritten,
     56     PropAction_MaybeAddWeakOrUnsafe
     57   };
     58 
     59   struct PropData {
     60     ObjCPropertyDecl *PropD;
     61     ObjCIvarDecl *IvarD;
     62     ObjCPropertyImplDecl *ImplD;
     63 
     64     PropData(ObjCPropertyDecl *propD) : PropD(propD), IvarD(0), ImplD(0) { }
     65   };
     66 
     67   typedef SmallVector<PropData, 2> PropsTy;
     68   typedef std::map<unsigned, PropsTy> AtPropDeclsTy;
     69   AtPropDeclsTy AtProps;
     70   llvm::DenseMap<IdentifierInfo *, PropActionKind> ActionOnProp;
     71 
     72 public:
     73   explicit PropertiesRewriter(MigrationContext &MigrateCtx)
     74     : MigrateCtx(MigrateCtx), Pass(MigrateCtx.Pass) { }
     75 
     76   static void collectProperties(ObjCContainerDecl *D, AtPropDeclsTy &AtProps,
     77                                 AtPropDeclsTy *PrevAtProps = 0) {
     78     for (ObjCInterfaceDecl::prop_iterator
     79            propI = D->prop_begin(),
     80            propE = D->prop_end(); propI != propE; ++propI) {
     81       if (propI->getAtLoc().isInvalid())
     82         continue;
     83       unsigned RawLoc = propI->getAtLoc().getRawEncoding();
     84       if (PrevAtProps)
     85         if (PrevAtProps->find(RawLoc) != PrevAtProps->end())
     86           continue;
     87       PropsTy &props = AtProps[RawLoc];
     88       props.push_back(*propI);
     89     }
     90   }
     91 
     92   void doTransform(ObjCImplementationDecl *D) {
     93     CurImplD = D;
     94     ObjCInterfaceDecl *iface = D->getClassInterface();
     95     if (!iface)
     96       return;
     97 
     98     collectProperties(iface, AtProps);
     99 
    100     typedef DeclContext::specific_decl_iterator<ObjCPropertyImplDecl>
    101         prop_impl_iterator;
    102     for (prop_impl_iterator
    103            I = prop_impl_iterator(D->decls_begin()),
    104            E = prop_impl_iterator(D->decls_end()); I != E; ++I) {
    105       ObjCPropertyImplDecl *implD = *I;
    106       if (implD->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
    107         continue;
    108       ObjCPropertyDecl *propD = implD->getPropertyDecl();
    109       if (!propD || propD->isInvalidDecl())
    110         continue;
    111       ObjCIvarDecl *ivarD = implD->getPropertyIvarDecl();
    112       if (!ivarD || ivarD->isInvalidDecl())
    113         continue;
    114       unsigned rawAtLoc = propD->getAtLoc().getRawEncoding();
    115       AtPropDeclsTy::iterator findAtLoc = AtProps.find(rawAtLoc);
    116       if (findAtLoc == AtProps.end())
    117         continue;
    118 
    119       PropsTy &props = findAtLoc->second;
    120       for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
    121         if (I->PropD == propD) {
    122           I->IvarD = ivarD;
    123           I->ImplD = implD;
    124           break;
    125         }
    126       }
    127     }
    128 
    129     for (AtPropDeclsTy::iterator
    130            I = AtProps.begin(), E = AtProps.end(); I != E; ++I) {
    131       SourceLocation atLoc = SourceLocation::getFromRawEncoding(I->first);
    132       PropsTy &props = I->second;
    133       if (!getPropertyType(props)->isObjCRetainableType())
    134         continue;
    135       if (hasIvarWithExplicitARCOwnership(props))
    136         continue;
    137 
    138       Transaction Trans(Pass.TA);
    139       rewriteProperty(props, atLoc);
    140     }
    141 
    142     AtPropDeclsTy AtExtProps;
    143     // Look through extensions.
    144     for (ObjCCategoryDecl *Cat = iface->getCategoryList();
    145            Cat; Cat = Cat->getNextClassCategory())
    146       if (Cat->IsClassExtension())
    147         collectProperties(Cat, AtExtProps, &AtProps);
    148 
    149     for (AtPropDeclsTy::iterator
    150            I = AtExtProps.begin(), E = AtExtProps.end(); I != E; ++I) {
    151       SourceLocation atLoc = SourceLocation::getFromRawEncoding(I->first);
    152       PropsTy &props = I->second;
    153       Transaction Trans(Pass.TA);
    154       doActionForExtensionProp(props, atLoc);
    155     }
    156   }
    157 
    158 private:
    159   void doPropAction(PropActionKind kind,
    160                     PropsTy &props, SourceLocation atLoc,
    161                     bool markAction = true) {
    162     if (markAction)
    163       for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
    164         ActionOnProp[I->PropD->getIdentifier()] = kind;
    165 
    166     switch (kind) {
    167     case PropAction_None:
    168       return;
    169     case PropAction_RetainReplacedWithStrong: {
    170       StringRef toAttr = "strong";
    171       MigrateCtx.rewritePropertyAttribute("retain", toAttr, atLoc);
    172       return;
    173     }
    174     case PropAction_AssignRemoved:
    175       return removeAssignForDefaultStrong(props, atLoc);
    176     case PropAction_AssignRewritten:
    177       return rewriteAssign(props, atLoc);
    178     case PropAction_MaybeAddWeakOrUnsafe:
    179       return maybeAddWeakOrUnsafeUnretainedAttr(props, atLoc);
    180     }
    181   }
    182 
    183   void doActionForExtensionProp(PropsTy &props, SourceLocation atLoc) {
    184     llvm::DenseMap<IdentifierInfo *, PropActionKind>::iterator I;
    185     I = ActionOnProp.find(props[0].PropD->getIdentifier());
    186     if (I == ActionOnProp.end())
    187       return;
    188 
    189     doPropAction(I->second, props, atLoc, false);
    190   }
    191 
    192   void rewriteProperty(PropsTy &props, SourceLocation atLoc) {
    193     ObjCPropertyDecl::PropertyAttributeKind propAttrs = getPropertyAttrs(props);
    194 
    195     if (propAttrs & (ObjCPropertyDecl::OBJC_PR_copy |
    196                      ObjCPropertyDecl::OBJC_PR_unsafe_unretained |
    197                      ObjCPropertyDecl::OBJC_PR_strong |
    198                      ObjCPropertyDecl::OBJC_PR_weak))
    199       return;
    200 
    201     if (propAttrs & ObjCPropertyDecl::OBJC_PR_retain) {
    202       // strong is the default.
    203       return doPropAction(PropAction_RetainReplacedWithStrong, props, atLoc);
    204     }
    205 
    206     bool HasIvarAssignedAPlusOneObject = hasIvarAssignedAPlusOneObject(props);
    207 
    208     if (propAttrs & ObjCPropertyDecl::OBJC_PR_assign) {
    209       if (HasIvarAssignedAPlusOneObject)
    210         return doPropAction(PropAction_AssignRemoved, props, atLoc);
    211       return doPropAction(PropAction_AssignRewritten, props, atLoc);
    212     }
    213 
    214     if (HasIvarAssignedAPlusOneObject ||
    215         (Pass.isGCMigration() && !hasGCWeak(props, atLoc)))
    216       return; // 'strong' by default.
    217 
    218     return doPropAction(PropAction_MaybeAddWeakOrUnsafe, props, atLoc);
    219   }
    220 
    221   void removeAssignForDefaultStrong(PropsTy &props,
    222                                     SourceLocation atLoc) const {
    223     removeAttribute("retain", atLoc);
    224     if (!removeAttribute("assign", atLoc))
    225       return;
    226 
    227     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
    228       if (I->ImplD)
    229         Pass.TA.clearDiagnostic(diag::err_arc_assign_property_ownership,
    230                                 I->ImplD->getLocation());
    231     }
    232   }
    233 
    234   void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {
    235     bool canUseWeak = canApplyWeak(Pass.Ctx, getPropertyType(props),
    236                                   /*AllowOnUnknownClass=*/Pass.isGCMigration());
    237     const char *toWhich =
    238       (Pass.isGCMigration() && !hasGCWeak(props, atLoc)) ? "strong" :
    239       (canUseWeak ? "weak" : "unsafe_unretained");
    240 
    241     bool rewroteAttr = rewriteAttribute("assign", toWhich, atLoc);
    242     if (!rewroteAttr)
    243       canUseWeak = false;
    244 
    245     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
    246       if (isUserDeclared(I->IvarD)) {
    247         if (I->IvarD &&
    248             I->IvarD->getType().getObjCLifetime() != Qualifiers::OCL_Weak) {
    249           const char *toWhich =
    250             (Pass.isGCMigration() && !hasGCWeak(props, atLoc)) ? "__strong " :
    251               (canUseWeak ? "__weak " : "__unsafe_unretained ");
    252           Pass.TA.insert(I->IvarD->getLocation(), toWhich);
    253         }
    254       }
    255       if (I->ImplD)
    256         Pass.TA.clearDiagnostic(diag::err_arc_assign_property_ownership,
    257                                 I->ImplD->getLocation());
    258     }
    259   }
    260 
    261   void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props,
    262                                           SourceLocation atLoc) const {
    263     bool canUseWeak = canApplyWeak(Pass.Ctx, getPropertyType(props),
    264                                   /*AllowOnUnknownClass=*/Pass.isGCMigration());
    265 
    266     bool addedAttr = addAttribute(canUseWeak ? "weak" : "unsafe_unretained",
    267                                   atLoc);
    268     if (!addedAttr)
    269       canUseWeak = false;
    270 
    271     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
    272       if (isUserDeclared(I->IvarD)) {
    273         if (I->IvarD &&
    274             I->IvarD->getType().getObjCLifetime() != Qualifiers::OCL_Weak)
    275           Pass.TA.insert(I->IvarD->getLocation(),
    276                          canUseWeak ? "__weak " : "__unsafe_unretained ");
    277       }
    278       if (I->ImplD) {
    279         Pass.TA.clearDiagnostic(diag::err_arc_assign_property_ownership,
    280                                 I->ImplD->getLocation());
    281         Pass.TA.clearDiagnostic(
    282                            diag::err_arc_objc_property_default_assign_on_object,
    283                            I->ImplD->getLocation());
    284       }
    285     }
    286   }
    287 
    288   bool removeAttribute(StringRef fromAttr, SourceLocation atLoc) const {
    289     return MigrateCtx.removePropertyAttribute(fromAttr, atLoc);
    290   }
    291 
    292   bool rewriteAttribute(StringRef fromAttr, StringRef toAttr,
    293                         SourceLocation atLoc) const {
    294     return MigrateCtx.rewritePropertyAttribute(fromAttr, toAttr, atLoc);
    295   }
    296 
    297   bool addAttribute(StringRef attr, SourceLocation atLoc) const {
    298     return MigrateCtx.addPropertyAttribute(attr, atLoc);
    299   }
    300 
    301   class PlusOneAssign : public RecursiveASTVisitor<PlusOneAssign> {
    302     ObjCIvarDecl *Ivar;
    303   public:
    304     PlusOneAssign(ObjCIvarDecl *D) : Ivar(D) {}
    305 
    306     bool VisitBinAssign(BinaryOperator *E) {
    307       Expr *lhs = E->getLHS()->IgnoreParenImpCasts();
    308       if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(lhs)) {
    309         if (RE->getDecl() != Ivar)
    310           return true;
    311 
    312       if (ObjCMessageExpr *
    313             ME = dyn_cast<ObjCMessageExpr>(E->getRHS()->IgnoreParenCasts()))
    314         if (ME->getMethodFamily() == OMF_retain)
    315           return false;
    316 
    317       ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(E->getRHS());
    318       while (implCE && implCE->getCastKind() ==  CK_BitCast)
    319         implCE = dyn_cast<ImplicitCastExpr>(implCE->getSubExpr());
    320 
    321       if (implCE && implCE->getCastKind() == CK_ARCConsumeObject)
    322         return false;
    323       }
    324 
    325       return true;
    326     }
    327   };
    328 
    329   bool hasIvarAssignedAPlusOneObject(PropsTy &props) const {
    330     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
    331       PlusOneAssign oneAssign(I->IvarD);
    332       bool notFound = oneAssign.TraverseDecl(CurImplD);
    333       if (!notFound)
    334         return true;
    335     }
    336 
    337     return false;
    338   }
    339 
    340   bool hasIvarWithExplicitARCOwnership(PropsTy &props) const {
    341     if (Pass.isGCMigration())
    342       return false;
    343 
    344     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
    345       if (isUserDeclared(I->IvarD)) {
    346         if (isa<AttributedType>(I->IvarD->getType()))
    347           return true;
    348         if (I->IvarD->getType().getLocalQualifiers().getObjCLifetime()
    349               != Qualifiers::OCL_Strong)
    350           return true;
    351       }
    352     }
    353 
    354     return false;
    355   }
    356 
    357   bool hasAllIvarsBacked(PropsTy &props) const {
    358     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
    359       if (!isUserDeclared(I->IvarD))
    360         return false;
    361 
    362     return true;
    363   }
    364 
    365   // \brief Returns true if all declarations in the @property have GC __weak.
    366   bool hasGCWeak(PropsTy &props, SourceLocation atLoc) const {
    367     if (!Pass.isGCMigration())
    368       return false;
    369     if (props.empty())
    370       return false;
    371     return MigrateCtx.AtPropsWeak.count(atLoc.getRawEncoding());
    372   }
    373 
    374   bool isUserDeclared(ObjCIvarDecl *ivarD) const {
    375     return ivarD && !ivarD->getSynthesize();
    376   }
    377 
    378   QualType getPropertyType(PropsTy &props) const {
    379     assert(!props.empty());
    380     QualType ty = props[0].PropD->getType().getUnqualifiedType();
    381 
    382 #ifndef NDEBUG
    383     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
    384       assert(ty == I->PropD->getType().getUnqualifiedType());
    385 #endif
    386 
    387     return ty;
    388   }
    389 
    390   ObjCPropertyDecl::PropertyAttributeKind
    391   getPropertyAttrs(PropsTy &props) const {
    392     assert(!props.empty());
    393     ObjCPropertyDecl::PropertyAttributeKind
    394       attrs = props[0].PropD->getPropertyAttributesAsWritten();
    395 
    396 #ifndef NDEBUG
    397     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
    398       assert(attrs == I->PropD->getPropertyAttributesAsWritten());
    399 #endif
    400 
    401     return attrs;
    402   }
    403 };
    404 
    405 } // anonymous namespace
    406 
    407 void PropertyRewriteTraverser::traverseObjCImplementation(
    408                                            ObjCImplementationContext &ImplCtx) {
    409   PropertiesRewriter(ImplCtx.getMigrationContext())
    410                                   .doTransform(ImplCtx.getImplementationDecl());
    411 }
    412