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/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/ModuleFile.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
33using namespace clang;
34
35//===----------------------------------------------------------------------===//
36// AST Consumer Actions
37//===----------------------------------------------------------------------===//
38
39std::unique_ptr<ASTConsumer>
40HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
41 if (std::unique_ptr<raw_ostream> OS =
42 CI.createDefaultOutputFile(Binary: false, BaseInput: InFile))
43 return CreateHTMLPrinter(OS: std::move(OS), PP&: CI.getPreprocessor());
44 return nullptr;
45}
46
47FixItAction::FixItAction() {}
48FixItAction::~FixItAction() {}
49
50std::unique_ptr<ASTConsumer>
51FixItAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
52 return std::make_unique<ASTConsumer>();
53}
54
55namespace {
56class FixItRewriteInPlace : public FixItOptions {
57public:
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
65class FixItActionSuffixInserter : public FixItOptions {
66 std::string NewSuffix;
67
68public:
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&: Path,
78 extension: NewSuffix + llvm::sys::path::extension(path: Path));
79 return std::string(Path);
80 }
81};
82
83class FixItRewriteToTemp : public FixItOptions {
84public:
85 std::string RewriteFilename(const std::string &Filename, int &fd) override {
86 SmallString<128> Path;
87 llvm::sys::fs::createTemporaryFile(Prefix: llvm::sys::path::filename(path: Filename),
88 Suffix: llvm::sys::path::extension(path: Filename).drop_front(), ResultFD&: fd,
89 ResultPath&: Path);
90 return std::string(Path);
91 }
92};
93} // end anonymous namespace
94
95bool FixItAction::BeginSourceFileAction(CompilerInstance &CI) {
96 const FrontendOptions &FEOpts = getCompilerInstance().getFrontendOpts();
97 if (!FEOpts.FixItSuffix.empty()) {
98 FixItOpts.reset(p: new FixItActionSuffixInserter(FEOpts.FixItSuffix,
99 FEOpts.FixWhatYouCan));
100 } else {
101 FixItOpts.reset(p: new FixItRewriteInPlace);
102 FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
103 }
104 Rewriter.reset(p: new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(),
105 CI.getLangOpts(), FixItOpts.get()));
106 return ASTFrontendAction::BeginSourceFileAction(CI);
107}
108
109void FixItAction::EndSourceFileAction() {
110 // Otherwise rewrite all files.
111 Rewriter->WriteFixedFiles();
112 ASTFrontendAction::EndSourceFileAction();
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, Input: FEOpts.Inputs[0])) {
123 std::unique_ptr<FixItOptions> FixItOpts;
124 if (FEOpts.FixToTemporaries)
125 FixItOpts.reset(p: new FixItRewriteToTemp());
126 else
127 FixItOpts.reset(p: 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(Err: std::move(Err));
136 return false;
137 }
138
139 err = Rewriter.WriteFixedFiles(RewrittenFiles: &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 ProcessWarningOptions(Diags&: CI.getDiagnostics(), Opts: CI.getDiagnosticOpts(),
153 VFS&: CI.getVirtualFileSystem());
154
155 PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
156 PPOpts.RemappedFiles.insert(position: PPOpts.RemappedFiles.end(),
157 first: RewrittenFiles.begin(), last: RewrittenFiles.end());
158 PPOpts.RemappedFilesKeepOriginalName = false;
159
160 return true;
161}
162
163#if CLANG_ENABLE_OBJC_REWRITER
164
165std::unique_ptr<ASTConsumer>
166RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
167 if (std::unique_ptr<raw_ostream> OS =
168 CI.createDefaultOutputFile(false, InFile, "cpp")) {
169 if (CI.getLangOpts().ObjCRuntime.isNonFragile())
170 return CreateModernObjCRewriter(std::string(InFile), std::move(OS),
171 CI.getDiagnostics(), CI.getLangOpts(),
172 CI.getDiagnosticOpts().NoRewriteMacros,
173 (CI.getCodeGenOpts().getDebugInfo() !=
174 llvm::codegenoptions::NoDebugInfo));
175 return CreateObjCRewriter(std::string(InFile), std::move(OS),
176 CI.getDiagnostics(), CI.getLangOpts(),
177 CI.getDiagnosticOpts().NoRewriteMacros);
178 }
179 return nullptr;
180}
181
182#endif
183
184//===----------------------------------------------------------------------===//
185// Preprocessor Actions
186//===----------------------------------------------------------------------===//
187
188void RewriteMacrosAction::ExecuteAction() {
189 CompilerInstance &CI = getCompilerInstance();
190 std::unique_ptr<raw_ostream> OS =
191 CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: getCurrentFileOrBufferName());
192 if (!OS) return;
193
194 RewriteMacrosInInput(PP&: CI.getPreprocessor(), OS: OS.get());
195}
196
197void RewriteTestAction::ExecuteAction() {
198 CompilerInstance &CI = getCompilerInstance();
199 std::unique_ptr<raw_ostream> OS =
200 CI.createDefaultOutputFile(/*Binary=*/false, BaseInput: getCurrentFileOrBufferName());
201 if (!OS) return;
202
203 DoRewriteTest(PP&: CI.getPreprocessor(), OS: OS.get());
204}
205
206class RewriteIncludesAction::RewriteImportsListener : public ASTReaderListener {
207 CompilerInstance &CI;
208 std::weak_ptr<raw_ostream> Out;
209
210 llvm::DenseSet<const serialization::ModuleFile *> Rewritten;
211
212public:
213 RewriteImportsListener(CompilerInstance &CI, std::shared_ptr<raw_ostream> Out)
214 : CI(CI), Out(Out) {}
215
216 void visitModuleFile(ModuleFileName Filename, serialization::ModuleKind Kind,
217 bool DirectlyImported) override {
218 serialization::ModuleFile *MF =
219 CI.getASTReader()->getModuleManager().lookupByFileName(FileName: Filename);
220 assert(MF && "missing module file for loaded module?");
221
222 // Only rewrite each module file once.
223 if (!Rewritten.insert(V: MF).second)
224 return;
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 (isValidAsciiIdentifier(S: MF->ModuleName))
235 (*OS) << MF->ModuleName;
236 else {
237 (*OS) << '"';
238 OS->write_escaped(Str: MF->ModuleName);
239 (*OS) << '"';
240 }
241 (*OS) << '\n';
242
243 // Rewrite the contents of the module in a separate compiler instance.
244 CompilerInstance Instance(
245 std::make_shared<CompilerInvocation>(args&: CI.getInvocation()),
246 CI.getPCHContainerOperations(), CI.getModuleCachePtr());
247 Instance.setVirtualFileSystem(CI.getVirtualFileSystemPtr());
248 Instance.createDiagnostics(
249 Client: new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
250 /*ShouldOwnClient=*/true);
251 Instance.getFrontendOpts().DisableFree = false;
252 Instance.getFrontendOpts().Inputs.clear();
253 Instance.getFrontendOpts().Inputs.emplace_back(
254 Args&: Filename, Args: 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(Act&: 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(/*Binary=*/true, BaseInput: 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(Str: 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 L: std::make_unique<RewriteImportsListener>(args&: CI, args&: OutputStream));
299 }
300
301 return PreprocessorFrontendAction::BeginSourceFileAction(CI);
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(PP&: CI.getPreprocessor(), OS: &OS,
314 Opts: CI.getPreprocessorOutputOpts());
315
316 (*OutputStream) << OS.str();
317 } else {
318 RewriteIncludesInInput(PP&: CI.getPreprocessor(), OS: OutputStream.get(),
319 Opts: CI.getPreprocessorOutputOpts());
320 }
321
322 OutputStream.reset();
323}
324