clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp

   1 //===-- TransEmptyStatementsAndDealloc.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 // removeEmptyStatementsAndDealloc:
  10 //
  11 // Removes empty statements that are leftovers from previous transformations.
  12 // e.g for
  13 //
  14 //  [x retain];
  15 //
  16 // removeRetainReleaseDealloc will leave an empty ";" that removeEmptyStatements
  17 // will remove.
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 #include "Transforms.h"
  22 #include "Internals.h"
  23 #include "clang/AST/ASTContext.h"
  24 #include "clang/AST/StmtVisitor.h"
  25 #include "clang/Basic/SourceManager.h"
  26
  27 using namespace clang;
  28 using namespace arcmt;
  29 using namespace trans;
  30
  31 static bool isEmptyARCMTMacroStatement(NullStmt *S,
  32                                        std::vector<SourceLocation> &MacroLocs,
  33                                        ASTContext &Ctx) {
  34   if (!S->hasLeadingEmptyMacro())
  35     return false;
  36
  37   SourceLocation SemiLoc = S->getSemiLoc();
  38   if (SemiLoc.isInvalid() || SemiLoc.isMacroID())
  39     return false;
  40
  41   if (MacroLocs.empty())
  42     return false;
  43
  44   SourceManager &SM = Ctx.getSourceManager();
  45   std::vector<SourceLocation>::iterator I = llvm::upper_bound(
  46       MacroLocs, SemiLoc, BeforeThanCompare<SourceLocation>(SM));
  47   --I;
  48   SourceLocation
  49       AfterMacroLoc = I->getLocWithOffset(getARCMTMacroName().size());
  50   assert(AfterMacroLoc.isFileID());
  51
  52   if (AfterMacroLoc == SemiLoc)
  53     return true;
  54
  55   SourceLocation::IntTy RelOffs = 0;
  56   if (!SM.isInSameSLocAddrSpace(AfterMacroLoc, SemiLoc, &RelOffs))
  57     return false;
  58   if (RelOffs < 0)
  59     return false;
  60
  61   // We make the reasonable assumption that a semicolon after 100 characters
  62   // means that it is not the next token after our macro. If this assumption
  63   // fails it is not critical, we will just fail to clear out, e.g., an empty
  64   // 'if'.
  65   if (RelOffs - getARCMTMacroName().size() > 100)
  66     return false;
  67
  68   SourceLocation AfterMacroSemiLoc = findSemiAfterLocation(AfterMacroLoc, Ctx);
  69   return AfterMacroSemiLoc == SemiLoc;
  70 }
  71
  72 namespace {
  73
  74 /// Returns true if the statement became empty due to previous
  75 /// transformations.
  76 class EmptyChecker : public StmtVisitor<EmptyChecker, bool> {
  77   ASTContext &Ctx;
  78   std::vector<SourceLocation> &MacroLocs;
  79
  80 public:
  81   EmptyChecker(ASTContext &ctx, std::vector<SourceLocation> &macroLocs)
  82     : Ctx(ctx), MacroLocs(macroLocs) { }
  83
  84   bool VisitNullStmt(NullStmt *S) {
  85     return isEmptyARCMTMacroStatement(S, MacroLocs, Ctx);
  86   }
  87   bool VisitCompoundStmt(CompoundStmt *S) {
  88     if (S->body_empty())
  89       return false; // was already empty, not because of transformations.
  90     for (auto *I : S->body())
  91       if (!Visit(I))
  92         return false;
  93     return true;
  94   }
  95   bool VisitIfStmt(IfStmt *S) {
  96     if (S->getConditionVariable())
  97       return false;
  98     Expr *condE = S->getCond();
  99     if (!condE)
 100       return false;
 101     if (hasSideEffects(condE, Ctx))
 102       return false;
 103     if (!S->getThen() || !Visit(S->getThen()))
 104       return false;
 105     return !S->getElse() || Visit(S->getElse());
 106   }
 107   bool VisitWhileStmt(WhileStmt *S) {
 108     if (S->getConditionVariable())
 109       return false;
 110     Expr *condE = S->getCond();
 111     if (!condE)
 112       return false;
 113     if (hasSideEffects(condE, Ctx))
 114       return false;
 115     if (!S->getBody())
 116       return false;
 117     return Visit(S->getBody());
 118   }
 119   bool VisitDoStmt(DoStmt *S) {
 120     Expr *condE = S->getCond();
 121     if (!condE)
 122       return false;
 123     if (hasSideEffects(condE, Ctx))
 124       return false;
 125     if (!S->getBody())
 126       return false;
 127     return Visit(S->getBody());
 128   }
 129   bool VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
 130     Expr *Exp = S->getCollection();
 131     if (!Exp)
 132       return false;
 133     if (hasSideEffects(Exp, Ctx))
 134       return false;
 135     if (!S->getBody())
 136       return false;
 137     return Visit(S->getBody());
 138   }
 139   bool VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
 140     if (!S->getSubStmt())
 141       return false;
 142     return Visit(S->getSubStmt());
 143   }
 144 };
 145
 146 class EmptyStatementsRemover :
 147                             public RecursiveASTVisitor<EmptyStatementsRemover> {
 148   MigrationPass &Pass;
 149
 150 public:
 151   EmptyStatementsRemover(MigrationPass &pass) : Pass(pass) { }
 152
 153   bool TraverseStmtExpr(StmtExpr *E) {
 154     CompoundStmt *S = E->getSubStmt();
 155     for (CompoundStmt::body_iterator
 156            I = S->body_begin(), E = S->body_end(); I != E; ++I) {
 157       if (I != E - 1)
 158         check(*I);
 159       TraverseStmt(*I);
 160     }
 161     return true;
 162   }
 163
 164   bool VisitCompoundStmt(CompoundStmt *S) {
 165     for (auto *I : S->body())
 166       check(I);
 167     return true;
 168   }
 169
 170   ASTContext &getContext() { return Pass.Ctx; }
 171
 172 private:
 173   void check(Stmt *S) {
 174     if (!S) return;
 175     if (EmptyChecker(Pass.Ctx, Pass.ARCMTMacroLocs).Visit(S)) {
 176       Transaction Trans(Pass.TA);
 177       Pass.TA.removeStmt(S);
 178     }
 179   }
 180 };
 181
 182 } // anonymous namespace
 183
 184 static bool isBodyEmpty(CompoundStmt *body, ASTContext &Ctx,
 185                         std::vector<SourceLocation> &MacroLocs) {
 186   for (auto *I : body->body())
 187     if (!EmptyChecker(Ctx, MacroLocs).Visit(I))
 188       return false;
 189
 190   return true;
 191 }
 192
 193 static void cleanupDeallocOrFinalize(MigrationPass &pass) {
 194   ASTContext &Ctx = pass.Ctx;
 195   TransformActions &TA = pass.TA;
 196   DeclContext *DC = Ctx.getTranslationUnitDecl();
 197   Selector FinalizeSel =
 198       Ctx.Selectors.getNullarySelector(&pass.Ctx.Idents.get("finalize"));
 199
 200   typedef DeclContext::specific_decl_iterator<ObjCImplementationDecl>
 201     impl_iterator;
 202   for (impl_iterator I = impl_iterator(DC->decls_begin()),
 203                      E = impl_iterator(DC->decls_end()); I != E; ++I) {
 204     ObjCMethodDecl *DeallocM = nullptr;
 205     ObjCMethodDecl *FinalizeM = nullptr;
 206     for (auto *MD : I->instance_methods()) {
 207       if (!MD->hasBody())
 208         continue;
 209
 210       if (MD->getMethodFamily() == OMF_dealloc) {
 211         DeallocM = MD;
 212       } else if (MD->isInstanceMethod() && MD->getSelector() == FinalizeSel) {
 213         FinalizeM = MD;
 214       }
 215     }
 216
 217     if (DeallocM) {
 218       if (isBodyEmpty(DeallocM->getCompoundBody(), Ctx, pass.ARCMTMacroLocs)) {
 219         Transaction Trans(TA);
 220         TA.remove(DeallocM->getSourceRange());
 221       }
 222
 223       if (FinalizeM) {
 224         Transaction Trans(TA);
 225         TA.remove(FinalizeM->getSourceRange());
 226       }
 227
 228     } else if (FinalizeM) {
 229       if (isBodyEmpty(FinalizeM->getCompoundBody(), Ctx, pass.ARCMTMacroLocs)) {
 230         Transaction Trans(TA);
 231         TA.remove(FinalizeM->getSourceRange());
 232       } else {
 233         Transaction Trans(TA);
 234         TA.replaceText(FinalizeM->getSelectorStartLoc(), "finalize", "dealloc");
 235       }
 236     }
 237   }
 238 }
 239
 240 void trans::removeEmptyStatementsAndDeallocFinalize(MigrationPass &pass) {
 241   EmptyStatementsRemover(pass).TraverseDecl(pass.Ctx.getTranslationUnitDecl());
 242
 243   cleanupDeallocOrFinalize(pass);
 244
 245   for (unsigned i = 0, e = pass.ARCMTMacroLocs.size(); i != e; ++i) {
 246     Transaction Trans(pass.TA);
 247     pass.TA.remove(pass.ARCMTMacroLocs[i]);
 248   }
 249 }