Home | History | Annotate | Line # | Download | only in AST 
      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