1 //===--- ASTMutationListener.h - AST Mutation Interface --------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the ASTMutationListener interface. 10 // 11 //===----------------------------------------------------------------------===// 12 #ifndef LLVM_CLANG_AST_ASTMUTATIONLISTENER_H 13 #define LLVM_CLANG_AST_ASTMUTATIONLISTENER_H 14 15 namespace clang { 16 class Attr; 17 class ClassTemplateDecl; 18 class ClassTemplateSpecializationDecl; 19 class ConstructorUsingShadowDecl; 20 class CXXDestructorDecl; 21 class CXXRecordDecl; 22 class Decl; 23 class DeclContext; 24 class Expr; 25 class FieldDecl; 26 class FunctionDecl; 27 class FunctionTemplateDecl; 28 class Module; 29 class NamedDecl; 30 class ObjCCategoryDecl; 31 class ObjCContainerDecl; 32 class ObjCInterfaceDecl; 33 class ObjCPropertyDecl; 34 class ParmVarDecl; 35 class QualType; 36 class RecordDecl; 37 class TagDecl; 38 class ValueDecl; 39 class VarDecl; 40 class VarTemplateDecl; 41 class VarTemplateSpecializationDecl; 42 43 /// An abstract interface that should be implemented by listeners 44 /// that want to be notified when an AST entity gets modified after its 45 /// initial creation. 46 class ASTMutationListener { 47 public: 48 virtual ~ASTMutationListener(); 49 50 /// A new TagDecl definition was completed. CompletedTagDefinition(const TagDecl * D)51 virtual void CompletedTagDefinition(const TagDecl *D) { } 52 53 /// A new declaration with name has been added to a DeclContext. AddedVisibleDecl(const DeclContext * DC,const Decl * D)54 virtual void AddedVisibleDecl(const DeclContext *DC, const Decl *D) {} 55 56 /// An implicit member was added after the definition was completed. AddedCXXImplicitMember(const CXXRecordDecl * RD,const Decl * D)57 virtual void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) {} 58 59 /// A template specialization (or partial one) was added to the 60 /// template declaration. AddedCXXTemplateSpecialization(const ClassTemplateDecl * TD,const ClassTemplateSpecializationDecl * D)61 virtual void AddedCXXTemplateSpecialization(const ClassTemplateDecl *TD, 62 const ClassTemplateSpecializationDecl *D) {} 63 64 /// A template specialization (or partial one) was added to the 65 /// template declaration. 66 virtual void AddedCXXTemplateSpecialization(const VarTemplateDecl * TD,const VarTemplateSpecializationDecl * D)67 AddedCXXTemplateSpecialization(const VarTemplateDecl *TD, 68 const VarTemplateSpecializationDecl *D) {} 69 70 /// A template specialization (or partial one) was added to the 71 /// template declaration. AddedCXXTemplateSpecialization(const FunctionTemplateDecl * TD,const FunctionDecl * D)72 virtual void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, 73 const FunctionDecl *D) {} 74 75 /// A function's exception specification has been evaluated or 76 /// instantiated. ResolvedExceptionSpec(const FunctionDecl * FD)77 virtual void ResolvedExceptionSpec(const FunctionDecl *FD) {} 78 79 /// A function's return type has been deduced. 80 virtual void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType); 81 82 /// A virtual destructor's operator delete has been resolved. ResolvedOperatorDelete(const CXXDestructorDecl * DD,const FunctionDecl * Delete,Expr * ThisArg)83 virtual void ResolvedOperatorDelete(const CXXDestructorDecl *DD, 84 const FunctionDecl *Delete, 85 Expr *ThisArg) {} 86 87 /// An implicit member got a definition. CompletedImplicitDefinition(const FunctionDecl * D)88 virtual void CompletedImplicitDefinition(const FunctionDecl *D) {} 89 90 /// The instantiation of a templated function or variable was 91 /// requested. In particular, the point of instantiation and template 92 /// specialization kind of \p D may have changed. InstantiationRequested(const ValueDecl * D)93 virtual void InstantiationRequested(const ValueDecl *D) {} 94 95 /// A templated variable's definition was implicitly instantiated. VariableDefinitionInstantiated(const VarDecl * D)96 virtual void VariableDefinitionInstantiated(const VarDecl *D) {} 97 98 /// A function template's definition was instantiated. FunctionDefinitionInstantiated(const FunctionDecl * D)99 virtual void FunctionDefinitionInstantiated(const FunctionDecl *D) {} 100 101 /// A default argument was instantiated. DefaultArgumentInstantiated(const ParmVarDecl * D)102 virtual void DefaultArgumentInstantiated(const ParmVarDecl *D) {} 103 104 /// A default member initializer was instantiated. DefaultMemberInitializerInstantiated(const FieldDecl * D)105 virtual void DefaultMemberInitializerInstantiated(const FieldDecl *D) {} 106 107 /// A new objc category class was added for an interface. AddedObjCCategoryToInterface(const ObjCCategoryDecl * CatD,const ObjCInterfaceDecl * IFD)108 virtual void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD, 109 const ObjCInterfaceDecl *IFD) {} 110 111 /// A declaration is marked used which was not previously marked used. 112 /// 113 /// \param D the declaration marked used DeclarationMarkedUsed(const Decl * D)114 virtual void DeclarationMarkedUsed(const Decl *D) {} 115 116 /// A declaration is marked as OpenMP threadprivate which was not 117 /// previously marked as threadprivate. 118 /// 119 /// \param D the declaration marked OpenMP threadprivate. DeclarationMarkedOpenMPThreadPrivate(const Decl * D)120 virtual void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) {} 121 122 /// A declaration is marked as OpenMP declaretarget which was not 123 /// previously marked as declaretarget. 124 /// 125 /// \param D the declaration marked OpenMP declaretarget. 126 /// \param Attr the added attribute. DeclarationMarkedOpenMPDeclareTarget(const Decl * D,const Attr * Attr)127 virtual void DeclarationMarkedOpenMPDeclareTarget(const Decl *D, 128 const Attr *Attr) {} 129 130 /// A declaration is marked as a variable with OpenMP allocator. 131 /// 132 /// \param D the declaration marked as a variable with OpenMP allocator. DeclarationMarkedOpenMPAllocate(const Decl * D,const Attr * A)133 virtual void DeclarationMarkedOpenMPAllocate(const Decl *D, const Attr *A) {} 134 135 /// A definition has been made visible by being redefined locally. 136 /// 137 /// \param D The definition that was previously not visible. 138 /// \param M The containing module in which the definition was made visible, 139 /// if any. RedefinedHiddenDefinition(const NamedDecl * D,Module * M)140 virtual void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) {} 141 142 /// An attribute was added to a RecordDecl 143 /// 144 /// \param Attr The attribute that was added to the Record 145 /// 146 /// \param Record The RecordDecl that got a new attribute AddedAttributeToRecord(const Attr * Attr,const RecordDecl * Record)147 virtual void AddedAttributeToRecord(const Attr *Attr, 148 const RecordDecl *Record) {} 149 150 // NOTE: If new methods are added they should also be added to 151 // MultiplexASTMutationListener. 152 }; 153 154 } // end namespace clang 155 156 #endif 157