MultiplexConsumer.cpp Source File (original) (raw)

19using namespace clang;

27 const std::vector<ASTDeserializationListener*>& L)

28 : Listeners(L) {

29}

33 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

34 Listeners[i]->ReaderInitialized(Reader);

35}

39 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

40 Listeners[i]->IdentifierRead(ID, II);

41}

45 for (auto &Listener : Listeners)

46 Listener->MacroRead(ID, MI);

47}

51 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

52 Listeners[i]->TypeRead(Idx, T);

53}

57 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

58 Listeners[i]->DeclRead(ID, D);

59}

62 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

63 Listeners[i]->PredefinedDeclBuilt(ID, D);

64}

68 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

69 Listeners[i]->SelectorRead(ID, Sel);

70}

74 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

75 Listeners[i]->MacroDefinitionRead(ID, MD);

76}

80 for (auto &Listener : Listeners)

81 Listener->ModuleRead(ID, Mod);

82}

86 for (auto &Listener : Listeners)

87 Listener->ModuleImportRead(ID, ImportLoc);

88}

93public:

109 Expr *ThisArg) override;

131

132private:

133 std::vector<ASTMutationListener*> Listeners;

134};

135

138 : Listeners(L.begin(), L.end()) {

139}

140

142 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

143 Listeners[i]->CompletedTagDefinition(D);

144}

145

148 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

149 Listeners[i]->AddedVisibleDecl(DC, D);

150}

151

154 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

155 Listeners[i]->AddedCXXImplicitMember(RD, D);

156}

159 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

160 Listeners[i]->AddedCXXTemplateSpecialization(TD, D);

161}

164 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

165 Listeners[i]->AddedCXXTemplateSpecialization(TD, D);

166}

169 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

170 Listeners[i]->AddedCXXTemplateSpecialization(TD, D);

171}

174 for (auto &Listener : Listeners)

175 Listener->ResolvedExceptionSpec(FD);

176}

179 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

180 Listeners[i]->DeducedReturnType(FD, ReturnType);

181}

184 for (auto *L : Listeners)

185 L->ResolvedOperatorDelete(DD, Delete, ThisArg);

186}

189 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

190 Listeners[i]->CompletedImplicitDefinition(D);

191}

193 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

194 Listeners[i]->InstantiationRequested(D);

195}

198 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

199 Listeners[i]->VariableDefinitionInstantiated(D);

200}

203 for (auto &Listener : Listeners)

204 Listener->FunctionDefinitionInstantiated(D);

205}

208 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

209 Listeners[i]->DefaultArgumentInstantiated(D);

210}

213 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

214 Listeners[i]->DefaultMemberInitializerInstantiated(D);

215}

219 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

220 Listeners[i]->AddedObjCCategoryToInterface(CatD, IFD);

221}

223 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

224 Listeners[i]->DeclarationMarkedUsed(D);

225}

228 for (size_t i = 0, e = Listeners.size(); i != e; ++i)

229 Listeners[i]->DeclarationMarkedOpenMPThreadPrivate(D);

230}

234 L->DeclarationMarkedOpenMPAllocate(D, A);

235}

238 for (auto *L : Listeners)

239 L->DeclarationMarkedOpenMPDeclareTarget(D, Attr);

240}

243 for (auto *L : Listeners)

244 L->RedefinedHiddenDefinition(D, M);

245}

246

250 for (auto *L : Listeners)

251 L->AddedAttributeToRecord(Attr, Record);

252}

253

255 for (auto *L : Listeners)

256 L->EnteringModulePurview();

257}

258

260 unsigned Number) {

261 for (auto *L : Listeners)

262 L->AddedManglingNumber(D, Number);

263}

265 unsigned Number) {

266 for (auto *L : Listeners)

267 L->AddedStaticLocalNumbers(D, Number);

268}

271 for (auto *L : Listeners)

272 L->AddedAnonymousNamespace(TU, AnonNamespace);

273}

274

275}

276

278 std::vector<std::unique_ptr> C)

279 : Consumers(std::move(C)) {

280

281

282 std::vector<ASTMutationListener *> mutationListeners;

283 std::vector<ASTDeserializationListener*> serializationListeners;

284 for (auto &Consumer : Consumers) {

285 if (auto *mutationListener = Consumer->GetASTMutationListener())

286 mutationListeners.push_back(mutationListener);

287 if (auto *serializationListener = Consumer->GetASTDeserializationListener())

288 serializationListeners.push_back(serializationListener);

289 }

290 if (!mutationListeners.empty()) {

292 std::make_unique(mutationListeners);

293 }

294 if (!serializationListeners.empty()) {

296 std::make_unique(

297 serializationListeners);

298 }

299}

300

303 std::vector<std::unique_ptr> Consumers;

304 Consumers.push_back(std::move(Consumer));

306 }(std::move(C))) {}

307

309

312 Consumer->Initialize(Context);

313}

314

316 bool Continue = true;

318 Continue = Continue && Consumer->HandleTopLevelDecl(D);

319 return Continue;

320}

321

324 Consumer->HandleInlineFunctionDefinition(D);

