blob: 2930cb3952cabd7abd5a74667ada4d5d6fac76d3 [file] [log] [blame]
Nico Weber2992efa2011-01-25 20:34:14 +00001//===- MultiplexConsumer.cpp - AST Consumer for PCH Generation --*- C++ -*-===//
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// This file defines the MultiplexConsumer class. It also declares and defines
11// MultiplexASTDeserializationListener and MultiplexASTMutationListener, which
12// are implementation details of MultiplexConsumer.
13//
14//===----------------------------------------------------------------------===//
15
16#include "clang/Frontend/MultiplexConsumer.h"
Nico Weber2992efa2011-01-25 20:34:14 +000017#include "clang/AST/ASTMutationListener.h"
18#include "clang/AST/DeclGroup.h"
19#include "clang/Serialization/ASTDeserializationListener.h"
20
21using namespace clang;
22
23namespace clang {
24
25// This ASTDeserializationListener forwards its notifications to a set of
26// child listeners.
27class MultiplexASTDeserializationListener
28 : public ASTDeserializationListener {
29public:
30 // Does NOT take ownership of the elements in L.
31 MultiplexASTDeserializationListener(
32 const std::vector<ASTDeserializationListener*>& L);
Craig Topperafa7cb32014-03-13 06:07:04 +000033 void ReaderInitialized(ASTReader *Reader) override;
34 void IdentifierRead(serialization::IdentID ID,
35 IdentifierInfo *II) override;
36 void TypeRead(serialization::TypeIdx Idx, QualType T) override;
37 void DeclRead(serialization::DeclID ID, const Decl *D) override;
38 void SelectorRead(serialization::SelectorID iD, Selector Sel) override;
39 void MacroDefinitionRead(serialization::PreprocessedEntityID,
40 MacroDefinition *MD) override;
Nico Weber2992efa2011-01-25 20:34:14 +000041private:
42 std::vector<ASTDeserializationListener*> Listeners;
43};
44
45MultiplexASTDeserializationListener::MultiplexASTDeserializationListener(
46 const std::vector<ASTDeserializationListener*>& L)
47 : Listeners(L) {
48}
49
50void MultiplexASTDeserializationListener::ReaderInitialized(
51 ASTReader *Reader) {
52 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
53 Listeners[i]->ReaderInitialized(Reader);
54}
55
56void MultiplexASTDeserializationListener::IdentifierRead(
57 serialization::IdentID ID, IdentifierInfo *II) {
58 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
59 Listeners[i]->IdentifierRead(ID, II);
60}
61
62void MultiplexASTDeserializationListener::TypeRead(
63 serialization::TypeIdx Idx, QualType T) {
64 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
65 Listeners[i]->TypeRead(Idx, T);
66}
67
68void MultiplexASTDeserializationListener::DeclRead(
69 serialization::DeclID ID, const Decl *D) {
70 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
71 Listeners[i]->DeclRead(ID, D);
72}
73
74void MultiplexASTDeserializationListener::SelectorRead(
75 serialization::SelectorID ID, Selector Sel) {
76 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
77 Listeners[i]->SelectorRead(ID, Sel);
78}
79
80void MultiplexASTDeserializationListener::MacroDefinitionRead(
Argyrios Kyrtzidis03c40c52011-09-15 18:02:56 +000081 serialization::PreprocessedEntityID ID, MacroDefinition *MD) {
Nico Weber2992efa2011-01-25 20:34:14 +000082 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
83 Listeners[i]->MacroDefinitionRead(ID, MD);
84}
85
86// This ASTMutationListener forwards its notifications to a set of
87// child listeners.
88class MultiplexASTMutationListener : public ASTMutationListener {
89public:
90 // Does NOT take ownership of the elements in L.
Argyrios Kyrtzidis9e0cd462012-02-10 20:10:38 +000091 MultiplexASTMutationListener(ArrayRef<ASTMutationListener*> L);
Craig Topperafa7cb32014-03-13 06:07:04 +000092 void CompletedTagDefinition(const TagDecl *D) override;
93 void AddedVisibleDecl(const DeclContext *DC, const Decl *D) override;
94 void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) override;
95 void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
96 const ClassTemplateSpecializationDecl *D) override;
97 void AddedCXXTemplateSpecialization(const VarTemplateDecl *TD,
98 const VarTemplateSpecializationDecl *D) override;
99 void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
100 const FunctionDecl *D) override;
101 void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) override;
102 void CompletedImplicitDefinition(const FunctionDecl *D) override;
103 void StaticDataMemberInstantiated(const VarDecl *D) override;
104 void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
105 const ObjCInterfaceDecl *IFD) override;
106 void AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop,
107 const ObjCPropertyDecl *OrigProp,
108 const ObjCCategoryDecl *ClassExt) override;
Craig Toppera798a9d2014-03-02 09:32:10 +0000109 void DeclarationMarkedUsed(const Decl *D) override;
Eli Friedman276dd182013-09-05 00:02:25 +0000110
Nico Weber2992efa2011-01-25 20:34:14 +0000111private:
112 std::vector<ASTMutationListener*> Listeners;
113};
114
115MultiplexASTMutationListener::MultiplexASTMutationListener(
Argyrios Kyrtzidis9e0cd462012-02-10 20:10:38 +0000116 ArrayRef<ASTMutationListener*> L)
117 : Listeners(L.begin(), L.end()) {
Nico Weber2992efa2011-01-25 20:34:14 +0000118}
119
120void MultiplexASTMutationListener::CompletedTagDefinition(const TagDecl *D) {
121 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
122 Listeners[i]->CompletedTagDefinition(D);
123}
124
125void MultiplexASTMutationListener::AddedVisibleDecl(
126 const DeclContext *DC, const Decl *D) {
127 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
128 Listeners[i]->AddedVisibleDecl(DC, D);
129}
130
131void MultiplexASTMutationListener::AddedCXXImplicitMember(
132 const CXXRecordDecl *RD, const Decl *D) {
133 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
134 Listeners[i]->AddedCXXImplicitMember(RD, D);
135}
136void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
137 const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) {
138 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
139 Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
140}
Sebastian Redl9ab988f2011-04-14 14:07:59 +0000141void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
Larisse Voufo39a1e502013-08-06 01:03:05 +0000142 const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) {
143 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
144 Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
145}
146void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
Sebastian Redl9ab988f2011-04-14 14:07:59 +0000147 const FunctionTemplateDecl *TD, const FunctionDecl *D) {
148 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
149 Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
150}
Richard Smith1fa5d642013-05-11 05:45:24 +0000151void MultiplexASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
152 QualType ReturnType) {
153 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
154 Listeners[i]->DeducedReturnType(FD, ReturnType);
155}
Sebastian Redlab238a72011-04-24 16:28:06 +0000156void MultiplexASTMutationListener::CompletedImplicitDefinition(
157 const FunctionDecl *D) {
158 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
159 Listeners[i]->CompletedImplicitDefinition(D);
160}
Sebastian Redl2ac2c722011-04-29 08:19:30 +0000161void MultiplexASTMutationListener::StaticDataMemberInstantiated(
162 const VarDecl *D) {
163 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
164 Listeners[i]->StaticDataMemberInstantiated(D);
165}
Argyrios Kyrtzidis92622782012-02-10 20:10:36 +0000166void MultiplexASTMutationListener::AddedObjCCategoryToInterface(
167 const ObjCCategoryDecl *CatD,
168 const ObjCInterfaceDecl *IFD) {
169 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
170 Listeners[i]->AddedObjCCategoryToInterface(CatD, IFD);
171}
172void MultiplexASTMutationListener::AddedObjCPropertyInClassExtension(
173 const ObjCPropertyDecl *Prop,
174 const ObjCPropertyDecl *OrigProp,
175 const ObjCCategoryDecl *ClassExt) {
176 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
177 Listeners[i]->AddedObjCPropertyInClassExtension(Prop, OrigProp, ClassExt);
178}
Eli Friedman276dd182013-09-05 00:02:25 +0000179void MultiplexASTMutationListener::DeclarationMarkedUsed(const Decl *D) {
180 for (size_t i = 0, e = Listeners.size(); i != e; ++i)
181 Listeners[i]->DeclarationMarkedUsed(D);
182}
Nico Weber2992efa2011-01-25 20:34:14 +0000183
184} // end namespace clang
185
David Blaikie6beb6aa2014-08-10 19:56:51 +0000186MultiplexConsumer::MultiplexConsumer(
187 std::vector<std::unique_ptr<ASTConsumer>> C)
188 : Consumers(std::move(C)), MutationListener(), DeserializationListener() {
Nico Weber2992efa2011-01-25 20:34:14 +0000189 // Collect the mutation listeners and deserialization listeners of all
190 // children, and create a multiplex listener each if so.
191 std::vector<ASTMutationListener*> mutationListeners;
192 std::vector<ASTDeserializationListener*> serializationListeners;
David Blaikie6beb6aa2014-08-10 19:56:51 +0000193 for (auto &Consumer : Consumers) {
194 if (auto *mutationListener = Consumer->GetASTMutationListener())
Nico Weber2992efa2011-01-25 20:34:14 +0000195 mutationListeners.push_back(mutationListener);
David Blaikie6beb6aa2014-08-10 19:56:51 +0000196 if (auto *serializationListener = Consumer->GetASTDeserializationListener())
Nico Weber2992efa2011-01-25 20:34:14 +0000197 serializationListeners.push_back(serializationListener);
198 }
David Blaikie6beb6aa2014-08-10 19:56:51 +0000199 if (!mutationListeners.empty()) {
200 MutationListener =
201 llvm::make_unique<MultiplexASTMutationListener>(mutationListeners);
Nico Weber2992efa2011-01-25 20:34:14 +0000202 }
David Blaikie6beb6aa2014-08-10 19:56:51 +0000203 if (!serializationListeners.empty()) {
204 DeserializationListener =
205 llvm::make_unique<MultiplexASTDeserializationListener>(
206 serializationListeners);
Nico Weber2992efa2011-01-25 20:34:14 +0000207 }
208}
209
David Blaikie6beb6aa2014-08-10 19:56:51 +0000210MultiplexConsumer::~MultiplexConsumer() {}
Nico Weber2992efa2011-01-25 20:34:14 +0000211
212void MultiplexConsumer::Initialize(ASTContext &Context) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000213 for (auto &Consumer : Consumers)
214 Consumer->Initialize(Context);
Nico Weber2992efa2011-01-25 20:34:14 +0000215}
216
Argyrios Kyrtzidis841dd882011-11-18 00:26:59 +0000217bool MultiplexConsumer::HandleTopLevelDecl(DeclGroupRef D) {
Argyrios Kyrtzidisb11f5a42011-11-28 04:56:00 +0000218 bool Continue = true;
David Blaikie6beb6aa2014-08-10 19:56:51 +0000219 for (auto &Consumer : Consumers)
220 Continue = Continue && Consumer->HandleTopLevelDecl(D);
Argyrios Kyrtzidisb11f5a42011-11-28 04:56:00 +0000221 return Continue;
Nico Weber2992efa2011-01-25 20:34:14 +0000222}
223
Hans Wennborga926d842014-05-23 20:37:38 +0000224void MultiplexConsumer::HandleInlineMethodDefinition(CXXMethodDecl *D) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000225 for (auto &Consumer : Consumers)
226 Consumer->HandleInlineMethodDefinition(D);
Hans Wennborga926d842014-05-23 20:37:38 +0000227}
228
David Blaikie6beb6aa2014-08-10 19:56:51 +0000229void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
230 for (auto &Consumer : Consumers)
231 Consumer->HandleCXXStaticMemberVarInstantiation(VD);
Rafael Espindola189fa742012-03-05 10:54:55 +0000232}
233
Nico Weber2992efa2011-01-25 20:34:14 +0000234void MultiplexConsumer::HandleInterestingDecl(DeclGroupRef D) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000235 for (auto &Consumer : Consumers)
236 Consumer->HandleInterestingDecl(D);
Nico Weber2992efa2011-01-25 20:34:14 +0000237}
238
239void MultiplexConsumer::HandleTranslationUnit(ASTContext &Ctx) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000240 for (auto &Consumer : Consumers)
241 Consumer->HandleTranslationUnit(Ctx);
Nico Weber2992efa2011-01-25 20:34:14 +0000242}
243
244void MultiplexConsumer::HandleTagDeclDefinition(TagDecl *D) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000245 for (auto &Consumer : Consumers)
246 Consumer->HandleTagDeclDefinition(D);
Nico Weber2992efa2011-01-25 20:34:14 +0000247}
248
David Blaikie13269752014-07-16 23:52:46 +0000249void MultiplexConsumer::HandleTagDeclRequiredDefinition(const TagDecl *D) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000250 for (auto &Consumer : Consumers)
251 Consumer->HandleTagDeclRequiredDefinition(D);
David Blaikie13269752014-07-16 23:52:46 +0000252}
253
Argyrios Kyrtzidise5dc5b32012-02-10 20:10:44 +0000254void MultiplexConsumer::HandleCXXImplicitFunctionInstantiation(FunctionDecl *D){
David Blaikie6beb6aa2014-08-10 19:56:51 +0000255 for (auto &Consumer : Consumers)
256 Consumer->HandleCXXImplicitFunctionInstantiation(D);
Argyrios Kyrtzidise5dc5b32012-02-10 20:10:44 +0000257}
258
Argyrios Kyrtzidisb11f5a42011-11-28 04:56:00 +0000259void MultiplexConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef D) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000260 for (auto &Consumer : Consumers)
261 Consumer->HandleTopLevelDeclInObjCContainer(D);
Argyrios Kyrtzidisb11f5a42011-11-28 04:56:00 +0000262}
263
David Blaikie13269752014-07-16 23:52:46 +0000264void MultiplexConsumer::HandleImplicitImportDecl(ImportDecl *D) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000265 for (auto &Consumer : Consumers)
266 Consumer->HandleImplicitImportDecl(D);
David Blaikie13269752014-07-16 23:52:46 +0000267}
268
269void MultiplexConsumer::HandleLinkerOptionPragma(llvm::StringRef Opts) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000270 for (auto &Consumer : Consumers)
271 Consumer->HandleLinkerOptionPragma(Opts);
David Blaikie13269752014-07-16 23:52:46 +0000272}
273
274void MultiplexConsumer::HandleDetectMismatch(llvm::StringRef Name, llvm::StringRef Value) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000275 for (auto &Consumer : Consumers)
276 Consumer->HandleDetectMismatch(Name, Value);
David Blaikie13269752014-07-16 23:52:46 +0000277}
278
279void MultiplexConsumer::HandleDependentLibrary(llvm::StringRef Lib) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000280 for (auto &Consumer : Consumers)
281 Consumer->HandleDependentLibrary(Lib);
David Blaikie13269752014-07-16 23:52:46 +0000282}
283
Nico Weber2992efa2011-01-25 20:34:14 +0000284void MultiplexConsumer::CompleteTentativeDefinition(VarDecl *D) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000285 for (auto &Consumer : Consumers)
286 Consumer->CompleteTentativeDefinition(D);
Nico Weber2992efa2011-01-25 20:34:14 +0000287}
288
289void MultiplexConsumer::HandleVTable(
290 CXXRecordDecl *RD, bool DefinitionRequired) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000291 for (auto &Consumer : Consumers)
292 Consumer->HandleVTable(RD, DefinitionRequired);
Nico Weber2992efa2011-01-25 20:34:14 +0000293}
294
295ASTMutationListener *MultiplexConsumer::GetASTMutationListener() {
296 return MutationListener.get();
297}
298
299ASTDeserializationListener *MultiplexConsumer::GetASTDeserializationListener() {
300 return DeserializationListener.get();
301}
302
303void MultiplexConsumer::PrintStats() {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000304 for (auto &Consumer : Consumers)
305 Consumer->PrintStats();
Nico Weber2992efa2011-01-25 20:34:14 +0000306}
307
308void MultiplexConsumer::InitializeSema(Sema &S) {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000309 for (auto &Consumer : Consumers)
310 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))
Nico Weber2992efa2011-01-25 20:34:14 +0000311 SC->InitializeSema(S);
312}
313
314void MultiplexConsumer::ForgetSema() {
David Blaikie6beb6aa2014-08-10 19:56:51 +0000315 for (auto &Consumer : Consumers)
316 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))
Nico Weber2992efa2011-01-25 20:34:14 +0000317 SC->ForgetSema();
318}