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

   1 //===--- TransUnbridgedCasts.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 // 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/CFBridgingRelease 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 = (NSString *)
  25 //            CFBridgingRelease(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 // Uses of Block_copy/Block_release macros are rewritten:
  34 //
  35 //  c = Block_copy(b);
  36 //  Block_release(c);
  37 // ---->
  38 //  c = [b copy];
  39 //  <removed>
  40 //
  41 //===----------------------------------------------------------------------===//
  42
  43 #include "Transforms.h"
  44 #include "Internals.h"
  45 #include "clang/AST/ASTContext.h"
  46 #include "clang/AST/Attr.h"
  47 #include "clang/AST/ParentMap.h"
  48 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
  49 #include "clang/Basic/SourceManager.h"
  50 #include "clang/Lex/Lexer.h"
  51 #include "clang/Sema/SemaDiagnostic.h"
  52 #include "llvm/ADT/SmallString.h"
  53
  54 using namespace clang;
  55 using namespace arcmt;
  56 using namespace trans;
  57
  58 namespace {
  59
  60 class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter>{
  61   MigrationPass &Pass;
  62   IdentifierInfo *SelfII;
  63   OwningPtr<ParentMap> StmtMap;
  64   Decl *ParentD;
  65   Stmt *Body;
  66   mutable OwningPtr<ExprSet> Removables;
  67
  68 public:
  69   UnbridgedCastRewriter(MigrationPass &pass) : Pass(pass), ParentD(0), Body(0) {
  70     SelfII = &Pass.Ctx.Idents.get("self");
  71   }
  72
  73   void transformBody(Stmt *body, Decl *ParentD) {
  74     this->ParentD = ParentD;
  75     Body = body;
  76     StmtMap.reset(new ParentMap(body));
  77     TraverseStmt(body);
  78   }
  79
  80   bool TraverseBlockDecl(BlockDecl *D) {
  81     // ParentMap does not enter into a BlockDecl to record its stmts, so use a
  82     // new UnbridgedCastRewriter to handle the block.
  83     UnbridgedCastRewriter(Pass).transformBody(D->getBody(), D);
  84     return true;
  85   }
  86
  87   bool VisitCastExpr(CastExpr *E) {
  88     if (E->getCastKind() != CK_CPointerToObjCPointerCast &&
  89         E->getCastKind() != CK_BitCast &&
  90         E->getCastKind() != CK_AnyPointerToBlockPointerCast)
  91       return true;
  92
  93     QualType castType = E->getType();
  94     Expr *castExpr = E->getSubExpr();
  95     QualType castExprType = castExpr->getType();
  96
  97     if (castType->isObjCRetainableType() == castExprType->isObjCRetainableType())
  98       return true;
  99
 100     bool exprRetainable = castExprType->isObjCIndirectLifetimeType();
 101     bool castRetainable = castType->isObjCIndirectLifetimeType();
 102     if (exprRetainable == castRetainable) return true;
 103
 104     if (castExpr->isNullPointerConstant(Pass.Ctx,
 105                                         Expr::NPC_ValueDependentIsNull))
 106       return true;
 107
 108     SourceLocation loc = castExpr->getExprLoc();
 109     if (loc.isValid() && Pass.Ctx.getSourceManager().isInSystemHeader(loc))
 110       return true;
 111
 112     if (castType->isObjCRetainableType())
 113       transformNonObjCToObjCCast(E);
 114     else
 115       transformObjCToNonObjCCast(E);
 116
 117     return true;
 118   }
 119
 120 private:
 121   void transformNonObjCToObjCCast(CastExpr *E) {
 122     if (!E) return;
 123
 124     // Global vars are assumed that are cast as unretained.
 125     if (isGlobalVar(E))
 126       if (E->getSubExpr()->getType()->isPointerType()) {
 127         castToObjCObject(E, /*retained=*/false);
 128         return;
 129       }
 130
 131     // If the cast is directly over the result of a Core Foundation function
 132     // try to figure out whether it should be cast as retained or unretained.
 133     Expr *inner = E->IgnoreParenCasts();
 134     if (CallExpr *callE = dyn_cast<CallExpr>(inner)) {
 135       if (FunctionDecl *FD = callE->getDirectCallee()) {
 136         if (FD->getAttr<CFReturnsRetainedAttr>()) {
 137           castToObjCObject(E, /*retained=*/true);
 138           return;
 139         }
 140         if (FD->getAttr<CFReturnsNotRetainedAttr>()) {
 141           castToObjCObject(E, /*retained=*/false);
 142           return;
 143         }
 144         if (FD->isGlobal() &&
 145             FD->getIdentifier() &&
 146             ento::cocoa::isRefType(E->getSubExpr()->getType(), "CF",
 147                                    FD->getIdentifier()->getName())) {
 148           StringRef fname = FD->getIdentifier()->getName();
 149           if (fname.endswith("Retain") ||
 150               fname.find("Create") != StringRef::npos ||
 151               fname.find("Copy") != StringRef::npos) {
 152             // Do not migrate to couple of bridge transfer casts which
 153             // cancel each other out. Leave it unchanged so error gets user
 154             // attention instead.
 155             if (FD->getName() == "CFRetain" &&
 156                 FD->getNumParams() == 1 &&
 157                 FD->getParent()->isTranslationUnit() &&
 158                 FD->isExternallyVisible()) {
 159               Expr *Arg = callE->getArg(0);
 160               if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
 161                 const Expr *sub = ICE->getSubExpr();
 162                 QualType T = sub->getType();
 163                 if (T->isObjCObjectPointerType())
 164                   return;
 165               }
 166             }
 167             castToObjCObject(E, /*retained=*/true);
 168             return;
 169           }
 170
 171           if (fname.find("Get") != StringRef::npos) {
 172             castToObjCObject(E, /*retained=*/false);
 173             return;
 174           }
 175         }
 176       }
 177     }
 178
 179     // If returning an ivar or a member of an ivar from a +0 method, use
 180     // a __bridge cast.
 181     Expr *base = inner->IgnoreParenImpCasts();
 182     while (isa<MemberExpr>(base))
 183       base = cast<MemberExpr>(base)->getBase()->IgnoreParenImpCasts();
 184     if (isa<ObjCIvarRefExpr>(base) &&
 185         isa<ReturnStmt>(StmtMap->getParentIgnoreParenCasts(E))) {
 186       if (ObjCMethodDecl *method = dyn_cast_or_null<ObjCMethodDecl>(ParentD)) {
 187         if (!method->hasAttr<NSReturnsRetainedAttr>()) {
 188           castToObjCObject(E, /*retained=*/false);
 189           return;
 190         }
 191       }
 192     }
 193   }
 194
 195   void castToObjCObject(CastExpr *E, bool retained) {
 196     rewriteToBridgedCast(E, retained ? OBC_BridgeTransfer : OBC_Bridge);
 197   }
 198
 199   void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind) {
 200     Transaction Trans(Pass.TA);
 201     rewriteToBridgedCast(E, Kind, Trans);
 202   }
 203
 204   void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind,
 205                             Transaction &Trans) {
 206     TransformActions &TA = Pass.TA;
 207
 208     // We will remove the compiler diagnostic.
 209     if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast,
 210                           diag::err_arc_cast_requires_bridge,
 211                           E->getLocStart())) {
 212       Trans.abort();
 213       return;
 214     }
 215
 216     StringRef bridge;
 217     switch(Kind) {
 218     case OBC_Bridge:
 219       bridge = "__bridge "; break;
 220     case OBC_BridgeTransfer:
 221       bridge = "__bridge_transfer "; break;
 222     case OBC_BridgeRetained:
 223       bridge = "__bridge_retained "; break;
 224     }
 225
 226     TA.clearDiagnostic(diag::err_arc_mismatched_cast,
 227                        diag::err_arc_cast_requires_bridge,
 228                        E->getLocStart());
 229     if (Kind == OBC_Bridge || !Pass.CFBridgingFunctionsDefined()) {
 230       if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) {
 231         TA.insertAfterToken(CCE->getLParenLoc(), bridge);
 232       } else {
 233         SourceLocation insertLoc = E->getSubExpr()->getLocStart();
 234         SmallString<128> newCast;
 235         newCast += '(';
 236         newCast += bridge;
 237         newCast += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
 238         newCast += ')';
 239
 240         if (isa<ParenExpr>(E->getSubExpr())) {
 241           TA.insert(insertLoc, newCast.str());
 242         } else {
 243           newCast += '(';
 244           TA.insert(insertLoc, newCast.str());
 245           TA.insertAfterToken(E->getLocEnd(), ")");
 246         }
 247       }
 248     } else {
 249       assert(Kind == OBC_BridgeTransfer || Kind == OBC_BridgeRetained);
 250       SmallString<32> BridgeCall;
 251
 252       Expr *WrapE = E->getSubExpr();
 253       SourceLocation InsertLoc = WrapE->getLocStart();
 254
 255       SourceManager &SM = Pass.Ctx.getSourceManager();
 256       char PrevChar = *SM.getCharacterData(InsertLoc.getLocWithOffset(-1));
 257       if (Lexer::isIdentifierBodyChar(PrevChar, Pass.Ctx.getLangOpts()))
 258         BridgeCall += ' ';
 259
 260       if (Kind == OBC_BridgeTransfer)
 261         BridgeCall += "CFBridgingRelease";
 262       else
 263         BridgeCall += "CFBridgingRetain";
 264
 265       if (isa<ParenExpr>(WrapE)) {
 266         TA.insert(InsertLoc, BridgeCall);
 267       } else {
 268         BridgeCall += '(';
 269         TA.insert(InsertLoc, BridgeCall);
 270         TA.insertAfterToken(WrapE->getLocEnd(), ")");
 271       }
 272     }
 273   }
 274
 275   void rewriteCastForCFRetain(CastExpr *castE, CallExpr *callE) {
 276     Transaction Trans(Pass.TA);
 277     Pass.TA.replace(callE->getSourceRange(), callE->getArg(0)->getSourceRange());
 278     rewriteToBridgedCast(castE, OBC_BridgeRetained, Trans);
 279   }
 280
 281   void getBlockMacroRanges(CastExpr *E, SourceRange &Outer, SourceRange &Inner) {
 282     SourceManager &SM = Pass.Ctx.getSourceManager();
 283     SourceLocation Loc = E->getExprLoc();
 284     assert(Loc.isMacroID());
 285     SourceLocation MacroBegin, MacroEnd;
 286     llvm::tie(MacroBegin, MacroEnd) = SM.getImmediateExpansionRange(Loc);
 287     SourceRange SubRange = E->getSubExpr()->IgnoreParenImpCasts()->getSourceRange();
 288     SourceLocation InnerBegin = SM.getImmediateMacroCallerLoc(SubRange.getBegin());
 289     SourceLocation InnerEnd = SM.getImmediateMacroCallerLoc(SubRange.getEnd());
 290
 291     Outer = SourceRange(MacroBegin, MacroEnd);
 292     Inner = SourceRange(InnerBegin, InnerEnd);
 293   }
 294
 295   void rewriteBlockCopyMacro(CastExpr *E) {
 296     SourceRange OuterRange, InnerRange;
 297     getBlockMacroRanges(E, OuterRange, InnerRange);
 298
 299     Transaction Trans(Pass.TA);
 300     Pass.TA.replace(OuterRange, InnerRange);
 301     Pass.TA.insert(InnerRange.getBegin(), "[");
 302     Pass.TA.insertAfterToken(InnerRange.getEnd(), " copy]");
 303     Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast,
 304                             diag::err_arc_cast_requires_bridge,
 305                             OuterRange);
 306   }
 307
 308   void removeBlockReleaseMacro(CastExpr *E) {
 309     SourceRange OuterRange, InnerRange;
 310     getBlockMacroRanges(E, OuterRange, InnerRange);
 311
 312     Transaction Trans(Pass.TA);
 313     Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast,
 314                             diag::err_arc_cast_requires_bridge,
 315                             OuterRange);
 316     if (!hasSideEffects(E, Pass.Ctx)) {
 317       if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E))))
 318         return;
 319     }
 320     Pass.TA.replace(OuterRange, InnerRange);
 321   }
 322
 323   bool tryRemoving(Expr *E) const {
 324     if (!Removables) {
 325       Removables.reset(new ExprSet);
 326       collectRemovables(Body, *Removables);
 327     }
 328
 329     if (Removables->count(E)) {
 330       Pass.TA.removeStmt(E);
 331       return true;
 332     }
 333
 334     return false;
 335   }
 336
 337   void transformObjCToNonObjCCast(CastExpr *E) {
 338     SourceLocation CastLoc = E->getExprLoc();
 339     if (CastLoc.isMacroID()) {
 340       StringRef MacroName = Lexer::getImmediateMacroName(CastLoc,
 341                                                     Pass.Ctx.getSourceManager(),
 342                                                     Pass.Ctx.getLangOpts());
 343       if (MacroName == "Block_copy") {
 344         rewriteBlockCopyMacro(E);
 345         return;
 346       }
 347       if (MacroName == "Block_release") {
 348         removeBlockReleaseMacro(E);
 349         return;
 350       }
 351     }
 352
 353     if (isSelf(E->getSubExpr()))
 354       return rewriteToBridgedCast(E, OBC_Bridge);
 355
 356     CallExpr *callE;
 357     if (isPassedToCFRetain(E, callE))
 358       return rewriteCastForCFRetain(E, callE);
 359
 360     ObjCMethodFamily family = getFamilyOfMessage(E->getSubExpr());
 361     if (family == OMF_retain)
 362       return rewriteToBridgedCast(E, OBC_BridgeRetained);
 363
 364     if (family == OMF_autorelease || family == OMF_release) {
 365       std::string err = "it is not safe to cast to '";
 366       err += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());
 367       err += "' the result of '";
 368       err += family == OMF_autorelease ? "autorelease" : "release";
 369       err += "' message; a __bridge cast may result in a pointer to a "
 370           "destroyed object and a __bridge_retained may leak the object";
 371       Pass.TA.reportError(err, E->getLocStart(),
 372                           E->getSubExpr()->getSourceRange());
 373       Stmt *parent = E;
 374       do {
 375         parent = StmtMap->getParentIgnoreParenImpCasts(parent);
 376       } while (parent && isa<ExprWithCleanups>(parent));
 377
 378       if (ReturnStmt *retS = dyn_cast_or_null<ReturnStmt>(parent)) {
 379         std::string note = "remove the cast and change return type of function "
 380             "to '";
 381         note += E->getSubExpr()->getType().getAsString(Pass.Ctx.getPrintingPolicy());
 382         note += "' to have the object automatically autoreleased";
 383         Pass.TA.reportNote(note, retS->getLocStart());
 384       }
 385     }
 386
 387     Expr *subExpr = E->getSubExpr();
 388
 389     // Look through pseudo-object expressions.
 390     if (PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(subExpr)) {
 391       subExpr = pseudo->getResultExpr();
 392       assert(subExpr && "no result for pseudo-object of non-void type?");
 393     }
 394
 395     if (ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(subExpr)) {
 396       if (implCE->getCastKind() == CK_ARCConsumeObject)
 397         return rewriteToBridgedCast(E, OBC_BridgeRetained);
 398       if (implCE->getCastKind() == CK_ARCReclaimReturnedObject)
 399         return rewriteToBridgedCast(E, OBC_Bridge);
 400     }
 401
 402     bool isConsumed = false;
 403     if (isPassedToCParamWithKnownOwnership(E, isConsumed))
 404       return rewriteToBridgedCast(E, isConsumed ? OBC_BridgeRetained
 405                                                 : OBC_Bridge);
 406   }
 407
 408   static ObjCMethodFamily getFamilyOfMessage(Expr *E) {
 409     E = E->IgnoreParenCasts();
 410     if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))
 411       return ME->getMethodFamily();
 412
 413     return OMF_None;
 414   }
 415
 416   bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {
 417     if ((callE = dyn_cast_or_null<CallExpr>(
 418                                      StmtMap->getParentIgnoreParenImpCasts(E))))
 419       if (FunctionDecl *
 420             FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl()))
 421         if (FD->getName() == "CFRetain" && FD->getNumParams() == 1 &&
 422             FD->getParent()->isTranslationUnit() &&
 423             FD->isExternallyVisible())
 424           return true;
 425
 426     return false;
 427   }
 428
 429   bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const {
 430     if (CallExpr *callE = dyn_cast_or_null<CallExpr>(
 431                                      StmtMap->getParentIgnoreParenImpCasts(E)))
 432       if (FunctionDecl *
 433             FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) {
 434         unsigned i = 0;
 435         for (unsigned e = callE->getNumArgs(); i != e; ++i) {
 436           Expr *arg = callE->getArg(i);
 437           if (arg == E || arg->IgnoreParenImpCasts() == E)
 438             break;
 439         }
 440         if (i < callE->getNumArgs() && i < FD->getNumParams()) {
 441           ParmVarDecl *PD = FD->getParamDecl(i);
 442           if (PD->getAttr<CFConsumedAttr>()) {
 443             isConsumed = true;
 444             return true;
 445           }
 446         }
 447       }
 448
 449     return false;
 450   }
 451
 452   bool isSelf(Expr *E) const {
 453     E = E->IgnoreParenLValueCasts();
 454     if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
 455       if (ImplicitParamDecl *IPD = dyn_cast<ImplicitParamDecl>(DRE->getDecl()))
 456         if (IPD->getIdentifier() == SelfII)
 457           return true;
 458
 459     return false;
 460   }
 461 };
 462
 463 } // end anonymous namespace
 464
 465 void trans::rewriteUnbridgedCasts(MigrationPass &pass) {
 466   BodyTransform<UnbridgedCastRewriter> trans(pass);
 467   trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
 468 }