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 virtual void ReaderInitialized(ASTReader *Reader); 34 virtual void IdentifierRead(serialization::IdentID ID, 35 IdentifierInfo *II); 36 virtual void TypeRead(serialization::TypeIdx Idx, QualType T); 37 virtual void DeclRead(serialization::DeclID ID, const Decl *D); 38 virtual void SelectorRead(serialization::SelectorID iD, Selector Sel); 39 virtual void MacroDefinitionRead(serialization::PreprocessedEntityID, 40 MacroDefinition *MD); 41private: 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( 81 serialization::PreprocessedEntityID ID, MacroDefinition *MD) { 82 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. 91 MultiplexASTMutationListener(ArrayRef<ASTMutationListener*> L); 92 virtual void CompletedTagDefinition(const TagDecl *D); 93 virtual void AddedVisibleDecl(const DeclContext *DC, const Decl *D); 94 virtual void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D); 95 virtual void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, 96 const ClassTemplateSpecializationDecl *D); 97 virtual void 98 AddedCXXTemplateSpecialization(const VarTemplateDecl *TD, 99 const VarTemplateSpecializationDecl *D); 100 virtual void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, 101 const FunctionDecl *D); 102 virtual void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType); 103 virtual void CompletedImplicitDefinition(const FunctionDecl *D); 104 virtual void StaticDataMemberInstantiated(const VarDecl *D); 105 virtual void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, 106 const ObjCInterfaceDecl *IFD); 107 virtual void AddedObjCPropertyInClassExtension(const ObjCPropertyDecl *Prop, 108 const ObjCPropertyDecl *OrigProp, 109 const ObjCCategoryDecl *ClassExt); 110private: 111 std::vector<ASTMutationListener*> Listeners; 112}; 113 114MultiplexASTMutationListener::MultiplexASTMutationListener( 115 ArrayRef<ASTMutationListener*> L) 116 : Listeners(L.begin(), L.end()) { 117} 118 119void MultiplexASTMutationListener::CompletedTagDefinition(const TagDecl *D) { 120 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 121 Listeners[i]->CompletedTagDefinition(D); 122} 123 124void MultiplexASTMutationListener::AddedVisibleDecl( 125 const DeclContext *DC, const Decl *D) { 126 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 127 Listeners[i]->AddedVisibleDecl(DC, D); 128} 129 130void MultiplexASTMutationListener::AddedCXXImplicitMember( 131 const CXXRecordDecl *RD, const Decl *D) { 132 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 133 Listeners[i]->AddedCXXImplicitMember(RD, D); 134} 135void MultiplexASTMutationListener::AddedCXXTemplateSpecialization( 136 const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) { 137 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 138 Listeners[i]->AddedCXXTemplateSpecialization(TD, D); 139} 140void MultiplexASTMutationListener::AddedCXXTemplateSpecialization( 141 const VarTemplateDecl *TD, const VarTemplateSpecializationDecl *D) { 142 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 143 Listeners[i]->AddedCXXTemplateSpecialization(TD, D); 144} 145void MultiplexASTMutationListener::AddedCXXTemplateSpecialization( 146 const FunctionTemplateDecl *TD, const FunctionDecl *D) { 147 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 148 Listeners[i]->AddedCXXTemplateSpecialization(TD, D); 149} 150void MultiplexASTMutationListener::DeducedReturnType(const FunctionDecl *FD, 151 QualType ReturnType) { 152 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 153 Listeners[i]->DeducedReturnType(FD, ReturnType); 154} 155void MultiplexASTMutationListener::CompletedImplicitDefinition( 156 const FunctionDecl *D) { 157 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 158 Listeners[i]->CompletedImplicitDefinition(D); 159} 160void MultiplexASTMutationListener::StaticDataMemberInstantiated( 161 const VarDecl *D) { 162 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 163 Listeners[i]->StaticDataMemberInstantiated(D); 164} 165void MultiplexASTMutationListener::AddedObjCCategoryToInterface( 166 const ObjCCategoryDecl *CatD, 167 const ObjCInterfaceDecl *IFD) { 168 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 169 Listeners[i]->AddedObjCCategoryToInterface(CatD, IFD); 170} 171void MultiplexASTMutationListener::AddedObjCPropertyInClassExtension( 172 const ObjCPropertyDecl *Prop, 173 const ObjCPropertyDecl *OrigProp, 174 const ObjCCategoryDecl *ClassExt) { 175 for (size_t i = 0, e = Listeners.size(); i != e; ++i) 176 Listeners[i]->AddedObjCPropertyInClassExtension(Prop, OrigProp, ClassExt); 177} 178 179} // end namespace clang 180 181 182MultiplexConsumer::MultiplexConsumer(ArrayRef<ASTConsumer*> C) 183 : Consumers(C.begin(), C.end()), 184 MutationListener(0), DeserializationListener(0) { 185 // Collect the mutation listeners and deserialization listeners of all 186 // children, and create a multiplex listener each if so. 187 std::vector<ASTMutationListener*> mutationListeners; 188 std::vector<ASTDeserializationListener*> serializationListeners; 189 for (size_t i = 0, e = Consumers.size(); i != e; ++i) { 190 ASTMutationListener* mutationListener = 191 Consumers[i]->GetASTMutationListener(); 192 if (mutationListener) 193 mutationListeners.push_back(mutationListener); 194 ASTDeserializationListener* serializationListener = 195 Consumers[i]->GetASTDeserializationListener(); 196 if (serializationListener) 197 serializationListeners.push_back(serializationListener); 198 } 199 if (mutationListeners.size()) { 200 MutationListener.reset(new MultiplexASTMutationListener(mutationListeners)); 201 } 202 if (serializationListeners.size()) { 203 DeserializationListener.reset( 204 new MultiplexASTDeserializationListener(serializationListeners)); 205 } 206} 207 208MultiplexConsumer::~MultiplexConsumer() { 209 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 210 delete Consumers[i]; 211} 212 213void MultiplexConsumer::Initialize(ASTContext &Context) { 214 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 215 Consumers[i]->Initialize(Context); 216} 217 218bool MultiplexConsumer::HandleTopLevelDecl(DeclGroupRef D) { 219 bool Continue = true; 220 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 221 Continue = Continue && Consumers[i]->HandleTopLevelDecl(D); 222 return Continue; 223} 224 225void MultiplexConsumer::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) { 226 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 227 Consumers[i]->HandleCXXStaticMemberVarInstantiation(VD); 228} 229 230void MultiplexConsumer::HandleInterestingDecl(DeclGroupRef D) { 231 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 232 Consumers[i]->HandleInterestingDecl(D); 233} 234 235void MultiplexConsumer::HandleTranslationUnit(ASTContext &Ctx) { 236 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 237 Consumers[i]->HandleTranslationUnit(Ctx); 238} 239 240void MultiplexConsumer::HandleTagDeclDefinition(TagDecl *D) { 241 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 242 Consumers[i]->HandleTagDeclDefinition(D); 243} 244 245void MultiplexConsumer::HandleCXXImplicitFunctionInstantiation(FunctionDecl *D){ 246 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 247 Consumers[i]->HandleCXXImplicitFunctionInstantiation(D); 248} 249 250void MultiplexConsumer::HandleTopLevelDeclInObjCContainer(DeclGroupRef D) { 251 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 252 Consumers[i]->HandleTopLevelDeclInObjCContainer(D); 253} 254 255void MultiplexConsumer::CompleteTentativeDefinition(VarDecl *D) { 256 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 257 Consumers[i]->CompleteTentativeDefinition(D); 258} 259 260void MultiplexConsumer::HandleVTable( 261 CXXRecordDecl *RD, bool DefinitionRequired) { 262 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 263 Consumers[i]->HandleVTable(RD, DefinitionRequired); 264} 265 266ASTMutationListener *MultiplexConsumer::GetASTMutationListener() { 267 return MutationListener.get(); 268} 269 270ASTDeserializationListener *MultiplexConsumer::GetASTDeserializationListener() { 271 return DeserializationListener.get(); 272} 273 274void MultiplexConsumer::PrintStats() { 275 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 276 Consumers[i]->PrintStats(); 277} 278 279void MultiplexConsumer::InitializeSema(Sema &S) { 280 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 281 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumers[i])) 282 SC->InitializeSema(S); 283} 284 285void MultiplexConsumer::ForgetSema() { 286 for (size_t i = 0, e = Consumers.size(); i != e; ++i) 287 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(Consumers[i])) 288 SC->ForgetSema(); 289} 290