1 //===--- ARCMT.cpp - Migration 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 #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/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                                        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          std::find(IDs.begin(), IDs.end(), I->getID()) != IDs.end()) &&
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          std::find(IDs.begin(), IDs.end(), I->getID()) != IDs.end()) &&
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();
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     unsigned Major, Minor, Micro;
166     triple.getOSVersion(Major, Minor, Micro);
167     return Major > 10 || (Major == 10 && Minor >= 7);
168   }
169 
170   return false;
171 }
172 
173 static CompilerInvocation *
174 createInvocationForMigration(CompilerInvocation &origCI,
175                              const PCHContainerReader &PCHContainerRdr) {
176   std::unique_ptr<CompilerInvocation> CInvok;
177   CInvok.reset(new CompilerInvocation(origCI));
178   PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts();
179   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     FileManager FileMgr(origCI.getFileSystemOpts());
183     IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
184     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
185         new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
186                               new IgnoringDiagConsumer()));
187     std::string OriginalFile = ASTReader::getOriginalSourceFile(
188         PPOpts.ImplicitPCHInclude, FileMgr, PCHContainerRdr, *Diags);
189     if (!OriginalFile.empty())
190       PPOpts.Includes.insert(PPOpts.Includes.begin(), OriginalFile);
191     PPOpts.ImplicitPCHInclude.clear();
192   }
193   // FIXME: Get the original header of a PTH as well.
194   CInvok->getPreprocessorOpts().ImplicitPTHInclude.clear();
195   std::string define = getARCMTMacroName();
196   define += '=';
197   CInvok->getPreprocessorOpts().addMacroDef(define);
198   CInvok->getLangOpts()->ObjCAutoRefCount = true;
199   CInvok->getLangOpts()->setGC(LangOptions::NonGC);
200   CInvok->getDiagnosticOpts().ErrorLimit = 0;
201   CInvok->getDiagnosticOpts().PedanticErrors = 0;
202 
203   // Ignore -Werror flags when migrating.
204   std::vector<std::string> WarnOpts;
205   for (std::vector<std::string>::iterator
206          I = CInvok->getDiagnosticOpts().Warnings.begin(),
207          E = CInvok->getDiagnosticOpts().Warnings.end(); I != E; ++I) {
208     if (!StringRef(*I).startswith("error"))
209       WarnOpts.push_back(*I);
210   }
211   WarnOpts.push_back("error=arc-unsafe-retained-assign");
212   CInvok->getDiagnosticOpts().Warnings = std::move(WarnOpts);
213 
214   CInvok->getLangOpts()->ObjCWeakRuntime = HasARCRuntime(origCI);
215   CInvok->getLangOpts()->ObjCWeak = CInvok->getLangOpts()->ObjCWeakRuntime;
216 
217   return CInvok.release();
218 }
219 
220 static void emitPremigrationErrors(const CapturedDiagList &arcDiags,
221                                    DiagnosticOptions *diagOpts,
222                                    Preprocessor &PP) {
223   TextDiagnosticPrinter printer(llvm::errs(), diagOpts);
224   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
225   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
226       new DiagnosticsEngine(DiagID, diagOpts, &printer,
227                             /*ShouldOwnClient=*/false));
228   Diags->setSourceManager(&PP.getSourceManager());
229 
230   printer.BeginSourceFile(PP.getLangOpts(), &PP);
231   arcDiags.reportDiagnostics(*Diags);
232   printer.EndSourceFile();
233 }
234 
235 //===----------------------------------------------------------------------===//
236 // checkForManualIssues.
237 //===----------------------------------------------------------------------===//
238 
239 bool arcmt::checkForManualIssues(
240     CompilerInvocation &origCI, const FrontendInputFile &Input,
241     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
242     DiagnosticConsumer *DiagClient, bool emitPremigrationARCErrors,
243     StringRef plistOut) {
244   if (!origCI.getLangOpts()->ObjC1)
245     return false;
246 
247   LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC();
248   bool NoNSAllocReallocError = origCI.getMigratorOpts().NoNSAllocReallocError;
249   bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval;
250 
251   std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode,
252                                                                      NoFinalizeRemoval);
253   assert(!transforms.empty());
254 
255   std::unique_ptr<CompilerInvocation> CInvok;
256   CInvok.reset(
257       createInvocationForMigration(origCI, PCHContainerOps->getRawReader()));
258   CInvok->getFrontendOpts().Inputs.clear();
259   CInvok->getFrontendOpts().Inputs.push_back(Input);
260 
261   CapturedDiagList capturedDiags;
262 
263   assert(DiagClient);
264   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
265   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
266       new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
267                             DiagClient, /*ShouldOwnClient=*/false));
268 
269   // Filter of all diagnostics.
270   CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags);
271   Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
272 
273   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
274       std::move(CInvok), PCHContainerOps, Diags));
275   if (!Unit) {
276     errRec.FinishCapture();
277     return true;
278   }
279 
280   // Don't filter diagnostics anymore.
281   Diags->setClient(DiagClient, /*ShouldOwnClient=*/false);
282 
283   ASTContext &Ctx = Unit->getASTContext();
284 
285   if (Diags->hasFatalErrorOccurred()) {
286     Diags->Reset();
287     DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor());
288     capturedDiags.reportDiagnostics(*Diags);
289     DiagClient->EndSourceFile();
290     errRec.FinishCapture();
291     return true;
292   }
293 
294   if (emitPremigrationARCErrors)
295     emitPremigrationErrors(capturedDiags, &origCI.getDiagnosticOpts(),
296                            Unit->getPreprocessor());
297   if (!plistOut.empty()) {
298     SmallVector<StoredDiagnostic, 8> arcDiags;
299     for (CapturedDiagList::iterator
300            I = capturedDiags.begin(), E = capturedDiags.end(); I != E; ++I)
301       arcDiags.push_back(*I);
302     writeARCDiagsToPlist(plistOut, arcDiags,
303                          Ctx.getSourceManager(), Ctx.getLangOpts());
304   }
305 
306   // After parsing of source files ended, we want to reuse the
307   // diagnostics objects to emit further diagnostics.
308   // We call BeginSourceFile because DiagnosticConsumer requires that
309   // diagnostics with source range information are emitted only in between
310   // BeginSourceFile() and EndSourceFile().
311   DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor());
312 
313   // No macros will be added since we are just checking and we won't modify
314   // source code.
315   std::vector<SourceLocation> ARCMTMacroLocs;
316 
317   TransformActions testAct(*Diags, capturedDiags, Ctx, Unit->getPreprocessor());
318   MigrationPass pass(Ctx, OrigGCMode, Unit->getSema(), testAct, capturedDiags,
319                      ARCMTMacroLocs);
320   pass.setNoFinalizeRemoval(NoFinalizeRemoval);
321   if (!NoNSAllocReallocError)
322     Diags->setSeverity(diag::warn_arcmt_nsalloc_realloc, diag::Severity::Error,
323                        SourceLocation());
324 
325   for (unsigned i=0, e = transforms.size(); i != e; ++i)
326     transforms[i](pass);
327 
328   capturedDiags.reportDiagnostics(*Diags);
329 
330   DiagClient->EndSourceFile();
331   errRec.FinishCapture();
332 
333   return capturedDiags.hasErrors() || testAct.hasReportedErrors();
334 }
335 
336 //===----------------------------------------------------------------------===//
337 // applyTransformations.
338 //===----------------------------------------------------------------------===//
339 
340 static bool
341 applyTransforms(CompilerInvocation &origCI, const FrontendInputFile &Input,
342                 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
343                 DiagnosticConsumer *DiagClient, StringRef outputDir,
344                 bool emitPremigrationARCErrors, StringRef plistOut) {
345   if (!origCI.getLangOpts()->ObjC1)
346     return false;
347 
348   LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC();
349 
350   // Make sure checking is successful first.
351   CompilerInvocation CInvokForCheck(origCI);
352   if (arcmt::checkForManualIssues(CInvokForCheck, Input, PCHContainerOps,
353                                   DiagClient, emitPremigrationARCErrors,
354                                   plistOut))
355     return true;
356 
357   CompilerInvocation CInvok(origCI);
358   CInvok.getFrontendOpts().Inputs.clear();
359   CInvok.getFrontendOpts().Inputs.push_back(Input);
360 
361   MigrationProcess migration(CInvok, PCHContainerOps, DiagClient, outputDir);
362   bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval;
363 
364   std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode,
365                                                                      NoFinalizeRemoval);
366   assert(!transforms.empty());
367 
368   for (unsigned i=0, e = transforms.size(); i != e; ++i) {
369     bool err = migration.applyTransform(transforms[i]);
370     if (err) return true;
371   }
372 
373   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
374   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
375       new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
376                             DiagClient, /*ShouldOwnClient=*/false));
377 
378   if (outputDir.empty()) {
379     origCI.getLangOpts()->ObjCAutoRefCount = true;
380     return migration.getRemapper().overwriteOriginal(*Diags);
381   } else {
382     return migration.getRemapper().flushToDisk(outputDir, *Diags);
383   }
384 }
385 
386 bool arcmt::applyTransformations(
387     CompilerInvocation &origCI, const FrontendInputFile &Input,
388     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
389     DiagnosticConsumer *DiagClient) {
390   return applyTransforms(origCI, Input, PCHContainerOps, DiagClient,
391                          StringRef(), false, StringRef());
392 }
393 
394 bool arcmt::migrateWithTemporaryFiles(
395     CompilerInvocation &origCI, const FrontendInputFile &Input,
396     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
397     DiagnosticConsumer *DiagClient, StringRef outputDir,
398     bool emitPremigrationARCErrors, StringRef plistOut) {
399   assert(!outputDir.empty() && "Expected output directory path");
400   return applyTransforms(origCI, Input, PCHContainerOps, DiagClient, outputDir,
401                          emitPremigrationARCErrors, plistOut);
402 }
403 
404 bool arcmt::getFileRemappings(std::vector<std::pair<std::string,std::string> > &
405                                   remap,
406                               StringRef outputDir,
407                               DiagnosticConsumer *DiagClient) {
408   assert(!outputDir.empty());
409 
410   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
411   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
412       new DiagnosticsEngine(DiagID, new DiagnosticOptions,
413                             DiagClient, /*ShouldOwnClient=*/false));
414 
415   FileRemapper remapper;
416   bool err = remapper.initFromDisk(outputDir, *Diags,
417                                    /*ignoreIfFilesChanged=*/true);
418   if (err)
419     return true;
420 
421   PreprocessorOptions PPOpts;
422   remapper.applyMappings(PPOpts);
423   remap = PPOpts.RemappedFiles;
424 
425   return false;
426 }
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     : ARCMTMacroLocs(ARCMTMacroLocs) { }
441 
442   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
443                     SourceRange Range, const MacroArgs *Args) override {
444     if (MacroNameTok.getIdentifierInfo()->getName() == getARCMTMacroName())
445       ARCMTMacroLocs.push_back(MacroNameTok.getLocation());
446   }
447 };
448 
449 class ARCMTMacroTrackerAction : public ASTFrontendAction {
450   std::vector<SourceLocation> &ARCMTMacroLocs;
451 
452 public:
453   ARCMTMacroTrackerAction(std::vector<SourceLocation> &ARCMTMacroLocs)
454     : ARCMTMacroLocs(ARCMTMacroLocs) { }
455 
456   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
457                                                  StringRef InFile) override {
458     CI.getPreprocessor().addPPCallbacks(
459                llvm::make_unique<ARCMTMacroTrackerPPCallbacks>(ARCMTMacroLocs));
460     return llvm::make_unique<ASTConsumer>();
461   }
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     : rewriter(rewriter), Listener(listener) {
472     if (Listener)
473       Listener->start(ctx);
474   }
475   ~RewritesApplicator() override {
476     if (Listener)
477       Listener->finish();
478   }
479 
480   void insert(SourceLocation loc, StringRef text) override {
481     bool err = rewriter.InsertText(loc, text, /*InsertAfter=*/true,
482                                    /*indentNewLines=*/true);
483     if (!err && Listener)
484       Listener->insert(loc, text);
485   }
486 
487   void remove(CharSourceRange range) override {
488     Rewriter::RewriteOptions removeOpts;
489     removeOpts.IncludeInsertsAtBeginOfRange = false;
490     removeOpts.IncludeInsertsAtEndOfRange = false;
491     removeOpts.RemoveLineIfEmpty = true;
492 
493     bool err = rewriter.RemoveText(range, removeOpts);
494     if (!err && Listener)
495       Listener->remove(range);
496   }
497 
498   void increaseIndentation(CharSourceRange range,
499                             SourceLocation parentIndent) override {
500     rewriter.IncreaseIndentation(range, parentIndent);
501   }
502 };
503 
504 } // end anonymous namespace.
505 
506 /// \brief Anchor for VTable.
507 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       DiagClient(diagClient), HadARCErrors(false) {
515   if (!outputDir.empty()) {
516     IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
517     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
518       new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(),
519                             DiagClient, /*ShouldOwnClient=*/false));
520     Remapper.initFromDisk(outputDir, *Diags, /*ignoreIfFilesChanges=*/true);
521   }
522 }
523 
524 bool MigrationProcess::applyTransform(TransformFn trans,
525                                       RewriteListener *listener) {
526   std::unique_ptr<CompilerInvocation> CInvok;
527   CInvok.reset(
528       createInvocationForMigration(OrigCI, PCHContainerOps->getRawReader()));
529   CInvok->getDiagnosticOpts().IgnoreWarnings = true;
530 
531   Remapper.applyMappings(CInvok->getPreprocessorOpts());
532 
533   CapturedDiagList capturedDiags;
534   std::vector<SourceLocation> ARCMTMacroLocs;
535 
536   assert(DiagClient);
537   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
538   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
539       new DiagnosticsEngine(DiagID, new DiagnosticOptions,
540                             DiagClient, /*ShouldOwnClient=*/false));
541 
542   // Filter of all diagnostics.
543   CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags);
544   Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
545 
546   std::unique_ptr<ARCMTMacroTrackerAction> ASTAction;
547   ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs));
548 
549   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
550       std::move(CInvok), PCHContainerOps, Diags, ASTAction.get()));
551   if (!Unit) {
552     errRec.FinishCapture();
553     return true;
554   }
555   Unit->setOwnsRemappedFileBuffers(false); // FileRemapper manages that.
556 
557   HadARCErrors = HadARCErrors || capturedDiags.hasErrors();
558 
559   // Don't filter diagnostics anymore.
560   Diags->setClient(DiagClient, /*ShouldOwnClient=*/false);
561 
562   ASTContext &Ctx = Unit->getASTContext();
563 
564   if (Diags->hasFatalErrorOccurred()) {
565     Diags->Reset();
566     DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor());
567     capturedDiags.reportDiagnostics(*Diags);
568     DiagClient->EndSourceFile();
569     errRec.FinishCapture();
570     return true;
571   }
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   DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor());
579 
580   Rewriter rewriter(Ctx.getSourceManager(), Ctx.getLangOpts());
581   TransformActions TA(*Diags, capturedDiags, Ctx, Unit->getPreprocessor());
582   MigrationPass pass(Ctx, OrigCI.getLangOpts()->getGC(),
583                      Unit->getSema(), TA, capturedDiags, ARCMTMacroLocs);
584 
585   trans(pass);
586 
587   {
588     RewritesApplicator applicator(rewriter, Ctx, listener);
589     TA.applyRewrites(applicator);
590   }
591 
592   DiagClient->EndSourceFile();
593   errRec.FinishCapture();
594 
595   if (DiagClient->getNumErrors())
596     return true;
597 
598   for (Rewriter::buffer_iterator
599         I = rewriter.buffer_begin(), E = rewriter.buffer_end(); I != E; ++I) {
600     FileID FID = I->first;
601     RewriteBuffer &buf = I->second;
602     const FileEntry *file = Ctx.getSourceManager().getFileEntryForID(FID);
603     assert(file);
604     std::string newFname = file->getName();
605     newFname += "-trans";
606     SmallString<512> newText;
607     llvm::raw_svector_ostream vecOS(newText);
608     buf.write(vecOS);
609     std::unique_ptr<llvm::MemoryBuffer> memBuf(
610         llvm::MemoryBuffer::getMemBufferCopy(
611             StringRef(newText.data(), newText.size()), newFname));
612     SmallString<64> filePath(file->getName());
613     Unit->getFileManager().FixupRelativePath(filePath);
614     Remapper.remap(filePath.str(), std::move(memBuf));
615   }
616 
617   return false;
618 }
619