Home | History | Annotate | Download | only in ARCMigrate 
      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 using namespace clang;
     25 using namespace arcmt;
     26 
     27 bool CapturedDiagList::clearDiagnostic(ArrayRef<unsigned> IDs,
     28                                        SourceRange range) {
     29   if (range.isInvalid())
     30     return false;
     31 
     32   bool cleared = false;
     33   ListTy::iterator I = List.begin();
     34   while (I != List.end()) {
     35     FullSourceLoc diagLoc = I->getLocation();
     36     if ((IDs.empty() || // empty means clear all diagnostics in the range.
     37          std::find(IDs.begin(), IDs.end(), I->getID()) != IDs.end()) &&
     38         !diagLoc.isBeforeInTranslationUnitThan(range.getBegin()) &&
     39         (diagLoc == range.getEnd() ||
     40            diagLoc.isBeforeInTranslationUnitThan(range.getEnd()))) {
     41       cleared = true;
     42       ListTy::iterator eraseS = I++;
     43       if (eraseS->getLevel() != DiagnosticsEngine::Note)
     44         while (I != List.end() && I->getLevel() == DiagnosticsEngine::Note)
     45           ++I;
     46       // Clear the diagnostic and any notes following it.
     47       I = List.erase(eraseS, I);
     48       continue;
     49     }
     50 
     51     ++I;
     52   }
     53 
     54   return cleared;
     55 }
     56 
     57 bool CapturedDiagList::hasDiagnostic(ArrayRef<unsigned> IDs,
     58                                      SourceRange range) const {
     59   if (range.isInvalid())
     60     return false;
     61 
     62   ListTy::const_iterator I = List.begin();
     63   while (I != List.end()) {
     64     FullSourceLoc diagLoc = I->getLocation();
     65     if ((IDs.empty() || // empty means any diagnostic in the range.
     66          std::find(IDs.begin(), IDs.end(), I->getID()) != IDs.end()) &&
     67         !diagLoc.isBeforeInTranslationUnitThan(range.getBegin()) &&
     68         (diagLoc == range.getEnd() ||
     69            diagLoc.isBeforeInTranslationUnitThan(range.getEnd()))) {
     70       return true;
     71     }
     72 
     73     ++I;
     74   }
     75 
     76   return false;
     77 }
     78 
     79 void CapturedDiagList::reportDiagnostics(DiagnosticsEngine &Diags) const {
     80   for (ListTy::const_iterator I = List.begin(), E = List.end(); I != E; ++I)
     81     Diags.Report(*I);
     82 }
     83 
     84 bool CapturedDiagList::hasErrors() const {
     85   for (ListTy::const_iterator I = List.begin(), E = List.end(); I != E; ++I)
     86     if (I->getLevel() >= DiagnosticsEngine::Error)
     87       return true;
     88 
     89   return false;
     90 }
     91 
     92 namespace {
     93 
     94 class CaptureDiagnosticConsumer : public DiagnosticConsumer {
     95   DiagnosticsEngine &Diags;
     96   DiagnosticConsumer &DiagClient;
     97   CapturedDiagList &CapturedDiags;
     98   bool HasBegunSourceFile;
     99 public:
    100   CaptureDiagnosticConsumer(DiagnosticsEngine &diags,
    101                             DiagnosticConsumer &client,
    102                             CapturedDiagList &capturedDiags)
    103     : Diags(diags), DiagClient(client), CapturedDiags(capturedDiags),
    104       HasBegunSourceFile(false) { }
    105 
    106   virtual void BeginSourceFile(const LangOptions &Opts,
    107                                const Preprocessor *PP) {
    108     // Pass BeginSourceFile message onto DiagClient on first call.
    109     // The corresponding EndSourceFile call will be made from an
    110     // explicit call to FinishCapture.
    111     if (!HasBegunSourceFile) {
    112       DiagClient.BeginSourceFile(Opts, PP);
    113       HasBegunSourceFile = true;
    114     }
    115   }
    116 
    117   void FinishCapture() {
    118     // Call EndSourceFile on DiagClient on completion of capture to
    119     // enable VerifyDiagnosticConsumer to check diagnostics *after*
    120     // it has received the diagnostic list.
    121     if (HasBegunSourceFile) {
    122       DiagClient.EndSourceFile();
    123       HasBegunSourceFile = false;
    124     }
    125   }
    126 
    127   virtual ~CaptureDiagnosticConsumer() {
    128     assert(!HasBegunSourceFile && "FinishCapture not called!");
    129   }
    130 
    131   virtual void HandleDiagnostic(DiagnosticsEngine::Level level,
    132                                 const Diagnostic &Info) {
    133     if (DiagnosticIDs::isARCDiagnostic(Info.getID()) ||
    134         level >= DiagnosticsEngine::Error || level == DiagnosticsEngine::Note) {
    135       if (Info.getLocation().isValid())
    136         CapturedDiags.push_back(StoredDiagnostic(level, Info));
    137       return;
    138     }
    139 
    140     // Non-ARC warnings are ignored.
    141     Diags.setLastDiagnosticIgnored();
    142   }
    143 
    144   DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
    145     // Just drop any diagnostics that come from cloned consumers; they'll
    146     // have different source managers anyway.
    147     return new IgnoringDiagConsumer();
    148   }
    149 };
    150 
    151 } // end anonymous namespace
    152 
    153 static bool HasARCRuntime(CompilerInvocation &origCI) {
    154   // This duplicates some functionality from Darwin::AddDeploymentTarget
    155   // but this function is well defined, so keep it decoupled from the driver
    156   // and avoid unrelated complications.
    157   llvm::Triple triple(origCI.getTargetOpts().Triple);
    158 
    159   if (triple.getOS() == llvm::Triple::IOS)
    160     return triple.getOSMajorVersion() >= 5;
    161 
    162   if (triple.getOS() == llvm::Triple::Darwin)
    163     return triple.getOSMajorVersion() >= 11;
    164 
    165   if (triple.getOS() == llvm::Triple::MacOSX) {
    166     unsigned Major, Minor, Micro;
    167     triple.getOSVersion(Major, Minor, Micro);
    168     return Major > 10 || (Major == 10 && Minor >= 7);
    169   }
    170 
    171   return false;
    172 }
    173 
    174 static CompilerInvocation *
    175 createInvocationForMigration(CompilerInvocation &origCI) {
    176   OwningPtr<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 =
    188         ASTReader::getOriginalSourceFile(PPOpts.ImplicitPCHInclude,
    189                                          FileMgr, *Diags);
    190     if (!OriginalFile.empty())
    191       PPOpts.Includes.insert(PPOpts.Includes.begin(), OriginalFile);
    192     PPOpts.ImplicitPCHInclude.clear();
    193   }
    194   // FIXME: Get the original header of a PTH as well.
    195   CInvok->getPreprocessorOpts().ImplicitPTHInclude.clear();
    196   std::string define = getARCMTMacroName();
    197   define += '=';
    198   CInvok->getPreprocessorOpts().addMacroDef(define);
    199   CInvok->getLangOpts()->ObjCAutoRefCount = true;
    200   CInvok->getLangOpts()->setGC(LangOptions::NonGC);
    201   CInvok->getDiagnosticOpts().ErrorLimit = 0;
    202   CInvok->getDiagnosticOpts().PedanticErrors = 0;
    203 
    204   // Ignore -Werror flags when migrating.
    205   std::vector<std::string> WarnOpts;
    206   for (std::vector<std::string>::iterator
    207          I = CInvok->getDiagnosticOpts().Warnings.begin(),
    208          E = CInvok->getDiagnosticOpts().Warnings.end(); I != E; ++I) {
    209     if (!StringRef(*I).startswith("error"))
    210       WarnOpts.push_back(*I);
    211   }
    212   WarnOpts.push_back("error=arc-unsafe-retained-assign");
    213   CInvok->getDiagnosticOpts().Warnings = llvm_move(WarnOpts);
    214 
    215   CInvok->getLangOpts()->ObjCARCWeak = HasARCRuntime(origCI);
    216 
    217   return CInvok.take();
    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(CompilerInvocation &origCI,
    240                                  const FrontendInputFile &Input,
    241                                  DiagnosticConsumer *DiagClient,
    242                                  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   OwningPtr<CompilerInvocation> CInvok;
    256   CInvok.reset(createInvocationForMigration(origCI));
    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   OwningPtr<ASTUnit> Unit(
    273       ASTUnit::LoadFromCompilerInvocationAction(CInvok.take(), 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.setNSAllocReallocError(NoNSAllocReallocError);
    320   pass.setNoFinalizeRemoval(NoFinalizeRemoval);
    321 
    322   for (unsigned i=0, e = transforms.size(); i != e; ++i)
    323     transforms[i](pass);
    324 
    325   capturedDiags.reportDiagnostics(*Diags);
    326 
    327   DiagClient->EndSourceFile();
    328   errRec.FinishCapture();
    329 
    330   // If we are migrating code that gets the '-fobjc-arc' flag, make sure
    331   // to remove it so that we don't get errors from normal compilation.
    332   origCI.getLangOpts()->ObjCAutoRefCount = false;
    333 
    334   return capturedDiags.hasErrors() || testAct.hasReportedErrors();
    335 }
    336 
    337 //===----------------------------------------------------------------------===//
    338 // applyTransformations.
    339 //===----------------------------------------------------------------------===//
    340 
    341 static bool applyTransforms(CompilerInvocation &origCI,
    342                             const FrontendInputFile &Input,
    343                             DiagnosticConsumer *DiagClient,
    344                             StringRef outputDir,
    345                             bool emitPremigrationARCErrors,
    346                             StringRef plistOut) {
    347   if (!origCI.getLangOpts()->ObjC1)
    348     return false;
    349 
    350   LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC();
    351 
    352   // Make sure checking is successful first.
    353   CompilerInvocation CInvokForCheck(origCI);
    354   if (arcmt::checkForManualIssues(CInvokForCheck, Input, DiagClient,
    355                                   emitPremigrationARCErrors, plistOut))
    356     return true;
    357 
    358   CompilerInvocation CInvok(origCI);
    359   CInvok.getFrontendOpts().Inputs.clear();
    360   CInvok.getFrontendOpts().Inputs.push_back(Input);
    361 
    362   MigrationProcess migration(CInvok, DiagClient, outputDir);
    363   bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval;
    364 
    365   std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode,
    366                                                                      NoFinalizeRemoval);
    367   assert(!transforms.empty());
    368 
    369   for (unsigned i=0, e = transforms.size(); i != e; ++i) {
    370     bool err = migration.applyTransform(transforms[i]);
    371     if (err) return true;
    372   }
    373 
    374   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
    375   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
    376       new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
    377                             DiagClient, /*ShouldOwnClient=*/false));
    378 
    379   if (outputDir.empty()) {
    380     origCI.getLangOpts()->ObjCAutoRefCount = true;
    381     return migration.getRemapper().overwriteOriginal(*Diags);
    382   } else {
    383     // If we are migrating code that gets the '-fobjc-arc' flag, make sure
    384     // to remove it so that we don't get errors from normal compilation.
    385     origCI.getLangOpts()->ObjCAutoRefCount = false;
    386     return migration.getRemapper().flushToDisk(outputDir, *Diags);
    387   }
    388 }
    389 
    390 bool arcmt::applyTransformations(CompilerInvocation &origCI,
    391                                  const FrontendInputFile &Input,
    392                                  DiagnosticConsumer *DiagClient) {
    393   return applyTransforms(origCI, Input, DiagClient,
    394                          StringRef(), false, StringRef());
    395 }
    396 
    397 bool arcmt::migrateWithTemporaryFiles(CompilerInvocation &origCI,
    398                                       const FrontendInputFile &Input,
    399                                       DiagnosticConsumer *DiagClient,
    400                                       StringRef outputDir,
    401                                       bool emitPremigrationARCErrors,
    402                                       StringRef plistOut) {
    403   assert(!outputDir.empty() && "Expected output directory path");
    404   return applyTransforms(origCI, Input, DiagClient,
    405                          outputDir, emitPremigrationARCErrors, plistOut);
    406 }
    407 
    408 bool arcmt::getFileRemappings(std::vector<std::pair<std::string,std::string> > &
    409                                   remap,
    410                               StringRef outputDir,
    411                               DiagnosticConsumer *DiagClient) {
    412   assert(!outputDir.empty());
    413 
    414   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
    415   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
    416       new DiagnosticsEngine(DiagID, new DiagnosticOptions,
    417                             DiagClient, /*ShouldOwnClient=*/false));
    418 
    419   FileRemapper remapper;
    420   bool err = remapper.initFromDisk(outputDir, *Diags,
    421                                    /*ignoreIfFilesChanged=*/true);
    422   if (err)
    423     return true;
    424 
    425   PreprocessorOptions PPOpts;
    426   remapper.applyMappings(PPOpts);
    427   remap = PPOpts.RemappedFiles;
    428 
    429   return false;
    430 }
    431 
    432 bool arcmt::getFileRemappingsFromFileList(
    433                         std::vector<std::pair<std::string,std::string> > &remap,
    434                         ArrayRef<StringRef> remapFiles,
    435                         DiagnosticConsumer *DiagClient) {
    436   bool hasErrorOccurred = false;
    437   llvm::StringMap<bool> Uniquer;
    438 
    439   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
    440   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
    441       new DiagnosticsEngine(DiagID, new DiagnosticOptions,
    442                             DiagClient, /*ShouldOwnClient=*/false));
    443 
    444   for (ArrayRef<StringRef>::iterator
    445          I = remapFiles.begin(), E = remapFiles.end(); I != E; ++I) {
    446     StringRef file = *I;
    447 
    448     FileRemapper remapper;
    449     bool err = remapper.initFromFile(file, *Diags,
    450                                      /*ignoreIfFilesChanged=*/true);
    451     hasErrorOccurred = hasErrorOccurred || err;
    452     if (err)
    453       continue;
    454 
    455     PreprocessorOptions PPOpts;
    456     remapper.applyMappings(PPOpts);
    457     for (PreprocessorOptions::remapped_file_iterator
    458            RI = PPOpts.remapped_file_begin(), RE = PPOpts.remapped_file_end();
    459            RI != RE; ++RI) {
    460       bool &inserted = Uniquer[RI->first];
    461       if (inserted)
    462         continue;
    463       inserted = true;
    464       remap.push_back(*RI);
    465     }
    466   }
    467 
    468   return hasErrorOccurred;
    469 }
    470 
    471 //===----------------------------------------------------------------------===//
    472 // CollectTransformActions.
    473 //===----------------------------------------------------------------------===//
    474 
    475 namespace {
    476 
    477 class ARCMTMacroTrackerPPCallbacks : public PPCallbacks {
    478   std::vector<SourceLocation> &ARCMTMacroLocs;
    479 
    480 public:
    481   ARCMTMacroTrackerPPCallbacks(std::vector<SourceLocation> &ARCMTMacroLocs)
    482     : ARCMTMacroLocs(ARCMTMacroLocs) { }
    483 
    484   virtual void MacroExpands(const Token &MacroNameTok, const MacroDirective *MD,
    485                             SourceRange Range) {
    486     if (MacroNameTok.getIdentifierInfo()->getName() == getARCMTMacroName())
    487       ARCMTMacroLocs.push_back(MacroNameTok.getLocation());
    488   }
    489 };
    490 
    491 class ARCMTMacroTrackerAction : public ASTFrontendAction {
    492   std::vector<SourceLocation> &ARCMTMacroLocs;
    493 
    494 public:
    495   ARCMTMacroTrackerAction(std::vector<SourceLocation> &ARCMTMacroLocs)
    496     : ARCMTMacroLocs(ARCMTMacroLocs) { }
    497 
    498   virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
    499                                          StringRef InFile) {
    500     CI.getPreprocessor().addPPCallbacks(
    501                               new ARCMTMacroTrackerPPCallbacks(ARCMTMacroLocs));
    502     return new ASTConsumer();
    503   }
    504 };
    505 
    506 class RewritesApplicator : public TransformActions::RewriteReceiver {
    507   Rewriter &rewriter;
    508   MigrationProcess::RewriteListener *Listener;
    509 
    510 public:
    511   RewritesApplicator(Rewriter &rewriter, ASTContext &ctx,
    512                      MigrationProcess::RewriteListener *listener)
    513     : rewriter(rewriter), Listener(listener) {
    514     if (Listener)
    515       Listener->start(ctx);
    516   }
    517   ~RewritesApplicator() {
    518     if (Listener)
    519       Listener->finish();
    520   }
    521 
    522   virtual void insert(SourceLocation loc, StringRef text) {
    523     bool err = rewriter.InsertText(loc, text, /*InsertAfter=*/true,
    524                                    /*indentNewLines=*/true);
    525     if (!err && Listener)
    526       Listener->insert(loc, text);
    527   }
    528 
    529   virtual void remove(CharSourceRange range) {
    530     Rewriter::RewriteOptions removeOpts;
    531     removeOpts.IncludeInsertsAtBeginOfRange = false;
    532     removeOpts.IncludeInsertsAtEndOfRange = false;
    533     removeOpts.RemoveLineIfEmpty = true;
    534 
    535     bool err = rewriter.RemoveText(range, removeOpts);
    536     if (!err && Listener)
    537       Listener->remove(range);
    538   }
    539 
    540   virtual void increaseIndentation(CharSourceRange range,
    541                                     SourceLocation parentIndent) {
    542     rewriter.IncreaseIndentation(range, parentIndent);
    543   }
    544 };
    545 
    546 } // end anonymous namespace.
    547 
    548 /// \brief Anchor for VTable.
    549 MigrationProcess::RewriteListener::~RewriteListener() { }
    550 
    551 MigrationProcess::MigrationProcess(const CompilerInvocation &CI,
    552                                    DiagnosticConsumer *diagClient,
    553                                    StringRef outputDir)
    554   : OrigCI(CI), DiagClient(diagClient) {
    555   if (!outputDir.empty()) {
    556     IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
    557     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
    558       new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(),
    559                             DiagClient, /*ShouldOwnClient=*/false));
    560     Remapper.initFromDisk(outputDir, *Diags, /*ignoreIfFilesChanges=*/true);
    561   }
    562 }
    563 
    564 bool MigrationProcess::applyTransform(TransformFn trans,
    565                                       RewriteListener *listener) {
    566   OwningPtr<CompilerInvocation> CInvok;
    567   CInvok.reset(createInvocationForMigration(OrigCI));
    568   CInvok->getDiagnosticOpts().IgnoreWarnings = true;
    569 
    570   Remapper.applyMappings(CInvok->getPreprocessorOpts());
    571 
    572   CapturedDiagList capturedDiags;
    573   std::vector<SourceLocation> ARCMTMacroLocs;
    574 
    575   assert(DiagClient);
    576   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
    577   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
    578       new DiagnosticsEngine(DiagID, new DiagnosticOptions,
    579                             DiagClient, /*ShouldOwnClient=*/false));
    580 
    581   // Filter of all diagnostics.
    582   CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags);
    583   Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
    584 
    585   OwningPtr<ARCMTMacroTrackerAction> ASTAction;
    586   ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs));
    587 
    588   OwningPtr<ASTUnit> Unit(
    589       ASTUnit::LoadFromCompilerInvocationAction(CInvok.take(), Diags,
    590                                                 ASTAction.get()));
    591   if (!Unit) {
    592     errRec.FinishCapture();
    593     return true;
    594   }
    595   Unit->setOwnsRemappedFileBuffers(false); // FileRemapper manages that.
    596 
    597   // Don't filter diagnostics anymore.
    598   Diags->setClient(DiagClient, /*ShouldOwnClient=*/false);
    599 
    600   ASTContext &Ctx = Unit->getASTContext();
    601 
    602   if (Diags->hasFatalErrorOccurred()) {
    603     Diags->Reset();
    604     DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor());
    605     capturedDiags.reportDiagnostics(*Diags);
    606     DiagClient->EndSourceFile();
    607     errRec.FinishCapture();
    608     return true;
    609   }
    610 
    611   // After parsing of source files ended, we want to reuse the
    612   // diagnostics objects to emit further diagnostics.
    613   // We call BeginSourceFile because DiagnosticConsumer requires that
    614   // diagnostics with source range information are emitted only in between
    615   // BeginSourceFile() and EndSourceFile().
    616   DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor());
    617 
    618   Rewriter rewriter(Ctx.getSourceManager(), Ctx.getLangOpts());
    619   TransformActions TA(*Diags, capturedDiags, Ctx, Unit->getPreprocessor());
    620   MigrationPass pass(Ctx, OrigCI.getLangOpts()->getGC(),
    621                      Unit->getSema(), TA, capturedDiags, ARCMTMacroLocs);
    622 
    623   trans(pass);
    624 
    625   {
    626     RewritesApplicator applicator(rewriter, Ctx, listener);
    627     TA.applyRewrites(applicator);
    628   }
    629 
    630   DiagClient->EndSourceFile();
    631   errRec.FinishCapture();
    632 
    633   if (DiagClient->getNumErrors())
    634     return true;
    635 
    636   for (Rewriter::buffer_iterator
    637         I = rewriter.buffer_begin(), E = rewriter.buffer_end(); I != E; ++I) {
    638     FileID FID = I->first;
    639     RewriteBuffer &buf = I->second;
    640     const FileEntry *file = Ctx.getSourceManager().getFileEntryForID(FID);
    641     assert(file);
    642     std::string newFname = file->getName();
    643     newFname += "-trans";
    644     SmallString<512> newText;
    645     llvm::raw_svector_ostream vecOS(newText);
    646     buf.write(vecOS);
    647     vecOS.flush();
    648     llvm::MemoryBuffer *memBuf = llvm::MemoryBuffer::getMemBufferCopy(
    649                    StringRef(newText.data(), newText.size()), newFname);
    650     SmallString<64> filePath(file->getName());
    651     Unit->getFileManager().FixupRelativePath(filePath);
    652     Remapper.remap(filePath.str(), memBuf);
    653   }
    654 
    655   return false;
    656 }
    657