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(Binary: false, BaseInput: InFile))
44 return CreateHTMLPrinter(OS: std::move(OS), PP&: 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&: Path,
79 extension: NewSuffix + llvm::sys::path::extension(path: Path));
80 return std::string(Path);
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(Prefix: llvm::sys::path::filename(path: Filename),
89 Suffix: llvm::sys::path::extension(path: Filename).drop_front(), ResultFD&: fd,
90 ResultPath&: Path);
91 return std::string(Path);
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(p: new FixItActionSuffixInserter(FEOpts.FixItSuffix,
100 FEOpts.FixWhatYouCan));
101 } else {
102 FixItOpts.reset(p: new FixItRewriteInPlace);
103 FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
104 }
105 Rewriter.reset(p: 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, 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
153 PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
154 PPOpts.RemappedFiles.insert(position: PPOpts.RemappedFiles.end(),
155 first: RewrittenFiles.begin(), last: 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(Binary: false, BaseInput: InFile, Extension: "cpp")) {
167 if (CI.getLangOpts().ObjCRuntime.isNonFragile())
168 return CreateModernObjCRewriter(InFile: std::string(InFile), OS: std::move(OS),
169 Diags&: CI.getDiagnostics(), LOpts: CI.getLangOpts(),
170 SilenceRewriteMacroWarning: CI.getDiagnosticOpts().NoRewriteMacros,
171 LineInfo: (CI.getCodeGenOpts().getDebugInfo() !=
172 llvm::codegenoptions::NoDebugInfo));
173 return CreateObjCRewriter(InFile: std::string(InFile), OS: std::move(OS),
174 Diags&: CI.getDiagnostics(), LOpts: CI.getLangOpts(),
175 SilenceRewriteMacroWarning: CI.getDiagnosticOpts().NoRewriteMacros);
176 }
177 return nullptr;
178}
179
180#endif
181
182//===----------------------------------------------------------------------===//
183// Preprocessor Actions
184//===----------------------------------------------------------------------===//
185
186void RewriteMacrosAction::ExecuteAction() {
187 CompilerInstance &CI = getCompilerInstance();
188 std::unique_ptr<raw_ostream> OS =
189 CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: getCurrentFileOrBufferName());
190 if (!OS) return;
191
192 RewriteMacrosInInput(PP&: CI.getPreprocessor(), OS: OS.get());
193}
194
195void RewriteTestAction::ExecuteAction() {
196 CompilerInstance &CI = getCompilerInstance();
197 std::unique_ptr<raw_ostream> OS =
198 CI.createDefaultOutputFile(/*Binary=*/false, BaseInput: getCurrentFileOrBufferName());
199 if (!OS) return;
200
201 DoRewriteTest(PP&: CI.getPreprocessor(), OS: OS.get());
202}
203
204class RewriteIncludesAction::RewriteImportsListener : public ASTReaderListener {
205 CompilerInstance &CI;
206 std::weak_ptr<raw_ostream> Out;
207
208 llvm::DenseSet<const FileEntry*> Rewritten;
209
210public:
211 RewriteImportsListener(CompilerInstance &CI, std::shared_ptr<raw_ostream> Out)
212 : CI(CI), Out(Out) {}
213
214 void visitModuleFile(StringRef Filename,
215 serialization::ModuleKind Kind) override {
216 auto File = CI.getFileManager().getFile(Filename);
217 assert(File && "missing file for loaded module?");
218
219 // Only rewrite each module file once.
220 if (!Rewritten.insert(V: *File).second)
221 return;
222
223 serialization::ModuleFile *MF =
224 CI.getASTReader()->getModuleManager().lookup(File: *File);
225 assert(MF && "missing module file for loaded module?");
226
227 // Not interested in PCH / preambles.
228 if (!MF->isModule())
229 return;
230
231 auto OS = Out.lock();
232 assert(OS && "loaded module file after finishing rewrite action?");
233
234 (*OS) << "#pragma clang module build ";
235 if (isValidAsciiIdentifier(S: MF->ModuleName))
236 (*OS) << MF->ModuleName;
237 else {
238 (*OS) << '"';
239 OS->write_escaped(Str: MF->ModuleName);
240 (*OS) << '"';
241 }
242 (*OS) << '\n';
243
244 // Rewrite the contents of the module in a separate compiler instance.
245 CompilerInstance Instance(CI.getPCHContainerOperations(),
246 &CI.getModuleCache());
247 Instance.setInvocation(
248 std::make_shared<CompilerInvocation>(args&: CI.getInvocation()));
249 Instance.createDiagnostics(
250 Client: new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
251 /*ShouldOwnClient=*/true);
252 Instance.getFrontendOpts().DisableFree = false;
253 Instance.getFrontendOpts().Inputs.clear();
254 Instance.getFrontendOpts().Inputs.emplace_back(
255 Args&: Filename, Args: InputKind(Language::Unknown, InputKind::Precompiled));
256 Instance.getFrontendOpts().ModuleFiles.clear();
257 Instance.getFrontendOpts().ModuleMapFiles.clear();
258 // Don't recursively rewrite imports. We handle them all at the top level.
259 Instance.getPreprocessorOutputOpts().RewriteImports = false;
260
261 llvm::CrashRecoveryContext().RunSafelyOnThread([&]() {
262 RewriteIncludesAction Action;
263 Action.OutputStream = OS;
264 Instance.ExecuteAction(Act&: Action);
265 });
266
267 (*OS) << "#pragma clang module endbuild /*" << MF->ModuleName << "*/\n";
268 }
269};
270
271bool RewriteIncludesAction::BeginSourceFileAction(CompilerInstance &CI) {
272 if (!OutputStream) {
273 OutputStream =
274 CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: getCurrentFileOrBufferName());
275 if (!OutputStream)
276 return false;
277 }
278
279 auto &OS = *OutputStream;
280
281 // If we're preprocessing a module map, start by dumping the contents of the
282 // module itself before switching to the input buffer.
283 auto &Input = getCurrentInput();
284 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
285 if (Input.isFile()) {
286 OS << "# 1 \"";
287 OS.write_escaped(Str: Input.getFile());
288 OS << "\"\n";
289 }
290 getCurrentModule()->print(OS);
291 OS << "#pragma clang module contents\n";
292 }
293
294 // If we're rewriting imports, set up a listener to track when we import
295 // module files.
296 if (CI.getPreprocessorOutputOpts().RewriteImports) {
297 CI.createASTReader();
298 CI.getASTReader()->addListener(
299 L: std::make_unique<RewriteImportsListener>(args&: CI, args&: OutputStream));
300 }
301
302 return true;
303}
304
305void RewriteIncludesAction::ExecuteAction() {
306 CompilerInstance &CI = getCompilerInstance();
307
308 // If we're rewriting imports, emit the module build output first rather
309 // than switching back and forth (potentially in the middle of a line).
310 if (CI.getPreprocessorOutputOpts().RewriteImports) {
311 std::string Buffer;
312 llvm::raw_string_ostream OS(Buffer);
313
314 RewriteIncludesInInput(PP&: CI.getPreprocessor(), OS: &OS,
315 Opts: CI.getPreprocessorOutputOpts());
316
317 (*OutputStream) << OS.str();
318 } else {
319 RewriteIncludesInInput(PP&: CI.getPreprocessor(), OS: OutputStream.get(),
320 Opts: CI.getPreprocessorOutputOpts());
321 }
322
323 OutputStream.reset();
324}
325