xref: /freebsd/contrib/llvm-project/clang/lib/Frontend/Rewrite/FrontendActions.cpp (revision 6966ac055c3b7a39266fb982493330df7a097997)
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 }
323