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