//===--- TransUnbridgedCasts.cpp - Transformations to ARC mode ------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// rewriteUnbridgedCasts:

//

// A cast of non-objc pointer to an objc one is checked. If the non-objc pointer

// is from a file-level variable, __bridge cast is used to convert it.

// For the result of a function call that we know is +1/+0,

// __bridge/CFBridgingRelease is used.

//

//  NSString *str = (NSString *)kUTTypePlainText;

//  str = b ? kUTTypeRTF : kUTTypePlainText;

//  NSString *_uuidString = (NSString *)CFUUIDCreateString(kCFAllocatorDefault,

//                                                         _uuid);

// ---->

//  NSString *str = (__bridge NSString *)kUTTypePlainText;

//  str = (__bridge NSString *)(b ? kUTTypeRTF : kUTTypePlainText);

// NSString *_uuidString = (NSString *)

//            CFBridgingRelease(CFUUIDCreateString(kCFAllocatorDefault, _uuid));

//

// For a C pointer to ObjC, for casting 'self', __bridge is used.

//

//  CFStringRef str = (CFStringRef)self;

// ---->

//  CFStringRef str = (__bridge CFStringRef)self;

//

// Uses of Block_copy/Block_release macros are rewritten:

//

//  c = Block_copy(b);

//  Block_release(c);

// ---->

//  c = [b copy];

//  <removed>

//

//===----------------------------------------------------------------------===//

#include "Transforms.h"

#include "Internals.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/Attr.h"

#include "clang/AST/ParentMap.h"

#include "clang/Analysis/DomainSpecific/CocoaConventions.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Lex/Lexer.h"

#include "clang/Sema/SemaDiagnostic.h"

#include "llvm/ADT/SmallString.h"

using namespace clang;

using namespace arcmt;

using namespace trans;

namespace {

class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter>{

  MigrationPass &Pass;

  IdentifierInfo *SelfII;

  std::unique_ptr<ParentMap> StmtMap;

  Decl *ParentD;

  Stmt *Body;

  mutable std::unique_ptr<ExprSet> Removables;

public:

  UnbridgedCastRewriter(MigrationPass &pass)

    : Pass(pass), ParentD(nullptr), Body(nullptr) {

    SelfII = &Pass.Ctx.Idents.get("self");

  }

  void transformBody(Stmt *body, Decl *ParentD) {

    this->ParentD = ParentD;

    Body = body;

    StmtMap.reset(new ParentMap(body));

    TraverseStmt(body);

  }

  bool TraverseBlockDecl(BlockDecl *D) {

    // ParentMap does not enter into a BlockDecl to record its stmts, so use a

    // new UnbridgedCastRewriter to handle the block.

    UnbridgedCastRewriter(Pass).transformBody(D->getBody(), D);

    return true;

  }

  bool VisitCastExpr(CastExpr *E) {

    if (E->getCastKind() != CK_CPointerToObjCPointerCast &&

        
E->getCastKind() != CK_BitCast1.77k
 &&

        
E->getCastKind() != CK_AnyPointerToBlockPointerCast1.57k
)

      return true;

    QualType castType = E->getType();

    Expr *castExpr = E->getSubExpr();

    QualType castExprType = castExpr->getType();

    if (castType->isObjCRetainableType() == castExprType->isObjCRetainableType())

      return true;

    bool exprRetainable = castExprType->isObjCIndirectLifetimeType();

    bool castRetainable = castType->isObjCIndirectLifetimeType();

    if (exprRetainable == castRetainable) 
return true2
;

    if (castExpr->isNullPointerConstant(Pass.Ctx,

                                        Expr::NPC_ValueDependentIsNull))

      return true;

    SourceLocation loc = castExpr->getExprLoc();

    if (loc.isValid() && Pass.Ctx.getSourceManager().isInSystemHeader(loc))

      return true;

    if (castType->isObjCRetainableType())

      transformNonObjCToObjCCast(E);

    else

      transformObjCToNonObjCCast(E);

    return true;

  }

private:

