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

   1 //===--- FrontendActions.cpp ----------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "clang/Rewrite/Frontend/FrontendActions.h"
  10 #include "clang/AST/ASTConsumer.h"
  11 #include "clang/Basic/CharInfo.h"
  12 #include "clang/Config/config.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/Lex/PreprocessorOptions.h"
  19 #include "clang/Rewrite/Frontend/ASTConsumers.h"
  20 #include "clang/Rewrite/Frontend/FixItRewriter.h"
  21 #include "clang/Rewrite/Frontend/Rewriters.h"
  22 #include "clang/Serialization/ASTReader.h"
  23 #include "clang/Serialization/Module.h"
  24 #include "clang/Serialization/ModuleManager.h"
  25 #include "llvm/ADT/DenseSet.h"
  26 #include "llvm/Support/CrashRecoveryContext.h"
  27 #include "llvm/Support/FileSystem.h"
  28 #include "llvm/Support/Path.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 #include <memory>
  31 #include <utility>
  32
  33 using namespace clang;
  34
  35 //===----------------------------------------------------------------------===//
  36 // AST Consumer Actions
  37 //===----------------------------------------------------------------------===//
  38
  39 std::unique_ptr<ASTConsumer>
  40 HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  41   if (std::unique_ptr<raw_ostream> OS =
  42           CI.createDefaultOutputFile(false, InFile))
  43     return CreateHTMLPrinter(std::move(OS), CI.getPreprocessor());
  44   return nullptr;
  45 }
  46
  47 FixItAction::FixItAction() {}
  48 FixItAction::~FixItAction() {}
  49
  50 std::unique_ptr<ASTConsumer>
  51 FixItAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
  52   return llvm::make_unique<ASTConsumer>();
  53 }
  54
  55 namespace {
  56 class FixItRewriteInPlace : public FixItOptions {
  57 public:
  58   FixItRewriteInPlace() { InPlace = true; }
  59
  60   std::string RewriteFilename(const std::string &Filename, int &fd) override {
  61     llvm_unreachable("don't call RewriteFilename for inplace rewrites");
  62   }
  63 };
  64
  65 class FixItActionSuffixInserter : public FixItOptions {
  66   std::string NewSuffix;
  67
  68 public:
  69   FixItActionSuffixInserter(std::string NewSuffix, bool FixWhatYouCan)
  70       : NewSuffix(std::move(NewSuffix)) {
  71     this->FixWhatYouCan = FixWhatYouCan;
  72   }
  73
  74   std::string RewriteFilename(const std::string &Filename, int &fd) override {
  75     fd = -1;
  76     SmallString<128> Path(Filename);
  77     llvm::sys::path::replace_extension(Path,
  78       NewSuffix + llvm::sys::path::extension(Path));
  79     return Path.str();
  80   }
  81 };
  82
  83 class FixItRewriteToTemp : public FixItOptions {
  84 public:
  85   std::string RewriteFilename(const std::string &Filename, int &fd) override {
  86     SmallString<128> Path;
  87     llvm::sys::fs::createTemporaryFile(llvm::sys::path::filename(Filename),
  88                                        llvm::sys::path::extension(Filename).drop_front(), fd,
  89                                        Path);
  90     return Path.str();
  91   }
  92 };
  93 } // end anonymous namespace
  94
  95 bool FixItAction::BeginSourceFileAction(CompilerInstance &CI) {
  96   const FrontendOptions &FEOpts = getCompilerInstance().getFrontendOpts();
  97   if (!FEOpts.FixItSuffix.empty()) {
  98     FixItOpts.reset(new FixItActionSuffixInserter(FEOpts.FixItSuffix,
  99                                                   FEOpts.FixWhatYouCan));
 100   } else {
 101     FixItOpts.reset(new FixItRewriteInPlace);
 102     FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
 103   }
 104   Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(),
 105                                    CI.getLangOpts(), FixItOpts.get()));
 106   return true;
 107 }
 108
 109 void FixItAction::EndSourceFileAction() {
 110   // Otherwise rewrite all files.
 111   Rewriter->WriteFixedFiles();
 112 }
 113
 114 bool FixItRecompile::BeginInvocation(CompilerInstance &CI) {
 115
 116   std::vector<std::pair<std::string, std::string> > RewrittenFiles;
 117   bool err = false;
 118   {
 119     const FrontendOptions &FEOpts = CI.getFrontendOpts();
 120     std::unique_ptr<FrontendAction> FixAction(new SyntaxOnlyAction());
 121     if (FixAction->BeginSourceFile(CI, FEOpts.Inputs[0])) {
 122       std::unique_ptr<FixItOptions> FixItOpts;
 123       if (FEOpts.FixToTemporaries)
 124         FixItOpts.reset(new FixItRewriteToTemp());
 125       else
 126         FixItOpts.reset(new FixItRewriteInPlace());
 127       FixItOpts->Silent = true;
 128       FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
 129       FixItOpts->FixOnlyWarnings = FEOpts.FixOnlyWarnings;
 130       FixItRewriter Rewriter(CI.getDiagnostics(), CI.getSourceManager(),
 131                              CI.getLangOpts(), FixItOpts.get());
 132       if (llvm::Error Err = FixAction->Execute()) {
 133         // FIXME this drops the error on the floor.
 134         consumeError(std::move(Err));
 135         return false;
 136       }
 137
 138       err = Rewriter.WriteFixedFiles(&RewrittenFiles);
 139
 140       FixAction->EndSourceFile();
 141       CI.setSourceManager(nullptr);
 142       CI.setFileManager(nullptr);
 143     } else {
 144       err = true;
 145     }
 146   }
 147   if (err)
 148     return false;
 149   CI.getDiagnosticClient().clear();
 150   CI.getDiagnostics().Reset();
 151
 152   PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
 153   PPOpts.RemappedFiles.insert(PPOpts.RemappedFiles.end(),
 154                               RewrittenFiles.begin(), RewrittenFiles.end());
 155   PPOpts.RemappedFilesKeepOriginalName = false;
 156
 157   return true;
 158 }
 159
 160 #if CLANG_ENABLE_OBJC_REWRITER
 161
 162 std::unique_ptr<ASTConsumer>
 163 RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
 164   if (std::unique_ptr<raw_ostream> OS =
 165           CI.createDefaultOutputFile(false, InFile, "cpp")) {
 166     if (CI.getLangOpts().ObjCRuntime.isNonFragile())
 167       return CreateModernObjCRewriter(
 168           InFile, std::move(OS), CI.getDiagnostics(), CI.getLangOpts(),
 169           CI.getDiagnosticOpts().NoRewriteMacros,
 170           (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo));
 171     return CreateObjCRewriter(InFile, std::move(OS), CI.getDiagnostics(),
 172                               CI.getLangOpts(),
 173                               CI.getDiagnosticOpts().NoRewriteMacros);
 174   }
 175   return nullptr;
 176 }
 177
 178 #endif
 179
 180 //===----------------------------------------------------------------------===//
 181 // Preprocessor Actions
 182 //===----------------------------------------------------------------------===//
 183
 184 void RewriteMacrosAction::ExecuteAction() {
 185   CompilerInstance &CI = getCompilerInstance();
 186   std::unique_ptr<raw_ostream> OS =
 187       CI.createDefaultOutputFile(true, getCurrentFileOrBufferName());
 188   if (!OS) return;
 189
 190   RewriteMacrosInInput(CI.getPreprocessor(), OS.get());
 191 }
 192
 193 void RewriteTestAction::ExecuteAction() {
 194   CompilerInstance &CI = getCompilerInstance();
 195   std::unique_ptr<raw_ostream> OS =
 196       CI.createDefaultOutputFile(false, getCurrentFileOrBufferName());
 197   if (!OS) return;
 198
 199   DoRewriteTest(CI.getPreprocessor(), OS.get());
 200 }
 201
 202 class RewriteIncludesAction::RewriteImportsListener : public ASTReaderListener {
 203   CompilerInstance &CI;
 204   std::weak_ptr<raw_ostream> Out;
 205
 206   llvm::DenseSet<const FileEntry*> Rewritten;
 207
 208 public:
 209   RewriteImportsListener(CompilerInstance &CI, std::shared_ptr<raw_ostream> Out)
 210       : CI(CI), Out(Out) {}
 211
 212   void visitModuleFile(StringRef Filename,
 213                        serialization::ModuleKind Kind) override {
 214     auto *File = CI.getFileManager().getFile(Filename);
 215     assert(File && "missing file for loaded module?");
 216
 217     // Only rewrite each module file once.
 218     if (!Rewritten.insert(File).second)
 219       return;
 220
 221     serialization::ModuleFile *MF =
 222         CI.getModuleManager()->getModuleManager().lookup(File);
 223     assert(File && "missing module file for loaded module?");
 224
 225     // Not interested in PCH / preambles.
 226     if (!MF->isModule())
 227       return;
 228
 229     auto OS = Out.lock();
 230     assert(OS && "loaded module file after finishing rewrite action?");
 231
 232     (*OS) << "#pragma clang module build ";
 233     if (isValidIdentifier(MF->ModuleName))
 234       (*OS) << MF->ModuleName;
 235     else {
 236       (*OS) << '"';
 237       OS->write_escaped(MF->ModuleName);
 238       (*OS) << '"';
 239     }
 240     (*OS) << '\n';
 241
 242     // Rewrite the contents of the module in a separate compiler instance.
 243     CompilerInstance Instance(CI.getPCHContainerOperations(),
 244                               &CI.getModuleCache());
 245     Instance.setInvocation(
 246         std::make_shared<CompilerInvocation>(CI.getInvocation()));
 247     Instance.createDiagnostics(
 248         new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
 249         /*ShouldOwnClient=*/true);
 250     Instance.getFrontendOpts().DisableFree = false;
 251     Instance.getFrontendOpts().Inputs.clear();
 252     Instance.getFrontendOpts().Inputs.emplace_back(
 253         Filename, InputKind(InputKind::Unknown, InputKind::Precompiled));
 254     Instance.getFrontendOpts().ModuleFiles.clear();
 255     Instance.getFrontendOpts().ModuleMapFiles.clear();
 256     // Don't recursively rewrite imports. We handle them all at the top level.
 257     Instance.getPreprocessorOutputOpts().RewriteImports = false;
 258
 259     llvm::CrashRecoveryContext().RunSafelyOnThread([&]() {
 260       RewriteIncludesAction Action;
 261       Action.OutputStream = OS;
 262       Instance.ExecuteAction(Action);
 263     });
 264
 265     (*OS) << "#pragma clang module endbuild /*" << MF->ModuleName << "*/\n";
 266   }
 267 };
 268
 269 bool RewriteIncludesAction::BeginSourceFileAction(CompilerInstance &CI) {
 270   if (!OutputStream) {
 271     OutputStream =
 272         CI.createDefaultOutputFile(true, getCurrentFileOrBufferName());
 273     if (!OutputStream)
 274       return false;
 275   }
 276
 277   auto &OS = *OutputStream;
 278
 279   // If we're preprocessing a module map, start by dumping the contents of the
 280   // module itself before switching to the input buffer.
 281   auto &Input = getCurrentInput();
 282   if (Input.getKind().getFormat() == InputKind::ModuleMap) {
 283     if (Input.isFile()) {
 284       OS << "# 1 \"";
 285       OS.write_escaped(Input.getFile());
 286       OS << "\"\n";
 287     }
 288     getCurrentModule()->print(OS);
 289     OS << "#pragma clang module contents\n";
 290   }
 291
 292   // If we're rewriting imports, set up a listener to track when we import
 293   // module files.
 294   if (CI.getPreprocessorOutputOpts().RewriteImports) {
 295     CI.createModuleManager();
 296     CI.getModuleManager()->addListener(
 297         llvm::make_unique<RewriteImportsListener>(CI, OutputStream));
 298   }
 299
 300   return true;
 301 }
 302
 303 void RewriteIncludesAction::ExecuteAction() {
 304   CompilerInstance &CI = getCompilerInstance();
 305
 306   // If we're rewriting imports, emit the module build output first rather
 307   // than switching back and forth (potentially in the middle of a line).
 308   if (CI.getPreprocessorOutputOpts().RewriteImports) {
 309     std::string Buffer;
 310     llvm::raw_string_ostream OS(Buffer);
 311
 312     RewriteIncludesInInput(CI.getPreprocessor(), &OS,
 313                            CI.getPreprocessorOutputOpts());
 314
 315     (*OutputStream) << OS.str();
 316   } else {
 317     RewriteIncludesInInput(CI.getPreprocessor(), OutputStream.get(),
 318                            CI.getPreprocessorOutputOpts());
 319   }
 320
 321   OutputStream.reset();
 322 }