clang/lib/ARCMigrate/TransProperties.cpp

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