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