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

   1 //===--- TransUnbridgedCasts.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 // rewriteUnbridgedCasts:
  11 //
  12 // A cast of non-objc pointer to an objc one is checked. If the non-objc pointer
  13 // is from a file-level variable, __bridge cast is used to convert it.
  14 // For the result of a function call that we know is +1/+0,
  15 // __bridge/__bridge_transfer is used.
  16 //
  17 //  NSString *str = (NSString *)kUTTypePlainText;
  18 //  str = b ? kUTTypeRTF : kUTTypePlainText;
  19 //  NSString *_uuidString = (NSString *)CFUUIDCreateString(kCFAllocatorDefault,
  20 //                                                         _uuid);
  21 // ---->
  22 //  NSString *str = (__bridge NSString *)kUTTypePlainText;
  23 //  str = (__bridge NSString *)(b ? kUTTypeRTF : kUTTypePlainText);
  24 // NSString *_uuidString = (__bridge_transfer NSString *)
  25 //                               CFUUIDCreateString(kCFAllocatorDefault, _uuid);
  26 //
  27 // For a C pointer to ObjC, for casting 'self', __bridge is used.
  28 //
  29 //  CFStringRef str = (CFStringRef)self;
  30 // ---->
  31 //  CFStringRef str = (__bridge CFStringRef)self;
  32 //
  33 //===----------------------------------------------------------------------===//
  34
  35 #include "Transforms.h"
  36 #include "Internals.h"
  37 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
  38 #include "clang/Sema/SemaDiagnostic.h"
  39 #include "clang/AST/ParentMap.h"
  40 #include "clang/Basic/SourceManager.h"
  41 #include "llvm/ADT/SmallString.h"
  42
  43 using namespace clang;
  44 using namespace arcmt;
  45 using namespace trans;
  46
  47 namespace {
  48
  49 class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter>{
  50   MigrationPass &Pass;
  51   IdentifierInfo *SelfII;
  52   OwningPtr<ParentMap> StmtMap;
  53
  54 public:
  55   UnbridgedCastRewriter(MigrationPass &pass) : Pass(pass) {
  56     SelfII = &Pass.Ctx.Idents.get("self");
  57   }
  58
  59   void transformBody(Stmt *body) {
  60     StmtMap.reset(new ParentMap(body));
  61     TraverseStmt(body);
  62   }
  63
  64   bool VisitCastExpr(CastExpr *E) {
  65     if (E->getCastKind() != CK_CPointerToObjCPointerCast
  66         && E->getCastKind() != CK_BitCast)
  67       return true;
  68
  69     QualType castType = E->getType();
  70     Expr *castExpr = E->getSubExpr();
  71     QualType castExprType = castExpr->getType();
  72
  73     if (castType->isObjCObjectPointerType() &&
  74         castExprType->isObjCObjectPointerType())
  75       return true;
  76     if (!castType->isObjCObjectPointerType() &&
  77         !castExprType->isObjCObjectPointerType())
  78       return true;
  79
  80     bool exprRetainable = castExprType->isObjCIndirectLifetimeType();
  81     bool castRetainable = castType->isObjCIndirectLifetimeType();
  82     if (exprRetainable == castRetainable) return true;
  83
  84     if (castExpr->isNullPointerConstant(Pass.Ctx,
  85                                         Expr::NPC_ValueDependentIsNull))
  86       return true;
  87
  88     SourceLocation loc = castExpr->getExprLoc();
  89     if (loc.isValid() && Pass.Ctx.getSourceManager().isInSystemHeader(loc))
  90       return true;
  91
  92     if (castType->isObjCObjectPointerType())
  93       transformNonObjCToObjCCast(E);
  94     else
  95       transformObjCToNonObjCCast(E);
  96
  97     return true;
  98   }
  99
 100 private:
 101   void transformNonObjCToObjCCast(CastExpr *E) {
 102     if (!E) return;
 103
 104     // Global vars are assumed that are cast as unretained.
 105     if (isGlobalVar(E))
 106       if (E->getSubExpr()->getType()->isPointerType()) {
 107         castToObjCObject(E, /*retained=*/false);
 108         return;
 109       }
 110
 111     // If the cast is directly over the result of a Core Foundation function
 112     // try to figure out whether it should be cast as retained or unretained.
 113     Expr *inner = E->IgnoreParenCasts();
 114     if (CallExpr *callE = dyn_cast<CallExpr>(inner)) {
 115       if (FunctionDecl *FD = callE->getDirectCallee()) {
 116         if (FD->getAttr<CFReturnsRetainedAttr>()) {
 117           castToObjCObject(E, /*retained=*/true);
 118           return;
 119         }
 120         if (FD->getAttr<CFReturnsNotRetainedAttr>()) {
 121           castToObjCObject(E, /*retained=*/false);
 122           return;
 123         }
 124         if (FD->isGlobal() &&
 125             FD->getIdentifier() &&
 126             ento::cocoa::isRefType(E->getSubExpr()->getType(), "CF",
 127                                    FD->getIdentifier()->getName())) {
 128           StringRef fname = FD->getIdentifier()->getName();
 129           if (fname.endswith("Retain") ||
 130               fname.find("Create") != StringRef::npos ||
 131               fname.find("Copy") != StringRef::npos) {
 132             // Do not migrate to couple of bridge transfer casts which
 133             // cancel each other out. Leave it unchanged so error gets user
 134             // attention instead.
 135             if (FD->getName() == "CFRetain" &&
 136                 FD->getNumParams() == 1 &&
 137                 FD->getParent()->isTranslationUnit() &&
 138                 FD->getLinkage() == ExternalLinkage) {
 139               Expr *Arg = callE->getArg(0);
 140               if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
 141                 const Expr *sub = ICE->getSubExpr();
 142                 QualType T = sub->getType();
 143                 if (T->isObjCObjectPointerType())
 144                   return;
 145               }
 146             }
 147             castToObjCObject(E, /*retained=*/true);
 148             return;
 149           }
 150
 151           if (fname.find("Get") != StringRef::npos) {
 152             castToObjCObject(E, /*retained=*/false);
 153             return;
 154           }
 155         }
 156       }
 157     }
 158   }
 159
 160   void castToObjCObject(CastExpr *E, bool retained) {
 161     rewriteToBridgedCast(E, retained ? OBC_BridgeTransfer : OBC_Bridge);
 162   }
 163
 164   void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind) {
 165     Transaction Trans(Pass.TA);
 166     rewriteToBridgedCast(E, Kind, Trans);
 167   }
 168
 169   void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind,
 170                             Transaction &Trans) {
 171     TransformActions &TA = Pass.TA;
 172
 173     // We will remove the compiler diagnostic.
 174     if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast,
 175                           diag::err_arc_cast_requires_bridge,
 176                           E->getLocStart())) {
 177       Trans.abort();
 178       return;
 179     }
 180
 181     StringRef bridge;
 182     switch(Kind) {
 183     case OBC_Bridge:
 184       bridge = "__bridge "; break;
 185     case OBC_BridgeTransfer:
 186       bridge = "__bridge_transfer "; break;
 187     case OBC_BridgeRetained:
 188       bridge = "__bridge_retained "; break;
 189     }
 190
 191     TA.clearDiagnostic(diag::err_arc_mismatched_cast,
 192                        diag::err_arc_cast_requires_bridge,
 193                        E->getLocStart());
 194     if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) {
 195       TA.insertAfterToken(CCE->getLParenLoc(), bridge);
 196     } else {
 197       SourceLocation insertLoc = E->getSubExpr()->getLocStart();
 198       SmallString<128> newCast;
 199       newCast += '(';
 200       newCast += bridge;
 201       newCast += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
 202       newCast += ')';
 203
 204       if (isa<ParenExpr>(E->getSubExpr())) {
 205         TA.insert(insertLoc, newCast.str());
 206       } else {
 207         newCast += '(';
 208         TA.insert(insertLoc, newCast.str());
 209         TA.insertAfterToken(E->getLocEnd(), ")");
 210       }
 211     }
 212   }
 213
 214   void rewriteCastForCFRetain(CastExpr *castE, CallExpr *callE) {
 215     Transaction Trans(Pass.TA);
 216     Pass.TA.replace(callE->getSourceRange(), callE->getArg(0)->getSourceRange());
 217     rewriteToBridgedCast(castE, OBC_BridgeRetained, Trans);
 218   }
 219
 220   void transformObjCToNonObjCCast(CastExpr *E) {
 221     if (isSelf(E->getSubExpr()))
 222       return rewriteToBridgedCast(E, OBC_Bridge);
 223
 224     CallExpr *callE;
 225     if (isPassedToCFRetain(E, callE))
 226       return rewriteCastForCFRetain(E, callE);
 227
 228     ObjCMethodFamily family = getFamilyOfMessage(E->getSubExpr());
 229     if (family == OMF_retain)
 230       return rewriteToBridgedCast(E, OBC_BridgeRetained);
 231
 232     if (family == OMF_autorelease || family == OMF_release) {
 233       std::string err = "it is not safe to cast to '";
 234       err += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
 235       err += "' the result of '";
 236       err += family == OMF_autorelease ? "autorelease" : "release";
 237       err += "' message; a __bridge cast may result in a pointer to a "
 238           "destroyed object and a __bridge_retained may leak the object";
 239       Pass.TA.reportError(err, E->getLocStart(),
 240                           E->getSubExpr()->getSourceRange());
 241       Stmt *parent = E;
 242       do {
 243         parent = StmtMap->getParentIgnoreParenImpCasts(parent);
 244       } while (parent && isa<ExprWithCleanups>(parent));
 245
 246       if (ReturnStmt *retS = dyn_cast_or_null<ReturnStmt>(parent)) {
 247         std::string note = "remove the cast and change return type of function "
 248             "to '";
 249         note += E->getSubExpr()->getType().getAsString(Pass.Ctx.getPrintingPolicy());
 250         note += "' to have the object automatically autoreleased";
 251         Pass.TA.reportNote(note, retS->getLocStart());
 252       }
 253     }
 254
 255     Expr *subExpr = E->getSubExpr();
 256
 257     // Look through pseudo-object expressions.
 258     if (PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(subExpr)) {
 259       subExpr = pseudo->getResultExpr();
 260       assert(subExpr && "no result for pseudo-object of non-void type?");
 261     }
 262
 263     if (ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(subExpr)) {
 264       if (implCE->getCastKind() == CK_ARCConsumeObject)
 265         return rewriteToBridgedCast(E, OBC_BridgeRetained);
 266       if (implCE->getCastKind() == CK_ARCReclaimReturnedObject)
 267         return rewriteToBridgedCast(E, OBC_Bridge);
 268     }
 269
 270     bool isConsumed = false;
 271     if (isPassedToCParamWithKnownOwnership(E, isConsumed))
 272       return rewriteToBridgedCast(E, isConsumed ? OBC_BridgeRetained
 273                                                 : OBC_Bridge);
 274   }
 275
 276   static ObjCMethodFamily getFamilyOfMessage(Expr *E) {
 277     E = E->IgnoreParenCasts();
 278     if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
 279       return ME->getMethodFamily();
 280
 281     return OMF_None;
 282   }
 283
 284   bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {
 285     if ((callE = dyn_cast_or_null<CallExpr>(
 286                                      StmtMap->getParentIgnoreParenImpCasts(E))))
 287       if (FunctionDecl *
 288             FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl()))
 289         if (FD->getName() == "CFRetain" && FD->getNumParams() == 1 &&
 290             FD->getParent()->isTranslationUnit() &&
 291             FD->getLinkage() == ExternalLinkage)
 292           return true;
 293
 294     return false;
 295   }
 296
 297   bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const {
 298     if (CallExpr *callE = dyn_cast_or_null<CallExpr>(
 299                                      StmtMap->getParentIgnoreParenImpCasts(E)))
 300       if (FunctionDecl *
 301             FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) {
 302         unsigned i = 0;
 303         for (unsigned e = callE->getNumArgs(); i != e; ++i) {
 304           Expr *arg = callE->getArg(i);
 305           if (arg == E || arg->IgnoreParenImpCasts() == E)
 306             break;
 307         }
 308         if (i < callE->getNumArgs()) {
 309           ParmVarDecl *PD = FD->getParamDecl(i);
 310           if (PD->getAttr<CFConsumedAttr>()) {
 311             isConsumed = true;
 312             return true;
 313           }
 314         }
 315       }
 316
 317     return false;
 318   }
 319
 320   bool isSelf(Expr *E) const {
 321     E = E->IgnoreParenLValueCasts();
 322     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
 323       if (ImplicitParamDecl *IPD = dyn_cast<ImplicitParamDecl>(DRE->getDecl()))
 324         if (IPD->getIdentifier() == SelfII)
 325           return true;
 326
 327     return false;
 328   }
 329 };
 330
 331 } // end anonymous namespace
 332
 333 void trans::rewriteUnbridgedCasts(MigrationPass &pass) {
 334   BodyTransform<UnbridgedCastRewriter> trans(pass);
 335   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
 336 }