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