MultiplexConsumer.cpp revision b6d6993e6e6d3daf4d9876794254d20a134e37c2 
1//===- 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"
17#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);
33  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                           MacroDefinitionRecord *MD) override;
41
42private:
43  std::vector<ASTDeserializationListener *> Listeners;
44};
45
46MultiplexASTDeserializationListener::MultiplexASTDeserializationListener(
47      const std::vector<ASTDeserializationListener*>& L)
48    : Listeners(L) {
49}
50
51void MultiplexASTDeserializationListener::ReaderInitialized(
52    ASTReader *Reader) {
53  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
54    Listeners[i]->ReaderInitialized(Reader);
55}
56
57void MultiplexASTDeserializationListener::IdentifierRead(
58    serialization::IdentID ID, IdentifierInfo *II) {
59  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
60    Listeners[i]->IdentifierRead(ID, II);
61}
62
63void MultiplexASTDeserializationListener::TypeRead(
64    serialization::TypeIdx Idx, QualType T) {
65  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
66    Listeners[i]->TypeRead(Idx, T);
67}
68
69void MultiplexASTDeserializationListener::DeclRead(
70    serialization::DeclID ID, const Decl *D) {
71  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
72    Listeners[i]->DeclRead(ID, D);
73}
74
75void MultiplexASTDeserializationListener::SelectorRead(
76    serialization::SelectorID ID, Selector Sel) {
77  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
78    Listeners[i]->SelectorRead(ID, Sel);
79}
80
81void MultiplexASTDeserializationListener::MacroDefinitionRead(
82    serialization::PreprocessedEntityID ID, MacroDefinitionRecord *MD) {
83  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
84    Listeners[i]->MacroDefinitionRead(ID, MD);
85}
86
87// This ASTMutationListener forwards its notifications to a set of
88// child listeners.
89class MultiplexASTMutationListener : public ASTMutationListener {
90public:
91  // Does NOT take ownership of the elements in L.
92  MultiplexASTMutationListener(ArrayRef<ASTMutationListener*> L);
93  void CompletedTagDefinition(const TagDecl *D) override;
94  void AddedVisibleDecl(const DeclContext *DC, const Decl *D) override;
95  void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) override;
96  void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD,
97                            const ClassTemplateSpecializationDecl *D) override;
98  void AddedCXXTemplateSpecialization(const VarTemplateDecl *TD,
99                               const VarTemplateSpecializationDecl *D) override;
100  void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
101                                      const FunctionDecl *D) override;
102  void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) override;
103  void ResolvedOperatorDelete(const CXXDestructorDecl *DD,
104                              const FunctionDecl *Delete) override;
105  void CompletedImplicitDefinition(const FunctionDecl *D) override;
106  void StaticDataMemberInstantiated(const VarDecl *D) override;
107  void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
108                                    const ObjCInterfaceDecl *IFD) override;
109  void AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop,
110                                    const ObjCPropertyDecl *OrigProp,
111                                    const ObjCCategoryDecl *ClassExt) override;
112  void DeclarationMarkedUsed(const Decl *D) override;
113  void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) override;
114  void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) override;
115
116private:
117  std::vector<ASTMutationListener*> Listeners;
118};
119
120MultiplexASTMutationListener::MultiplexASTMutationListener(
121    ArrayRef<ASTMutationListener*> L)
122    : Listeners(L.begin(), L.end()) {
123}
124
125void MultiplexASTMutationListener::CompletedTagDefinition(const TagDecl *D) {
126  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
127    Listeners[i]->CompletedTagDefinition(D);
128}
129
130void MultiplexASTMutationListener::AddedVisibleDecl(
131    const DeclContext *DC, const Decl *D) {
132  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
133    Listeners[i]->AddedVisibleDecl(DC, D);
134}
135
136void MultiplexASTMutationListener::AddedCXXImplicitMember(
137    const CXXRecordDecl *RD, const Decl *D) {
138  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
139    Listeners[i]->AddedCXXImplicitMember(RD, D);
140}
141void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
142    const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) {
143  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
144    Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
145}
146void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
147    const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) {
148  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
149    Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
150}
151void MultiplexASTMutationListener::AddedCXXTemplateSpecialization(
152    const FunctionTemplateDecl *TD, const FunctionDecl *D) {
153  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
154    Listeners[i]->AddedCXXTemplateSpecialization(TD, D);
155}
156void MultiplexASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
157                                                     QualType ReturnType) {
158  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
159    Listeners[i]->DeducedReturnType(FD, ReturnType);
160}
161void MultiplexASTMutationListener::ResolvedOperatorDelete(
162    const CXXDestructorDecl *DD, const FunctionDecl *Delete) {
163  for (auto *L : Listeners)
164    L->ResolvedOperatorDelete(DD, Delete);
165}
166void MultiplexASTMutationListener::CompletedImplicitDefinition(
167                                                        const FunctionDecl *D) {
168  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
169    Listeners[i]->CompletedImplicitDefinition(D);
170}
171void MultiplexASTMutationListener::StaticDataMemberInstantiated(
172                                                             const VarDecl *D) {
173  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
174    Listeners[i]->StaticDataMemberInstantiated(D);
175}
176void MultiplexASTMutationListener::AddedObjCCategoryToInterface(
177                                                 const ObjCCategoryDecl *CatD,
178                                                 const ObjCInterfaceDecl *IFD) {
179  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
180    Listeners[i]->AddedObjCCategoryToInterface(CatD, IFD);
181}
182void MultiplexASTMutationListener::AddedObjCPropertyInClassExtension(
183                                             const ObjCPropertyDecl *Prop,
184                                             const ObjCPropertyDecl *OrigProp,
185                                             const ObjCCategoryDecl *ClassExt) {
186  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
187    Listeners[i]->AddedObjCPropertyInClassExtension(Prop, OrigProp, ClassExt);
188}
189void MultiplexASTMutationListener::DeclarationMarkedUsed(const Decl *D) {
190  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
191    Listeners[i]->DeclarationMarkedUsed(D);
192}
193void MultiplexASTMutationListener::DeclarationMarkedOpenMPThreadPrivate(
194    const Decl *D) {
195  for (size_t i = 0, e = Listeners.size(); i != e; ++i)
196    Listeners[i]->DeclarationMarkedOpenMPThreadPrivate(D);
197}
198void MultiplexASTMutationListener::RedefinedHiddenDefinition(const NamedDecl *D,
199                                                             Module *M) {
200  for (auto *L : Listeners)
201    L->RedefinedHiddenDefinition(D, M);
202}
203
204}  // end namespace clang
205
206MultiplexConsumer::MultiplexConsumer(
207    std::vector<std::unique_ptr<ASTConsumer>> C)
208    : Consumers(std::move(C)), MutationListener(), DeserializationListener() {
209  // Collect the mutation listeners and deserialization listeners of all
210  // children, and create a multiplex listener each if so.
211  std::vector<ASTMutationListener*> mutationListeners;
212  std::vector<ASTDeserializationListener*> serializationListeners;
213  for (auto &Consumer : Consumers) {
214    if (auto *mutationListener = Consumer->GetASTMutationListener())
215      mutationListeners.push_back(mutationListener);
216    if (auto *serializationListener = Consumer->GetASTDeserializationListener())
217      serializationListeners.push_back(serializationListener);
218  }
219  if (!mutationListeners.empty()) {
220    MutationListener =
221        llvm::make_unique<MultiplexASTMutationListener>(mutationListeners);
222  }
223  if (!serializationListeners.empty()) {
224    DeserializationListener =
225        llvm::make_unique<MultiplexASTDeserializationListener>(
226            serializationListeners);
227  }
228}
229
230MultiplexConsumer::~MultiplexConsumer() {}
231
232void MultiplexConsumer::Initialize(ASTContext &Context) {
233  for (auto &Consumer : Consumers)
234    Consumer->Initialize(Context);
235}
236
237bool MultiplexConsumer::HandleTopLevelDecl(DeclGroupRef D) {
238  bool Continue = true;
239  for (auto &Consumer : Consumers)
240    Continue = Continue && Consumer->HandleTopLevelDecl(D);
241  return Continue;
242}
243
244void MultiplexConsumer::HandleInlineMethodDefinition(CXXMethodDecl *D) {
245  for (auto &Consumer : Consumers)
246    Consumer->HandleInlineMethodDefinition(D);
247}
248
249void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
250  for (auto &Consumer : Consumers)
251    Consumer->HandleCXXStaticMemberVarInstantiation(VD);
252}
253
254void MultiplexConsumer::HandleInterestingDecl(DeclGroupRef D) {
255  for (auto &Consumer : Consumers)
256    Consumer->HandleInterestingDecl(D);
257}
258
259void MultiplexConsumer::HandleTranslationUnit(ASTContext &Ctx) {
260  for (auto &Consumer : Consumers)
261    Consumer->HandleTranslationUnit(Ctx);
262}
263
264void MultiplexConsumer::HandleTagDeclDefinition(TagDecl *D) {
265  for (auto &Consumer : Consumers)
266    Consumer->HandleTagDeclDefinition(D);
267}
268
269void MultiplexConsumer::HandleTagDeclRequiredDefinition(const TagDecl *D) {
270  for (auto &Consumer : Consumers)
271    Consumer->HandleTagDeclRequiredDefinition(D);
272}
273
274void MultiplexConsumer::HandleCXXImplicitFunctionInstantiation(FunctionDecl *D){
275  for (auto &Consumer : Consumers)
276    Consumer->HandleCXXImplicitFunctionInstantiation(D);
277}
278
279void MultiplexConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef D) {
280  for (auto &Consumer : Consumers)
281    Consumer->HandleTopLevelDeclInObjCContainer(D);
282}
283
284void MultiplexConsumer::HandleImplicitImportDecl(ImportDecl *D) {
285  for (auto &Consumer : Consumers)
286    Consumer->HandleImplicitImportDecl(D);
287}
288
289void MultiplexConsumer::HandleLinkerOptionPragma(llvm::StringRef Opts) {
290  for (auto &Consumer : Consumers)
291    Consumer->HandleLinkerOptionPragma(Opts);
292}
293
294void MultiplexConsumer::HandleDetectMismatch(llvm::StringRef Name, llvm::StringRef Value) {
295  for (auto &Consumer : Consumers)
296    Consumer->HandleDetectMismatch(Name, Value);
297}
298
299void MultiplexConsumer::HandleDependentLibrary(llvm::StringRef Lib) {
300  for (auto &Consumer : Consumers)
301    Consumer->HandleDependentLibrary(Lib);
302}
303
304void MultiplexConsumer::CompleteTentativeDefinition(VarDecl *D) {
305  for (auto &Consumer : Consumers)
306    Consumer->CompleteTentativeDefinition(D);
307}
308
309void MultiplexConsumer::HandleVTable(CXXRecordDecl *RD) {
310  for (auto &Consumer : Consumers)
311    Consumer->HandleVTable(RD);
312}
313
314ASTMutationListener *MultiplexConsumer::GetASTMutationListener() {
315  return MutationListener.get();
316}
317
318ASTDeserializationListener *MultiplexConsumer::GetASTDeserializationListener() {
319  return DeserializationListener.get();
320}
321
322void MultiplexConsumer::PrintStats() {
323  for (auto &Consumer : Consumers)
324    Consumer->PrintStats();
325}
326
327void MultiplexConsumer::InitializeSema(Sema &S) {
328  for (auto &Consumer : Consumers)
329    if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))
330      SC->InitializeSema(S);
331}
332
333void MultiplexConsumer::ForgetSema() {
334  for (auto &Consumer : Consumers)
335    if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumer.get()))
336      SC->ForgetSema();
337}
338