contrib/llvm/tools/clang/lib/ARCMigrate/ARCMT.cpp

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