contrib/llvm-project/clang/include/clang/AST/ASTMutationListener.h

   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