/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/AST/ASTMutationListener.h
Line | Count | Source (jump to first uncovered line) |
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 | 0 | virtual void CompletedTagDefinition(const TagDecl *D) { } |
52 | | |
53 | | /// A new declaration with name has been added to a DeclContext. |
54 | 0 | virtual void AddedVisibleDecl(const DeclContext *DC, const Decl *D) {} |
55 | | |
56 | | /// An implicit member was added after the definition was completed. |
57 | 0 | 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 | 0 | 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 | 0 | 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 | 0 | const FunctionDecl *D) {} |
74 | | |
75 | | /// A function's exception specification has been evaluated or |
76 | | /// instantiated. |
77 | 0 | 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 | 0 | Expr *ThisArg) {} |
86 | | |
87 | | /// An implicit member got a definition. |
88 | 0 | 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 | 0 | virtual void InstantiationRequested(const ValueDecl *D) {} |
94 | | |
95 | | /// A templated variable's definition was implicitly instantiated. |
96 | 0 | virtual void VariableDefinitionInstantiated(const VarDecl *D) {} |
97 | | |
98 | | /// A function template's definition was instantiated. |
99 | 0 | virtual void FunctionDefinitionInstantiated(const FunctionDecl *D) {} |
100 | | |
101 | | /// A default argument was instantiated. |
102 | 0 | virtual void DefaultArgumentInstantiated(const ParmVarDecl *D) {} |
103 | | |
104 | | /// A default member initializer was instantiated. |
105 | 0 | 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 | 0 | 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 | 0 | 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 | 0 | 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 | 0 | 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 | 0 | 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 | 0 | 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 | 0 | 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 |