325}

326

329 Consumer->HandleCXXStaticMemberVarInstantiation(VD);

330}

331

334 Consumer->HandleInterestingDecl(D);

335}

336

339 Consumer->HandleTranslationUnit(Ctx);

340}

341

344 Consumer->HandleTagDeclDefinition(D);

345}

346

349 Consumer->HandleTagDeclRequiredDefinition(D);

350}

351

354 Consumer->HandleCXXImplicitFunctionInstantiation(D);

355}

356

359 Consumer->HandleTopLevelDeclInObjCContainer(D);

360}

361

364 Consumer->HandleImplicitImportDecl(D);

365}

366

369 Consumer->CompleteTentativeDefinition(D);

370}

371

374 Consumer->CompleteExternalDeclaration(D);

375}

376

379 Consumer->AssignInheritanceModel(RD);

380}

381

384 Consumer->HandleVTable(RD);

385}

386

389}

390

393}

394

397 Consumer->PrintStats();

398}

399

401 bool Skip = true;

403 Skip = Skip && Consumer->shouldSkipFunctionBody(D);

405}

406

409 if (SemaConsumer *SC = dyn_cast(Consumer.get()))

410 SC->InitializeSema(S);

411}

412

415 if (SemaConsumer *SC = dyn_cast(Consumer.get()))

416 SC->ForgetSema();

417}

llvm::MachO::Record Record

ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

An abstract interface that should be implemented by listeners that want to be notified when an AST en...

Reads an AST files chain containing the contents of a translation unit.

Attr - This represents one attribute.

Represents a C++ destructor within a class.

Represents a C++ struct/union/class.

Declaration of a class template.

Represents a class template specialization, which refers to a class template with a given set of temp...

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

Decl - This represents one declaration (or definition), e.g.

Represents a ValueDecl that came out of a declarator.

This represents one expression.

Represents a member of a struct/union/class.

Represents a function declaration or definition.

Declaration of a template function.

One of these records is kept for each identifier that is lexed.

Describes a module import declaration, which makes the contents of the named module visible in the cu...

Record the location of a macro definition.

Encapsulates the data about a macro definition (e.g.

Describes a module or submodule.

void IdentifierRead(serialization::IdentifierID ID, IdentifierInfo *II) override

An identifier was deserialized from the AST file.

void MacroDefinitionRead(serialization::PreprocessedEntityID, MacroDefinitionRecord *MD) override

A macro definition was read from the AST file.

void PredefinedDeclBuilt(PredefinedDeclIDs ID, const Decl *D) override

A predefined decl was built during the serialization.

void ModuleRead(serialization::SubmoduleID ID, Module *Mod) override

A module definition was read from the AST file.

void TypeRead(serialization::TypeIdx Idx, QualType T) override

A type was deserialized from the AST file.

void DeclRead(GlobalDeclID ID, const Decl *D) override

A decl was deserialized from the AST file.

void SelectorRead(serialization::SelectorID iD, Selector Sel) override

A selector was read from the AST file.

void MacroRead(serialization::MacroID ID, MacroInfo *MI) override

A macro was read from the AST file.

void ReaderInitialized(ASTReader *Reader) override

The ASTReader was initialized.

void ModuleImportRead(serialization::SubmoduleID ID, SourceLocation ImportLoc) override

A module import was read from the AST file.

MultiplexASTDeserializationListener(const std::vector< ASTDeserializationListener * > &L)

void DeclarationMarkedUsed(const Decl *D) override

A declaration is marked used which was not previously marked used.

void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, const ObjCInterfaceDecl *IFD) override

A new objc category class was added for an interface.

void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) override

A definition has been made visible by being redefined locally.

void ResolvedExceptionSpec(const FunctionDecl *FD) override

A function's exception specification has been evaluated or instantiated.

void DeclarationMarkedOpenMPAllocate(const Decl *D, const Attr *A) override

A declaration is marked as a variable with OpenMP allocator.

void CompletedImplicitDefinition(const FunctionDecl *D) override

An implicit member got a definition.

void EnteringModulePurview() override

The parser find the named module declaration.

void DefaultArgumentInstantiated(const ParmVarDecl *D) override

A default argument was instantiated.

void AddedStaticLocalNumbers(const Decl *D, unsigned) override

An static local number was added to a Decl.

void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) override

A function's return type has been deduced.

void AddedManglingNumber(const Decl *D, unsigned) override

An mangling number was added to a Decl.

void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) override

An implicit member was added after the definition was completed.

void VariableDefinitionInstantiated(const VarDecl *D) override

A templated variable's definition was implicitly instantiated.

void AddedAnonymousNamespace(const TranslationUnitDecl *, NamespaceDecl *AnonNamespace) override

An anonymous namespace was added the translation unit decl.

void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) override

A declaration is marked as OpenMP threadprivate which was not previously marked as threadprivate.

MultiplexASTMutationListener(ArrayRef< ASTMutationListener * > L)

void ResolvedOperatorDelete(const CXXDestructorDecl *DD, const FunctionDecl *Delete, Expr *ThisArg) override

A virtual destructor's operator delete has been resolved.

