contrib/llvm/tools/clang/lib/Rewrite/Frontend/FrontendActions.cpp

   1 //===--- FrontendActions.cpp ----------------------------------------------===//
   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/Rewrite/Frontend/FrontendActions.h"
  11 #include "clang/AST/ASTConsumer.h"
  12 #include "clang/Basic/FileManager.h"
  13 #include "clang/Frontend/CompilerInstance.h"
  14 #include "clang/Frontend/FrontendActions.h"
  15 #include "clang/Frontend/FrontendDiagnostic.h"
  16 #include "clang/Frontend/Utils.h"
  17 #include "clang/Lex/Preprocessor.h"
  18 #include "clang/Parse/Parser.h"
  19 #include "clang/Rewrite/Frontend/ASTConsumers.h"
  20 #include "clang/Rewrite/Frontend/FixItRewriter.h"
  21 #include "clang/Rewrite/Frontend/Rewriters.h"
  22 #include "llvm/ADT/OwningPtr.h"
  23 #include "llvm/Support/FileSystem.h"
  24 #include "llvm/Support/Path.h"
  25 #include "llvm/Support/raw_ostream.h"
  26
  27 using namespace clang;
  28
  29 //===----------------------------------------------------------------------===//
  30 // AST Consumer Actions
  31 //===----------------------------------------------------------------------===//
  32
  33 ASTConsumer *HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI,
  34                                                 StringRef InFile) {
  35   if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile))
  36     return CreateHTMLPrinter(OS, CI.getPreprocessor());
  37   return 0;
  38 }
  39
  40 FixItAction::FixItAction() {}
  41 FixItAction::~FixItAction() {}
  42
  43 ASTConsumer *FixItAction::CreateASTConsumer(CompilerInstance &CI,
  44                                             StringRef InFile) {
  45   return new ASTConsumer();
  46 }
  47
  48 namespace {
  49 class FixItRewriteInPlace : public FixItOptions {
  50 public:
  51   std::string RewriteFilename(const std::string &Filename, int &fd) {
  52     fd = -1;
  53     return Filename;
  54   }
  55 };
  56
  57 class FixItActionSuffixInserter : public FixItOptions {
  58   std::string NewSuffix;
  59
  60 public:
  61   FixItActionSuffixInserter(std::string NewSuffix, bool FixWhatYouCan)
  62     : NewSuffix(NewSuffix) {
  63       this->FixWhatYouCan = FixWhatYouCan;
  64   }
  65
  66   std::string RewriteFilename(const std::string &Filename, int &fd) {
  67     fd = -1;
  68     SmallString<128> Path(Filename);
  69     llvm::sys::path::replace_extension(Path,
  70       NewSuffix + llvm::sys::path::extension(Path));
  71     return Path.str();
  72   }
  73 };
  74
  75 class FixItRewriteToTemp : public FixItOptions {
  76 public:
  77   std::string RewriteFilename(const std::string &Filename, int &fd) {
  78     SmallString<128> Path;
  79     Path = llvm::sys::path::filename(Filename);
  80     Path += "-%%%%%%%%";
  81     Path += llvm::sys::path::extension(Filename);
  82     SmallString<128> NewPath;
  83     llvm::sys::fs::unique_file(Path.str(), fd, NewPath);
  84     return NewPath.str();
  85   }
  86 };
  87 } // end anonymous namespace
  88
  89 bool FixItAction::BeginSourceFileAction(CompilerInstance &CI,
  90                                         StringRef Filename) {
  91   const FrontendOptions &FEOpts = getCompilerInstance().getFrontendOpts();
  92   if (!FEOpts.FixItSuffix.empty()) {
  93     FixItOpts.reset(new FixItActionSuffixInserter(FEOpts.FixItSuffix,
  94                                                   FEOpts.FixWhatYouCan));
  95   } else {
  96     FixItOpts.reset(new FixItRewriteInPlace);
  97     FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
  98   }
  99   Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(),
 100                                    CI.getLangOpts(), FixItOpts.get()));
 101   return true;
 102 }
 103
 104 void FixItAction::EndSourceFileAction() {
 105   // Otherwise rewrite all files.
 106   Rewriter->WriteFixedFiles();
 107 }
 108
 109 bool FixItRecompile::BeginInvocation(CompilerInstance &CI) {
 110
 111   std::vector<std::pair<std::string, std::string> > RewrittenFiles;
 112   bool err = false;
 113   {
 114     const FrontendOptions &FEOpts = CI.getFrontendOpts();
 115     OwningPtr<FrontendAction> FixAction(new SyntaxOnlyAction());
 116     if (FixAction->BeginSourceFile(CI, FEOpts.Inputs[0])) {
 117       OwningPtr<FixItOptions> FixItOpts;
 118       if (FEOpts.FixToTemporaries)
 119         FixItOpts.reset(new FixItRewriteToTemp());
 120       else
 121         FixItOpts.reset(new FixItRewriteInPlace());
 122       FixItOpts->Silent = true;
 123       FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
 124       FixItOpts->FixOnlyWarnings = FEOpts.FixOnlyWarnings;
 125       FixItRewriter Rewriter(CI.getDiagnostics(), CI.getSourceManager(),
 126                              CI.getLangOpts(), FixItOpts.get());
 127       FixAction->Execute();
 128
 129       err = Rewriter.WriteFixedFiles(&RewrittenFiles);
 130
 131       FixAction->EndSourceFile();
 132       CI.setSourceManager(0);
 133       CI.setFileManager(0);
 134     } else {
 135       err = true;
 136     }
 137   }
 138   if (err)
 139     return false;
 140   CI.getDiagnosticClient().clear();
 141   CI.getDiagnostics().Reset();
 142
 143   PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
 144   PPOpts.RemappedFiles.insert(PPOpts.RemappedFiles.end(),
 145                               RewrittenFiles.begin(), RewrittenFiles.end());
 146   PPOpts.RemappedFilesKeepOriginalName = false;
 147
 148   return true;
 149 }
 150
 151 //===----------------------------------------------------------------------===//
 152 // Preprocessor Actions
 153 //===----------------------------------------------------------------------===//
 154
 155 ASTConsumer *RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI,
 156                                                   StringRef InFile) {
 157   if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile, "cpp")) {
 158     if (CI.getLangOpts().ObjCRuntime.isNonFragile())
 159       return CreateModernObjCRewriter(InFile, OS,
 160                                 CI.getDiagnostics(), CI.getLangOpts(),
 161                                 CI.getDiagnosticOpts().NoRewriteMacros,
 162                                 (CI.getCodeGenOpts().getDebugInfo() !=
 163                                  CodeGenOptions::NoDebugInfo));
 164     return CreateObjCRewriter(InFile, OS,
 165                               CI.getDiagnostics(), CI.getLangOpts(),
 166                               CI.getDiagnosticOpts().NoRewriteMacros);
 167   }
 168   return 0;
 169 }
 170
 171 void RewriteMacrosAction::ExecuteAction() {
 172   CompilerInstance &CI = getCompilerInstance();
 173   raw_ostream *OS = CI.createDefaultOutputFile(true, getCurrentFile());
 174   if (!OS) return;
 175
 176   RewriteMacrosInInput(CI.getPreprocessor(), OS);
 177 }
 178
 179 void RewriteTestAction::ExecuteAction() {
 180   CompilerInstance &CI = getCompilerInstance();
 181   raw_ostream *OS = CI.createDefaultOutputFile(false, getCurrentFile());
 182   if (!OS) return;
 183
 184   DoRewriteTest(CI.getPreprocessor(), OS);
 185 }
 186
 187 void RewriteIncludesAction::ExecuteAction() {
 188   CompilerInstance &CI = getCompilerInstance();
 189   raw_ostream *OS = CI.createDefaultOutputFile(true, getCurrentFile());
 190   if (!OS) return;
 191
 192   RewriteIncludesInInput(CI.getPreprocessor(), OS,
 193                          CI.getPreprocessorOutputOpts());
 194 }