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. |
51 | virtual void CompletedTagDefinition(const TagDecl *D) { } |
52 | |
53 | /// A new declaration with name has been added to a DeclContext. |
54 | virtual void AddedVisibleDecl(const DeclContext *DC, const Decl *D) {} |
55 | |
56 | /// An implicit member was added after the definition was completed. |
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. |
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 |
67 | AddedCXXTemplateSpecialization(const VarTemplateDecl *TD, |
68 | const VarTemplateSpecializationDecl *D) {} |
69 | |
70 | /// A template specialization (or partial one) was added to the |
71 | /// template declaration. |
72 | virtual void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD, |
73 | const FunctionDecl *D) {} |
74 | |
75 | /// A function's exception specification has been evaluated or |
76 | /// instantiated. |
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. |
83 | virtual void ResolvedOperatorDelete(const CXXDestructorDecl *DD, |
84 | const FunctionDecl *Delete, |
85 | Expr *ThisArg) {} |
86 | |
87 | /// An implicit member got a definition. |
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. |
93 | virtual void InstantiationRequested(const ValueDecl *D) {} |
94 | |
95 | /// A templated variable's definition was implicitly instantiated. |
96 | virtual void VariableDefinitionInstantiated(const VarDecl *D) {} |
97 | |
98 | /// A function template's definition was instantiated. |
99 | virtual void FunctionDefinitionInstantiated(const FunctionDecl *D) {} |
100 | |
101 | /// A default argument was instantiated. |
102 | virtual void DefaultArgumentInstantiated(const ParmVarDecl *D) {} |
103 | |
104 | /// A default member initializer was instantiated. |
105 | virtual void DefaultMemberInitializerInstantiated(const FieldDecl *D) {} |
106 | |
107 | /// A new objc category class was added for an interface. |
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 |
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. |
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. |
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. |
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. |
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 |
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 | |