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