contrib/llvm/tools/clang/lib/ARCMigrate/TransProperties.cpp

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