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