/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/ARCMigrate/ARCMT.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- ARCMT.cpp - Migration 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 | | #include "Internals.h" |
10 | | #include "clang/ARCMigrate/ARCMT.h" |
11 | | #include "clang/AST/ASTConsumer.h" |
12 | | #include "clang/Basic/DiagnosticCategories.h" |
13 | | #include "clang/Frontend/ASTUnit.h" |
14 | | #include "clang/Frontend/CompilerInstance.h" |
15 | | #include "clang/Frontend/FrontendAction.h" |
16 | | #include "clang/Frontend/TextDiagnosticPrinter.h" |
17 | | #include "clang/Frontend/Utils.h" |
18 | | #include "clang/Lex/Preprocessor.h" |
19 | | #include "clang/Lex/PreprocessorOptions.h" |
20 | | #include "clang/Rewrite/Core/Rewriter.h" |
21 | | #include "clang/Sema/SemaDiagnostic.h" |
22 | | #include "clang/Serialization/ASTReader.h" |
23 | | #include "llvm/ADT/Triple.h" |
24 | | #include "llvm/Support/MemoryBuffer.h" |
25 | | #include <utility> |
26 | | using namespace clang; |
27 | | using namespace arcmt; |
28 | | |
29 | | bool CapturedDiagList::clearDiagnostic(ArrayRef<unsigned> IDs, |
30 | 484 | SourceRange range) { |
31 | 484 | if (range.isInvalid()) |
32 | 0 | return false; |
33 | | |
34 | 484 | bool cleared = false; |
35 | 484 | ListTy::iterator I = List.begin(); |
36 | 8.88k | while (I != List.end()) { |
37 | 8.40k | FullSourceLoc diagLoc = I->getLocation(); |
38 | 8.40k | if ((IDs.empty() || // empty means clear all diagnostics in the range. |
39 | 8.40k | llvm::is_contained(IDs, I->getID())) && |
40 | 3.63k | !diagLoc.isBeforeInTranslationUnitThan(range.getBegin()) && |
41 | 3.30k | (diagLoc == range.getEnd() || |
42 | 2.74k | diagLoc.isBeforeInTranslationUnitThan(range.getEnd()))) { |
43 | 621 | cleared = true; |
44 | 621 | ListTy::iterator eraseS = I++; |
45 | 621 | if (eraseS->getLevel() != DiagnosticsEngine::Note) |
46 | 970 | while (596 I != List.end() && I->getLevel() == DiagnosticsEngine::Note884 ) |
47 | 374 | ++I; |
48 | | // Clear the diagnostic and any notes following it. |
49 | 621 | I = List.erase(eraseS, I); |
50 | 621 | continue; |
51 | 621 | } |
52 | | |
53 | 7.78k | ++I; |
54 | 7.78k | } |
55 | | |
56 | 484 | return cleared; |
57 | 484 | } |
58 | | |
59 | | bool CapturedDiagList::hasDiagnostic(ArrayRef<unsigned> IDs, |
60 | 810 | SourceRange range) const { |
61 | 810 | if (range.isInvalid()) |
62 | 0 | return false; |
63 | | |
64 | 810 | ListTy::const_iterator I = List.begin(); |
65 | 5.55k | while (I != List.end()) { |
66 | 5.29k | FullSourceLoc diagLoc = I->getLocation(); |
67 | 5.29k | if ((IDs.empty() || // empty means any diagnostic in the range. |
68 | 5.29k | llvm::find(IDs, I->getID()) != IDs.end()) && |
69 | 1.33k | !diagLoc.isBeforeInTranslationUnitThan(range.getBegin()) && |
70 | 876 | (diagLoc == range.getEnd() || |
71 | 550 | diagLoc.isBeforeInTranslationUnitThan(range.getEnd())382 )) { |
72 | 550 | return true; |
73 | 550 | } |
74 | | |
75 | 4.74k | ++I; |
76 | 4.74k | } |
77 | | |
78 | 260 | return false; |
79 | 810 | } |
80 | | |
81 | 51 | void CapturedDiagList::reportDiagnostics(DiagnosticsEngine &Diags) const { |
82 | 201 | for (ListTy::const_iterator I = List.begin(), E = List.end(); I != E; ++I150 ) |
83 | 150 | Diags.Report(*I); |
84 | 51 | } |
85 | | |
86 | 88 | bool CapturedDiagList::hasErrors() const { |
87 | 88 | for (ListTy::const_iterator I = List.begin(), E = List.end(); I != E; ++I0 ) |
88 | 43 | if (I->getLevel() >= DiagnosticsEngine::Error) |
89 | 43 | return true; |
90 | | |
91 | 45 | return false; |
92 | 88 | } |
93 | | |
94 | | namespace { |
95 | | |
96 | | class CaptureDiagnosticConsumer : public DiagnosticConsumer { |
97 | | DiagnosticsEngine &Diags; |
98 | | DiagnosticConsumer &DiagClient; |
99 | | CapturedDiagList &CapturedDiags; |
100 | | bool HasBegunSourceFile; |
101 | | public: |
102 | | CaptureDiagnosticConsumer(DiagnosticsEngine &diags, |
103 | | DiagnosticConsumer &client, |
104 | | CapturedDiagList &capturedDiags) |
105 | | : Diags(diags), DiagClient(client), CapturedDiags(capturedDiags), |
106 | 122 | HasBegunSourceFile(false) { } |
107 | | |
108 | | void BeginSourceFile(const LangOptions &Opts, |
109 | 122 | const Preprocessor *PP) override { |
110 | | // Pass BeginSourceFile message onto DiagClient on first call. |
111 | | // The corresponding EndSourceFile call will be made from an |
112 | | // explicit call to FinishCapture. |
113 | 122 | if (!HasBegunSourceFile) { |
114 | 122 | DiagClient.BeginSourceFile(Opts, PP); |
115 | 122 | HasBegunSourceFile = true; |
116 | 122 | } |
117 | 122 | } |
118 | | |
119 | 122 | void FinishCapture() { |
120 | | // Call EndSourceFile on DiagClient on completion of capture to |
121 | | // enable VerifyDiagnosticConsumer to check diagnostics *after* |
122 | | // it has received the diagnostic list. |
123 | 122 | if (HasBegunSourceFile) { |
124 | 122 | DiagClient.EndSourceFile(); |
125 | 122 | HasBegunSourceFile = false; |
126 | 122 | } |
127 | 122 | } |
128 | | |
129 | 122 | ~CaptureDiagnosticConsumer() override { |
130 | 122 | assert(!HasBegunSourceFile && "FinishCapture not called!"); |
131 | 122 | } |
132 | | |
133 | | void HandleDiagnostic(DiagnosticsEngine::Level level, |
134 | 1.26k | const Diagnostic &Info) override { |
135 | 1.26k | if (DiagnosticIDs::isARCDiagnostic(Info.getID()) || |
136 | 1.18k | level >= DiagnosticsEngine::Error590 || level == DiagnosticsEngine::Note367 ) { |
137 | 1.18k | if (Info.getLocation().isValid()) |
138 | 1.18k | CapturedDiags.push_back(StoredDiagnostic(level, Info)); |
139 | 1.18k | return; |
140 | 1.18k | } |
141 | | |
142 | | // Non-ARC warnings are ignored. |
143 | 82 | Diags.setLastDiagnosticIgnored(true); |
144 | 82 | } |
145 | | }; |
146 | | |
147 | | } // end anonymous namespace |
148 | | |
149 | 122 | static bool HasARCRuntime(CompilerInvocation &origCI) { |
150 | | // This duplicates some functionality from Darwin::AddDeploymentTarget |
151 | | // but this function is well defined, so keep it decoupled from the driver |
152 | | // and avoid unrelated complications. |
153 | 122 | llvm::Triple triple(origCI.getTargetOpts().Triple); |
154 | | |
155 | 122 | if (triple.isiOS()) |
156 | 0 | return triple.getOSMajorVersion() >= 5; |
157 | | |
158 | 122 | if (triple.isWatchOS()) |
159 | 0 | return true; |
160 | | |
161 | 122 | if (triple.getOS() == llvm::Triple::Darwin) |
162 | 94 | return triple.getOSMajorVersion() >= 11; |
163 | | |
164 | 28 | if (triple.getOS() == llvm::Triple::MacOSX) { |
165 | 28 | unsigned Major, Minor, Micro; |
166 | 28 | triple.getOSVersion(Major, Minor, Micro); |
167 | 28 | return Major > 10 || (Major == 10 && Minor >= 7); |
168 | 28 | } |
169 | | |
170 | 0 | return false; |
171 | 0 | } |
172 | | |
173 | | static CompilerInvocation * |
174 | | createInvocationForMigration(CompilerInvocation &origCI, |
175 | 122 | const PCHContainerReader &PCHContainerRdr) { |
176 | 122 | std::unique_ptr<CompilerInvocation> CInvok; |
177 | 122 | CInvok.reset(new CompilerInvocation(origCI)); |
178 | 122 | PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts(); |
179 | 122 | if (!PPOpts.ImplicitPCHInclude.empty()) { |
180 | | // We can't use a PCH because it was likely built in non-ARC mode and we |
181 | | // want to parse in ARC. Include the original header. |
182 | 7 | FileManager FileMgr(origCI.getFileSystemOpts()); |
183 | 7 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
184 | 7 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
185 | 7 | new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(), |
186 | 7 | new IgnoringDiagConsumer())); |
187 | 7 | std::string OriginalFile = ASTReader::getOriginalSourceFile( |
188 | 7 | PPOpts.ImplicitPCHInclude, FileMgr, PCHContainerRdr, *Diags); |
189 | 7 | if (!OriginalFile.empty()) |
190 | 7 | PPOpts.Includes.insert(PPOpts.Includes.begin(), OriginalFile); |
191 | 7 | PPOpts.ImplicitPCHInclude.clear(); |
192 | 7 | } |
193 | 122 | std::string define = std::string(getARCMTMacroName()); |
194 | 122 | define += '='; |
195 | 122 | CInvok->getPreprocessorOpts().addMacroDef(define); |
196 | 122 | CInvok->getLangOpts()->ObjCAutoRefCount = true; |
197 | 122 | CInvok->getLangOpts()->setGC(LangOptions::NonGC); |
198 | 122 | CInvok->getDiagnosticOpts().ErrorLimit = 0; |
199 | 122 | CInvok->getDiagnosticOpts().PedanticErrors = 0; |
200 | | |
201 | | // Ignore -Werror flags when migrating. |
202 | 122 | std::vector<std::string> WarnOpts; |
203 | 122 | for (std::vector<std::string>::iterator |
204 | 122 | I = CInvok->getDiagnosticOpts().Warnings.begin(), |
205 | 125 | E = CInvok->getDiagnosticOpts().Warnings.end(); I != E; ++I3 ) { |
206 | 3 | if (!StringRef(*I).startswith("error")) |
207 | 0 | WarnOpts.push_back(*I); |
208 | 3 | } |
209 | 122 | WarnOpts.push_back("error=arc-unsafe-retained-assign"); |
210 | 122 | CInvok->getDiagnosticOpts().Warnings = std::move(WarnOpts); |
211 | | |
212 | 122 | CInvok->getLangOpts()->ObjCWeakRuntime = HasARCRuntime(origCI); |
213 | 122 | CInvok->getLangOpts()->ObjCWeak = CInvok->getLangOpts()->ObjCWeakRuntime; |
214 | | |
215 | 122 | return CInvok.release(); |
216 | 122 | } |
217 | | |
218 | | static void emitPremigrationErrors(const CapturedDiagList &arcDiags, |
219 | | DiagnosticOptions *diagOpts, |
220 | 1 | Preprocessor &PP) { |
221 | 1 | TextDiagnosticPrinter printer(llvm::errs(), diagOpts); |
222 | 1 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
223 | 1 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
224 | 1 | new DiagnosticsEngine(DiagID, diagOpts, &printer, |
225 | 1 | /*ShouldOwnClient=*/false)); |
226 | 1 | Diags->setSourceManager(&PP.getSourceManager()); |
227 | | |
228 | 1 | printer.BeginSourceFile(PP.getLangOpts(), &PP); |
229 | 1 | arcDiags.reportDiagnostics(*Diags); |
230 | 1 | printer.EndSourceFile(); |
231 | 1 | } |
232 | | |
233 | | //===----------------------------------------------------------------------===// |
234 | | // checkForManualIssues. |
235 | | //===----------------------------------------------------------------------===// |
236 | | |
237 | | bool arcmt::checkForManualIssues( |
238 | | CompilerInvocation &origCI, const FrontendInputFile &Input, |
239 | | std::shared_ptr<PCHContainerOperations> PCHContainerOps, |
240 | | DiagnosticConsumer *DiagClient, bool emitPremigrationARCErrors, |
241 | 51 | StringRef plistOut) { |
242 | 51 | if (!origCI.getLangOpts()->ObjC) |
243 | 1 | return false; |
244 | | |
245 | 50 | LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC(); |
246 | 50 | bool NoNSAllocReallocError = origCI.getMigratorOpts().NoNSAllocReallocError; |
247 | 50 | bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval; |
248 | | |
249 | 50 | std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode, |
250 | 50 | NoFinalizeRemoval); |
251 | 50 | assert(!transforms.empty()); |
252 | | |
253 | 50 | std::unique_ptr<CompilerInvocation> CInvok; |
254 | 50 | CInvok.reset( |
255 | 50 | createInvocationForMigration(origCI, PCHContainerOps->getRawReader())); |
256 | 50 | CInvok->getFrontendOpts().Inputs.clear(); |
257 | 50 | CInvok->getFrontendOpts().Inputs.push_back(Input); |
258 | | |
259 | 50 | CapturedDiagList capturedDiags; |
260 | | |
261 | 50 | assert(DiagClient); |
262 | 50 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
263 | 50 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
264 | 50 | new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(), |
265 | 50 | DiagClient, /*ShouldOwnClient=*/false)); |
266 | | |
267 | | // Filter of all diagnostics. |
268 | 50 | CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags); |
269 | 50 | Diags->setClient(&errRec, /*ShouldOwnClient=*/false); |
270 | | |
271 | 50 | std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction( |
272 | 50 | std::move(CInvok), PCHContainerOps, Diags)); |
273 | 50 | if (!Unit) { |
274 | 0 | errRec.FinishCapture(); |
275 | 0 | return true; |
276 | 0 | } |
277 | | |
278 | | // Don't filter diagnostics anymore. |
279 | 50 | Diags->setClient(DiagClient, /*ShouldOwnClient=*/false); |
280 | | |
281 | 50 | ASTContext &Ctx = Unit->getASTContext(); |
282 | | |
283 | 50 | if (Diags->hasFatalErrorOccurred()) { |
284 | 0 | Diags->Reset(); |
285 | 0 | DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor()); |
286 | 0 | capturedDiags.reportDiagnostics(*Diags); |
287 | 0 | DiagClient->EndSourceFile(); |
288 | 0 | errRec.FinishCapture(); |
289 | 0 | return true; |
290 | 0 | } |
291 | | |
292 | 50 | if (emitPremigrationARCErrors) |
293 | 1 | emitPremigrationErrors(capturedDiags, &origCI.getDiagnosticOpts(), |
294 | 1 | Unit->getPreprocessor()); |
295 | 50 | if (!plistOut.empty()) { |
296 | 1 | SmallVector<StoredDiagnostic, 8> arcDiags; |
297 | 1 | for (CapturedDiagList::iterator |
298 | 2 | I = capturedDiags.begin(), E = capturedDiags.end(); I != E; ++I1 ) |
299 | 1 | arcDiags.push_back(*I); |
300 | 1 | writeARCDiagsToPlist(std::string(plistOut), arcDiags, |
301 | 1 | Ctx.getSourceManager(), Ctx.getLangOpts()); |
302 | 1 | } |
303 | | |
304 | | // After parsing of source files ended, we want to reuse the |
305 | | // diagnostics objects to emit further diagnostics. |
306 | | // We call BeginSourceFile because DiagnosticConsumer requires that |
307 | | // diagnostics with source range information are emitted only in between |
308 | | // BeginSourceFile() and EndSourceFile(). |
309 | 50 | DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor()); |
310 | | |
311 | | // No macros will be added since we are just checking and we won't modify |
312 | | // source code. |
313 | 50 | std::vector<SourceLocation> ARCMTMacroLocs; |
314 | | |
315 | 50 | TransformActions testAct(*Diags, capturedDiags, Ctx, Unit->getPreprocessor()); |
316 | 50 | MigrationPass pass(Ctx, OrigGCMode, Unit->getSema(), testAct, capturedDiags, |
317 | 50 | ARCMTMacroLocs); |
318 | 50 | pass.setNoFinalizeRemoval(NoFinalizeRemoval); |
319 | 50 | if (!NoNSAllocReallocError) |
320 | 48 | Diags->setSeverity(diag::warn_arcmt_nsalloc_realloc, diag::Severity::Error, |
321 | 48 | SourceLocation()); |
322 | | |
323 | 152 | for (unsigned i=0, e = transforms.size(); i != e; ++i102 ) |
324 | 102 | transforms[i](pass); |
325 | | |
326 | 50 | capturedDiags.reportDiagnostics(*Diags); |
327 | | |
328 | 50 | DiagClient->EndSourceFile(); |
329 | 50 | errRec.FinishCapture(); |
330 | | |
331 | 50 | return capturedDiags.hasErrors() || testAct.hasReportedErrors()39 ; |
332 | 50 | } |
333 | | |
334 | | //===----------------------------------------------------------------------===// |
335 | | // applyTransformations. |
336 | | //===----------------------------------------------------------------------===// |
337 | | |
338 | | static bool |
339 | | applyTransforms(CompilerInvocation &origCI, const FrontendInputFile &Input, |
340 | | std::shared_ptr<PCHContainerOperations> PCHContainerOps, |
341 | | DiagnosticConsumer *DiagClient, StringRef outputDir, |
342 | 10 | bool emitPremigrationARCErrors, StringRef plistOut) { |
343 | 10 | if (!origCI.getLangOpts()->ObjC) |
344 | 0 | return false; |
345 | | |
346 | 10 | LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC(); |
347 | | |
348 | | // Make sure checking is successful first. |
349 | 10 | CompilerInvocation CInvokForCheck(origCI); |
350 | 10 | if (arcmt::checkForManualIssues(CInvokForCheck, Input, PCHContainerOps, |
351 | 10 | DiagClient, emitPremigrationARCErrors, |
352 | 10 | plistOut)) |
353 | 0 | return true; |
354 | | |
355 | 10 | CompilerInvocation CInvok(origCI); |
356 | 10 | CInvok.getFrontendOpts().Inputs.clear(); |
357 | 10 | CInvok.getFrontendOpts().Inputs.push_back(Input); |
358 | | |
359 | 10 | MigrationProcess migration(CInvok, PCHContainerOps, DiagClient, outputDir); |
360 | 10 | bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval; |
361 | | |
362 | 10 | std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode, |
363 | 10 | NoFinalizeRemoval); |
364 | 10 | assert(!transforms.empty()); |
365 | | |
366 | 30 | for (unsigned i=0, e = transforms.size(); i != e; ++i20 ) { |
367 | 20 | bool err = migration.applyTransform(transforms[i]); |
368 | 20 | if (err) return true0 ; |
369 | 20 | } |
370 | | |
371 | 10 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
372 | 10 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
373 | 10 | new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(), |
374 | 10 | DiagClient, /*ShouldOwnClient=*/false)); |
375 | | |
376 | 10 | if (outputDir.empty()) { |
377 | 2 | origCI.getLangOpts()->ObjCAutoRefCount = true; |
378 | 2 | return migration.getRemapper().overwriteOriginal(*Diags); |
379 | 8 | } else { |
380 | 8 | return migration.getRemapper().flushToDisk(outputDir, *Diags); |
381 | 8 | } |
382 | 10 | } |
383 | | |
384 | | bool arcmt::applyTransformations( |
385 | | CompilerInvocation &origCI, const FrontendInputFile &Input, |
386 | | std::shared_ptr<PCHContainerOperations> PCHContainerOps, |
387 | 2 | DiagnosticConsumer *DiagClient) { |
388 | 2 | return applyTransforms(origCI, Input, PCHContainerOps, DiagClient, |
389 | 2 | StringRef(), false, StringRef()); |
390 | 2 | } |
391 | | |
392 | | bool arcmt::migrateWithTemporaryFiles( |
393 | | CompilerInvocation &origCI, const FrontendInputFile &Input, |
394 | | std::shared_ptr<PCHContainerOperations> PCHContainerOps, |
395 | | DiagnosticConsumer *DiagClient, StringRef outputDir, |
396 | 8 | bool emitPremigrationARCErrors, StringRef plistOut) { |
397 | 8 | assert(!outputDir.empty() && "Expected output directory path"); |
398 | 8 | return applyTransforms(origCI, Input, PCHContainerOps, DiagClient, outputDir, |
399 | 8 | emitPremigrationARCErrors, plistOut); |
400 | 8 | } |
401 | | |
402 | | bool arcmt::getFileRemappings(std::vector<std::pair<std::string,std::string> > & |
403 | | remap, |
404 | | StringRef outputDir, |
405 | 24 | DiagnosticConsumer *DiagClient) { |
406 | 24 | assert(!outputDir.empty()); |
407 | | |
408 | 24 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
409 | 24 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
410 | 24 | new DiagnosticsEngine(DiagID, new DiagnosticOptions, |
411 | 24 | DiagClient, /*ShouldOwnClient=*/false)); |
412 | | |
413 | 24 | FileRemapper remapper; |
414 | 24 | bool err = remapper.initFromDisk(outputDir, *Diags, |
415 | 24 | /*ignoreIfFilesChanged=*/true); |
416 | 24 | if (err) |
417 | 0 | return true; |
418 | | |
419 | 24 | remapper.forEachMapping( |
420 | 30 | [&](StringRef From, StringRef To) { |
421 | 30 | remap.push_back(std::make_pair(From.str(), To.str())); |
422 | 30 | }, |
423 | 0 | [](StringRef, const llvm::MemoryBufferRef &) {}); |
424 | | |
425 | 24 | return false; |
426 | 24 | } |
427 | | |
428 | | |
429 | | //===----------------------------------------------------------------------===// |
430 | | // CollectTransformActions. |
431 | | //===----------------------------------------------------------------------===// |
432 | | |
433 | | namespace { |
434 | | |
435 | | class ARCMTMacroTrackerPPCallbacks : public PPCallbacks { |
436 | | std::vector<SourceLocation> &ARCMTMacroLocs; |
437 | | |
438 | | public: |
439 | | ARCMTMacroTrackerPPCallbacks(std::vector<SourceLocation> &ARCMTMacroLocs) |
440 | 72 | : ARCMTMacroLocs(ARCMTMacroLocs) { } |
441 | | |
442 | | void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD, |
443 | 964 | SourceRange Range, const MacroArgs *Args) override { |
444 | 964 | if (MacroNameTok.getIdentifierInfo()->getName() == getARCMTMacroName()) |
445 | 92 | ARCMTMacroLocs.push_back(MacroNameTok.getLocation()); |
446 | 964 | } |
447 | | }; |
448 | | |
449 | | class ARCMTMacroTrackerAction : public ASTFrontendAction { |
450 | | std::vector<SourceLocation> &ARCMTMacroLocs; |
451 | | |
452 | | public: |
453 | | ARCMTMacroTrackerAction(std::vector<SourceLocation> &ARCMTMacroLocs) |
454 | 72 | : ARCMTMacroLocs(ARCMTMacroLocs) { } |
455 | | |
456 | | std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, |
457 | 72 | StringRef InFile) override { |
458 | 72 | CI.getPreprocessor().addPPCallbacks( |
459 | 72 | std::make_unique<ARCMTMacroTrackerPPCallbacks>(ARCMTMacroLocs)); |
460 | 72 | return std::make_unique<ASTConsumer>(); |
461 | 72 | } |
462 | | }; |
463 | | |
464 | | class RewritesApplicator : public TransformActions::RewriteReceiver { |
465 | | Rewriter &rewriter; |
466 | | MigrationProcess::RewriteListener *Listener; |
467 | | |
468 | | public: |
469 | | RewritesApplicator(Rewriter &rewriter, ASTContext &ctx, |
470 | | MigrationProcess::RewriteListener *listener) |
471 | 72 | : rewriter(rewriter), Listener(listener) { |
472 | 72 | if (Listener) |
473 | 0 | Listener->start(ctx); |
474 | 72 | } |
475 | 72 | ~RewritesApplicator() override { |
476 | 72 | if (Listener) |
477 | 0 | Listener->finish(); |
478 | 72 | } |
479 | | |
480 | 313 | void insert(SourceLocation loc, StringRef text) override { |
481 | 313 | bool err = rewriter.InsertText(loc, text, /*InsertAfter=*/true, |
482 | 313 | /*indentNewLines=*/true); |
483 | 313 | if (!err && Listener) |
484 | 0 | Listener->insert(loc, text); |
485 | 313 | } |
486 | | |
487 | 402 | void remove(CharSourceRange range) override { |
488 | 402 | Rewriter::RewriteOptions removeOpts; |
489 | 402 | removeOpts.IncludeInsertsAtBeginOfRange = false; |
490 | 402 | removeOpts.IncludeInsertsAtEndOfRange = false; |
491 | 402 | removeOpts.RemoveLineIfEmpty = true; |
492 | | |
493 | 402 | bool err = rewriter.RemoveText(range, removeOpts); |
494 | 402 | if (!err && Listener) |
495 | 0 | Listener->remove(range); |
496 | 402 | } |
497 | | |
498 | | void increaseIndentation(CharSourceRange range, |
499 | 16 | SourceLocation parentIndent) override { |
500 | 16 | rewriter.IncreaseIndentation(range, parentIndent); |
501 | 16 | } |
502 | | }; |
503 | | |
504 | | } // end anonymous namespace. |
505 | | |
506 | | /// Anchor for VTable. |
507 | 0 | MigrationProcess::RewriteListener::~RewriteListener() { } |
508 | | |
509 | | MigrationProcess::MigrationProcess( |
510 | | const CompilerInvocation &CI, |
511 | | std::shared_ptr<PCHContainerOperations> PCHContainerOps, |
512 | | DiagnosticConsumer *diagClient, StringRef outputDir) |
513 | | : OrigCI(CI), PCHContainerOps(std::move(PCHContainerOps)), |
514 | 35 | DiagClient(diagClient), HadARCErrors(false) { |
515 | 35 | if (!outputDir.empty()) { |
516 | 8 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
517 | 8 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
518 | 8 | new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(), |
519 | 8 | DiagClient, /*ShouldOwnClient=*/false)); |
520 | 8 | Remapper.initFromDisk(outputDir, *Diags, /*ignoreIfFilesChanged=*/true); |
521 | 8 | } |
522 | 35 | } |
523 | | |
524 | | bool MigrationProcess::applyTransform(TransformFn trans, |
525 | 72 | RewriteListener *listener) { |
526 | 72 | std::unique_ptr<CompilerInvocation> CInvok; |
527 | 72 | CInvok.reset( |
528 | 72 | createInvocationForMigration(OrigCI, PCHContainerOps->getRawReader())); |
529 | 72 | CInvok->getDiagnosticOpts().IgnoreWarnings = true; |
530 | | |
531 | 72 | Remapper.applyMappings(CInvok->getPreprocessorOpts()); |
532 | | |
533 | 72 | CapturedDiagList capturedDiags; |
534 | 72 | std::vector<SourceLocation> ARCMTMacroLocs; |
535 | | |
536 | 72 | assert(DiagClient); |
537 | 72 | IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
538 | 72 | IntrusiveRefCntPtr<DiagnosticsEngine> Diags( |
539 | 72 | new DiagnosticsEngine(DiagID, new DiagnosticOptions, |
540 | 72 | DiagClient, /*ShouldOwnClient=*/false)); |
541 | | |
542 | | // Filter of all diagnostics. |
543 | 72 | CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags); |
544 | 72 | Diags->setClient(&errRec, /*ShouldOwnClient=*/false); |
545 | | |
546 | 72 | std::unique_ptr<ARCMTMacroTrackerAction> ASTAction; |
547 | 72 | ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs)); |
548 | | |
549 | 72 | std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction( |
550 | 72 | std::move(CInvok), PCHContainerOps, Diags, ASTAction.get())); |
551 | 72 | if (!Unit) { |
552 | 0 | errRec.FinishCapture(); |
553 | 0 | return true; |
554 | 0 | } |
555 | 72 | Unit->setOwnsRemappedFileBuffers(false); // FileRemapper manages that. |
556 | | |
557 | 72 | HadARCErrors = HadARCErrors || capturedDiags.hasErrors()38 ; |
558 | | |
559 | | // Don't filter diagnostics anymore. |
560 | 72 | Diags->setClient(DiagClient, /*ShouldOwnClient=*/false); |
561 | | |
562 | 72 | ASTContext &Ctx = Unit->getASTContext(); |
563 | | |
564 | 72 | if (Diags->hasFatalErrorOccurred()) { |
565 | 0 | Diags->Reset(); |
566 | 0 | DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor()); |
567 | 0 | capturedDiags.reportDiagnostics(*Diags); |
568 | 0 | DiagClient->EndSourceFile(); |
569 | 0 | errRec.FinishCapture(); |
570 | 0 | return true; |
571 | 0 | } |
572 | | |
573 | | // After parsing of source files ended, we want to reuse the |
574 | | // diagnostics objects to emit further diagnostics. |
575 | | // We call BeginSourceFile because DiagnosticConsumer requires that |
576 | | // diagnostics with source range information are emitted only in between |
577 | | // BeginSourceFile() and EndSourceFile(). |
578 | 72 | DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor()); |
579 | | |
580 | 72 | Rewriter rewriter(Ctx.getSourceManager(), Ctx.getLangOpts()); |
581 | 72 | TransformActions TA(*Diags, capturedDiags, Ctx, Unit->getPreprocessor()); |
582 | 72 | MigrationPass pass(Ctx, OrigCI.getLangOpts()->getGC(), |
583 | 72 | Unit->getSema(), TA, capturedDiags, ARCMTMacroLocs); |
584 | | |
585 | 72 | trans(pass); |
586 | | |
587 | 72 | { |
588 | 72 | RewritesApplicator applicator(rewriter, Ctx, listener); |
589 | 72 | TA.applyRewrites(applicator); |
590 | 72 | } |
591 | | |
592 | 72 | DiagClient->EndSourceFile(); |
593 | 72 | errRec.FinishCapture(); |
594 | | |
595 | 72 | if (DiagClient->getNumErrors()) |
596 | 0 | return true; |
597 | | |
598 | 72 | for (Rewriter::buffer_iterator |
599 | 149 | I = rewriter.buffer_begin(), E = rewriter.buffer_end(); I != E; ++I77 ) { |
600 | 77 | FileID FID = I->first; |
601 | 77 | RewriteBuffer &buf = I->second; |
602 | 77 | const FileEntry *file = Ctx.getSourceManager().getFileEntryForID(FID); |
603 | 77 | assert(file); |
604 | 77 | std::string newFname = std::string(file->getName()); |
605 | 77 | newFname += "-trans"; |
606 | 77 | SmallString<512> newText; |
607 | 77 | llvm::raw_svector_ostream vecOS(newText); |
608 | 77 | buf.write(vecOS); |
609 | 77 | std::unique_ptr<llvm::MemoryBuffer> memBuf( |
610 | 77 | llvm::MemoryBuffer::getMemBufferCopy( |
611 | 77 | StringRef(newText.data(), newText.size()), newFname)); |
612 | 77 | SmallString<64> filePath(file->getName()); |
613 | 77 | Unit->getFileManager().FixupRelativePath(filePath); |
614 | 77 | Remapper.remap(filePath.str(), std::move(memBuf)); |
615 | 77 | } |
616 | | |
617 | 72 | return false; |
618 | 72 | } |