2011-06-16 07:25:17 +08:00
|
|
|
//===--- Tranforms.cpp - Tranformations to ARC mode -----------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Transformations:
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// castNonObjCToObjC:
|
|
|
|
//
|
|
|
|
// A cast of non-objc pointer to an objc one is checked. If the non-objc pointer
|
|
|
|
// is from a file-level variable, objc_unretainedObject function is used to
|
|
|
|
// convert it.
|
|
|
|
//
|
|
|
|
// NSString *str = (NSString *)kUTTypePlainText;
|
|
|
|
// str = b ? kUTTypeRTF : kUTTypePlainText;
|
|
|
|
// ---->
|
|
|
|
// NSString *str = objc_unretainedObject(kUTTypePlainText);
|
|
|
|
// str = objc_unretainedObject(b ? kUTTypeRTF : kUTTypePlainText);
|
|
|
|
//
|
|
|
|
// For a C pointer to ObjC, objc_unretainedPointer is used.
|
|
|
|
//
|
|
|
|
// void *vp = str; // NSString*
|
|
|
|
// ---->
|
|
|
|
// void *vp = (void*)objc_unretainedPointer(str);
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// rewriteAllocCopyWithZone:
|
|
|
|
//
|
|
|
|
// Calls to +allocWithZone/-copyWithZone/-mutableCopyWithZone are changed to
|
|
|
|
// +alloc/-copy/-mutableCopy if we can safely remove the given parameter.
|
|
|
|
//
|
|
|
|
// Foo *foo1 = [[Foo allocWithZone:[self zone]] init];
|
|
|
|
// ---->
|
|
|
|
// Foo *foo1 = [[Foo alloc] init];
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// rewriteAutoreleasePool:
|
|
|
|
//
|
|
|
|
// Calls to NSAutoreleasePools will be rewritten as an @autorelease scope.
|
|
|
|
//
|
|
|
|
// NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
|
|
|
|
// ...
|
|
|
|
// [pool release];
|
|
|
|
// ---->
|
|
|
|
// @autorelease {
|
|
|
|
// ...
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// An NSAutoreleasePool will not be touched if:
|
|
|
|
// - There is not a corresponding -release/-drain in the same scope
|
|
|
|
// - Not all references of the NSAutoreleasePool variable can be removed
|
|
|
|
// - There is a variable that is declared inside the intended @autorelease scope
|
|
|
|
// which is also used outside it.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// makeAssignARCSafe:
|
|
|
|
//
|
|
|
|
// Add '__strong' where appropriate.
|
|
|
|
//
|
|
|
|
// for (id x in collection) {
|
|
|
|
// x = 0;
|
|
|
|
// }
|
|
|
|
// ---->
|
|
|
|
// for (__strong id x in collection) {
|
|
|
|
// x = 0;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// removeRetainReleaseDealloc:
|
|
|
|
//
|
|
|
|
// Removes retain/release/autorelease/dealloc messages.
|
|
|
|
//
|
|
|
|
// return [[foo retain] autorelease];
|
|
|
|
// ---->
|
|
|
|
// return foo;
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// removeEmptyStatements:
|
|
|
|
//
|
|
|
|
// Removes empty statements that are leftovers from previous transformations.
|
|
|
|
// e.g for
|
|
|
|
//
|
|
|
|
// [x retain];
|
|
|
|
//
|
|
|
|
// removeRetainReleaseDealloc will leave an empty ";" that removeEmptyStatements
|
|
|
|
// will remove.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// changeIvarsOfAssignProperties:
|
|
|
|
//
|
|
|
|
// If a property is synthesized with 'assign' attribute and the user didn't
|
|
|
|
// set a lifetime attribute, change the property to 'weak' or add
|
|
|
|
// __unsafe_unretained if the ARC runtime is not available.
|
|
|
|
//
|
|
|
|
// @interface Foo : NSObject {
|
|
|
|
// NSObject *x;
|
|
|
|
// }
|
|
|
|
// @property (assign) id x;
|
|
|
|
// @end
|
|
|
|
// ---->
|
|
|
|
// @interface Foo : NSObject {
|
|
|
|
// NSObject *__weak x;
|
|
|
|
// }
|
|
|
|
// @property (weak) id x;
|
|
|
|
// @end
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// rewriteUnusedDelegateInit:
|
|
|
|
//
|
|
|
|
// Rewrites an unused result of calling a delegate initialization, to assigning
|
|
|
|
// the result to self.
|
|
|
|
// e.g
|
|
|
|
// [self init];
|
|
|
|
// ---->
|
|
|
|
// self = [self init];
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// rewriteBlockObjCVariable:
|
|
|
|
//
|
|
|
|
// Adding __block to an obj-c variable could be either because the the variable
|
|
|
|
// is used for output storage or the user wanted to break a retain cycle.
|
|
|
|
// This transformation checks whether a reference of the variable for the block
|
|
|
|
// is actually needed (it is assigned to or its address is taken) or not.
|
|
|
|
// If the reference is not needed it will assume __block was added to break a
|
|
|
|
// cycle so it will remove '__block' and add __weak/__unsafe_unretained.
|
|
|
|
// e.g
|
|
|
|
//
|
|
|
|
// __block Foo *x;
|
|
|
|
// bar(^ { [x cake]; });
|
|
|
|
// ---->
|
|
|
|
// __weak Foo *x;
|
|
|
|
// bar(^ { [x cake]; });
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// removeZeroOutIvarsInDealloc:
|
|
|
|
//
|
|
|
|
// Removes zero'ing out "strong" @synthesized properties in a -dealloc method.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "Internals.h"
|
|
|
|
#include "clang/Sema/SemaDiagnostic.h"
|
|
|
|
#include "clang/AST/RecursiveASTVisitor.h"
|
|
|
|
#include "clang/AST/StmtVisitor.h"
|
|
|
|
#include "clang/AST/ParentMap.h"
|
|
|
|
#include "clang/Analysis/DomainSpecific/CocoaConventions.h"
|
|
|
|
#include "clang/Lex/Lexer.h"
|
|
|
|
#include "clang/Basic/SourceManager.h"
|
|
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
|
|
#include "llvm/ADT/DenseSet.h"
|
|
|
|
#include <map>
|
|
|
|
|
|
|
|
using namespace clang;
|
|
|
|
using namespace arcmt;
|
|
|
|
using llvm::StringRef;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Transformations.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class RemovablesCollector : public RecursiveASTVisitor<RemovablesCollector> {
|
|
|
|
llvm::DenseSet<Expr *> &Removables;
|
|
|
|
|
|
|
|
public:
|
|
|
|
RemovablesCollector(llvm::DenseSet<Expr *> &removables)
|
|
|
|
: Removables(removables) { }
|
|
|
|
|
|
|
|
bool shouldWalkTypesOfTypeLocs() const { return false; }
|
|
|
|
|
|
|
|
bool TraverseStmtExpr(StmtExpr *E) {
|
|
|
|
CompoundStmt *S = E->getSubStmt();
|
|
|
|
for (CompoundStmt::body_iterator
|
|
|
|
I = S->body_begin(), E = S->body_end(); I != E; ++I) {
|
|
|
|
if (I != E - 1)
|
|
|
|
mark(*I);
|
|
|
|
TraverseStmt(*I);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitCompoundStmt(CompoundStmt *S) {
|
|
|
|
for (CompoundStmt::body_iterator
|
|
|
|
I = S->body_begin(), E = S->body_end(); I != E; ++I)
|
|
|
|
mark(*I);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitIfStmt(IfStmt *S) {
|
|
|
|
mark(S->getThen());
|
|
|
|
mark(S->getElse());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitWhileStmt(WhileStmt *S) {
|
|
|
|
mark(S->getBody());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitDoStmt(DoStmt *S) {
|
|
|
|
mark(S->getBody());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitForStmt(ForStmt *S) {
|
|
|
|
mark(S->getInit());
|
|
|
|
mark(S->getInc());
|
|
|
|
mark(S->getBody());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void mark(Stmt *S) {
|
|
|
|
if (!S) return;
|
|
|
|
|
|
|
|
if (LabelStmt *Label = dyn_cast<LabelStmt>(S))
|
|
|
|
return mark(Label->getSubStmt());
|
|
|
|
if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(S))
|
|
|
|
return mark(CE->getSubExpr());
|
|
|
|
if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(S))
|
|
|
|
return mark(EWC->getSubExpr());
|
|
|
|
if (Expr *E = dyn_cast<Expr>(S))
|
|
|
|
Removables.insert(E);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // end anonymous namespace.
|
|
|
|
|
|
|
|
static bool HasSideEffects(Expr *E, ASTContext &Ctx) {
|
|
|
|
if (!E || !E->HasSideEffects(Ctx))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
E = E->IgnoreParenCasts();
|
|
|
|
ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E);
|
|
|
|
if (!ME)
|
|
|
|
return true;
|
|
|
|
switch (ME->getMethodFamily()) {
|
|
|
|
case OMF_autorelease:
|
|
|
|
case OMF_dealloc:
|
|
|
|
case OMF_release:
|
|
|
|
case OMF_retain:
|
|
|
|
switch (ME->getReceiverKind()) {
|
|
|
|
case ObjCMessageExpr::SuperInstance:
|
|
|
|
return false;
|
|
|
|
case ObjCMessageExpr::Instance:
|
|
|
|
return HasSideEffects(ME->getInstanceReceiver(), Ctx);
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void removeDeallocMethod(MigrationPass &pass) {
|
|
|
|
ASTContext &Ctx = pass.Ctx;
|
|
|
|
TransformActions &TA = pass.TA;
|
|
|
|
DeclContext *DC = Ctx.getTranslationUnitDecl();
|
|
|
|
ObjCMethodDecl *DeallocMethodDecl = 0;
|
|
|
|
IdentifierInfo *II = &Ctx.Idents.get("dealloc");
|
|
|
|
|
|
|
|
for (DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
Decl *D = *I;
|
|
|
|
if (ObjCImplementationDecl *IMD =
|
|
|
|
dyn_cast<ObjCImplementationDecl>(D)) {
|
|
|
|
DeallocMethodDecl = 0;
|
|
|
|
for (ObjCImplementationDecl::instmeth_iterator I =
|
|
|
|
IMD->instmeth_begin(), E = IMD->instmeth_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
ObjCMethodDecl *OMD = *I;
|
|
|
|
if (OMD->isInstanceMethod() &&
|
|
|
|
OMD->getSelector() == Ctx.Selectors.getSelector(0, &II)) {
|
|
|
|
DeallocMethodDecl = OMD;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (DeallocMethodDecl &&
|
|
|
|
DeallocMethodDecl->getCompoundBody()->body_empty()) {
|
|
|
|
Transaction Trans(TA);
|
|
|
|
TA.remove(DeallocMethodDecl->getSourceRange());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class ReferenceClear : public RecursiveASTVisitor<ReferenceClear> {
|
|
|
|
llvm::DenseSet<Expr *> &Refs;
|
|
|
|
public:
|
|
|
|
ReferenceClear(llvm::DenseSet<Expr *> &refs) : Refs(refs) { }
|
|
|
|
bool VisitDeclRefExpr(DeclRefExpr *E) { Refs.erase(E); return true; }
|
|
|
|
bool VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { Refs.erase(E); return true; }
|
|
|
|
void clearRefsIn(Stmt *S) { TraverseStmt(S); }
|
|
|
|
template <typename iterator>
|
|
|
|
void clearRefsIn(iterator begin, iterator end) {
|
|
|
|
for (; begin != end; ++begin)
|
|
|
|
TraverseStmt(*begin);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ReferenceCollector : public RecursiveASTVisitor<ReferenceCollector> {
|
|
|
|
ValueDecl *Dcl;
|
|
|
|
llvm::DenseSet<Expr *> &Refs;
|
|
|
|
|
|
|
|
public:
|
|
|
|
ReferenceCollector(llvm::DenseSet<Expr *> &refs)
|
|
|
|
: Dcl(0), Refs(refs) { }
|
|
|
|
|
|
|
|
void lookFor(ValueDecl *D, Stmt *S) {
|
|
|
|
Dcl = D;
|
|
|
|
TraverseStmt(S);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitDeclRefExpr(DeclRefExpr *E) {
|
|
|
|
if (E->getDecl() == Dcl)
|
|
|
|
Refs.insert(E);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
|
|
|
|
if (E->getDecl() == Dcl)
|
|
|
|
Refs.insert(E);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ReleaseCollector : public RecursiveASTVisitor<ReleaseCollector> {
|
|
|
|
Decl *Dcl;
|
|
|
|
llvm::SmallVectorImpl<ObjCMessageExpr *> &Releases;
|
|
|
|
|
|
|
|
public:
|
|
|
|
ReleaseCollector(Decl *D, llvm::SmallVectorImpl<ObjCMessageExpr *> &releases)
|
|
|
|
: Dcl(D), Releases(releases) { }
|
|
|
|
|
|
|
|
bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
|
|
|
|
if (!E->isInstanceMessage())
|
|
|
|
return true;
|
|
|
|
if (E->getMethodFamily() != OMF_release)
|
|
|
|
return true;
|
|
|
|
Expr *instance = E->getInstanceReceiver()->IgnoreParenCasts();
|
|
|
|
if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(instance)) {
|
|
|
|
if (DE->getDecl() == Dcl)
|
|
|
|
Releases.push_back(E);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename BODY_TRANS>
|
|
|
|
class BodyTransform : public RecursiveASTVisitor<BodyTransform<BODY_TRANS> > {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
public:
|
|
|
|
BodyTransform(MigrationPass &pass) : Pass(pass) { }
|
|
|
|
|
|
|
|
void handleBody(Decl *D) {
|
|
|
|
Stmt *body = D->getBody();
|
|
|
|
if (body) {
|
|
|
|
BODY_TRANS(D, Pass).transformBody(body);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TraverseBlockDecl(BlockDecl *D) {
|
|
|
|
handleBody(D);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool TraverseObjCMethodDecl(ObjCMethodDecl *D) {
|
|
|
|
if (D->isThisDeclarationADefinition())
|
|
|
|
handleBody(D);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool TraverseFunctionDecl(FunctionDecl *D) {
|
|
|
|
if (D->isThisDeclarationADefinition())
|
|
|
|
handleBody(D);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// makeAssignARCSafe
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class ARCAssignChecker : public RecursiveASTVisitor<ARCAssignChecker> {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
llvm::DenseSet<VarDecl *> ModifiedVars;
|
|
|
|
|
|
|
|
public:
|
|
|
|
ARCAssignChecker(MigrationPass &pass) : Pass(pass) { }
|
|
|
|
|
|
|
|
bool VisitBinaryOperator(BinaryOperator *Exp) {
|
|
|
|
Expr *E = Exp->getLHS();
|
|
|
|
SourceLocation OrigLoc = E->getExprLoc();
|
|
|
|
SourceLocation Loc = OrigLoc;
|
|
|
|
DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts());
|
|
|
|
if (declRef && isa<VarDecl>(declRef->getDecl())) {
|
|
|
|
ASTContext &Ctx = Pass.Ctx;
|
|
|
|
Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(Ctx, &Loc);
|
|
|
|
if (IsLV != Expr::MLV_ConstQualified)
|
|
|
|
return true;
|
|
|
|
VarDecl *var = cast<VarDecl>(declRef->getDecl());
|
2011-06-17 14:42:21 +08:00
|
|
|
if (var->isARCPseudoStrong()) {
|
2011-06-16 07:25:17 +08:00
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
if (Pass.TA.clearDiagnostic(diag::err_typecheck_arr_assign_enumeration,
|
|
|
|
Exp->getOperatorLoc())) {
|
|
|
|
if (!ModifiedVars.count(var)) {
|
|
|
|
TypeLoc TLoc = var->getTypeSourceInfo()->getTypeLoc();
|
|
|
|
Pass.TA.insert(TLoc.getBeginLoc(), "__strong ");
|
|
|
|
ModifiedVars.insert(var);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void makeAssignARCSafe(MigrationPass &pass) {
|
|
|
|
ARCAssignChecker assignCheck(pass);
|
|
|
|
assignCheck.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// castNonObjCToObjC
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class NonObjCToObjCCaster : public RecursiveASTVisitor<NonObjCToObjCCaster> {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
public:
|
|
|
|
NonObjCToObjCCaster(MigrationPass &pass) : Pass(pass) { }
|
|
|
|
|
|
|
|
bool VisitCastExpr(CastExpr *E) {
|
|
|
|
if (E->getCastKind() != CK_AnyPointerToObjCPointerCast
|
|
|
|
&& E->getCastKind() != CK_BitCast)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
QualType castType = E->getType();
|
|
|
|
Expr *castExpr = E->getSubExpr();
|
|
|
|
QualType castExprType = castExpr->getType();
|
|
|
|
|
|
|
|
if (castType->isObjCObjectPointerType() &&
|
|
|
|
castExprType->isObjCObjectPointerType())
|
|
|
|
return true;
|
|
|
|
if (!castType->isObjCObjectPointerType() &&
|
|
|
|
!castExprType->isObjCObjectPointerType())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
bool exprRetainable = castExprType->isObjCIndirectLifetimeType();
|
|
|
|
bool castRetainable = castType->isObjCIndirectLifetimeType();
|
|
|
|
if (exprRetainable == castRetainable) return true;
|
|
|
|
|
|
|
|
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->isObjCObjectPointerType())
|
|
|
|
transformNonObjCToObjCCast(E);
|
|
|
|
else
|
|
|
|
transformObjCToNonObjCCast(E);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void transformNonObjCToObjCCast(CastExpr *E) {
|
|
|
|
if (!E) return;
|
|
|
|
|
|
|
|
// 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->getAttr<CFReturnsRetainedAttr>()) {
|
|
|
|
castToObjCObject(E, /*retained=*/true);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (FD->getAttr<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.find("Create") != StringRef::npos ||
|
|
|
|
fname.find("Copy") != StringRef::npos) {
|
|
|
|
castToObjCObject(E, /*retained=*/true);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fname.find("Get") != StringRef::npos) {
|
|
|
|
castToObjCObject(E, /*retained=*/false);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void castToObjCObject(CastExpr *E, bool retained) {
|
|
|
|
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->getLocStart()))
|
|
|
|
return;
|
|
|
|
|
|
|
|
Transaction Trans(TA);
|
|
|
|
TA.clearDiagnostic(diag::err_arc_mismatched_cast,
|
|
|
|
diag::err_arc_cast_requires_bridge,
|
|
|
|
E->getLocStart());
|
|
|
|
if (CStyleCastExpr *CCE = dyn_cast<CStyleCastExpr>(E)) {
|
|
|
|
TA.insertAfterToken(CCE->getLParenLoc(), retained ? "__bridge_transfer "
|
|
|
|
: "__bridge ");
|
|
|
|
} else {
|
|
|
|
SourceLocation insertLoc = E->getSubExpr()->getLocStart();
|
|
|
|
llvm::SmallString<128> newCast;
|
|
|
|
newCast += '(';
|
|
|
|
newCast += retained ? "__bridge_transfer " : "__bridge ";
|
|
|
|
newCast += E->getType().getAsString(Pass.Ctx.PrintingPolicy);
|
|
|
|
newCast += ')';
|
|
|
|
|
|
|
|
if (isa<ParenExpr>(E->getSubExpr())) {
|
|
|
|
TA.insert(insertLoc, newCast.str());
|
|
|
|
} else {
|
|
|
|
newCast += '(';
|
|
|
|
TA.insert(insertLoc, newCast.str());
|
|
|
|
TA.insertAfterToken(E->getLocEnd(), ")");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void transformObjCToNonObjCCast(CastExpr *E) {
|
|
|
|
// FIXME: Handle these casts.
|
|
|
|
return;
|
|
|
|
#if 0
|
|
|
|
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->getLocStart()))
|
|
|
|
return;
|
|
|
|
|
|
|
|
Transaction Trans(TA);
|
|
|
|
TA.clearDiagnostic(diag::err_arc_mismatched_cast,
|
|
|
|
diag::err_arc_cast_requires_bridge,
|
|
|
|
E->getLocStart());
|
|
|
|
|
|
|
|
assert(!E->getType()->isObjCObjectPointerType());
|
|
|
|
|
|
|
|
bool shouldCast = !isa<CStyleCastExpr>(E) &&
|
|
|
|
!E->getType()->getPointeeType().isConstQualified();
|
|
|
|
SourceLocation loc = E->getSubExpr()->getLocStart();
|
|
|
|
if (isa<ParenExpr>(E->getSubExpr())) {
|
|
|
|
TA.insert(loc, shouldCast ? "(void*)objc_unretainedPointer"
|
|
|
|
: "objc_unretainedPointer");
|
|
|
|
} else {
|
|
|
|
TA.insert(loc, shouldCast ? "(void*)objc_unretainedPointer("
|
|
|
|
: "objc_unretainedPointer(");
|
|
|
|
TA.insertAfterToken(E->getLocEnd(), ")");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool isGlobalVar(Expr *E) {
|
|
|
|
E = E->IgnoreParenCasts();
|
|
|
|
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
|
|
|
|
return DRE->getDecl()->getDeclContext()->isFileContext();
|
|
|
|
if (ConditionalOperator *condOp = dyn_cast<ConditionalOperator>(E))
|
|
|
|
return isGlobalVar(condOp->getTrueExpr()) &&
|
|
|
|
isGlobalVar(condOp->getFalseExpr());
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
static void castNonObjCToObjC(MigrationPass &pass) {
|
|
|
|
NonObjCToObjCCaster trans(pass);
|
|
|
|
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// rewriteAllocCopyWithZone
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class AllocCopyWithZoneRewriter :
|
|
|
|
public RecursiveASTVisitor<AllocCopyWithZoneRewriter> {
|
|
|
|
Decl *Dcl;
|
|
|
|
Stmt *Body;
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
Selector allocWithZoneSel;
|
|
|
|
Selector copyWithZoneSel;
|
|
|
|
Selector mutableCopyWithZoneSel;
|
|
|
|
Selector zoneSel;
|
|
|
|
IdentifierInfo *NSZoneII;
|
|
|
|
|
|
|
|
std::vector<DeclStmt *> NSZoneVars;
|
|
|
|
std::vector<Expr *> Removals;
|
|
|
|
|
|
|
|
public:
|
|
|
|
AllocCopyWithZoneRewriter(Decl *D, MigrationPass &pass)
|
|
|
|
: Dcl(D), Body(0), Pass(pass) {
|
|
|
|
SelectorTable &sels = pass.Ctx.Selectors;
|
|
|
|
IdentifierTable &ids = pass.Ctx.Idents;
|
|
|
|
allocWithZoneSel = sels.getUnarySelector(&ids.get("allocWithZone"));
|
|
|
|
copyWithZoneSel = sels.getUnarySelector(&ids.get("copyWithZone"));
|
|
|
|
mutableCopyWithZoneSel = sels.getUnarySelector(
|
|
|
|
&ids.get("mutableCopyWithZone"));
|
|
|
|
zoneSel = sels.getNullarySelector(&ids.get("zone"));
|
|
|
|
NSZoneII = &ids.get("_NSZone");
|
|
|
|
}
|
|
|
|
|
|
|
|
void transformBody(Stmt *body) {
|
|
|
|
Body = body;
|
|
|
|
// Don't change allocWithZone/copyWithZone messages inside
|
|
|
|
// custom implementations of such methods, it can lead to infinite loops.
|
|
|
|
if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(Dcl)) {
|
|
|
|
Selector sel = MD->getSelector();
|
|
|
|
if (sel == allocWithZoneSel ||
|
|
|
|
sel == copyWithZoneSel ||
|
|
|
|
sel == mutableCopyWithZoneSel ||
|
|
|
|
sel == zoneSel)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
TraverseStmt(body);
|
|
|
|
}
|
|
|
|
|
|
|
|
~AllocCopyWithZoneRewriter() {
|
|
|
|
for (std::vector<DeclStmt *>::reverse_iterator
|
|
|
|
I = NSZoneVars.rbegin(), E = NSZoneVars.rend(); I != E; ++I) {
|
|
|
|
DeclStmt *DS = *I;
|
|
|
|
DeclGroupRef group = DS->getDeclGroup();
|
|
|
|
std::vector<Expr *> varRemovals = Removals;
|
|
|
|
|
|
|
|
bool areAllVarsUnused = true;
|
|
|
|
for (std::reverse_iterator<DeclGroupRef::iterator>
|
|
|
|
DI(group.end()), DE(group.begin()); DI != DE; ++DI) {
|
|
|
|
VarDecl *VD = cast<VarDecl>(*DI);
|
|
|
|
if (isNSZoneVarUsed(VD, varRemovals)) {
|
|
|
|
areAllVarsUnused = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
varRemovals.push_back(VD->getInit());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (areAllVarsUnused) {
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
clearUnavailableDiags(DS);
|
|
|
|
Pass.TA.removeStmt(DS);
|
|
|
|
Removals.swap(varRemovals);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
|
|
|
|
if (!isAllocCopyWithZoneCall(E))
|
|
|
|
return true;
|
|
|
|
Expr *arg = E->getArg(0);
|
|
|
|
if (paramToAllocWithZoneHasSideEffects(arg))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Pass.TA.startTransaction();
|
|
|
|
|
|
|
|
clearUnavailableDiags(arg);
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_unavailable_message,
|
|
|
|
E->getReceiverRange().getBegin());
|
|
|
|
|
|
|
|
Pass.TA.remove(SourceRange(E->getSelectorLoc(), arg->getLocEnd()));
|
|
|
|
StringRef rewrite;
|
|
|
|
if (E->getSelector() == allocWithZoneSel)
|
|
|
|
rewrite = "alloc";
|
|
|
|
else if (E->getSelector() == copyWithZoneSel)
|
|
|
|
rewrite = "copy";
|
|
|
|
else {
|
|
|
|
assert(E->getSelector() == mutableCopyWithZoneSel);
|
|
|
|
rewrite = "mutableCopy";
|
|
|
|
}
|
|
|
|
Pass.TA.insert(E->getSelectorLoc(), rewrite);
|
|
|
|
|
|
|
|
bool failed = Pass.TA.commitTransaction();
|
|
|
|
if (!failed)
|
|
|
|
Removals.push_back(arg);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitDeclStmt(DeclStmt *DS) {
|
|
|
|
DeclGroupRef group = DS->getDeclGroup();
|
|
|
|
if (group.begin() == group.end())
|
|
|
|
return true;
|
|
|
|
for (DeclGroupRef::iterator
|
|
|
|
DI = group.begin(), DE = group.end(); DI != DE; ++DI)
|
|
|
|
if (!isRemovableNSZoneVar(*DI))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
NSZoneVars.push_back(DS);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool isRemovableNSZoneVar(Decl *D) {
|
|
|
|
if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
|
|
|
|
if (isNSZone(VD->getType()))
|
|
|
|
return !paramToAllocWithZoneHasSideEffects(VD->getInit());
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isNSZone(RecordDecl *RD) {
|
|
|
|
return RD && RD->getIdentifier() == NSZoneII;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isNSZone(QualType Ty) {
|
|
|
|
QualType pointee = Ty->getPointeeType();
|
|
|
|
if (pointee.isNull())
|
|
|
|
return false;
|
|
|
|
if (const RecordType *recT = pointee->getAsStructureType())
|
|
|
|
return isNSZone(recT->getDecl());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isNSZoneVarUsed(VarDecl *D, std::vector<Expr *> &removals) {
|
|
|
|
llvm::DenseSet<Expr *> refs;
|
|
|
|
|
|
|
|
ReferenceCollector refColl(refs);
|
|
|
|
refColl.lookFor(D, Body);
|
|
|
|
|
|
|
|
ReferenceClear refClear(refs);
|
|
|
|
refClear.clearRefsIn(removals.begin(), removals.end());
|
|
|
|
|
|
|
|
return !refs.empty();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isAllocCopyWithZoneCall(ObjCMessageExpr *E) {
|
|
|
|
if (E->getNumArgs() == 1 &&
|
|
|
|
E->getSelector() == allocWithZoneSel &&
|
|
|
|
(E->isClassMessage() ||
|
|
|
|
Pass.TA.hasDiagnostic(diag::err_unavailable_message,
|
|
|
|
E->getReceiverRange().getBegin())))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return E->isInstanceMessage() &&
|
|
|
|
E->getNumArgs() == 1 &&
|
|
|
|
(E->getSelector() == copyWithZoneSel ||
|
|
|
|
E->getSelector() == mutableCopyWithZoneSel);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isZoneCall(ObjCMessageExpr *E) {
|
|
|
|
return E->isInstanceMessage() &&
|
|
|
|
E->getNumArgs() == 0 &&
|
|
|
|
E->getSelector() == zoneSel;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool paramToAllocWithZoneHasSideEffects(Expr *E) {
|
|
|
|
if (!HasSideEffects(E, Pass.Ctx))
|
|
|
|
return false;
|
|
|
|
E = E->IgnoreParenCasts();
|
|
|
|
ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E);
|
|
|
|
if (!ME)
|
|
|
|
return true;
|
|
|
|
if (!isZoneCall(ME))
|
|
|
|
return true;
|
|
|
|
return HasSideEffects(ME->getInstanceReceiver(), Pass.Ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
void clearUnavailableDiags(Stmt *S) {
|
|
|
|
if (S)
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_unavailable,
|
|
|
|
diag::err_unavailable_message,
|
|
|
|
S->getSourceRange());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
static void rewriteAllocCopyWithZone(MigrationPass &pass) {
|
|
|
|
BodyTransform<AllocCopyWithZoneRewriter> trans(pass);
|
|
|
|
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// rewriteAutoreleasePool
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// \brief 'Loc' is the end of a statement range. This returns the location
|
|
|
|
/// immediately after the semicolon following the statement.
|
|
|
|
/// If no semicolon is found or the location is inside a macro, the returned
|
|
|
|
/// source location will be invalid.
|
|
|
|
static SourceLocation findLocationAfterSemi(ASTContext &Ctx,
|
|
|
|
SourceLocation loc) {
|
|
|
|
SourceManager &SM = Ctx.getSourceManager();
|
|
|
|
if (loc.isMacroID()) {
|
|
|
|
if (!SM.isAtEndOfMacroInstantiation(loc))
|
|
|
|
return SourceLocation();
|
|
|
|
loc = SM.getInstantiationRange(loc).second;
|
|
|
|
}
|
|
|
|
loc = Lexer::getLocForEndOfToken(loc, /*Offset=*/0, SM, Ctx.getLangOptions());
|
|
|
|
|
|
|
|
// Break down the source location.
|
|
|
|
std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(loc);
|
|
|
|
|
|
|
|
// Try to load the file buffer.
|
|
|
|
bool invalidTemp = false;
|
|
|
|
llvm::StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
|
|
|
|
if (invalidTemp)
|
|
|
|
return SourceLocation();
|
|
|
|
|
|
|
|
const char *tokenBegin = file.data() + locInfo.second;
|
|
|
|
|
|
|
|
// Lex from the start of the given location.
|
|
|
|
Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
|
|
|
|
Ctx.getLangOptions(),
|
|
|
|
file.begin(), tokenBegin, file.end());
|
|
|
|
Token tok;
|
|
|
|
lexer.LexFromRawLexer(tok);
|
|
|
|
if (tok.isNot(tok::semi))
|
|
|
|
return SourceLocation();
|
|
|
|
|
|
|
|
return tok.getLocation().getFileLocWithOffset(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class AutoreleasePoolRewriter
|
|
|
|
: public RecursiveASTVisitor<AutoreleasePoolRewriter> {
|
|
|
|
public:
|
|
|
|
AutoreleasePoolRewriter(Decl *D, MigrationPass &pass)
|
|
|
|
: Dcl(D), Body(0), Pass(pass) {
|
|
|
|
PoolII = &pass.Ctx.Idents.get("NSAutoreleasePool");
|
|
|
|
DrainSel = pass.Ctx.Selectors.getNullarySelector(
|
|
|
|
&pass.Ctx.Idents.get("drain"));
|
|
|
|
}
|
|
|
|
|
|
|
|
void transformBody(Stmt *body) {
|
|
|
|
Body = body;
|
|
|
|
TraverseStmt(body);
|
|
|
|
}
|
|
|
|
|
|
|
|
~AutoreleasePoolRewriter() {
|
|
|
|
llvm::SmallVector<VarDecl *, 8> VarsToHandle;
|
|
|
|
|
|
|
|
for (std::map<VarDecl *, PoolVarInfo>::iterator
|
|
|
|
I = PoolVars.begin(), E = PoolVars.end(); I != E; ++I) {
|
|
|
|
VarDecl *var = I->first;
|
|
|
|
PoolVarInfo &info = I->second;
|
|
|
|
|
|
|
|
// Check that we can handle/rewrite all references of the pool.
|
|
|
|
|
|
|
|
ReferenceClear refClear(info.Refs);
|
|
|
|
refClear.clearRefsIn(info.Dcl);
|
|
|
|
for (llvm::SmallVectorImpl<PoolScope>::iterator
|
|
|
|
scpI = info.Scopes.begin(),
|
|
|
|
scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
|
|
|
|
PoolScope &scope = *scpI;
|
|
|
|
refClear.clearRefsIn(*scope.Begin);
|
|
|
|
refClear.clearRefsIn(*scope.End);
|
|
|
|
refClear.clearRefsIn(scope.Releases.begin(), scope.Releases.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Even if one reference is not handled we will not do anything about that
|
|
|
|
// pool variable.
|
|
|
|
if (info.Refs.empty())
|
|
|
|
VarsToHandle.push_back(var);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = VarsToHandle.size(); i != e; ++i) {
|
|
|
|
PoolVarInfo &info = PoolVars[VarsToHandle[i]];
|
|
|
|
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
|
|
|
|
clearUnavailableDiags(info.Dcl);
|
|
|
|
Pass.TA.removeStmt(info.Dcl);
|
|
|
|
|
|
|
|
// Add "@autoreleasepool { }"
|
|
|
|
for (llvm::SmallVectorImpl<PoolScope>::iterator
|
|
|
|
scpI = info.Scopes.begin(),
|
|
|
|
scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
|
|
|
|
PoolScope &scope = *scpI;
|
|
|
|
clearUnavailableDiags(*scope.Begin);
|
|
|
|
clearUnavailableDiags(*scope.End);
|
|
|
|
if (scope.IsFollowedBySimpleReturnStmt) {
|
|
|
|
// Include the return in the scope.
|
|
|
|
Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {");
|
|
|
|
Pass.TA.removeStmt(*scope.End);
|
|
|
|
Stmt::child_iterator retI = scope.End;
|
|
|
|
++retI;
|
|
|
|
SourceLocation afterSemi = findLocationAfterSemi(Pass.Ctx,
|
|
|
|
(*retI)->getLocEnd());
|
|
|
|
assert(afterSemi.isValid() &&
|
|
|
|
"Didn't we check before setting IsFollowedBySimpleReturnStmt "
|
|
|
|
"to true?");
|
|
|
|
Pass.TA.insertAfterToken(afterSemi, "\n}");
|
|
|
|
Pass.TA.increaseIndentation(
|
|
|
|
SourceRange(scope.getIndentedRange().getBegin(),
|
|
|
|
(*retI)->getLocEnd()),
|
|
|
|
scope.CompoundParent->getLocStart());
|
|
|
|
} else {
|
|
|
|
Pass.TA.replaceStmt(*scope.Begin, "@autoreleasepool {");
|
|
|
|
Pass.TA.replaceStmt(*scope.End, "}");
|
|
|
|
Pass.TA.increaseIndentation(scope.getIndentedRange(),
|
|
|
|
scope.CompoundParent->getLocStart());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove rest of pool var references.
|
|
|
|
for (llvm::SmallVectorImpl<PoolScope>::iterator
|
|
|
|
scpI = info.Scopes.begin(),
|
|
|
|
scpE = info.Scopes.end(); scpI != scpE; ++scpI) {
|
|
|
|
PoolScope &scope = *scpI;
|
|
|
|
for (llvm::SmallVectorImpl<ObjCMessageExpr *>::iterator
|
|
|
|
relI = scope.Releases.begin(),
|
|
|
|
relE = scope.Releases.end(); relI != relE; ++relI) {
|
|
|
|
clearUnavailableDiags(*relI);
|
|
|
|
Pass.TA.removeStmt(*relI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitCompoundStmt(CompoundStmt *S) {
|
|
|
|
llvm::SmallVector<PoolScope, 4> Scopes;
|
|
|
|
|
|
|
|
for (Stmt::child_iterator
|
|
|
|
I = S->body_begin(), E = S->body_end(); I != E; ++I) {
|
|
|
|
Stmt *child = getEssential(*I);
|
|
|
|
if (DeclStmt *DclS = dyn_cast<DeclStmt>(child)) {
|
|
|
|
if (DclS->isSingleDecl()) {
|
|
|
|
if (VarDecl *VD = dyn_cast<VarDecl>(DclS->getSingleDecl())) {
|
|
|
|
if (isNSAutoreleasePool(VD->getType())) {
|
|
|
|
PoolVarInfo &info = PoolVars[VD];
|
|
|
|
info.Dcl = DclS;
|
|
|
|
ReferenceCollector refColl(info.Refs);
|
|
|
|
refColl.lookFor(VD, S);
|
|
|
|
// Does this statement follow the pattern:
|
|
|
|
// NSAutoreleasePool * pool = [NSAutoreleasePool new];
|
|
|
|
if (isPoolCreation(VD->getInit())) {
|
|
|
|
Scopes.push_back(PoolScope());
|
|
|
|
Scopes.back().PoolVar = VD;
|
|
|
|
Scopes.back().CompoundParent = S;
|
|
|
|
Scopes.back().Begin = I;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (BinaryOperator *bop = dyn_cast<BinaryOperator>(child)) {
|
|
|
|
if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(bop->getLHS())) {
|
|
|
|
if (VarDecl *VD = dyn_cast<VarDecl>(dref->getDecl())) {
|
|
|
|
// Does this statement follow the pattern:
|
|
|
|
// pool = [NSAutoreleasePool new];
|
|
|
|
if (isNSAutoreleasePool(VD->getType()) &&
|
|
|
|
isPoolCreation(bop->getRHS())) {
|
|
|
|
Scopes.push_back(PoolScope());
|
|
|
|
Scopes.back().PoolVar = VD;
|
|
|
|
Scopes.back().CompoundParent = S;
|
|
|
|
Scopes.back().Begin = I;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Scopes.empty())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (isPoolDrain(Scopes.back().PoolVar, child)) {
|
|
|
|
PoolScope &scope = Scopes.back();
|
|
|
|
scope.End = I;
|
|
|
|
handlePoolScope(scope, S);
|
|
|
|
Scopes.pop_back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void clearUnavailableDiags(Stmt *S) {
|
|
|
|
if (S)
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_unavailable,
|
|
|
|
diag::err_unavailable_message,
|
|
|
|
S->getSourceRange());
|
|
|
|
}
|
|
|
|
|
|
|
|
struct PoolScope {
|
|
|
|
VarDecl *PoolVar;
|
|
|
|
CompoundStmt *CompoundParent;
|
|
|
|
Stmt::child_iterator Begin;
|
|
|
|
Stmt::child_iterator End;
|
|
|
|
bool IsFollowedBySimpleReturnStmt;
|
|
|
|
llvm::SmallVector<ObjCMessageExpr *, 4> Releases;
|
|
|
|
|
|
|
|
PoolScope() : PoolVar(0), CompoundParent(0), Begin(), End(),
|
|
|
|
IsFollowedBySimpleReturnStmt(false) { }
|
|
|
|
|
|
|
|
SourceRange getIndentedRange() const {
|
|
|
|
Stmt::child_iterator rangeS = Begin;
|
|
|
|
++rangeS;
|
|
|
|
if (rangeS == End)
|
|
|
|
return SourceRange();
|
|
|
|
Stmt::child_iterator rangeE = Begin;
|
|
|
|
for (Stmt::child_iterator I = rangeS; I != End; ++I)
|
|
|
|
++rangeE;
|
|
|
|
return SourceRange((*rangeS)->getLocStart(), (*rangeE)->getLocEnd());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class NameReferenceChecker : public RecursiveASTVisitor<NameReferenceChecker>{
|
|
|
|
ASTContext &Ctx;
|
|
|
|
SourceRange ScopeRange;
|
|
|
|
SourceLocation &referenceLoc, &declarationLoc;
|
|
|
|
|
|
|
|
public:
|
|
|
|
NameReferenceChecker(ASTContext &ctx, PoolScope &scope,
|
|
|
|
SourceLocation &referenceLoc,
|
|
|
|
SourceLocation &declarationLoc)
|
|
|
|
: Ctx(ctx), referenceLoc(referenceLoc),
|
|
|
|
declarationLoc(declarationLoc) {
|
|
|
|
ScopeRange = SourceRange((*scope.Begin)->getLocStart(),
|
|
|
|
(*scope.End)->getLocStart());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitDeclRefExpr(DeclRefExpr *E) {
|
|
|
|
return checkRef(E->getLocation(), E->getDecl()->getLocation());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
|
|
|
|
return checkRef(E->getLocation(), E->getDecl()->getLocation());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
|
|
|
|
return checkRef(TL.getBeginLoc(), TL.getTypedefNameDecl()->getLocation());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitTagTypeLoc(TagTypeLoc TL) {
|
|
|
|
return checkRef(TL.getBeginLoc(), TL.getDecl()->getLocation());
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool checkRef(SourceLocation refLoc, SourceLocation declLoc) {
|
|
|
|
if (isInScope(declLoc)) {
|
|
|
|
referenceLoc = refLoc;
|
|
|
|
declarationLoc = declLoc;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isInScope(SourceLocation loc) {
|
|
|
|
SourceManager &SM = Ctx.getSourceManager();
|
|
|
|
if (SM.isBeforeInTranslationUnit(loc, ScopeRange.getBegin()))
|
|
|
|
return false;
|
|
|
|
return SM.isBeforeInTranslationUnit(loc, ScopeRange.getEnd());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
void handlePoolScope(PoolScope &scope, CompoundStmt *compoundS) {
|
|
|
|
// Check that all names declared inside the scope are not used
|
|
|
|
// outside the scope.
|
|
|
|
{
|
|
|
|
bool nameUsedOutsideScope = false;
|
|
|
|
SourceLocation referenceLoc, declarationLoc;
|
|
|
|
Stmt::child_iterator SI = scope.End, SE = compoundS->body_end();
|
|
|
|
++SI;
|
|
|
|
// Check if the autoreleasepool scope is followed by a simple return
|
|
|
|
// statement, in which case we will include the return in the scope.
|
|
|
|
if (SI != SE)
|
|
|
|
if (ReturnStmt *retS = dyn_cast<ReturnStmt>(*SI))
|
|
|
|
if ((retS->getRetValue() == 0 ||
|
|
|
|
isa<DeclRefExpr>(retS->getRetValue()->IgnoreParenCasts())) &&
|
|
|
|
findLocationAfterSemi(Pass.Ctx, retS->getLocEnd()).isValid()) {
|
|
|
|
scope.IsFollowedBySimpleReturnStmt = true;
|
|
|
|
++SI; // the return will be included in scope, don't check it.
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; SI != SE; ++SI) {
|
|
|
|
nameUsedOutsideScope = !NameReferenceChecker(Pass.Ctx, scope,
|
|
|
|
referenceLoc,
|
|
|
|
declarationLoc).TraverseStmt(*SI);
|
|
|
|
if (nameUsedOutsideScope)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If not all references were cleared it means some variables/typenames/etc
|
|
|
|
// declared inside the pool scope are used outside of it.
|
|
|
|
// We won't try to rewrite the pool.
|
|
|
|
if (nameUsedOutsideScope) {
|
|
|
|
Pass.TA.reportError("a name is referenced outside the "
|
|
|
|
"NSAutoreleasePool scope that it was declared in", referenceLoc);
|
|
|
|
Pass.TA.reportNote("name declared here", declarationLoc);
|
|
|
|
Pass.TA.reportNote("intended @autoreleasepool scope begins here",
|
|
|
|
(*scope.Begin)->getLocStart());
|
|
|
|
Pass.TA.reportNote("intended @autoreleasepool scope ends here",
|
|
|
|
(*scope.End)->getLocStart());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Collect all releases of the pool; they will be removed.
|
|
|
|
{
|
|
|
|
ReleaseCollector releaseColl(scope.PoolVar, scope.Releases);
|
|
|
|
Stmt::child_iterator I = scope.Begin;
|
|
|
|
++I;
|
|
|
|
for (; I != scope.End; ++I)
|
|
|
|
releaseColl.TraverseStmt(*I);
|
|
|
|
}
|
|
|
|
|
|
|
|
PoolVars[scope.PoolVar].Scopes.push_back(scope);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isPoolCreation(Expr *E) {
|
|
|
|
if (!E) return false;
|
|
|
|
E = getEssential(E);
|
|
|
|
ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E);
|
|
|
|
if (!ME) return false;
|
|
|
|
if (ME->getMethodFamily() == OMF_new &&
|
|
|
|
ME->getReceiverKind() == ObjCMessageExpr::Class &&
|
|
|
|
isNSAutoreleasePool(ME->getReceiverInterface()))
|
|
|
|
return true;
|
|
|
|
if (ME->getReceiverKind() == ObjCMessageExpr::Instance &&
|
|
|
|
ME->getMethodFamily() == OMF_init) {
|
|
|
|
Expr *rec = getEssential(ME->getInstanceReceiver());
|
|
|
|
if (ObjCMessageExpr *recME = dyn_cast_or_null<ObjCMessageExpr>(rec)) {
|
|
|
|
if (recME->getMethodFamily() == OMF_alloc &&
|
|
|
|
recME->getReceiverKind() == ObjCMessageExpr::Class &&
|
|
|
|
isNSAutoreleasePool(recME->getReceiverInterface()))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isPoolDrain(VarDecl *poolVar, Stmt *S) {
|
|
|
|
if (!S) return false;
|
|
|
|
S = getEssential(S);
|
|
|
|
ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(S);
|
|
|
|
if (!ME) return false;
|
|
|
|
if (ME->getReceiverKind() == ObjCMessageExpr::Instance) {
|
|
|
|
Expr *rec = getEssential(ME->getInstanceReceiver());
|
|
|
|
if (DeclRefExpr *dref = dyn_cast<DeclRefExpr>(rec))
|
|
|
|
if (dref->getDecl() == poolVar)
|
|
|
|
return ME->getMethodFamily() == OMF_release ||
|
|
|
|
ME->getSelector() == DrainSel;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isNSAutoreleasePool(ObjCInterfaceDecl *IDecl) {
|
|
|
|
return IDecl && IDecl->getIdentifier() == PoolII;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isNSAutoreleasePool(QualType Ty) {
|
|
|
|
QualType pointee = Ty->getPointeeType();
|
|
|
|
if (pointee.isNull())
|
|
|
|
return false;
|
|
|
|
if (const ObjCInterfaceType *interT = pointee->getAs<ObjCInterfaceType>())
|
|
|
|
return isNSAutoreleasePool(interT->getDecl());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Expr *getEssential(Expr *E) {
|
|
|
|
return cast<Expr>(getEssential((Stmt*)E));
|
|
|
|
}
|
|
|
|
static Stmt *getEssential(Stmt *S) {
|
|
|
|
if (ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(S))
|
|
|
|
S = EWC->getSubExpr();
|
|
|
|
if (Expr *E = dyn_cast<Expr>(S))
|
|
|
|
S = E->IgnoreParenCasts();
|
|
|
|
return S;
|
|
|
|
}
|
|
|
|
|
|
|
|
Decl *Dcl;
|
|
|
|
Stmt *Body;
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
IdentifierInfo *PoolII;
|
|
|
|
Selector DrainSel;
|
|
|
|
|
|
|
|
struct PoolVarInfo {
|
|
|
|
DeclStmt *Dcl;
|
|
|
|
llvm::DenseSet<Expr *> Refs;
|
|
|
|
llvm::SmallVector<PoolScope, 2> Scopes;
|
|
|
|
|
|
|
|
PoolVarInfo() : Dcl(0) { }
|
|
|
|
};
|
|
|
|
|
|
|
|
std::map<VarDecl *, PoolVarInfo> PoolVars;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void rewriteAutoreleasePool(MigrationPass &pass) {
|
|
|
|
BodyTransform<AutoreleasePoolRewriter> trans(pass);
|
|
|
|
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// removeRetainReleaseDealloc
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class RetainReleaseDeallocRemover :
|
|
|
|
public RecursiveASTVisitor<RetainReleaseDeallocRemover> {
|
|
|
|
Decl *Dcl;
|
|
|
|
Stmt *Body;
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
llvm::DenseSet<Expr *> Removables;
|
|
|
|
llvm::OwningPtr<ParentMap> StmtMap;
|
|
|
|
|
|
|
|
public:
|
|
|
|
RetainReleaseDeallocRemover(Decl *D, MigrationPass &pass)
|
|
|
|
: Dcl(D), Body(0), Pass(pass) { }
|
|
|
|
|
|
|
|
void transformBody(Stmt *body) {
|
|
|
|
Body = body;
|
|
|
|
RemovablesCollector(Removables).TraverseStmt(body);
|
|
|
|
StmtMap.reset(new ParentMap(body));
|
|
|
|
TraverseStmt(body);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
|
|
|
|
switch (E->getMethodFamily()) {
|
|
|
|
default:
|
|
|
|
return true;
|
|
|
|
case OMF_retain:
|
|
|
|
case OMF_release:
|
|
|
|
case OMF_autorelease:
|
|
|
|
if (E->getReceiverKind() == ObjCMessageExpr::Instance)
|
|
|
|
if (Expr *rec = E->getInstanceReceiver()) {
|
|
|
|
rec = rec->IgnoreParenImpCasts();
|
|
|
|
if (rec->getType().getObjCLifetime() == Qualifiers::OCL_ExplicitNone){
|
|
|
|
std::string err = "It is not safe to remove '";
|
|
|
|
err += E->getSelector().getAsString() + "' message on "
|
|
|
|
"an __unsafe_unretained type";
|
|
|
|
Pass.TA.reportError(err, rec->getLocStart());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case OMF_dealloc:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (E->getReceiverKind()) {
|
|
|
|
default:
|
|
|
|
return true;
|
|
|
|
case ObjCMessageExpr::SuperInstance: {
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
|
|
|
|
diag::err_unavailable,
|
|
|
|
diag::err_unavailable_message,
|
|
|
|
E->getSuperLoc());
|
|
|
|
if (tryRemoving(E))
|
|
|
|
return true;
|
|
|
|
Pass.TA.replace(E->getSourceRange(), "self");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
case ObjCMessageExpr::Instance:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
Expr *rec = E->getInstanceReceiver();
|
|
|
|
if (!rec) return true;
|
|
|
|
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message,
|
|
|
|
diag::err_unavailable,
|
|
|
|
diag::err_unavailable_message,
|
|
|
|
rec->getExprLoc());
|
|
|
|
if (!HasSideEffects(E, Pass.Ctx)) {
|
|
|
|
if (tryRemoving(E))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
Pass.TA.replace(E->getSourceRange(), rec->getSourceRange());
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool isRemovable(Expr *E) const {
|
|
|
|
return Removables.count(E);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool tryRemoving(Expr *E) const {
|
|
|
|
if (isRemovable(E)) {
|
|
|
|
Pass.TA.removeStmt(E);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ParenExpr *parenE = dyn_cast_or_null<ParenExpr>(StmtMap->getParent(E)))
|
|
|
|
return tryRemoving(parenE);
|
|
|
|
|
|
|
|
if (BinaryOperator *
|
|
|
|
bopE = dyn_cast_or_null<BinaryOperator>(StmtMap->getParent(E))) {
|
|
|
|
if (bopE->getOpcode() == BO_Comma && bopE->getLHS() == E &&
|
|
|
|
isRemovable(bopE)) {
|
|
|
|
Pass.TA.replace(bopE->getSourceRange(), bopE->getRHS()->getSourceRange());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void removeRetainReleaseDealloc(MigrationPass &pass) {
|
|
|
|
BodyTransform<RetainReleaseDeallocRemover> trans(pass);
|
|
|
|
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// removeEmptyStatements
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class EmptyStatementsRemover :
|
|
|
|
public RecursiveASTVisitor<EmptyStatementsRemover> {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
llvm::DenseSet<unsigned> MacroLocs;
|
|
|
|
|
|
|
|
public:
|
|
|
|
EmptyStatementsRemover(MigrationPass &pass) : Pass(pass) {
|
|
|
|
for (unsigned i = 0, e = Pass.ARCMTMacroLocs.size(); i != e; ++i)
|
|
|
|
MacroLocs.insert(Pass.ARCMTMacroLocs[i].getRawEncoding());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TraverseStmtExpr(StmtExpr *E) {
|
|
|
|
CompoundStmt *S = E->getSubStmt();
|
|
|
|
for (CompoundStmt::body_iterator
|
|
|
|
I = S->body_begin(), E = S->body_end(); I != E; ++I) {
|
|
|
|
if (I != E - 1)
|
|
|
|
check(*I);
|
|
|
|
TraverseStmt(*I);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitCompoundStmt(CompoundStmt *S) {
|
|
|
|
for (CompoundStmt::body_iterator
|
|
|
|
I = S->body_begin(), E = S->body_end(); I != E; ++I)
|
|
|
|
check(*I);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isMacroLoc(SourceLocation loc) {
|
|
|
|
if (loc.isInvalid()) return false;
|
|
|
|
return MacroLocs.count(loc.getRawEncoding());
|
|
|
|
}
|
|
|
|
|
|
|
|
ASTContext &getContext() { return Pass.Ctx; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
/// \brief Returns true if the statement became empty due to previous
|
|
|
|
/// transformations.
|
|
|
|
class EmptyChecker : public StmtVisitor<EmptyChecker, bool> {
|
|
|
|
EmptyStatementsRemover &Trans;
|
|
|
|
|
|
|
|
public:
|
|
|
|
EmptyChecker(EmptyStatementsRemover &trans) : Trans(trans) { }
|
|
|
|
|
|
|
|
bool VisitNullStmt(NullStmt *S) {
|
|
|
|
return Trans.isMacroLoc(S->getLeadingEmptyMacroLoc());
|
|
|
|
}
|
|
|
|
bool VisitCompoundStmt(CompoundStmt *S) {
|
|
|
|
if (S->body_empty())
|
|
|
|
return false; // was already empty, not because of transformations.
|
|
|
|
for (CompoundStmt::body_iterator
|
|
|
|
I = S->body_begin(), E = S->body_end(); I != E; ++I)
|
|
|
|
if (!Visit(*I))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool VisitIfStmt(IfStmt *S) {
|
|
|
|
if (S->getConditionVariable())
|
|
|
|
return false;
|
|
|
|
Expr *condE = S->getCond();
|
|
|
|
if (!condE)
|
|
|
|
return false;
|
|
|
|
if (HasSideEffects(condE, Trans.getContext()))
|
|
|
|
return false;
|
|
|
|
if (!S->getThen() || !Visit(S->getThen()))
|
|
|
|
return false;
|
|
|
|
if (S->getElse() && !Visit(S->getElse()))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool VisitWhileStmt(WhileStmt *S) {
|
|
|
|
if (S->getConditionVariable())
|
|
|
|
return false;
|
|
|
|
Expr *condE = S->getCond();
|
|
|
|
if (!condE)
|
|
|
|
return false;
|
|
|
|
if (HasSideEffects(condE, Trans.getContext()))
|
|
|
|
return false;
|
|
|
|
if (!S->getBody())
|
|
|
|
return false;
|
|
|
|
return Visit(S->getBody());
|
|
|
|
}
|
|
|
|
bool VisitDoStmt(DoStmt *S) {
|
|
|
|
Expr *condE = S->getCond();
|
|
|
|
if (!condE)
|
|
|
|
return false;
|
|
|
|
if (HasSideEffects(condE, Trans.getContext()))
|
|
|
|
return false;
|
|
|
|
if (!S->getBody())
|
|
|
|
return false;
|
|
|
|
return Visit(S->getBody());
|
|
|
|
}
|
|
|
|
bool VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
|
|
|
|
Expr *Exp = S->getCollection();
|
|
|
|
if (!Exp)
|
|
|
|
return false;
|
|
|
|
if (HasSideEffects(Exp, Trans.getContext()))
|
|
|
|
return false;
|
|
|
|
if (!S->getBody())
|
|
|
|
return false;
|
|
|
|
return Visit(S->getBody());
|
|
|
|
}
|
|
|
|
bool VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
|
|
|
|
if (!S->getSubStmt())
|
|
|
|
return false;
|
|
|
|
return Visit(S->getSubStmt());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
void check(Stmt *S) {
|
|
|
|
if (!S) return;
|
|
|
|
if (EmptyChecker(*this).Visit(S)) {
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.removeStmt(S);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void removeEmptyStatements(MigrationPass &pass) {
|
|
|
|
EmptyStatementsRemover(pass).TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = pass.ARCMTMacroLocs.size(); i != e; ++i) {
|
|
|
|
Transaction Trans(pass.TA);
|
|
|
|
pass.TA.remove(pass.ARCMTMacroLocs[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// changeIvarsOfAssignProperties.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class AssignPropertiesTrans {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
struct PropData {
|
|
|
|
ObjCPropertyDecl *PropD;
|
|
|
|
ObjCIvarDecl *IvarD;
|
|
|
|
bool ShouldChangeToWeak;
|
|
|
|
SourceLocation ArcPropAssignErrorLoc;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef llvm::SmallVector<PropData, 2> PropsTy;
|
|
|
|
typedef llvm::DenseMap<unsigned, PropsTy> PropsMapTy;
|
|
|
|
PropsMapTy PropsMap;
|
|
|
|
|
|
|
|
public:
|
|
|
|
AssignPropertiesTrans(MigrationPass &pass) : Pass(pass) { }
|
|
|
|
|
|
|
|
void doTransform(ObjCImplementationDecl *D) {
|
|
|
|
SourceManager &SM = Pass.Ctx.getSourceManager();
|
|
|
|
|
|
|
|
ObjCInterfaceDecl *IFace = D->getClassInterface();
|
|
|
|
for (ObjCInterfaceDecl::prop_iterator
|
|
|
|
I = IFace->prop_begin(), E = IFace->prop_end(); I != E; ++I) {
|
|
|
|
ObjCPropertyDecl *propD = *I;
|
|
|
|
unsigned loc = SM.getInstantiationLoc(propD->getAtLoc()).getRawEncoding();
|
|
|
|
PropsTy &props = PropsMap[loc];
|
|
|
|
props.push_back(PropData());
|
|
|
|
props.back().PropD = propD;
|
|
|
|
props.back().IvarD = 0;
|
|
|
|
props.back().ShouldChangeToWeak = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef DeclContext::specific_decl_iterator<ObjCPropertyImplDecl>
|
|
|
|
prop_impl_iterator;
|
|
|
|
for (prop_impl_iterator
|
|
|
|
I = prop_impl_iterator(D->decls_begin()),
|
|
|
|
E = prop_impl_iterator(D->decls_end()); I != E; ++I) {
|
|
|
|
VisitObjCPropertyImplDecl(*I);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (PropsMapTy::iterator
|
|
|
|
I = PropsMap.begin(), E = PropsMap.end(); I != E; ++I) {
|
|
|
|
SourceLocation atLoc = SourceLocation::getFromRawEncoding(I->first);
|
|
|
|
PropsTy &props = I->second;
|
|
|
|
if (shouldApplyWeakToAllProp(props)) {
|
|
|
|
if (changeAssignToWeak(atLoc)) {
|
|
|
|
// Couldn't add the 'weak' property attribute,
|
|
|
|
// try adding __unsafe_unretained.
|
|
|
|
applyUnsafeUnretained(props);
|
|
|
|
} else {
|
|
|
|
for (PropsTy::iterator
|
|
|
|
PI = props.begin(), PE = props.end(); PI != PE; ++PI) {
|
|
|
|
applyWeak(*PI);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// We should not add 'weak' attribute since not all properties need it.
|
|
|
|
// So just add __unsafe_unretained to the ivars.
|
|
|
|
applyUnsafeUnretained(props);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool shouldApplyWeakToAllProp(PropsTy &props) {
|
|
|
|
for (PropsTy::iterator
|
|
|
|
PI = props.begin(), PE = props.end(); PI != PE; ++PI) {
|
|
|
|
if (!PI->ShouldChangeToWeak)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void applyWeak(PropData &prop) {
|
|
|
|
assert(!Pass.Ctx.getLangOptions().ObjCNoAutoRefCountRuntime);
|
|
|
|
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.insert(prop.IvarD->getLocation(), "__weak ");
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_arc_assign_property_lifetime,
|
|
|
|
prop.ArcPropAssignErrorLoc);
|
|
|
|
}
|
|
|
|
|
|
|
|
void applyUnsafeUnretained(PropsTy &props) {
|
|
|
|
for (PropsTy::iterator
|
|
|
|
PI = props.begin(), PE = props.end(); PI != PE; ++PI) {
|
|
|
|
if (PI->ShouldChangeToWeak) {
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.insert(PI->IvarD->getLocation(), "__unsafe_unretained ");
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_arc_assign_property_lifetime,
|
|
|
|
PI->ArcPropAssignErrorLoc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
|
|
|
|
SourceManager &SM = Pass.Ctx.getSourceManager();
|
|
|
|
|
|
|
|
if (D->getPropertyImplementation() != ObjCPropertyImplDecl::Synthesize)
|
|
|
|
return true;
|
|
|
|
ObjCPropertyDecl *propD = D->getPropertyDecl();
|
|
|
|
if (!propD || propD->isInvalidDecl())
|
|
|
|
return true;
|
|
|
|
ObjCIvarDecl *ivarD = D->getPropertyIvarDecl();
|
|
|
|
if (!ivarD || ivarD->isInvalidDecl())
|
|
|
|
return true;
|
|
|
|
if (!(propD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_assign))
|
|
|
|
return true;
|
|
|
|
if (isa<AttributedType>(ivarD->getType().getTypePtr()))
|
|
|
|
return true;
|
|
|
|
if (ivarD->getType().getLocalQualifiers().getObjCLifetime()
|
|
|
|
!= Qualifiers::OCL_Strong)
|
|
|
|
return true;
|
|
|
|
if (!Pass.TA.hasDiagnostic(
|
|
|
|
diag::err_arc_assign_property_lifetime, D->getLocation()))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// There is a "error: existing ivar for assign property must be
|
|
|
|
// __unsafe_unretained"; fix it.
|
|
|
|
|
|
|
|
if (Pass.Ctx.getLangOptions().ObjCNoAutoRefCountRuntime) {
|
|
|
|
// We will just add __unsafe_unretained to the ivar.
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.insert(ivarD->getLocation(), "__unsafe_unretained ");
|
|
|
|
Pass.TA.clearDiagnostic(
|
|
|
|
diag::err_arc_assign_property_lifetime, D->getLocation());
|
|
|
|
} else {
|
|
|
|
// Mark that we want the ivar to become weak.
|
|
|
|
unsigned loc = SM.getInstantiationLoc(propD->getAtLoc()).getRawEncoding();
|
|
|
|
PropsTy &props = PropsMap[loc];
|
|
|
|
for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {
|
|
|
|
if (I->PropD == propD) {
|
|
|
|
I->IvarD = ivarD;
|
|
|
|
I->ShouldChangeToWeak = true;
|
|
|
|
I->ArcPropAssignErrorLoc = D->getLocation();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool changeAssignToWeak(SourceLocation atLoc) {
|
|
|
|
SourceManager &SM = Pass.Ctx.getSourceManager();
|
|
|
|
|
|
|
|
// Break down the source location.
|
|
|
|
std::pair<FileID, unsigned> locInfo = SM.getDecomposedLoc(atLoc);
|
|
|
|
|
|
|
|
// Try to load the file buffer.
|
|
|
|
bool invalidTemp = false;
|
|
|
|
llvm::StringRef file = SM.getBufferData(locInfo.first, &invalidTemp);
|
|
|
|
if (invalidTemp)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
const char *tokenBegin = file.data() + locInfo.second;
|
|
|
|
|
|
|
|
// Lex from the start of the given location.
|
|
|
|
Lexer lexer(SM.getLocForStartOfFile(locInfo.first),
|
|
|
|
Pass.Ctx.getLangOptions(),
|
|
|
|
file.begin(), tokenBegin, file.end());
|
|
|
|
Token tok;
|
|
|
|
lexer.LexFromRawLexer(tok);
|
|
|
|
if (tok.isNot(tok::at)) return true;
|
|
|
|
lexer.LexFromRawLexer(tok);
|
|
|
|
if (tok.isNot(tok::raw_identifier)) return true;
|
|
|
|
if (llvm::StringRef(tok.getRawIdentifierData(), tok.getLength())
|
|
|
|
!= "property")
|
|
|
|
return true;
|
|
|
|
lexer.LexFromRawLexer(tok);
|
|
|
|
if (tok.isNot(tok::l_paren)) return true;
|
|
|
|
|
|
|
|
SourceLocation LParen = tok.getLocation();
|
|
|
|
SourceLocation assignLoc;
|
|
|
|
bool isEmpty = false;
|
|
|
|
|
|
|
|
lexer.LexFromRawLexer(tok);
|
|
|
|
if (tok.is(tok::r_paren)) {
|
|
|
|
isEmpty = true;
|
|
|
|
} else {
|
|
|
|
while (1) {
|
|
|
|
if (tok.isNot(tok::raw_identifier)) return true;
|
|
|
|
llvm::StringRef ident(tok.getRawIdentifierData(), tok.getLength());
|
|
|
|
if (ident == "assign")
|
|
|
|
assignLoc = tok.getLocation();
|
|
|
|
|
|
|
|
do {
|
|
|
|
lexer.LexFromRawLexer(tok);
|
|
|
|
} while (tok.isNot(tok::comma) && tok.isNot(tok::r_paren));
|
|
|
|
if (tok.is(tok::r_paren))
|
|
|
|
break;
|
|
|
|
lexer.LexFromRawLexer(tok);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
if (assignLoc.isValid())
|
|
|
|
Pass.TA.replaceText(assignLoc, "assign", "weak");
|
|
|
|
else
|
|
|
|
Pass.TA.insertAfterToken(LParen, isEmpty ? "weak" : "weak, ");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class PropertiesChecker : public RecursiveASTVisitor<PropertiesChecker> {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
public:
|
|
|
|
PropertiesChecker(MigrationPass &pass) : Pass(pass) { }
|
|
|
|
|
|
|
|
bool TraverseObjCImplementationDecl(ObjCImplementationDecl *D) {
|
|
|
|
AssignPropertiesTrans(Pass).doTransform(D);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void changeIvarsOfAssignProperties(MigrationPass &pass) {
|
|
|
|
PropertiesChecker(pass).TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// rewriteUnusedDelegateInit
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class UnusedInitRewriter : public RecursiveASTVisitor<UnusedInitRewriter> {
|
|
|
|
Decl *Dcl;
|
|
|
|
Stmt *Body;
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
llvm::DenseSet<Expr *> Removables;
|
|
|
|
|
|
|
|
public:
|
|
|
|
UnusedInitRewriter(Decl *D, MigrationPass &pass)
|
|
|
|
: Dcl(D), Body(0), Pass(pass) { }
|
|
|
|
|
|
|
|
void transformBody(Stmt *body) {
|
|
|
|
Body = body;
|
|
|
|
RemovablesCollector(Removables).TraverseStmt(body);
|
|
|
|
TraverseStmt(body);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {
|
|
|
|
if (ME->isDelegateInitCall() &&
|
|
|
|
isRemovable(ME) &&
|
|
|
|
Pass.TA.hasDiagnostic(diag::err_arc_unused_init_message,
|
|
|
|
ME->getExprLoc())) {
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.clearDiagnostic(diag::err_arc_unused_init_message,
|
|
|
|
ME->getExprLoc());
|
|
|
|
Pass.TA.insert(ME->getExprLoc(), "self = ");
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool isRemovable(Expr *E) const {
|
|
|
|
return Removables.count(E);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void rewriteUnusedDelegateInit(MigrationPass &pass) {
|
|
|
|
BodyTransform<UnusedInitRewriter> trans(pass);
|
|
|
|
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// rewriteBlockObjCVariable
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class RootBlockObjCVarRewriter :
|
|
|
|
public RecursiveASTVisitor<RootBlockObjCVarRewriter> {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
llvm::DenseSet<VarDecl *> CheckedVars;
|
|
|
|
|
|
|
|
class BlockVarChecker : public RecursiveASTVisitor<BlockVarChecker> {
|
|
|
|
VarDecl *Var;
|
|
|
|
|
|
|
|
typedef RecursiveASTVisitor<BlockVarChecker> base;
|
|
|
|
public:
|
|
|
|
BlockVarChecker(VarDecl *var) : Var(var) { }
|
|
|
|
|
|
|
|
bool TraverseImplicitCastExpr(ImplicitCastExpr *castE) {
|
|
|
|
if (BlockDeclRefExpr *
|
|
|
|
ref = dyn_cast<BlockDeclRefExpr>(castE->getSubExpr())) {
|
|
|
|
if (ref->getDecl() == Var) {
|
|
|
|
if (castE->getCastKind() == CK_LValueToRValue)
|
|
|
|
return true; // Using the value of the variable.
|
|
|
|
if (castE->getCastKind() == CK_NoOp && castE->isLValue() &&
|
|
|
|
Var->getASTContext().getLangOptions().CPlusPlus)
|
|
|
|
return true; // Binding to const C++ reference.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return base::TraverseImplicitCastExpr(castE);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
|
|
|
|
if (E->getDecl() == Var)
|
|
|
|
return false; // The reference of the variable, and not just its value,
|
|
|
|
// is needed.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public:
|
|
|
|
RootBlockObjCVarRewriter(MigrationPass &pass) : Pass(pass) { }
|
|
|
|
|
|
|
|
bool VisitBlockDecl(BlockDecl *block) {
|
|
|
|
llvm::SmallVector<VarDecl *, 4> BlockVars;
|
|
|
|
|
|
|
|
for (BlockDecl::capture_iterator
|
|
|
|
I = block->capture_begin(), E = block->capture_end(); I != E; ++I) {
|
|
|
|
VarDecl *var = I->getVariable();
|
|
|
|
if (I->isByRef() &&
|
|
|
|
!isAlreadyChecked(var) &&
|
|
|
|
var->getType()->isObjCObjectPointerType() &&
|
|
|
|
isImplicitStrong(var->getType())) {
|
|
|
|
BlockVars.push_back(var);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = BlockVars.size(); i != e; ++i) {
|
|
|
|
VarDecl *var = BlockVars[i];
|
|
|
|
CheckedVars.insert(var);
|
|
|
|
|
|
|
|
BlockVarChecker checker(var);
|
|
|
|
bool onlyValueOfVarIsNeeded = checker.TraverseStmt(block->getBody());
|
|
|
|
if (onlyValueOfVarIsNeeded) {
|
|
|
|
BlocksAttr *attr = var->getAttr<BlocksAttr>();
|
|
|
|
if(!attr)
|
|
|
|
continue;
|
|
|
|
bool hasARCRuntime = !Pass.Ctx.getLangOptions().ObjCNoAutoRefCountRuntime;
|
|
|
|
SourceManager &SM = Pass.Ctx.getSourceManager();
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.replaceText(SM.getInstantiationLoc(attr->getLocation()),
|
|
|
|
"__block",
|
|
|
|
hasARCRuntime ? "__weak" : "__unsafe_unretained");
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool isAlreadyChecked(VarDecl *VD) {
|
|
|
|
return CheckedVars.count(VD);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isImplicitStrong(QualType ty) {
|
|
|
|
if (isa<AttributedType>(ty.getTypePtr()))
|
|
|
|
return false;
|
|
|
|
return ty.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class BlockObjCVarRewriter : public RecursiveASTVisitor<BlockObjCVarRewriter> {
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
public:
|
|
|
|
BlockObjCVarRewriter(MigrationPass &pass) : Pass(pass) { }
|
|
|
|
|
|
|
|
bool TraverseBlockDecl(BlockDecl *block) {
|
|
|
|
RootBlockObjCVarRewriter(Pass).TraverseDecl(block);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void rewriteBlockObjCVariable(MigrationPass &pass) {
|
|
|
|
BlockObjCVarRewriter trans(pass);
|
|
|
|
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// removeZeroOutIvarsInDealloc
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
class ZeroOutInDeallocRemover :
|
|
|
|
public RecursiveASTVisitor<ZeroOutInDeallocRemover> {
|
|
|
|
typedef RecursiveASTVisitor<ZeroOutInDeallocRemover> base;
|
|
|
|
|
|
|
|
MigrationPass &Pass;
|
|
|
|
|
|
|
|
llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*> SynthesizedProperties;
|
|
|
|
ImplicitParamDecl *SelfD;
|
|
|
|
llvm::DenseSet<Expr *> Removables;
|
|
|
|
|
|
|
|
public:
|
|
|
|
ZeroOutInDeallocRemover(MigrationPass &pass) : Pass(pass), SelfD(0) { }
|
|
|
|
|
|
|
|
bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {
|
|
|
|
ASTContext &Ctx = Pass.Ctx;
|
|
|
|
TransformActions &TA = Pass.TA;
|
|
|
|
|
|
|
|
if (ME->getReceiverKind() != ObjCMessageExpr::Instance)
|
|
|
|
return true;
|
|
|
|
Expr *receiver = ME->getInstanceReceiver();
|
|
|
|
if (!receiver)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
DeclRefExpr *refE = dyn_cast<DeclRefExpr>(receiver->IgnoreParenCasts());
|
|
|
|
if (!refE || refE->getDecl() != SelfD)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
bool BackedBySynthesizeSetter = false;
|
|
|
|
for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
|
|
|
|
P = SynthesizedProperties.begin(),
|
|
|
|
E = SynthesizedProperties.end(); P != E; ++P) {
|
|
|
|
ObjCPropertyDecl *PropDecl = P->first;
|
|
|
|
if (PropDecl->getSetterName() == ME->getSelector()) {
|
|
|
|
BackedBySynthesizeSetter = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!BackedBySynthesizeSetter)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Remove the setter message if RHS is null
|
|
|
|
Transaction Trans(TA);
|
|
|
|
Expr *RHS = ME->getArg(0);
|
|
|
|
bool RHSIsNull =
|
|
|
|
RHS->isNullPointerConstant(Ctx,
|
|
|
|
Expr::NPC_ValueDependentIsNull);
|
|
|
|
if (RHSIsNull && isRemovable(ME))
|
|
|
|
TA.removeStmt(ME);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool VisitBinaryOperator(BinaryOperator *BOE) {
|
|
|
|
if (isZeroingPropIvar(BOE) && isRemovable(BOE)) {
|
|
|
|
Transaction Trans(Pass.TA);
|
|
|
|
Pass.TA.removeStmt(BOE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TraverseObjCMethodDecl(ObjCMethodDecl *D) {
|
|
|
|
if (D->getMethodFamily() != OMF_dealloc)
|
|
|
|
return true;
|
|
|
|
if (!D->hasBody())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(D->getDeclContext());
|
|
|
|
if (!IMD)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
SelfD = D->getSelfDecl();
|
|
|
|
RemovablesCollector(Removables).TraverseStmt(D->getBody());
|
|
|
|
|
|
|
|
// For a 'dealloc' method use, find all property implementations in
|
|
|
|
// this class implementation.
|
|
|
|
for (ObjCImplDecl::propimpl_iterator
|
|
|
|
I = IMD->propimpl_begin(), EI = IMD->propimpl_end(); I != EI; ++I) {
|
|
|
|
ObjCPropertyImplDecl *PID = *I;
|
|
|
|
if (PID->getPropertyImplementation() ==
|
|
|
|
ObjCPropertyImplDecl::Synthesize) {
|
|
|
|
ObjCPropertyDecl *PD = PID->getPropertyDecl();
|
|
|
|
ObjCMethodDecl *setterM = PD->getSetterMethodDecl();
|
|
|
|
if (!(setterM && setterM->isDefined())) {
|
|
|
|
ObjCPropertyDecl::PropertyAttributeKind AttrKind =
|
|
|
|
PD->getPropertyAttributes();
|
|
|
|
if (AttrKind &
|
|
|
|
(ObjCPropertyDecl::OBJC_PR_retain |
|
|
|
|
ObjCPropertyDecl::OBJC_PR_copy |
|
|
|
|
ObjCPropertyDecl::OBJC_PR_strong))
|
|
|
|
SynthesizedProperties[PD] = PID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now, remove all zeroing of ivars etc.
|
|
|
|
base::TraverseObjCMethodDecl(D);
|
|
|
|
|
|
|
|
// clear out for next method.
|
|
|
|
SynthesizedProperties.clear();
|
|
|
|
SelfD = 0;
|
|
|
|
Removables.clear();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TraverseFunctionDecl(FunctionDecl *D) { return true; }
|
|
|
|
bool TraverseBlockDecl(BlockDecl *block) { return true; }
|
|
|
|
bool TraverseBlockExpr(BlockExpr *block) { return true; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool isRemovable(Expr *E) const {
|
|
|
|
return Removables.count(E);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isZeroingPropIvar(Expr *E) {
|
|
|
|
BinaryOperator *BOE = dyn_cast_or_null<BinaryOperator>(E);
|
|
|
|
if (!BOE) return false;
|
|
|
|
|
|
|
|
if (BOE->getOpcode() == BO_Comma)
|
|
|
|
return isZeroingPropIvar(BOE->getLHS()) &&
|
|
|
|
isZeroingPropIvar(BOE->getRHS());
|
|
|
|
|
|
|
|
if (BOE->getOpcode() != BO_Assign)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ASTContext &Ctx = Pass.Ctx;
|
|
|
|
|
|
|
|
Expr *LHS = BOE->getLHS();
|
|
|
|
if (ObjCIvarRefExpr *IV = dyn_cast<ObjCIvarRefExpr>(LHS)) {
|
|
|
|
ObjCIvarDecl *IVDecl = IV->getDecl();
|
|
|
|
if (!IVDecl->getType()->isObjCObjectPointerType())
|
|
|
|
return false;
|
|
|
|
bool IvarBacksPropertySynthesis = false;
|
|
|
|
for (llvm::DenseMap<ObjCPropertyDecl*, ObjCPropertyImplDecl*>::iterator
|
|
|
|
P = SynthesizedProperties.begin(),
|
|
|
|
E = SynthesizedProperties.end(); P != E; ++P) {
|
|
|
|
ObjCPropertyImplDecl *PropImpDecl = P->second;
|
|
|
|
if (PropImpDecl && PropImpDecl->getPropertyIvarDecl() == IVDecl) {
|
|
|
|
IvarBacksPropertySynthesis = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!IvarBacksPropertySynthesis)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if (ObjCPropertyRefExpr *PropRefExp = dyn_cast<ObjCPropertyRefExpr>(LHS)) {
|
|
|
|
// TODO: Using implicit property decl.
|
|
|
|
if (PropRefExp->isImplicitProperty())
|
|
|
|
return false;
|
|
|
|
if (ObjCPropertyDecl *PDecl = PropRefExp->getExplicitProperty()) {
|
|
|
|
if (!SynthesizedProperties.count(PDecl))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Expr *RHS = BOE->getRHS();
|
|
|
|
bool RHSIsNull = RHS->isNullPointerConstant(Ctx,
|
|
|
|
Expr::NPC_ValueDependentIsNull);
|
|
|
|
if (RHSIsNull)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return isZeroingPropIvar(RHS);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
|
|
static void removeZeroOutIvarsInDealloc(MigrationPass &pass) {
|
|
|
|
ZeroOutInDeallocRemover trans(pass);
|
|
|
|
trans.TraverseDecl(pass.Ctx.getTranslationUnitDecl());
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// getAllTransformations.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
static void independentTransforms(MigrationPass &pass) {
|
|
|
|
rewriteAutoreleasePool(pass);
|
|
|
|
changeIvarsOfAssignProperties(pass);
|
|
|
|
removeRetainReleaseDealloc(pass);
|
|
|
|
rewriteUnusedDelegateInit(pass);
|
|
|
|
removeZeroOutIvarsInDealloc(pass);
|
|
|
|
makeAssignARCSafe(pass);
|
|
|
|
castNonObjCToObjC(pass);
|
|
|
|
rewriteBlockObjCVariable(pass);
|
|
|
|
rewriteAllocCopyWithZone(pass);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<TransformFn> arcmt::getAllTransformations() {
|
|
|
|
std::vector<TransformFn> transforms;
|
|
|
|
|
|
|
|
// This must come first since rewriteAutoreleasePool depends on -release
|
|
|
|
// calls being present to determine the @autorelease ending scope.
|
|
|
|
transforms.push_back(independentTransforms);
|
|
|
|
|
|
|
|
transforms.push_back(removeEmptyStatements);
|
|
|
|
transforms.push_back(removeDeallocMethod);
|
|
|
|
|
|
|
|
return transforms;
|
|
|
|
}
|