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

   1 //===--- TransBlockObjCVariable.cpp - Transformations 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 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/AST/ASTContext.h"
  31 #include "clang/AST/Attr.h"
  32 #include "clang/Basic/SourceManager.h"
  33
  34 using namespace clang;
  35 using namespace arcmt;
  36 using namespace trans;
  37
  38 namespace {
  39
  40 class RootBlockObjCVarRewriter :
  41                           public RecursiveASTVisitor<RootBlockObjCVarRewriter> {
  42   llvm::DenseSet<VarDecl *> &VarsToChange;
  43
  44   class BlockVarChecker : public RecursiveASTVisitor<BlockVarChecker> {
  45     VarDecl *Var;
  46
  47     typedef RecursiveASTVisitor<BlockVarChecker> base;
  48   public:
  49     BlockVarChecker(VarDecl *var) : Var(var) { }
  50
  51     bool TraverseImplicitCastExpr(ImplicitCastExpr *castE) {
  52       if (DeclRefExpr *
  53             ref = dyn_cast<DeclRefExpr>(castE->getSubExpr())) {
  54         if (ref->getDecl() == Var) {
  55           if (castE->getCastKind() == CK_LValueToRValue)
  56             return true; // Using the value of the variable.
  57           if (castE->getCastKind() == CK_NoOp && castE->isLValue() &&
  58               Var->getASTContext().getLangOpts().CPlusPlus)
  59             return true; // Binding to const C++ reference.
  60         }
  61       }
  62
  63       return base::TraverseImplicitCastExpr(castE);
  64     }
  65
  66     bool VisitDeclRefExpr(DeclRefExpr *E) {
  67       if (E->getDecl() == Var)
  68         return false; // The reference of the variable, and not just its value,
  69                       //  is needed.
  70       return true;
  71     }
  72   };
  73
  74 public:
  75   RootBlockObjCVarRewriter(llvm::DenseSet<VarDecl *> &VarsToChange)
  76     : VarsToChange(VarsToChange) { }
  77
  78   bool VisitBlockDecl(BlockDecl *block) {
  79     SmallVector<VarDecl *, 4> BlockVars;
  80
  81     for (BlockDecl::capture_iterator
  82            I = block->capture_begin(), E = block->capture_end(); I != E; ++I) {
  83       VarDecl *var = I->getVariable();
  84       if (I->isByRef() &&
  85           var->getType()->isObjCObjectPointerType() &&
  86           isImplicitStrong(var->getType())) {
  87         BlockVars.push_back(var);
  88       }
  89     }
  90
  91     for (unsigned i = 0, e = BlockVars.size(); i != e; ++i) {
  92       VarDecl *var = BlockVars[i];
  93
  94       BlockVarChecker checker(var);
  95       bool onlyValueOfVarIsNeeded = checker.TraverseStmt(block->getBody());
  96       if (onlyValueOfVarIsNeeded)
  97         VarsToChange.insert(var);
  98       else
  99         VarsToChange.erase(var);
 100     }
 101
 102     return true;
 103   }
 104
 105 private:
 106   bool isImplicitStrong(QualType ty) {
 107     if (isa<AttributedType>(ty.getTypePtr()))
 108       return false;
 109     return ty.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong;
 110   }
 111 };
 112
 113 class BlockObjCVarRewriter : public RecursiveASTVisitor<BlockObjCVarRewriter> {
 114   llvm::DenseSet<VarDecl *> &VarsToChange;
 115
 116 public:
 117   BlockObjCVarRewriter(llvm::DenseSet<VarDecl *> &VarsToChange)
 118     : VarsToChange(VarsToChange) { }
 119
 120   bool TraverseBlockDecl(BlockDecl *block) {
 121     RootBlockObjCVarRewriter(VarsToChange).TraverseDecl(block);
 122     return true;
 123   }
 124 };
 125
 126 } // anonymous namespace
 127
 128 void BlockObjCVariableTraverser::traverseBody(BodyContext &BodyCtx) {
 129   MigrationPass &Pass = BodyCtx.getMigrationContext().Pass;
 130   llvm::DenseSet<VarDecl *> VarsToChange;
 131
 132   BlockObjCVarRewriter trans(VarsToChange);
 133   trans.TraverseStmt(BodyCtx.getTopStmt());
 134
 135   for (llvm::DenseSet<VarDecl *>::iterator
 136          I = VarsToChange.begin(), E = VarsToChange.end(); I != E; ++I) {
 137     VarDecl *var = *I;
 138     BlocksAttr *attr = var->getAttr<BlocksAttr>();
 139     if(!attr)
 140       continue;
 141     bool useWeak = canApplyWeak(Pass.Ctx, var->getType());
 142     SourceManager &SM = Pass.Ctx.getSourceManager();
 143     Transaction Trans(Pass.TA);
 144     Pass.TA.replaceText(SM.getExpansionLoc(attr->getLocation()),
 145                         "__block",
 146                         useWeak ? "__weak" : "__unsafe_unretained");
 147   }
 148 }