1 //===--- TransEmptyStatements.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 // removeEmptyStatementsAndDealloc:
11 //
12 // Removes empty statements that are leftovers from previous transformations.
13 // e.g for
14 //
15 // [x retain];
16 //
17 // removeRetainReleaseDealloc will leave an empty ";" that removeEmptyStatements
18 // will remove.
19 //
20 //===----------------------------------------------------------------------===//
21
22 #include "Transforms.h"
23 #include "Internals.h"
24 #include "clang/AST/ASTContext.h"
25 #include "clang/AST/StmtVisitor.h"
26 #include "clang/Basic/SourceManager.h"
27
28 using namespace clang;
29 using namespace arcmt;
30 using namespace trans;
31
isEmptyARCMTMacroStatement(NullStmt * S,std::vector<SourceLocation> & MacroLocs,ASTContext & Ctx)32 static bool isEmptyARCMTMacroStatement(NullStmt *S,
33 std::vector<SourceLocation> &MacroLocs,
34 ASTContext &Ctx) {
35 if (!S->hasLeadingEmptyMacro())
36 return false;
37
38 SourceLocation SemiLoc = S->getSemiLoc();
39 if (SemiLoc.isInvalid() || SemiLoc.isMacroID())
40 return false;
41
42 if (MacroLocs.empty())
43 return false;
44
45 SourceManager &SM = Ctx.getSourceManager();
46 std::vector<SourceLocation>::iterator
47 I = std::upper_bound(MacroLocs.begin(), MacroLocs.end(), SemiLoc,
48 BeforeThanCompare<SourceLocation>(SM));
49 --I;
50 SourceLocation
51 AfterMacroLoc = I->getLocWithOffset(getARCMTMacroName().size());
52 assert(AfterMacroLoc.isFileID());
53
54 if (AfterMacroLoc == SemiLoc)
55 return true;
56
57 int RelOffs = 0;
58 if (!SM.isInSameSLocAddrSpace(AfterMacroLoc, SemiLoc, &RelOffs))
59 return false;
60 if (RelOffs < 0)
61 return false;
62
63 // We make the reasonable assumption that a semicolon after 100 characters
64 // means that it is not the next token after our macro. If this assumption
65 // fails it is not critical, we will just fail to clear out, e.g., an empty
66 // 'if'.
67 if (RelOffs - getARCMTMacroName().size() > 100)
68 return false;
69
70 SourceLocation AfterMacroSemiLoc = findSemiAfterLocation(AfterMacroLoc, Ctx);
71 return AfterMacroSemiLoc == SemiLoc;
72 }
73
74 namespace {
75
76 /// \brief Returns true if the statement became empty due to previous
77 /// transformations.
78 class EmptyChecker : public StmtVisitor<EmptyChecker, bool> {
79 ASTContext &Ctx;
80 std::vector<SourceLocation> &MacroLocs;
81
82 public:
EmptyChecker(ASTContext & ctx,std::vector<SourceLocation> & macroLocs)83 EmptyChecker(ASTContext &ctx, std::vector<SourceLocation> ¯oLocs)
84 : Ctx(ctx), MacroLocs(macroLocs) { }
85
VisitNullStmt(NullStmt * S)86 bool VisitNullStmt(NullStmt *S) {
87 return isEmptyARCMTMacroStatement(S, MacroLocs, Ctx);
88 }
VisitCompoundStmt(CompoundStmt * S)89 bool VisitCompoundStmt(CompoundStmt *S) {
90 if (S->body_empty())
91 return false; // was already empty, not because of transformations.
92 for (auto *I : S->body())
93 if (!Visit(I))
94 return false;
95 return true;
96 }
VisitIfStmt(IfStmt * S)97 bool VisitIfStmt(IfStmt *S) {
98 if (S->getConditionVariable())
99 return false;
100 Expr *condE = S->getCond();
101 if (!condE)
102 return false;
103 if (hasSideEffects(condE, Ctx))
104 return false;
105 if (!S->getThen() || !Visit(S->getThen()))
106 return false;
107 return !S->getElse() || Visit(S->getElse());
108 }
VisitWhileStmt(WhileStmt * S)109 bool VisitWhileStmt(WhileStmt *S) {
110 if (S->getConditionVariable())
111 return false;
112 Expr *condE = S->getCond();
113 if (!condE)
114 return false;
115 if (hasSideEffects(condE, Ctx))
116 return false;
117 if (!S->getBody())
118 return false;
119 return Visit(S->getBody());
120 }
VisitDoStmt(DoStmt * S)121 bool VisitDoStmt(DoStmt *S) {
122 Expr *condE = S->getCond();
123 if (!condE)
124 return false;
125 if (hasSideEffects(condE, Ctx))
126 return false;
127 if (!S->getBody())
128 return false;
129 return Visit(S->getBody());
130 }
VisitObjCForCollectionStmt(ObjCForCollectionStmt * S)131 bool VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
132 Expr *Exp = S->getCollection();
133 if (!Exp)
134 return false;
135 if (hasSideEffects(Exp, Ctx))
136 return false;
137 if (!S->getBody())
138 return false;
139 return Visit(S->getBody());
140 }
VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt * S)141 bool VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
142 if (!S->getSubStmt())
143 return false;
144 return Visit(S->getSubStmt());
145 }
146 };
147
148 class EmptyStatementsRemover :
149 public RecursiveASTVisitor<EmptyStatementsRemover> {
150 MigrationPass &Pass;
151
152 public:
EmptyStatementsRemover(MigrationPass & pass)153 EmptyStatementsRemover(MigrationPass &pass) : Pass(pass) { }
154
TraverseStmtExpr(StmtExpr * E)155 bool TraverseStmtExpr(StmtExpr *E) {
156 CompoundStmt *S = E->getSubStmt();
157 for (CompoundStmt::body_iterator
158 I = S->body_begin(), E = S->body_end(); I != E; ++I) {
159 if (I != E - 1)
160 check(*I);
161 TraverseStmt(*I);
162 }
163 return true;
164 }
165
VisitCompoundStmt(CompoundStmt * S)166 bool VisitCompoundStmt(CompoundStmt *S) {
167 for (auto *I : S->body())
168 check(I);
169 return true;
170 }
171
getContext()172 ASTContext &getContext() { return Pass.Ctx; }
173
174 private:
check(Stmt * S)175 void check(Stmt *S) {
176 if (!S) return;
177 if (EmptyChecker(Pass.Ctx, Pass.ARCMTMacroLocs).Visit(S)) {
178 Transaction Trans(Pass.TA);
179 Pass.TA.removeStmt(S);
180 }
181 }
182 };
183
184 } // anonymous namespace
185
isBodyEmpty(CompoundStmt * body,ASTContext & Ctx,std::vector<SourceLocation> & MacroLocs)186 static bool isBodyEmpty(CompoundStmt *body, ASTContext &Ctx,
187 std::vector<SourceLocation> &MacroLocs) {
188 for (auto *I : body->body())
189 if (!EmptyChecker(Ctx, MacroLocs).Visit(I))
190 return false;
191
192 return true;
193 }
194
cleanupDeallocOrFinalize(MigrationPass & pass)195 static void cleanupDeallocOrFinalize(MigrationPass &pass) {
196 ASTContext &Ctx = pass.Ctx;
197 TransformActions &TA = pass.TA;
198 DeclContext *DC = Ctx.getTranslationUnitDecl();
199 Selector FinalizeSel =
200 Ctx.Selectors.getNullarySelector(&pass.Ctx.Idents.get("finalize"));
201
202 typedef DeclContext::specific_decl_iterator<ObjCImplementationDecl>
203 impl_iterator;
204 for (impl_iterator I = impl_iterator(DC->decls_begin()),
205 E = impl_iterator(DC->decls_end()); I != E; ++I) {
206 ObjCMethodDecl *DeallocM = nullptr;
207 ObjCMethodDecl *FinalizeM = nullptr;
208 for (auto *MD : I->instance_methods()) {
209 if (!MD->hasBody())
210 continue;
211
212 if (MD->getMethodFamily() == OMF_dealloc) {
213 DeallocM = MD;
214 } else if (MD->isInstanceMethod() && MD->getSelector() == FinalizeSel) {
215 FinalizeM = MD;
216 }
217 }
218
219 if (DeallocM) {
220 if (isBodyEmpty(DeallocM->getCompoundBody(), Ctx, pass.ARCMTMacroLocs)) {
221 Transaction Trans(TA);
222 TA.remove(DeallocM->getSourceRange());
223 }
224
225 if (FinalizeM) {
226 Transaction Trans(TA);
227 TA.remove(FinalizeM->getSourceRange());
228 }
229
230 } else if (FinalizeM) {
231 if (isBodyEmpty(FinalizeM->getCompoundBody(), Ctx, pass.ARCMTMacroLocs)) {
232 Transaction Trans(TA);
233 TA.remove(FinalizeM->getSourceRange());
234 } else {
235 Transaction Trans(TA);
236 TA.replaceText(FinalizeM->getSelectorStartLoc(), "finalize", "dealloc");
237 }
238 }
239 }
240 }
241
removeEmptyStatementsAndDeallocFinalize(MigrationPass & pass)242 void trans::removeEmptyStatementsAndDeallocFinalize(MigrationPass &pass) {
243 EmptyStatementsRemover(pass).TraverseDecl(pass.Ctx.getTranslationUnitDecl());
244
245 cleanupDeallocOrFinalize(pass);
246
247 for (unsigned i = 0, e = pass.ARCMTMacroLocs.size(); i != e; ++i) {
248 Transaction Trans(pass.TA);
249 pass.TA.remove(pass.ARCMTMacroLocs[i]);
250 }
251 }
252