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

   1 //===--- ObjCMT.cpp - ObjC Migrate Tool -----------------------------------===//
   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 "clang/ARCMigrate/ARCMTActions.h"
  11 #include "clang/Frontend/CompilerInstance.h"
  12 #include "clang/Frontend/MultiplexConsumer.h"
  13 #include "clang/AST/ASTContext.h"
  14 #include "clang/AST/RecursiveASTVisitor.h"
  15 #include "clang/AST/NSAPI.h"
  16 #include "clang/AST/ASTConsumer.h"
  17 #include "clang/Edit/Rewriters.h"
  18 #include "clang/Edit/EditedSource.h"
  19 #include "clang/Edit/Commit.h"
  20 #include "clang/Edit/EditsReceiver.h"
  21 #include "clang/Rewrite/Core/Rewriter.h"
  22 #include "clang/Lex/Preprocessor.h"
  23 #include "clang/Basic/FileManager.h"
  24 #include "llvm/ADT/SmallString.h"
  25
  26 using namespace clang;
  27 using namespace arcmt;
  28
  29 namespace {
  30
  31 class ObjCMigrateASTConsumer : public ASTConsumer {
  32   void migrateDecl(Decl *D);
  33
  34 public:
  35   std::string MigrateDir;
  36   bool MigrateLiterals;
  37   bool MigrateSubscripting;
  38   llvm::OwningPtr<NSAPI> NSAPIObj;
  39   llvm::OwningPtr<edit::EditedSource> Editor;
  40   FileRemapper &Remapper;
  41   FileManager &FileMgr;
  42   const PreprocessingRecord *PPRec;
  43   bool IsOutputFile;
  44
  45   ObjCMigrateASTConsumer(StringRef migrateDir,
  46                          bool migrateLiterals,
  47                          bool migrateSubscripting,
  48                          FileRemapper &remapper,
  49                          FileManager &fileMgr,
  50                          const PreprocessingRecord *PPRec,
  51                          bool isOutputFile = false)
  52   : MigrateDir(migrateDir),
  53     MigrateLiterals(migrateLiterals),
  54     MigrateSubscripting(migrateSubscripting),
  55     Remapper(remapper), FileMgr(fileMgr), PPRec(PPRec),
  56     IsOutputFile(isOutputFile) { }
  57
  58 protected:
  59   virtual void Initialize(ASTContext &Context) {
  60     NSAPIObj.reset(new NSAPI(Context));
  61     Editor.reset(new edit::EditedSource(Context.getSourceManager(),
  62                                         Context.getLangOpts(),
  63                                         PPRec));
  64   }
  65
  66   virtual bool HandleTopLevelDecl(DeclGroupRef DG) {
  67     for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
  68       migrateDecl(*I);
  69     return true;
  70   }
  71   virtual void HandleInterestingDecl(DeclGroupRef DG) {
  72     // Ignore decls from the PCH.
  73   }
  74   virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) {
  75     ObjCMigrateASTConsumer::HandleTopLevelDecl(DG);
  76   }
  77
  78   virtual void HandleTranslationUnit(ASTContext &Ctx);
  79 };
  80
  81 }
  82
  83 ObjCMigrateAction::ObjCMigrateAction(FrontendAction *WrappedAction,
  84                              StringRef migrateDir,
  85                              bool migrateLiterals,
  86                              bool migrateSubscripting)
  87   : WrapperFrontendAction(WrappedAction), MigrateDir(migrateDir),
  88     MigrateLiterals(migrateLiterals), MigrateSubscripting(migrateSubscripting),
  89     CompInst(0) {
  90   if (MigrateDir.empty())
  91     MigrateDir = "."; // user current directory if none is given.
  92 }
  93
  94 ASTConsumer *ObjCMigrateAction::CreateASTConsumer(CompilerInstance &CI,
  95                                                   StringRef InFile) {
  96   ASTConsumer *
  97     WrappedConsumer = WrapperFrontendAction::CreateASTConsumer(CI, InFile);
  98   ASTConsumer *MTConsumer = new ObjCMigrateASTConsumer(MigrateDir,
  99                                                        MigrateLiterals,
 100                                                        MigrateSubscripting,
 101                                                        Remapper,
 102                                                     CompInst->getFileManager(),
 103                           CompInst->getPreprocessor().getPreprocessingRecord());
 104   ASTConsumer *Consumers[] = { MTConsumer, WrappedConsumer };
 105   return new MultiplexConsumer(Consumers);
 106 }
 107
 108 bool ObjCMigrateAction::BeginInvocation(CompilerInstance &CI) {
 109   Remapper.initFromDisk(MigrateDir, CI.getDiagnostics(),
 110                         /*ignoreIfFilesChanges=*/true);
 111   CompInst = &CI;
 112   CI.getDiagnostics().setIgnoreAllWarnings(true);
 113   CI.getPreprocessorOpts().DetailedRecord = true;
 114   CI.getPreprocessorOpts().DetailedRecordConditionalDirectives = true;
 115   return true;
 116 }
 117
 118 namespace {
 119 class ObjCMigrator : public RecursiveASTVisitor<ObjCMigrator> {
 120   ObjCMigrateASTConsumer &Consumer;
 121
 122 public:
 123   ObjCMigrator(ObjCMigrateASTConsumer &consumer) : Consumer(consumer) { }
 124
 125   bool shouldVisitTemplateInstantiations() const { return false; }
 126   bool shouldWalkTypesOfTypeLocs() const { return false; }
 127
 128   bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
 129     if (Consumer.MigrateLiterals) {
 130       edit::Commit commit(*Consumer.Editor);
 131       edit::rewriteToObjCLiteralSyntax(E, *Consumer.NSAPIObj, commit);
 132       Consumer.Editor->commit(commit);
 133     }
 134
 135     if (Consumer.MigrateSubscripting) {
 136       edit::Commit commit(*Consumer.Editor);
 137       edit::rewriteToObjCSubscriptSyntax(E, *Consumer.NSAPIObj, commit);
 138       Consumer.Editor->commit(commit);
 139     }
 140
 141     return true;
 142   }
 143
 144   bool TraverseObjCMessageExpr(ObjCMessageExpr *E) {
 145     // Do depth first; we want to rewrite the subexpressions first so that if
 146     // we have to move expressions we will move them already rewritten.
 147     for (Stmt::child_range range = E->children(); range; ++range)
 148       if (!TraverseStmt(*range))
 149         return false;
 150
 151     return WalkUpFromObjCMessageExpr(E);
 152   }
 153 };
 154 }
 155
 156 void ObjCMigrateASTConsumer::migrateDecl(Decl *D) {
 157   if (!D)
 158     return;
 159   if (isa<ObjCMethodDecl>(D))
 160     return; // Wait for the ObjC container declaration.
 161
 162   ObjCMigrator(*this).TraverseDecl(D);
 163 }
 164
 165 namespace {
 166
 167 class RewritesReceiver : public edit::EditsReceiver {
 168   Rewriter &Rewrite;
 169
 170 public:
 171   RewritesReceiver(Rewriter &Rewrite) : Rewrite(Rewrite) { }
 172
 173   virtual void insert(SourceLocation loc, StringRef text) {
 174     Rewrite.InsertText(loc, text);
 175   }
 176   virtual void replace(CharSourceRange range, StringRef text) {
 177     Rewrite.ReplaceText(range.getBegin(), Rewrite.getRangeSize(range), text);
 178   }
 179 };
 180
 181 }
 182
 183 void ObjCMigrateASTConsumer::HandleTranslationUnit(ASTContext &Ctx) {
 184   Rewriter rewriter(Ctx.getSourceManager(), Ctx.getLangOpts());
 185   RewritesReceiver Rec(rewriter);
 186   Editor->applyRewrites(Rec);
 187
 188   for (Rewriter::buffer_iterator
 189         I = rewriter.buffer_begin(), E = rewriter.buffer_end(); I != E; ++I) {
 190     FileID FID = I->first;
 191     RewriteBuffer &buf = I->second;
 192     const FileEntry *file = Ctx.getSourceManager().getFileEntryForID(FID);
 193     assert(file);
 194     llvm::SmallString<512> newText;
 195     llvm::raw_svector_ostream vecOS(newText);
 196     buf.write(vecOS);
 197     vecOS.flush();
 198     llvm::MemoryBuffer *memBuf = llvm::MemoryBuffer::getMemBufferCopy(
 199                    StringRef(newText.data(), newText.size()), file->getName());
 200     llvm::SmallString<64> filePath(file->getName());
 201     FileMgr.FixupRelativePath(filePath);
 202     Remapper.remap(filePath.str(), memBuf);
 203   }
 204
 205   if (IsOutputFile) {
 206     Remapper.flushToFile(MigrateDir, Ctx.getDiagnostics());
 207   } else {
 208     Remapper.flushToDisk(MigrateDir, Ctx.getDiagnostics());
 209   }
 210 }
 211
 212 bool MigrateSourceAction::BeginInvocation(CompilerInstance &CI) {
 213   CI.getDiagnostics().setIgnoreAllWarnings(true);
 214   CI.getPreprocessorOpts().DetailedRecord = true;
 215   CI.getPreprocessorOpts().DetailedRecordConditionalDirectives = true;
 216   return true;
 217 }
 218
 219 ASTConsumer *MigrateSourceAction::CreateASTConsumer(CompilerInstance &CI,
 220                                                   StringRef InFile) {
 221   return new ObjCMigrateASTConsumer(CI.getFrontendOpts().OutputFile,
 222                                     /*MigrateLiterals=*/true,
 223                                     /*MigrateSubscripting=*/true,
 224                                     Remapper,
 225                                     CI.getFileManager(),
 226                                   CI.getPreprocessor().getPreprocessingRecord(),
 227                                     /*isOutputFile=*/true);
 228 }