Home | History | Annotate | Download | only in ARCMigrate 
      1 //===--- TransBlockObjCVariable.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 // rewriteBlockObjCVariable:
     11 //
     12 // Adding __block to an obj-c variable could be either because the the variable
     13 // is used for output storage or the user wanted to break a retain cycle.
     14 // This transformation checks whether a reference of the variable for the block
     15 // is actually needed (it is assigned to or its address is taken) or not.
     16 // If the reference is not needed it will assume __block was added to break a
     17 // cycle so it will remove '__block' and add __weak/__unsafe_unretained.
     18 // e.g
     19 //
     20 //   __block Foo *x;
     21 //   bar(^ { [x cake]; });
     22 // ---->
     23 //   __weak Foo *x;
     24 //   bar(^ { [x cake]; });
     25 //
     26 //===----------------------------------------------------------------------===//
     27 
     28 #include "Transforms.h"
     29 #include "Internals.h"
     30 #include "clang/Basic/SourceManager.h"
     31 
     32 using namespace clang;
     33 using namespace arcmt;
     34 using namespace trans;
     35 
     36 namespace {
     37 
     38 class RootBlockObjCVarRewriter :
     39                           public RecursiveASTVisitor<RootBlockObjCVarRewriter> {
     40   MigrationPass &Pass;
     41   llvm::DenseSet<VarDecl *> CheckedVars;
     42 
     43   class BlockVarChecker : public RecursiveASTVisitor<BlockVarChecker> {
     44     VarDecl *Var;
     45 
     46     typedef RecursiveASTVisitor<BlockVarChecker> base;
     47   public:
     48     BlockVarChecker(VarDecl *var) : Var(var) { }
     49 
     50     bool TraverseImplicitCastExpr(ImplicitCastExpr *castE) {
     51       if (BlockDeclRefExpr *
     52             ref = dyn_cast<BlockDeclRefExpr>(castE->getSubExpr())) {
     53         if (ref->getDecl() == Var) {
     54           if (castE->getCastKind() == CK_LValueToRValue)
     55             return true; // Using the value of the variable.
     56           if (castE->getCastKind() == CK_NoOp && castE->isLValue() &&
     57               Var->getASTContext().getLangOptions().CPlusPlus)
     58             return true; // Binding to const C++ reference.
     59         }
     60       }
     61 
     62       return base::TraverseImplicitCastExpr(castE);
     63     }
     64 
     65     bool VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
     66       if (E->getDecl() == Var)
     67         return false; // The reference of the variable, and not just its value,
     68                       //  is needed.
     69       return true;
     70     }
     71   };
     72 
     73 public:
     74   RootBlockObjCVarRewriter(MigrationPass &pass) : Pass(pass) { }
     75 
     76   bool VisitBlockDecl(BlockDecl *block) {
     77     SmallVector<VarDecl *, 4> BlockVars;
     78 
     79     for (BlockDecl::capture_iterator
     80            I = block->capture_begin(), E = block->capture_end(); I != E; ++I) {
     81       VarDecl *var = I->getVariable();
     82       if (I->isByRef() &&
     83           !isAlreadyChecked(var) &&
     84           var->getType()->isObjCObjectPointerType() &&
     85           isImplicitStrong(var->getType())) {
     86         BlockVars.push_back(var);
     87       }
     88     }
     89 
     90     for (unsigned i = 0, e = BlockVars.size(); i != e; ++i) {
     91       VarDecl *var = BlockVars[i];
     92       CheckedVars.insert(var);
     93 
     94       BlockVarChecker checker(var);
     95       bool onlyValueOfVarIsNeeded = checker.TraverseStmt(block->getBody());
     96       if (onlyValueOfVarIsNeeded) {
     97         BlocksAttr *attr = var->getAttr<BlocksAttr>();
     98         if(!attr)
     99           continue;
    100         bool useWeak = canApplyWeak(Pass.Ctx, var->getType());
    101         SourceManager &SM = Pass.Ctx.getSourceManager();
    102         Transaction Trans(Pass.TA);
    103         Pass.TA.replaceText(SM.getExpansionLoc(attr->getLocation()),
    104                             "__block",
    105                             useWeak ? "__weak" : "__unsafe_unretained");
    106       }
    107 
    108     }
    109 
    110     return true;
    111   }
    112 
    113 private:
    114   bool isAlreadyChecked(VarDecl *VD) {
    115     return CheckedVars.count(VD);
    116   }
    117 
    118   bool isImplicitStrong(QualType ty) {
    119     if (isa<AttributedType>(ty.getTypePtr()))
    120       return false;
    121     return ty.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong;
    122   }
    123 };
    124 
    125 class BlockObjCVarRewriter : public RecursiveASTVisitor<BlockObjCVarRewriter> {
    126   MigrationPass &Pass;
    127 
    128 public:
    129   BlockObjCVarRewriter(MigrationPass &pass) : Pass(pass) { }
    130 
    131   bool TraverseBlockDecl(BlockDecl *block) {
    132     RootBlockObjCVarRewriter(Pass).TraverseDecl(block);
    133     return true;
    134   }
    135 };
    136 
    137 } // anonymous namespace
    138 
    139 void trans::rewriteBlockObjCVariable(MigrationPass &pass) {
    140   BlockObjCVarRewriter trans(pass);
    141   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
    142 }
    143