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

   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   MigrationPass &Pass;
  48   ObjCImplementationDecl *CurImplD;
  49
  50   struct PropData {
  51     ObjCPropertyDecl *PropD;
  52     ObjCIvarDecl *IvarD;
  53     ObjCPropertyImplDecl *ImplD;
  54
  55     PropData(ObjCPropertyDecl *propD) : PropD(propD), IvarD(0), ImplD(0) { }
  56   };
  57
  58   typedef SmallVector<PropData, 2> PropsTy;
  59   typedef std::map<unsigned, PropsTy> AtPropDeclsTy;
  60   AtPropDeclsTy AtProps;
  61
  62 public:
  63   PropertiesRewriter(MigrationPass &pass) : Pass(pass) { }
  64
  65   void doTransform(ObjCImplementationDecl *D) {
  66     CurImplD = D;
  67     ObjCInterfaceDecl *iface = D->getClassInterface();
  68     if (!iface)
  69       return;
  70
  71     for (ObjCInterfaceDecl::prop_iterator
  72            propI = iface->prop_begin(),
  73            propE = iface->prop_end(); propI != propE; ++propI) {
  74       if (propI->getAtLoc().isInvalid())
  75         continue;
  76       PropsTy &props = AtProps[propI->getAtLoc().getRawEncoding()];
  77       props.push_back(*propI);
  78     }
  79
  80     typedef DeclContext::specific_decl_iterator<ObjCPropertyImplDecl>
  81         prop_impl_iterator;
  82     for (prop_impl_iterator
  83            I = prop_impl_iterator(D->decls_begin()),
  84            E = prop_impl_iterator(D->decls_end()); I != E; ++I) {
  85       ObjCPropertyImplDecl *implD = *I;
  86       if (implD->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
  87         continue;
  88       ObjCPropertyDecl *propD = implD->getPropertyDecl();
  89       if (!propD || propD->isInvalidDecl())
  90         continue;
  91       ObjCIvarDecl *ivarD = implD->getPropertyIvarDecl();
  92       if (!ivarD || ivarD->isInvalidDecl())
  93         continue;
  94       unsigned rawAtLoc = propD->getAtLoc().getRawEncoding();
  95       AtPropDeclsTy::iterator findAtLoc = AtProps.find(rawAtLoc);
  96       if (findAtLoc == AtProps.end())
  97         continue;
  98
  99       PropsTy &props = findAtLoc->second;
 100       for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
 101         if (I->PropD == propD) {
 102           I->IvarD = ivarD;
 103           I->ImplD = implD;
 104           break;
 105         }
 106       }
 107     }
 108
 109     for (AtPropDeclsTy::iterator
 110            I = AtProps.begin(), E = AtProps.end(); I != E; ++I) {
 111       SourceLocation atLoc = SourceLocation::getFromRawEncoding(I->first);
 112       PropsTy &props = I->second;
 113       QualType ty = getPropertyType(props);
 114       if (!ty->isObjCRetainableType())
 115         continue;
 116       if (hasIvarWithExplicitOwnership(props))
 117         continue;
 118
 119       Transaction Trans(Pass.TA);
 120       rewriteProperty(props, atLoc);
 121     }
 122   }
 123
 124 private:
 125   void rewriteProperty(PropsTy &props, SourceLocation atLoc) const {
 126     ObjCPropertyDecl::PropertyAttributeKind propAttrs = getPropertyAttrs(props);
 127
 128     if (propAttrs & (ObjCPropertyDecl::OBJC_PR_copy |
 129                      ObjCPropertyDecl::OBJC_PR_unsafe_unretained |
 130                      ObjCPropertyDecl::OBJC_PR_strong |
 131                      ObjCPropertyDecl::OBJC_PR_weak))
 132       return;
 133
 134     if (propAttrs & ObjCPropertyDecl::OBJC_PR_retain) {
 135       rewriteAttribute("retain", "strong", atLoc);
 136       return;
 137     }
 138
 139     if (propAttrs & ObjCPropertyDecl::OBJC_PR_assign) {
 140       if (hasIvarAssignedAPlusOneObject(props)) {
 141         rewriteAttribute("assign", "strong", atLoc);
 142         return;
 143       }
 144       return rewriteAssign(props, atLoc);
 145     }
 146
 147     if (hasIvarAssignedAPlusOneObject(props))
 148       return maybeAddStrongAttr(props, atLoc);
 149
 150     return maybeAddWeakOrUnsafeUnretainedAttr(props, atLoc);
 151   }
 152
 153   void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {
 154     bool canUseWeak = canApplyWeak(Pass.Ctx, getPropertyType(props));
 155
 156     bool rewroteAttr = rewriteAttribute("assign",
 157                                      canUseWeak ? "weak" : "unsafe_unretained",
 158                                          atLoc);
 159     if (!rewroteAttr)
 160       canUseWeak = false;
 161
 162     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
 163       if (isUserDeclared(I->IvarD))
 164         Pass.TA.insert(I->IvarD->getLocation(),
 165                        canUseWeak ? "__weak " : "__unsafe_unretained ");
 166       if (I->ImplD)
 167         Pass.TA.clearDiagnostic(diag::err_arc_assign_property_ownership,
 168                                 I->ImplD->getLocation());
 169     }
 170   }
 171
 172   void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props,
 173                                           SourceLocation atLoc) const {
 174     ObjCPropertyDecl::PropertyAttributeKind propAttrs = getPropertyAttrs(props);
 175
 176     bool canUseWeak = canApplyWeak(Pass.Ctx, getPropertyType(props));
 177     if (!(propAttrs & ObjCPropertyDecl::OBJC_PR_readonly) ||
 178         !hasAllIvarsBacked(props)) {
 179       bool addedAttr = addAttribute(canUseWeak ? "weak" : "unsafe_unretained",
 180                                     atLoc);
 181       if (!addedAttr)
 182         canUseWeak = false;
 183     }
 184
 185     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
 186       if (isUserDeclared(I->IvarD))
 187         Pass.TA.insert(I->IvarD->getLocation(),
 188                        canUseWeak ? "__weak " : "__unsafe_unretained ");
 189       if (I->ImplD) {
 190         Pass.TA.clearDiagnostic(diag::err_arc_assign_property_ownership,
 191                                 I->ImplD->getLocation());
 192         Pass.TA.clearDiagnostic(
 193                            diag::err_arc_objc_property_default_assign_on_object,
 194                            I->ImplD->getLocation());
 195       }
 196     }
 197   }
 198
 199   void maybeAddStrongAttr(PropsTy &props, SourceLocation atLoc) const {
 200     ObjCPropertyDecl::PropertyAttributeKind propAttrs = getPropertyAttrs(props);
 201
 202     if (!(propAttrs & ObjCPropertyDecl::OBJC_PR_readonly) ||
 203         !hasAllIvarsBacked(props)) {
 204       addAttribute("strong", atLoc);
 205     }
 206
 207     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
 208       if (I->ImplD) {
 209         Pass.TA.clearDiagnostic(diag::err_arc_assign_property_ownership,
 210                                 I->ImplD->getLocation());
 211         Pass.TA.clearDiagnostic(
 212                            diag::err_arc_objc_property_default_assign_on_object,
 213                            I->ImplD->getLocation());
 214       }
 215     }
 216   }
 217
 218   bool rewriteAttribute(StringRef fromAttr, StringRef toAttr,
 219                         SourceLocation atLoc) const {
 220     if (atLoc.isMacroID())
 221       return false;
 222
 223     SourceManager &SM = Pass.Ctx.getSourceManager();
 224
 225     // Break down the source location.
 226     std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(atLoc);
 227
 228     // Try to load the file buffer.
 229     bool invalidTemp = false;
 230     StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
 231     if (invalidTemp)
 232       return false;
 233
 234     const char *tokenBegin = file.data() + locInfo.second;
 235
 236     // Lex from the start of the given location.
 237     Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
 238                 Pass.Ctx.getLangOptions(),
 239                 file.begin(), tokenBegin, file.end());
 240     Token tok;
 241     lexer.LexFromRawLexer(tok);
 242     if (tok.isNot(tok::at)) return false;
 243     lexer.LexFromRawLexer(tok);
 244     if (tok.isNot(tok::raw_identifier)) return false;
 245     if (StringRef(tok.getRawIdentifierData(), tok.getLength())
 246           != "property")
 247       return false;
 248     lexer.LexFromRawLexer(tok);
 249     if (tok.isNot(tok::l_paren)) return false;
 250
 251     lexer.LexFromRawLexer(tok);
 252     if (tok.is(tok::r_paren))
 253       return false;
 254
 255     while (1) {
 256       if (tok.isNot(tok::raw_identifier)) return false;
 257       StringRef ident(tok.getRawIdentifierData(), tok.getLength());
 258       if (ident == fromAttr) {
 259         Pass.TA.replaceText(tok.getLocation(), fromAttr, toAttr);
 260         return true;
 261       }
 262
 263       do {
 264         lexer.LexFromRawLexer(tok);
 265       } while (tok.isNot(tok::comma) && tok.isNot(tok::r_paren));
 266       if (tok.is(tok::r_paren))
 267         break;
 268       lexer.LexFromRawLexer(tok);
 269     }
 270
 271     return false;
 272   }
 273
 274   bool addAttribute(StringRef attr, SourceLocation atLoc) const {
 275     if (atLoc.isMacroID())
 276       return false;
 277
 278     SourceManager &SM = Pass.Ctx.getSourceManager();
 279
 280     // Break down the source location.
 281     std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(atLoc);
 282
 283     // Try to load the file buffer.
 284     bool invalidTemp = false;
 285     StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
 286     if (invalidTemp)
 287       return false;
 288
 289     const char *tokenBegin = file.data() + locInfo.second;
 290
 291     // Lex from the start of the given location.
 292     Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
 293                 Pass.Ctx.getLangOptions(),
 294                 file.begin(), tokenBegin, file.end());
 295     Token tok;
 296     lexer.LexFromRawLexer(tok);
 297     if (tok.isNot(tok::at)) return false;
 298     lexer.LexFromRawLexer(tok);
 299     if (tok.isNot(tok::raw_identifier)) return false;
 300     if (StringRef(tok.getRawIdentifierData(), tok.getLength())
 301           != "property")
 302       return false;
 303     lexer.LexFromRawLexer(tok);
 304
 305     if (tok.isNot(tok::l_paren)) {
 306       Pass.TA.insert(tok.getLocation(), std::string("(") + attr.str() + ") ");
 307       return true;
 308     }
 309
 310     lexer.LexFromRawLexer(tok);
 311     if (tok.is(tok::r_paren)) {
 312       Pass.TA.insert(tok.getLocation(), attr);
 313       return true;
 314     }
 315
 316     if (tok.isNot(tok::raw_identifier)) return false;
 317
 318     Pass.TA.insert(tok.getLocation(), std::string(attr) + ", ");
 319     return true;
 320   }
 321
 322   class PlusOneAssign : public RecursiveASTVisitor<PlusOneAssign> {
 323     ObjCIvarDecl *Ivar;
 324   public:
 325     PlusOneAssign(ObjCIvarDecl *D) : Ivar(D) {}
 326
 327     bool VisitBinAssign(BinaryOperator *E) {
 328       Expr *lhs = E->getLHS()->IgnoreParenImpCasts();
 329       if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(lhs)) {
 330         if (RE->getDecl() != Ivar)
 331           return true;
 332
 333       if (ObjCMessageExpr *
 334             ME = dyn_cast<ObjCMessageExpr>(E->getRHS()->IgnoreParenCasts()))
 335         if (ME->getMethodFamily() == OMF_retain)
 336           return false;
 337
 338       ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(E->getRHS());
 339       while (implCE && implCE->getCastKind() ==  CK_BitCast)
 340         implCE = dyn_cast<ImplicitCastExpr>(implCE->getSubExpr());
 341
 342       if (implCE && implCE->getCastKind() == CK_ARCConsumeObject)
 343         return false;
 344       }
 345
 346       return true;
 347     }
 348   };
 349
 350   bool hasIvarAssignedAPlusOneObject(PropsTy &props) const {
 351     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
 352       PlusOneAssign oneAssign(I->IvarD);
 353       bool notFound = oneAssign.TraverseDecl(CurImplD);
 354       if (!notFound)
 355         return true;
 356     }
 357
 358     return false;
 359   }
 360
 361   bool hasIvarWithExplicitOwnership(PropsTy &props) const {
 362     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
 363       if (isUserDeclared(I->IvarD)) {
 364         if (isa<AttributedType>(I->IvarD->getType()))
 365           return true;
 366         if (I->IvarD->getType().getLocalQualifiers().getObjCLifetime()
 367               != Qualifiers::OCL_Strong)
 368           return true;
 369       }
 370     }
 371
 372     return false;
 373   }
 374
 375   bool hasAllIvarsBacked(PropsTy &props) const {
 376     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
 377       if (!isUserDeclared(I->IvarD))
 378         return false;
 379
 380     return true;
 381   }
 382
 383   bool isUserDeclared(ObjCIvarDecl *ivarD) const {
 384     return ivarD && !ivarD->getSynthesize();
 385   }
 386
 387   QualType getPropertyType(PropsTy &props) const {
 388     assert(!props.empty());
 389     QualType ty = props[0].PropD->getType();
 390
 391 #ifndef NDEBUG
 392     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
 393       assert(ty == I->PropD->getType());
 394 #endif
 395
 396     return ty;
 397   }
 398
 399   ObjCPropertyDecl::PropertyAttributeKind
 400   getPropertyAttrs(PropsTy &props) const {
 401     assert(!props.empty());
 402     ObjCPropertyDecl::PropertyAttributeKind
 403       attrs = props[0].PropD->getPropertyAttributesAsWritten();
 404
 405 #ifndef NDEBUG
 406     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
 407       assert(attrs == I->PropD->getPropertyAttributesAsWritten());
 408 #endif
 409
 410     return attrs;
 411   }
 412 };
 413
 414 class ImplementationChecker :
 415                              public RecursiveASTVisitor<ImplementationChecker> {
 416   MigrationPass &Pass;
 417
 418 public:
 419   ImplementationChecker(MigrationPass &pass) : Pass(pass) { }
 420
 421   bool TraverseObjCImplementationDecl(ObjCImplementationDecl *D) {
 422     PropertiesRewriter(Pass).doTransform(D);
 423     return true;
 424   }
 425 };
 426
 427 } // anonymous namespace
 428
 429 void trans::rewriteProperties(MigrationPass &pass) {
 430   ImplementationChecker(pass).TraverseDecl(pass.Ctx.getTranslationUnitDecl());
 431 }