Coverage Report

Created: 2018-07-22 10:17

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