  void transformNonObjCToObjCCast(CastExpr *E) {

    if (!E) 
return0
;

    // Global vars are assumed that are cast as unretained.

    if (isGlobalVar(E))

      if (E->getSubExpr()->getType()->isPointerType()) {

        castToObjCObject(E, /*retained=*/false);

        return;

      }

    // If the cast is directly over the result of a Core Foundation function

    // try to figure out whether it should be cast as retained or unretained.

    Expr *inner = E->IgnoreParenCasts();

    if (CallExpr *callE = dyn_cast<CallExpr>(inner)) {

      if (FunctionDecl *FD = callE->getDirectCallee()) {

        if (FD->hasAttr<CFReturnsRetainedAttr>()) {

          castToObjCObject(E, /*retained=*/true);

          return;

        }

        if (FD->hasAttr<CFReturnsNotRetainedAttr>()) {

          castToObjCObject(E, /*retained=*/false);

          return;

        }

        if (FD->isGlobal() &&

            FD->getIdentifier() &&

            ento::cocoa::isRefType(E->getSubExpr()->getType(), "CF",

                                   FD->getIdentifier()->getName())) {

          StringRef fname = FD->getIdentifier()->getName();

          if (fname.endswith("Retain") || 
fname.contains("Create")4
 ||

              
fname.contains("Copy")0
) {

            // Do not migrate to couple of bridge transfer casts which

            // cancel each other out. Leave it unchanged so error gets user

            // attention instead.

            if (FD->getName() == "CFRetain" &&

                
FD->getNumParams() == 19
 &&

                
FD->getParent()->isTranslationUnit()9
 &&

                
FD->isExternallyVisible()9
) {

              Expr *Arg = callE->getArg(0);

              if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {

                const Expr *sub = ICE->getSubExpr();

                QualType T = sub->getType();

                if (T->isObjCObjectPointerType())

                  return;

              }

            }

            castToObjCObject(E, /*retained=*/true);

            return;

          }

          if (fname.contains("Get")) {

            castToObjCObject(E, /*retained=*/false);

            return;

          }

        }

      }

    }

    // If returning an ivar or a member of an ivar from a +0 method, use

    // a __bridge cast.

    Expr *base = inner->IgnoreParenImpCasts();

    while (isa<MemberExpr>(base))

      base = cast<MemberExpr>(base)->getBase()->IgnoreParenImpCasts();

    if (isa<ObjCIvarRefExpr>(base) &&

        
isa<ReturnStmt>(StmtMap->getParentIgnoreParenCasts(E))9
) {

      if (ObjCMethodDecl *method = dyn_cast_or_null<ObjCMethodDecl>(ParentD)) {

        if (!method->hasAttr<NSReturnsRetainedAttr>()) {

          castToObjCObject(E, /*retained=*/false);

          return;

        }

      }

    }

  }

  void castToObjCObject(CastExpr *E, bool retained) {

    rewriteToBridgedCast(E, retained ? 
OBC_BridgeTransfer10
 : 
OBC_Bridge20
);

  }

  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind) {

    Transaction Trans(Pass.TA);

    rewriteToBridgedCast(E, Kind, Trans);

  }

  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind,

