1 //===--- FrontendAction.cpp -----------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "clang/Frontend/FrontendAction.h"
11 #include "clang/AST/ASTConsumer.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/AST/DeclGroup.h"
14 #include "clang/Frontend/ASTUnit.h"
15 #include "clang/Frontend/CompilerInstance.h"
16 #include "clang/Frontend/FrontendDiagnostic.h"
17 #include "clang/Frontend/FrontendPluginRegistry.h"
18 #include "clang/Frontend/LayoutOverrideSource.h"
19 #include "clang/Frontend/MultiplexConsumer.h"
20 #include "clang/Frontend/Utils.h"
21 #include "clang/Lex/HeaderSearch.h"
22 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Parse/ParseAST.h"
24 #include "clang/Serialization/ASTDeserializationListener.h"
25 #include "clang/Serialization/ASTReader.h"
26 #include "clang/Serialization/GlobalModuleIndex.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/MemoryBuffer.h"
30 #include "llvm/Support/Timer.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include <system_error>
33 using namespace clang;
34
35 template class llvm::Registry<clang::PluginASTAction>;
36
37 namespace {
38
39 class DelegatingDeserializationListener : public ASTDeserializationListener {
40 ASTDeserializationListener *Previous;
41 bool DeletePrevious;
42
43 public:
DelegatingDeserializationListener(ASTDeserializationListener * Previous,bool DeletePrevious)44 explicit DelegatingDeserializationListener(
45 ASTDeserializationListener *Previous, bool DeletePrevious)
46 : Previous(Previous), DeletePrevious(DeletePrevious) {}
~DelegatingDeserializationListener()47 virtual ~DelegatingDeserializationListener() {
48 if (DeletePrevious)
49 delete Previous;
50 }
51
ReaderInitialized(ASTReader * Reader)52 void ReaderInitialized(ASTReader *Reader) override {
53 if (Previous)
54 Previous->ReaderInitialized(Reader);
55 }
IdentifierRead(serialization::IdentID ID,IdentifierInfo * II)56 void IdentifierRead(serialization::IdentID ID,
57 IdentifierInfo *II) override {
58 if (Previous)
59 Previous->IdentifierRead(ID, II);
60 }
TypeRead(serialization::TypeIdx Idx,QualType T)61 void TypeRead(serialization::TypeIdx Idx, QualType T) override {
62 if (Previous)
63 Previous->TypeRead(Idx, T);
64 }
DeclRead(serialization::DeclID ID,const Decl * D)65 void DeclRead(serialization::DeclID ID, const Decl *D) override {
66 if (Previous)
67 Previous->DeclRead(ID, D);
68 }
SelectorRead(serialization::SelectorID ID,Selector Sel)69 void SelectorRead(serialization::SelectorID ID, Selector Sel) override {
70 if (Previous)
71 Previous->SelectorRead(ID, Sel);
72 }
MacroDefinitionRead(serialization::PreprocessedEntityID PPID,MacroDefinition * MD)73 void MacroDefinitionRead(serialization::PreprocessedEntityID PPID,
74 MacroDefinition *MD) override {
75 if (Previous)
76 Previous->MacroDefinitionRead(PPID, MD);
77 }
78 };
79
80 /// \brief Dumps deserialized declarations.
81 class DeserializedDeclsDumper : public DelegatingDeserializationListener {
82 public:
DeserializedDeclsDumper(ASTDeserializationListener * Previous,bool DeletePrevious)83 explicit DeserializedDeclsDumper(ASTDeserializationListener *Previous,
84 bool DeletePrevious)
85 : DelegatingDeserializationListener(Previous, DeletePrevious) {}
86
DeclRead(serialization::DeclID ID,const Decl * D)87 void DeclRead(serialization::DeclID ID, const Decl *D) override {
88 llvm::outs() << "PCH DECL: " << D->getDeclKindName();
89 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
90 llvm::outs() << " - " << *ND;
91 llvm::outs() << "\n";
92
93 DelegatingDeserializationListener::DeclRead(ID, D);
94 }
95 };
96
97 /// \brief Checks deserialized declarations and emits error if a name
98 /// matches one given in command-line using -error-on-deserialized-decl.
99 class DeserializedDeclsChecker : public DelegatingDeserializationListener {
100 ASTContext &Ctx;
101 std::set<std::string> NamesToCheck;
102
103 public:
DeserializedDeclsChecker(ASTContext & Ctx,const std::set<std::string> & NamesToCheck,ASTDeserializationListener * Previous,bool DeletePrevious)104 DeserializedDeclsChecker(ASTContext &Ctx,
105 const std::set<std::string> &NamesToCheck,
106 ASTDeserializationListener *Previous,
107 bool DeletePrevious)
108 : DelegatingDeserializationListener(Previous, DeletePrevious), Ctx(Ctx),
109 NamesToCheck(NamesToCheck) {}
110
DeclRead(serialization::DeclID ID,const Decl * D)111 void DeclRead(serialization::DeclID ID, const Decl *D) override {
112 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
113 if (NamesToCheck.find(ND->getNameAsString()) != NamesToCheck.end()) {
114 unsigned DiagID
115 = Ctx.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error,
116 "%0 was deserialized");
117 Ctx.getDiagnostics().Report(Ctx.getFullLoc(D->getLocation()), DiagID)
118 << ND->getNameAsString();
119 }
120
121 DelegatingDeserializationListener::DeclRead(ID, D);
122 }
123 };
124
125 } // end anonymous namespace
126
FrontendAction()127 FrontendAction::FrontendAction() : Instance(nullptr) {}
128
~FrontendAction()129 FrontendAction::~FrontendAction() {}
130
setCurrentInput(const FrontendInputFile & CurrentInput,std::unique_ptr<ASTUnit> AST)131 void FrontendAction::setCurrentInput(const FrontendInputFile &CurrentInput,
132 std::unique_ptr<ASTUnit> AST) {
133 this->CurrentInput = CurrentInput;
134 CurrentASTUnit = std::move(AST);
135 }
136
137 std::unique_ptr<ASTConsumer>
CreateWrappedASTConsumer(CompilerInstance & CI,StringRef InFile)138 FrontendAction::CreateWrappedASTConsumer(CompilerInstance &CI,
139 StringRef InFile) {
140 std::unique_ptr<ASTConsumer> Consumer = CreateASTConsumer(CI, InFile);
141 if (!Consumer)
142 return nullptr;
143
144 if (CI.getFrontendOpts().AddPluginActions.size() == 0)
145 return Consumer;
146
147 // Make sure the non-plugin consumer is first, so that plugins can't
148 // modifiy the AST.
149 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
150 Consumers.push_back(std::move(Consumer));
151
152 for (size_t i = 0, e = CI.getFrontendOpts().AddPluginActions.size();
153 i != e; ++i) {
154 // This is O(|plugins| * |add_plugins|), but since both numbers are
155 // way below 50 in practice, that's ok.
156 for (FrontendPluginRegistry::iterator
157 it = FrontendPluginRegistry::begin(),
158 ie = FrontendPluginRegistry::end();
159 it != ie; ++it) {
160 if (it->getName() != CI.getFrontendOpts().AddPluginActions[i])
161 continue;
162 std::unique_ptr<PluginASTAction> P = it->instantiate();
163 if (P->ParseArgs(CI, CI.getFrontendOpts().AddPluginArgs[i]))
164 Consumers.push_back(P->CreateASTConsumer(CI, InFile));
165 }
166 }
167
168 return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
169 }
170
BeginSourceFile(CompilerInstance & CI,const FrontendInputFile & Input)171 bool FrontendAction::BeginSourceFile(CompilerInstance &CI,
172 const FrontendInputFile &Input) {
173 assert(!Instance && "Already processing a source file!");
174 assert(!Input.isEmpty() && "Unexpected empty filename!");
175 setCurrentInput(Input);
176 setCompilerInstance(&CI);
177
178 StringRef InputFile = Input.getFile();
179 bool HasBegunSourceFile = false;
180 if (!BeginInvocation(CI))
181 goto failure;
182
183 // AST files follow a very different path, since they share objects via the
184 // AST unit.
185 if (Input.getKind() == IK_AST) {
186 assert(!usesPreprocessorOnly() &&
187 "Attempt to pass AST file to preprocessor only action!");
188 assert(hasASTFileSupport() &&
189 "This action does not have AST file support!");
190
191 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(&CI.getDiagnostics());
192
193 std::unique_ptr<ASTUnit> AST =
194 ASTUnit::LoadFromASTFile(InputFile, Diags, CI.getFileSystemOpts());
195
196 if (!AST)
197 goto failure;
198
199 // Inform the diagnostic client we are processing a source file.
200 CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
201 HasBegunSourceFile = true;
202
203 // Set the shared objects, these are reset when we finish processing the
204 // file, otherwise the CompilerInstance will happily destroy them.
205 CI.setFileManager(&AST->getFileManager());
206 CI.setSourceManager(&AST->getSourceManager());
207 CI.setPreprocessor(&AST->getPreprocessor());
208 CI.setASTContext(&AST->getASTContext());
209
210 setCurrentInput(Input, std::move(AST));
211
212 // Initialize the action.
213 if (!BeginSourceFileAction(CI, InputFile))
214 goto failure;
215
216 // Create the AST consumer.
217 CI.setASTConsumer(CreateWrappedASTConsumer(CI, InputFile));
218 if (!CI.hasASTConsumer())
219 goto failure;
220
221 return true;
222 }
223
224 if (!CI.hasVirtualFileSystem()) {
225 if (IntrusiveRefCntPtr<vfs::FileSystem> VFS =
226 createVFSFromCompilerInvocation(CI.getInvocation(),
227 CI.getDiagnostics()))
228 CI.setVirtualFileSystem(VFS);
229 else
230 goto failure;
231 }
232
233 // Set up the file and source managers, if needed.
234 if (!CI.hasFileManager())
235 CI.createFileManager();
236 if (!CI.hasSourceManager())
237 CI.createSourceManager(CI.getFileManager());
238
239 // IR files bypass the rest of initialization.
240 if (Input.getKind() == IK_LLVM_IR) {
241 assert(hasIRSupport() &&
242 "This action does not have IR file support!");
243
244 // Inform the diagnostic client we are processing a source file.
245 CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(), nullptr);
246 HasBegunSourceFile = true;
247
248 // Initialize the action.
249 if (!BeginSourceFileAction(CI, InputFile))
250 goto failure;
251
252 // Initialize the main file entry.
253 if (!CI.InitializeSourceManager(CurrentInput))
254 goto failure;
255
256 return true;
257 }
258
259 // If the implicit PCH include is actually a directory, rather than
260 // a single file, search for a suitable PCH file in that directory.
261 if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
262 FileManager &FileMgr = CI.getFileManager();
263 PreprocessorOptions &PPOpts = CI.getPreprocessorOpts();
264 StringRef PCHInclude = PPOpts.ImplicitPCHInclude;
265 if (const DirectoryEntry *PCHDir = FileMgr.getDirectory(PCHInclude)) {
266 std::error_code EC;
267 SmallString<128> DirNative;
268 llvm::sys::path::native(PCHDir->getName(), DirNative);
269 bool Found = false;
270 for (llvm::sys::fs::directory_iterator Dir(DirNative.str(), EC), DirEnd;
271 Dir != DirEnd && !EC; Dir.increment(EC)) {
272 // Check whether this is an acceptable AST file.
273 if (ASTReader::isAcceptableASTFile(Dir->path(), FileMgr,
274 CI.getLangOpts(),
275 CI.getTargetOpts(),
276 CI.getPreprocessorOpts())) {
277 PPOpts.ImplicitPCHInclude = Dir->path();
278 Found = true;
279 break;
280 }
281 }
282
283 if (!Found) {
284 CI.getDiagnostics().Report(diag::err_fe_no_pch_in_dir) << PCHInclude;
285 return true;
286 }
287 }
288 }
289
290 // Set up the preprocessor if needed. When parsing model files the
291 // preprocessor of the original source is reused.
292 if (!isModelParsingAction())
293 CI.createPreprocessor(getTranslationUnitKind());
294
295 // Inform the diagnostic client we are processing a source file.
296 CI.getDiagnosticClient().BeginSourceFile(CI.getLangOpts(),
297 &CI.getPreprocessor());
298 HasBegunSourceFile = true;
299
300 // Initialize the action.
301 if (!BeginSourceFileAction(CI, InputFile))
302 goto failure;
303
304 // Initialize the main file entry. It is important that this occurs after
305 // BeginSourceFileAction, which may change CurrentInput during module builds.
306 if (!CI.InitializeSourceManager(CurrentInput))
307 goto failure;
308
309 // Create the AST context and consumer unless this is a preprocessor only
310 // action.
311 if (!usesPreprocessorOnly()) {
312 // Parsing a model file should reuse the existing ASTContext.
313 if (!isModelParsingAction())
314 CI.createASTContext();
315
316 std::unique_ptr<ASTConsumer> Consumer =
317 CreateWrappedASTConsumer(CI, InputFile);
318 if (!Consumer)
319 goto failure;
320
321 // FIXME: should not overwrite ASTMutationListener when parsing model files?
322 if (!isModelParsingAction())
323 CI.getASTContext().setASTMutationListener(Consumer->GetASTMutationListener());
324
325 if (!CI.getPreprocessorOpts().ChainedIncludes.empty()) {
326 // Convert headers to PCH and chain them.
327 IntrusiveRefCntPtr<ExternalSemaSource> source, FinalReader;
328 source = createChainedIncludesSource(CI, FinalReader);
329 if (!source)
330 goto failure;
331 CI.setModuleManager(static_cast<ASTReader *>(FinalReader.get()));
332 CI.getASTContext().setExternalSource(source);
333 } else if (!CI.getPreprocessorOpts().ImplicitPCHInclude.empty()) {
334 // Use PCH.
335 assert(hasPCHSupport() && "This action does not have PCH support!");
336 ASTDeserializationListener *DeserialListener =
337 Consumer->GetASTDeserializationListener();
338 bool DeleteDeserialListener = false;
339 if (CI.getPreprocessorOpts().DumpDeserializedPCHDecls) {
340 DeserialListener = new DeserializedDeclsDumper(DeserialListener,
341 DeleteDeserialListener);
342 DeleteDeserialListener = true;
343 }
344 if (!CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn.empty()) {
345 DeserialListener = new DeserializedDeclsChecker(
346 CI.getASTContext(),
347 CI.getPreprocessorOpts().DeserializedPCHDeclsToErrorOn,
348 DeserialListener, DeleteDeserialListener);
349 DeleteDeserialListener = true;
350 }
351 CI.createPCHExternalASTSource(
352 CI.getPreprocessorOpts().ImplicitPCHInclude,
353 CI.getPreprocessorOpts().DisablePCHValidation,
354 CI.getPreprocessorOpts().AllowPCHWithCompilerErrors, DeserialListener,
355 DeleteDeserialListener);
356 if (!CI.getASTContext().getExternalSource())
357 goto failure;
358 }
359
360 CI.setASTConsumer(std::move(Consumer));
361 if (!CI.hasASTConsumer())
362 goto failure;
363 }
364
365 // Initialize built-in info as long as we aren't using an external AST
366 // source.
367 if (!CI.hasASTContext() || !CI.getASTContext().getExternalSource()) {
368 Preprocessor &PP = CI.getPreprocessor();
369
370 // If modules are enabled, create the module manager before creating
371 // any builtins, so that all declarations know that they might be
372 // extended by an external source.
373 if (CI.getLangOpts().Modules)
374 CI.createModuleManager();
375
376 PP.getBuiltinInfo().InitializeBuiltins(PP.getIdentifierTable(),
377 PP.getLangOpts());
378 } else {
379 // FIXME: If this is a problem, recover from it by creating a multiplex
380 // source.
381 assert((!CI.getLangOpts().Modules || CI.getModuleManager()) &&
382 "modules enabled but created an external source that "
383 "doesn't support modules");
384 }
385
386 // If we were asked to load any module files, do so now.
387 for (const auto &ModuleFile : CI.getFrontendOpts().ModuleFiles)
388 if (!CI.loadModuleFile(ModuleFile))
389 goto failure;
390
391 // If there is a layout overrides file, attach an external AST source that
392 // provides the layouts from that file.
393 if (!CI.getFrontendOpts().OverrideRecordLayoutsFile.empty() &&
394 CI.hasASTContext() && !CI.getASTContext().getExternalSource()) {
395 IntrusiveRefCntPtr<ExternalASTSource>
396 Override(new LayoutOverrideSource(
397 CI.getFrontendOpts().OverrideRecordLayoutsFile));
398 CI.getASTContext().setExternalSource(Override);
399 }
400
401 return true;
402
403 // If we failed, reset state since the client will not end up calling the
404 // matching EndSourceFile().
405 failure:
406 if (isCurrentFileAST()) {
407 CI.setASTContext(nullptr);
408 CI.setPreprocessor(nullptr);
409 CI.setSourceManager(nullptr);
410 CI.setFileManager(nullptr);
411 }
412
413 if (HasBegunSourceFile)
414 CI.getDiagnosticClient().EndSourceFile();
415 CI.clearOutputFiles(/*EraseFiles=*/true);
416 setCurrentInput(FrontendInputFile());
417 setCompilerInstance(nullptr);
418 return false;
419 }
420
Execute()421 bool FrontendAction::Execute() {
422 CompilerInstance &CI = getCompilerInstance();
423
424 if (CI.hasFrontendTimer()) {
425 llvm::TimeRegion Timer(CI.getFrontendTimer());
426 ExecuteAction();
427 }
428 else ExecuteAction();
429
430 // If we are supposed to rebuild the global module index, do so now unless
431 // there were any module-build failures.
432 if (CI.shouldBuildGlobalModuleIndex() && CI.hasFileManager() &&
433 CI.hasPreprocessor()) {
434 GlobalModuleIndex::writeIndex(
435 CI.getFileManager(),
436 CI.getPreprocessor().getHeaderSearchInfo().getModuleCachePath());
437 }
438
439 return true;
440 }
441
EndSourceFile()442 void FrontendAction::EndSourceFile() {
443 CompilerInstance &CI = getCompilerInstance();
444
445 // Inform the diagnostic client we are done with this source file.
446 CI.getDiagnosticClient().EndSourceFile();
447
448 // Inform the preprocessor we are done.
449 if (CI.hasPreprocessor())
450 CI.getPreprocessor().EndSourceFile();
451
452 // Finalize the action.
453 EndSourceFileAction();
454
455 // Sema references the ast consumer, so reset sema first.
456 //
457 // FIXME: There is more per-file stuff we could just drop here?
458 bool DisableFree = CI.getFrontendOpts().DisableFree;
459 if (DisableFree) {
460 if (!isCurrentFileAST()) {
461 CI.resetAndLeakSema();
462 CI.resetAndLeakASTContext();
463 }
464 BuryPointer(CI.takeASTConsumer().get());
465 } else {
466 if (!isCurrentFileAST()) {
467 CI.setSema(nullptr);
468 CI.setASTContext(nullptr);
469 }
470 CI.setASTConsumer(nullptr);
471 }
472
473 if (CI.getFrontendOpts().ShowStats) {
474 llvm::errs() << "\nSTATISTICS FOR '" << getCurrentFile() << "':\n";
475 CI.getPreprocessor().PrintStats();
476 CI.getPreprocessor().getIdentifierTable().PrintStats();
477 CI.getPreprocessor().getHeaderSearchInfo().PrintStats();
478 CI.getSourceManager().PrintStats();
479 llvm::errs() << "\n";
480 }
481
482 // Cleanup the output streams, and erase the output files if instructed by the
483 // FrontendAction.
484 CI.clearOutputFiles(/*EraseFiles=*/shouldEraseOutputFiles());
485
486 // FIXME: Only do this if DisableFree is set.
487 if (isCurrentFileAST()) {
488 CI.resetAndLeakSema();
489 CI.resetAndLeakASTContext();
490 CI.resetAndLeakPreprocessor();
491 CI.resetAndLeakSourceManager();
492 CI.resetAndLeakFileManager();
493 }
494
495 setCompilerInstance(nullptr);
496 setCurrentInput(FrontendInputFile());
497 }
498
shouldEraseOutputFiles()499 bool FrontendAction::shouldEraseOutputFiles() {
500 return getCompilerInstance().getDiagnostics().hasErrorOccurred();
501 }
502
503 //===----------------------------------------------------------------------===//
504 // Utility Actions
505 //===----------------------------------------------------------------------===//
506
ExecuteAction()507 void ASTFrontendAction::ExecuteAction() {
508 CompilerInstance &CI = getCompilerInstance();
509 if (!CI.hasPreprocessor())
510 return;
511
512 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
513 // here so the source manager would be initialized.
514 if (hasCodeCompletionSupport() &&
515 !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
516 CI.createCodeCompletionConsumer();
517
518 // Use a code completion consumer?
519 CodeCompleteConsumer *CompletionConsumer = nullptr;
520 if (CI.hasCodeCompletionConsumer())
521 CompletionConsumer = &CI.getCodeCompletionConsumer();
522
523 if (!CI.hasSema())
524 CI.createSema(getTranslationUnitKind(), CompletionConsumer);
525
526 ParseAST(CI.getSema(), CI.getFrontendOpts().ShowStats,
527 CI.getFrontendOpts().SkipFunctionBodies);
528 }
529
anchor()530 void PluginASTAction::anchor() { }
531
532 std::unique_ptr<ASTConsumer>
CreateASTConsumer(CompilerInstance & CI,StringRef InFile)533 PreprocessorFrontendAction::CreateASTConsumer(CompilerInstance &CI,
534 StringRef InFile) {
535 llvm_unreachable("Invalid CreateASTConsumer on preprocessor action!");
536 }
537
538 std::unique_ptr<ASTConsumer>
CreateASTConsumer(CompilerInstance & CI,StringRef InFile)539 WrapperFrontendAction::CreateASTConsumer(CompilerInstance &CI,
540 StringRef InFile) {
541 return WrappedAction->CreateASTConsumer(CI, InFile);
542 }
BeginInvocation(CompilerInstance & CI)543 bool WrapperFrontendAction::BeginInvocation(CompilerInstance &CI) {
544 return WrappedAction->BeginInvocation(CI);
545 }
BeginSourceFileAction(CompilerInstance & CI,StringRef Filename)546 bool WrapperFrontendAction::BeginSourceFileAction(CompilerInstance &CI,
547 StringRef Filename) {
548 WrappedAction->setCurrentInput(getCurrentInput());
549 WrappedAction->setCompilerInstance(&CI);
550 return WrappedAction->BeginSourceFileAction(CI, Filename);
551 }
ExecuteAction()552 void WrapperFrontendAction::ExecuteAction() {
553 WrappedAction->ExecuteAction();
554 }
EndSourceFileAction()555 void WrapperFrontendAction::EndSourceFileAction() {
556 WrappedAction->EndSourceFileAction();
557 }
558
usesPreprocessorOnly() const559 bool WrapperFrontendAction::usesPreprocessorOnly() const {
560 return WrappedAction->usesPreprocessorOnly();
561 }
getTranslationUnitKind()562 TranslationUnitKind WrapperFrontendAction::getTranslationUnitKind() {
563 return WrappedAction->getTranslationUnitKind();
564 }
hasPCHSupport() const565 bool WrapperFrontendAction::hasPCHSupport() const {
566 return WrappedAction->hasPCHSupport();
567 }
hasASTFileSupport() const568 bool WrapperFrontendAction::hasASTFileSupport() const {
569 return WrappedAction->hasASTFileSupport();
570 }
hasIRSupport() const571 bool WrapperFrontendAction::hasIRSupport() const {
572 return WrappedAction->hasIRSupport();
573 }
hasCodeCompletionSupport() const574 bool WrapperFrontendAction::hasCodeCompletionSupport() const {
575 return WrappedAction->hasCodeCompletionSupport();
576 }
577
WrapperFrontendAction(FrontendAction * WrappedAction)578 WrapperFrontendAction::WrapperFrontendAction(FrontendAction *WrappedAction)
579 : WrappedAction(WrappedAction) {}
580
581