Coverage Report

Created: 2019-02-23 12:57

/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
// 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 definition has been made visible by being redefined locally.
131
  ///
132
  /// \param D The definition that was previously not visible.
133
  /// \param M The containing module in which the definition was made visible,
134
  ///        if any.
135
0
  virtual void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) {}
136
137
  /// An attribute was added to a RecordDecl
138
  ///
139
  /// \param Attr The attribute that was added to the Record
140
  ///
141
  /// \param Record The RecordDecl that got a new attribute
142
  virtual void AddedAttributeToRecord(const Attr *Attr,
143
0
                                      const RecordDecl *Record) {}
144
145
  // NOTE: If new methods are added they should also be added to
146
  // MultiplexASTMutationListener.
147
};
148
149
} // end namespace clang
150
151
#endif