                            Transaction &Trans) {

    TransformActions &TA = Pass.TA;

    // We will remove the compiler diagnostic.

    if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast,

                          diag::err_arc_cast_requires_bridge,

                          E->getBeginLoc())) {

      Trans.abort();

      return;

    }

    StringRef bridge;

    switch(Kind) {

    case OBC_Bridge:

      bridge = "__bridge "; break;

    case OBC_BridgeTransfer:

      bridge = "__bridge_transfer "; break;

    case OBC_BridgeRetained:

      bridge = "__bridge_retained "; break;

    }

    TA.clearDiagnostic(diag::err_arc_mismatched_cast,

                       diag::err_arc_cast_requires_bridge, E->getBeginLoc());

    if (Kind == OBC_Bridge || 
!Pass.CFBridgingFunctionsDefined()36
) {

      if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) {

        TA.insertAfterToken(CCE->getLParenLoc(), bridge);

      } else {

        SourceLocation insertLoc = E->getSubExpr()->getBeginLoc();

        SmallString<128> newCast;

        newCast += '(';

        newCast += bridge;

        newCast += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());

        newCast += ')';

        if (isa<ParenExpr>(E->getSubExpr())) {

          TA.insert(insertLoc, newCast.str());

        } else {

          newCast += '(';

          TA.insert(insertLoc, newCast.str());

          TA.insertAfterToken(E->getEndLoc(), ")");

        }

      }

    } else {

      assert(Kind == OBC_BridgeTransfer || Kind == OBC_BridgeRetained);

      SmallString<32> BridgeCall;

      Expr *WrapE = E->getSubExpr();

      SourceLocation InsertLoc = WrapE->getBeginLoc();

      SourceManager &SM = Pass.Ctx.getSourceManager();

      char PrevChar = *SM.getCharacterData(InsertLoc.getLocWithOffset(-1));

      if (Lexer::isAsciiIdentifierContinueChar(PrevChar,

                                               Pass.Ctx.getLangOpts()))

        BridgeCall += ' ';

      if (Kind == OBC_BridgeTransfer)

        BridgeCall += "CFBridgingRelease";

      else

        BridgeCall += "CFBridgingRetain";

      if (isa<ParenExpr>(WrapE)) {

        TA.insert(InsertLoc, BridgeCall);

      } else {

        BridgeCall += '(';

        TA.insert(InsertLoc, BridgeCall);

        TA.insertAfterToken(WrapE->getEndLoc(), ")");

      }

    }

  }

  void rewriteCastForCFRetain(CastExpr *castE, CallExpr *callE) {

    Transaction Trans(Pass.TA);

    Pass.TA.replace(callE->getSourceRange(), callE->getArg(0)->getSourceRange());

    rewriteToBridgedCast(castE, OBC_BridgeRetained, Trans);

  }

  void getBlockMacroRanges(CastExpr *E, SourceRange &Outer, SourceRange &Inner) {

    SourceManager &SM = Pass.Ctx.getSourceManager();

    SourceLocation Loc = E->getExprLoc();

    assert(Loc.isMacroID());

    CharSourceRange MacroRange = SM.getImmediateExpansionRange(Loc);

    SourceRange SubRange = E->getSubExpr()->IgnoreParenImpCasts()->getSourceRange();

    SourceLocation InnerBegin = SM.getImmediateMacroCallerLoc(SubRange.getBegin());

    SourceLocation InnerEnd = SM.getImmediateMacroCallerLoc(SubRange.getEnd());

    Outer = MacroRange.getAsRange();

    Inner = SourceRange(InnerBegin, InnerEnd);

  }

  void rewriteBlockCopyMacro(CastExpr *E) {

    SourceRange OuterRange, InnerRange;

    getBlockMacroRanges(E, OuterRange, InnerRange);

    Transaction Trans(Pass.TA);

    Pass.TA.replace(OuterRange, InnerRange);

    Pass.TA.insert(InnerRange.getBegin(), "[");

    Pass.TA.insertAfterToken(InnerRange.getEnd(), " copy]");

    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast,

                            diag::err_arc_cast_requires_bridge,

                            OuterRange);

  }

  void removeBlockReleaseMacro(CastExpr *E) {

    SourceRange OuterRange, InnerRange;

    getBlockMacroRanges(E, OuterRange, InnerRange);

    Transaction Trans(Pass.TA);

    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast,

                            diag::err_arc_cast_requires_bridge,

                            OuterRange);

    if (!hasSideEffects(E, Pass.Ctx)) {

      if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E))))

        return;

    }

    Pass.TA.replace(OuterRange, InnerRange);

  }

  bool tryRemoving(Expr *E) const {

    if (!Removables) {

      Removables.reset(new ExprSet);

      collectRemovables(Body, *Removables);

    }

    if (Removables->count(E)) {

      Pass.TA.removeStmt(E);

      return true;

    }

    return false;

  }

  void transformObjCToNonObjCCast(CastExpr *E) {

    SourceLocation CastLoc = E->getExprLoc();

    if (CastLoc.isMacroID()) {

      StringRef MacroName = Lexer::getImmediateMacroName(CastLoc,

                                                    Pass.Ctx.getSourceManager(),

                                                    Pass.Ctx.getLangOpts());

      if (MacroName == "Block_copy") {

        rewriteBlockCopyMacro(E);

        return;

      }

      if (MacroName == "Block_release") {

        removeBlockReleaseMacro(E);

        return;

      }

    }

    if (isSelf(E->getSubExpr()))

      return rewriteToBridgedCast(E, OBC_Bridge);

    CallExpr *callE;

    if (isPassedToCFRetain(E, callE))

      return rewriteCastForCFRetain(E, callE);

    ObjCMethodFamily family = getFamilyOfMessage(E->getSubExpr());

    if (family == OMF_retain)

      return rewriteToBridgedCast(E, OBC_BridgeRetained);

    if (family == OMF_autorelease || 
family == OMF_release66
) {

      std::string err = "it is not safe to cast to '";

      err += E->getType().getAsString(Pass.Ctx.getPrintingPolicy());

      err += "' the result of '";

      err += family == OMF_autorelease ? "autorelease" : 
"release"0
;

      err += "' message; a __bridge cast may result in a pointer to a "

          "destroyed object and a __bridge_retained may leak the object";

      Pass.TA.reportError(err, E->getBeginLoc(),

                          E->getSubExpr()->getSourceRange());

      Stmt *parent = E;

      do {

        parent = StmtMap->getParentIgnoreParenImpCasts(parent);

      } while (parent && isa<FullExpr>(parent));

      if (ReturnStmt *retS = dyn_cast_or_null<ReturnStmt>(parent)) {

        std::string note = "remove the cast and change return type of function "

            "to '";

        note += E->getSubExpr()->getType().getAsString(Pass.Ctx.getPrintingPolicy());

        note += "' to have the object automatically autoreleased";

        Pass.TA.reportNote(note, retS->getBeginLoc());

      }

    }

    Expr *subExpr = E->getSubExpr();

    // Look through pseudo-object expressions.

    if (PseudoObjectExpr *pseudo = dyn_cast<PseudoObjectExpr>(subExpr)) {

      subExpr = pseudo->getResultExpr();

      assert(subExpr && "no result for pseudo-object of non-void type?");

    }

    if (ImplicitCastExpr *implCE = dyn_cast<ImplicitCastExpr>(subExpr)) {

      if (implCE->getCastKind() == CK_ARCConsumeObject)

        return rewriteToBridgedCast(E, OBC_BridgeRetained);

      if (implCE->getCastKind() == CK_ARCReclaimReturnedObject)

        return rewriteToBridgedCast(E, OBC_Bridge);

    }

    bool isConsumed = false;

    if (isPassedToCParamWithKnownOwnership(E, isConsumed))

      return rewriteToBridgedCast(E, isConsumed ? OBC_BridgeRetained

                                                : 
OBC_Bridge0
);

  }

  static ObjCMethodFamily getFamilyOfMessage(Expr *E) {

    E = E->IgnoreParenCasts();

    if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E))

      return ME->getMethodFamily();

    return OMF_None;

  }

  bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {

    if ((callE = dyn_cast_or_null<CallExpr>(

                                     StmtMap->getParentIgnoreParenImpCasts(E))))

      if (FunctionDecl *

            FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl()))

        if (FD->getName() == "CFRetain" && 
FD->getNumParams() == 110
 &&

            
FD->getParent()->isTranslationUnit()10
 &&

            
FD->isExternallyVisible()10
)

          return true;

    return false;

  }

  bool isPassedToCParamWithKnownOwnership(Expr *E, bool &isConsumed) const {

    if (CallExpr *callE = dyn_cast_or_null<CallExpr>(

                                     StmtMap->getParentIgnoreParenImpCasts(E)))

      if (FunctionDecl *

            FD = dyn_cast_or_null<FunctionDecl>(callE->getCalleeDecl())) {

        unsigned i = 0;

        for (unsigned e = callE->getNumArgs(); i != e; 
++i1
) {

          Expr *arg = callE->getArg(i);

          if (arg == E || 
arg->IgnoreParenImpCasts() == E2
)

            break;

        }

        if (i < callE->getNumArgs() && i < FD->getNumParams()) {

          ParmVarDecl *PD = FD->getParamDecl(i);

          if (PD->hasAttr<CFConsumedAttr>()) {

            isConsumed = true;

            return true;

          }

        }

      }

    return false;

  }

  bool isSelf(Expr *E) const {

    E = E->IgnoreParenLValueCasts();

    if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))

      if (ImplicitParamDecl *IPD = dyn_cast<ImplicitParamDecl>(DRE->getDecl()))

        if (IPD->getIdentifier() == SelfII)

          return true;

    return false;

  }

};

} // end anonymous namespace

void trans::rewriteUnbridgedCasts(MigrationPass &pass) {

  BodyTransform<UnbridgedCastRewriter> trans(pass);

  trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());

}