void InstantiationRequested(const ValueDecl *D) override

The instantiation of a templated function or variable was requested.

void DeclarationMarkedOpenMPDeclareTarget(const Decl *D, const Attr *Attr) override

A declaration is marked as OpenMP declaretarget which was not previously marked as declaretarget.

void AddedVisibleDecl(const DeclContext *DC, const Decl *D) override

A new declaration with name has been added to a DeclContext.

void FunctionDefinitionInstantiated(const FunctionDecl *D) override

A function template's definition was instantiated.

void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, const ClassTemplateSpecializationDecl *D) override

A template specialization (or partial one) was added to the template declaration.

void DefaultMemberInitializerInstantiated(const FieldDecl *D) override

A default member initializer was instantiated.

void CompletedTagDefinition(const TagDecl *D) override

A new TagDecl definition was completed.

void AddedAttributeToRecord(const Attr *Attr, const RecordDecl *Record) override

An attribute was added to a RecordDecl.

void HandleImplicitImportDecl(ImportDecl *D) override

Handle an ImportDecl that was implicitly created due to an inclusion directive.

ASTDeserializationListener * GetASTDeserializationListener() override

If the consumer is interested in entities being deserialized from AST files, it should return a point...

void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D) override

Invoked when a function is implicitly instantiated.

bool HandleTopLevelDecl(DeclGroupRef D) override

HandleTopLevelDecl - Handle the specified top-level declaration.

void HandleTagDeclRequiredDefinition(const TagDecl *D) override

This callback is invoked the first time each TagDecl is required to be complete.

void AssignInheritanceModel(CXXRecordDecl *RD) override

Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.

void HandleTagDeclDefinition(TagDecl *D) override

HandleTagDeclDefinition - This callback is invoked each time a TagDecl (e.g.

std::unique_ptr< MultiplexASTDeserializationListener > DeserializationListener

std::unique_ptr< MultiplexASTMutationListener > MutationListener

void InitializeSema(Sema &S) override

Initialize the semantic consumer with the Sema instance being used to perform semantic analysis on th...

void HandleTranslationUnit(ASTContext &Ctx) override

HandleTranslationUnit - This method is called when the ASTs for entire translation unit have been par...

void CompleteTentativeDefinition(VarDecl *D) override

CompleteTentativeDefinition - Callback invoked at the end of a translation unit to notify the consume...

void HandleInterestingDecl(DeclGroupRef D) override

HandleInterestingDecl - Handle the specified interesting declaration.

std::vector< std::unique_ptr< ASTConsumer > > Consumers

void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override

HandleCXXStaticMemberVarInstantiation - Tell the consumer that this.

void CompleteExternalDeclaration(DeclaratorDecl *D) override

CompleteExternalDeclaration - Callback invoked at the end of a translation unit to notify the consume...

void HandleVTable(CXXRecordDecl *RD) override

Callback involved at the end of a translation unit to notify the consumer that a vtable for the given...

bool shouldSkipFunctionBody(Decl *D) override

This callback is called for each function if the Parser was initialized with SkipFunctionBodies set t...

ASTMutationListener * GetASTMutationListener() override

If the consumer is interested in entities getting modified after their initial creation,...

~MultiplexConsumer() override

void PrintStats() override

PrintStats - If desired, print any statistics.

void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override

Handle the specified top-level declaration that occurred inside and ObjC container.

void ForgetSema() override

Inform the semantic consumer that Sema is no longer available.

MultiplexConsumer(std::vector< std::unique_ptr< ASTConsumer > > C)

void HandleInlineFunctionDefinition(FunctionDecl *D) override

This callback is invoked each time an inline (method or friend) function definition in a class is com...

void Initialize(ASTContext &Context) override

Initialize - This is called to initialize the consumer, providing the ASTContext.

This represents a decl that may have a name.

Represent a C++ namespace.

ObjCCategoryDecl - Represents a category declaration.

Represents an ObjC class declaration.

Represents a parameter to a function.

A (possibly-)qualified type.

Represents a struct/union/class.

Smart pointer class that efficiently represents Objective-C method names.

An abstract interface that should be implemented by clients that read ASTs and then require further s...

Sema - This implements semantic analysis and AST building for C.

Encodes a location in the source.

Represents the declaration of a struct/union/class/enum.

The top declaration context.

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

Declaration of a variable template.

Represents a variable template specialization, which refers to a variable template with a given set o...

A type index; the type ID with the qualifier bits removed.

uint32_t SubmoduleID

An ID number that refers to a submodule in a module file.

uint32_t SelectorID

An ID number that refers to an ObjC selector in an AST file.

uint32_t PreprocessedEntityID

An ID number that refers to an entity in the detailed preprocessing record.

uint64_t IdentifierID

An ID number that refers to an identifier in an AST file.

uint32_t MacroID

An ID number that refers to a macro in an AST file.

The JSON file list parser is used to communicate input to InstallAPI.

@ Delete

'delete' clause, allowed on the 'exit data' construct.

PredefinedDeclIDs

Predefined declaration IDs.

const FunctionProtoType * T