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

   1 //===--- TransRetainReleaseDealloc.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 // removeRetainReleaseDealloc:
  11 //
  12 // Removes retain/release/autorelease/dealloc messages.
  13 //
  14 //  return [[foo retain] autorelease];
  15 // ---->
  16 //  return foo;
  17 //
  18 //===----------------------------------------------------------------------===//
  19
  20 #include "Transforms.h"
  21 #include "Internals.h"
  22 #include "clang/Sema/SemaDiagnostic.h"
  23 #include "clang/AST/ParentMap.h"
  24
  25 using namespace clang;
  26 using namespace arcmt;
  27 using namespace trans;
  28 using llvm::StringRef;
  29
  30 namespace {
  31
  32 class RetainReleaseDeallocRemover :
  33                        public RecursiveASTVisitor<RetainReleaseDeallocRemover> {
  34   Stmt *Body;
  35   MigrationPass &Pass;
  36
  37   ExprSet Removables;
  38   llvm::OwningPtr<ParentMap> StmtMap;
  39
  40   Selector DelegateSel;
  41
  42 public:
  43   RetainReleaseDeallocRemover(MigrationPass &pass)
  44     : Body(0), Pass(pass) {
  45     DelegateSel =
  46         Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate"));
  47   }
  48
  49   void transformBody(Stmt *body) {
  50     Body = body;
  51     collectRemovables(body, Removables);
  52     StmtMap.reset(new ParentMap(body));
  53     TraverseStmt(body);
  54   }
  55
  56   bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
  57     switch (E->getMethodFamily()) {
  58     default:
  59       return true;
  60     case OMF_autorelease:
  61       if (isRemovable(E)) {
  62         // An unused autorelease is badness. If we remove it the receiver
  63         // will likely die immediately while previously it was kept alive
  64         // by the autorelease pool. This is bad practice in general, leave it
  65         // and emit an error to force the user to restructure his code.
  66         Pass.TA.reportError("it is not safe to remove an unused 'autorelease' "
  67             "message; its receiver may be destroyed immediately",
  68             E->getLocStart(), E->getSourceRange());
  69         return true;
  70       }
  71       // Pass through.
  72     case OMF_retain:
  73     case OMF_release:
  74       if (E->getReceiverKind() == ObjCMessageExpr::Instance)
  75         if (Expr *rec = E->getInstanceReceiver()) {
  76           rec = rec->IgnoreParenImpCasts();
  77           if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
  78               (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
  79             std::string err = "it is not safe to remove '";
  80             err += E->getSelector().getAsString() + "' message on "
  81                 "an __unsafe_unretained type";
  82             Pass.TA.reportError(err, rec->getLocStart());
  83             return true;
  84           }
  85
  86           if (isGlobalVar(rec) &&
  87               (E->getMethodFamily() != OMF_retain || isRemovable(E))) {
  88             std::string err = "it is not safe to remove '";
  89             err += E->getSelector().getAsString() + "' message on "
  90                 "a global variable";
  91             Pass.TA.reportError(err, rec->getLocStart());
  92             return true;
  93           }
  94
  95           if (E->getMethodFamily() == OMF_release && isDelegateMessage(rec)) {
  96             Pass.TA.reportError("it is not safe to remove 'retain' "
  97                 "message on the result of a 'delegate' message; "
  98                 "the object that was passed to 'setDelegate:' may not be "
  99                 "properly retained", rec->getLocStart());
 100             return true;
 101           }
 102         }
 103     case OMF_dealloc:
 104       break;
 105     }
 106
 107     switch (E->getReceiverKind()) {
 108     default:
 109       return true;
 110     case ObjCMessageExpr::SuperInstance: {
 111       Transaction Trans(Pass.TA);
 112       clearDiagnostics(E->getSuperLoc());
 113       if (tryRemoving(E))
 114         return true;
 115       Pass.TA.replace(E->getSourceRange(), "self");
 116       return true;
 117     }
 118     case ObjCMessageExpr::Instance:
 119       break;
 120     }
 121
 122     Expr *rec = E->getInstanceReceiver();
 123     if (!rec) return true;
 124
 125     Transaction Trans(Pass.TA);
 126     clearDiagnostics(rec->getExprLoc());
 127
 128     if (E->getMethodFamily() == OMF_release &&
 129         isRemovable(E) && isInAtFinally(E)) {
 130       // Change the -release to "receiver = nil" in a finally to avoid a leak
 131       // when an exception is thrown.
 132       Pass.TA.replace(E->getSourceRange(), rec->getSourceRange());
 133       if (Pass.Ctx.Idents.get("nil").hasMacroDefinition())
 134         Pass.TA.insertAfterToken(rec->getLocEnd(), " = nil");
 135       else
 136         Pass.TA.insertAfterToken(rec->getLocEnd(), " = 0");
 137       return true;
 138     }
 139
 140     if (!hasSideEffects(E, Pass.Ctx)) {
 141       if (tryRemoving(E))
 142         return true;
 143     }
 144     Pass.TA.replace(E->getSourceRange(), rec->getSourceRange());
 145
 146     return true;
 147   }
 148
 149 private:
 150   void clearDiagnostics(SourceLocation loc) const {
 151     Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
 152                             diag::err_unavailable,
 153                             diag::err_unavailable_message,
 154                             loc);
 155   }
 156
 157   bool isDelegateMessage(Expr *E) const {
 158     if (!E) return false;
 159
 160     E = E->IgnoreParenCasts();
 161     if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
 162       return (ME->isInstanceMessage() && ME->getSelector() == DelegateSel);
 163
 164     if (ObjCPropertyRefExpr *propE = dyn_cast<ObjCPropertyRefExpr>(E))
 165       return propE->getGetterSelector() == DelegateSel;
 166
 167     return false;
 168   }
 169
 170   bool isInAtFinally(Expr *E) const {
 171     assert(E);
 172     Stmt *S = E;
 173     while (S) {
 174       if (isa<ObjCAtFinallyStmt>(S))
 175         return true;
 176       S = StmtMap->getParent(S);
 177     }
 178
 179     return false;
 180   }
 181
 182   bool isRemovable(Expr *E) const {
 183     return Removables.count(E);
 184   }
 185
 186   bool tryRemoving(Expr *E) const {
 187     if (isRemovable(E)) {
 188       Pass.TA.removeStmt(E);
 189       return true;
 190     }
 191
 192     Stmt *parent = StmtMap->getParent(E);
 193
 194     if (ImplicitCastExpr *castE = dyn_cast_or_null<ImplicitCastExpr>(parent))
 195       return tryRemoving(castE);
 196
 197     if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(parent))
 198       return tryRemoving(parenE);
 199
 200     if (BinaryOperator *
 201           bopE = dyn_cast_or_null<BinaryOperator>(parent)) {
 202       if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E &&
 203           isRemovable(bopE)) {
 204         Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange());
 205         return true;
 206       }
 207     }
 208
 209     return false;
 210   }
 211
 212 };
 213
 214 } // anonymous namespace
 215
 216 void trans::removeRetainReleaseDealloc(MigrationPass &pass) {
 217   BodyTransform<RetainReleaseDeallocRemover> trans(pass);
 218   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
 219 }