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