Home | History | Annotate | Download | only in AST 
      1 //===--- ASTConsumer.h - Abstract interface for reading ASTs ----*- 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 ASTConsumer class.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #ifndef LLVM_CLANG_AST_ASTCONSUMER_H
     15 #define LLVM_CLANG_AST_ASTCONSUMER_H
     16 
     17 #include "llvm/ADT/StringRef.h"
     18 
     19 namespace clang {
     20   class ASTContext;
     21   class CXXRecordDecl;
     22   class Decl;
     23   class DeclGroupRef;
     24   class HandleTagDeclDefinition;
     25   class ASTMutationListener;
     26   class ASTDeserializationListener; // layering violation because void* is ugly
     27   class SemaConsumer; // layering violation required for safe SemaConsumer
     28   class TagDecl;
     29   class VarDecl;
     30   class FunctionDecl;
     31   class ImportDecl;
     32 
     33 /// ASTConsumer - This is an abstract interface that should be implemented by
     34 /// clients that read ASTs.  This abstraction layer allows the client to be
     35 /// independent of the AST producer (e.g. parser vs AST dump file reader, etc).
     36 class ASTConsumer {
     37   /// \brief Whether this AST consumer also requires information about
     38   /// semantic analysis.
     39   bool SemaConsumer;
     40 
     41   friend class SemaConsumer;
     42 
     43 public:
     44   ASTConsumer() : SemaConsumer(false) { }
     45 
     46   virtual ~ASTConsumer() {}
     47 
     48   /// Initialize - This is called to initialize the consumer, providing the
     49   /// ASTContext.
     50   virtual void Initialize(ASTContext &Context) {}
     51 
     52   /// HandleTopLevelDecl - Handle the specified top-level declaration.  This is
     53   /// called by the parser to process every top-level Decl*. Note that D can be
     54   /// the head of a chain of Decls (e.g. for `int a, b` the chain will have two
     55   /// elements). Use Decl::getNextDeclarator() to walk the chain.
     56   ///
     57   /// \returns true to continue parsing, or false to abort parsing.
     58   virtual bool HandleTopLevelDecl(DeclGroupRef D);
     59 
     60   /// HandleInterestingDecl - Handle the specified interesting declaration. This
     61   /// is called by the AST reader when deserializing things that might interest
     62   /// the consumer. The default implementation forwards to HandleTopLevelDecl.
     63   virtual void HandleInterestingDecl(DeclGroupRef D);
     64 
     65   /// HandleTranslationUnit - This method is called when the ASTs for entire
     66   /// translation unit have been parsed.
     67   virtual void HandleTranslationUnit(ASTContext &Ctx) {}
     68 
     69   /// HandleTagDeclDefinition - This callback is invoked each time a TagDecl
     70   /// (e.g. struct, union, enum, class) is completed.  This allows the client to
     71   /// hack on the type, which can occur at any point in the file (because these
     72   /// can be defined in declspecs).
     73   virtual void HandleTagDeclDefinition(TagDecl *D) {}
     74 
     75   /// \brief This callback is invoked the first time each TagDecl is required to
     76   /// be complete.
     77   virtual void HandleTagDeclRequiredDefinition(const TagDecl *D) {}
     78 
     79   /// \brief Invoked when a function is implicitly instantiated.
     80   /// Note that at this point point it does not have a body, its body is
     81   /// instantiated at the end of the translation unit and passed to
     82   /// HandleTopLevelDecl.
     83   virtual void HandleCXXImplicitFunctionInstantiation(FunctionDecl *D) {}
     84 
     85   /// \brief Handle the specified top-level declaration that occurred inside
     86   /// and ObjC container.
     87   /// The default implementation ignored them.
     88   virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef D);
     89 
     90   /// \brief Handle an ImportDecl that was implicitly created due to an
     91   /// inclusion directive.
     92   /// The default implementation passes it to HandleTopLevelDecl.
     93   virtual void HandleImplicitImportDecl(ImportDecl *D);
     94 
     95   /// \brief Handle a pragma that appends to Linker Options.  Currently this
     96   /// only exists to support Microsoft's #pragma comment(linker, "/foo").
     97   virtual void HandleLinkerOptionPragma(llvm::StringRef Opts) {}
     98 
     99   /// \brief Handle a pragma that emits a mismatch identifier and value to the
    100   /// object file for the linker to work with.  Currently, this only exists to
    101   /// support Microsoft's #pragma detect_mismatch.
    102   virtual void HandleDetectMismatch(llvm::StringRef Name,
    103                                     llvm::StringRef Value) {}
    104 
    105   /// \brief Handle a dependent library created by a pragma in the source.
    106   /// Currently this only exists to support Microsoft's
    107   /// #pragma comment(lib, "/foo").
    108   virtual void HandleDependentLibrary(llvm::StringRef Lib) {}
    109 
    110   /// CompleteTentativeDefinition - Callback invoked at the end of a translation
    111   /// unit to notify the consumer that the given tentative definition should be
    112   /// completed.
    113   ///
    114   /// The variable declaration itself will be a tentative
    115   /// definition. If it had an incomplete array type, its type will
    116   /// have already been changed to an array of size 1. However, the
    117   /// declaration remains a tentative definition and has not been
    118   /// modified by the introduction of an implicit zero initializer.
    119   virtual void CompleteTentativeDefinition(VarDecl *D) {}
    120 
    121   /// HandleCXXStaticMemberVarInstantiation - Tell the consumer that this
    122   // variable has been instantiated.
    123   virtual void HandleCXXStaticMemberVarInstantiation(VarDecl *D) {}
    124 
    125   /// \brief Callback involved at the end of a translation unit to
    126   /// notify the consumer that a vtable for the given C++ class is
    127   /// required.
    128   ///
    129   /// \param RD The class whose vtable was used.
    130   ///
    131   /// \param DefinitionRequired Whether a definition of this vtable is
    132   /// required in this translation unit; otherwise, it is only needed if
    133   /// it was actually used.
    134   virtual void HandleVTable(CXXRecordDecl *RD, bool DefinitionRequired) {}
    135 
    136   /// \brief If the consumer is interested in entities getting modified after
    137   /// their initial creation, it should return a pointer to
    138   /// an ASTMutationListener here.
    139   virtual ASTMutationListener *GetASTMutationListener() { return 0; }
    140 
    141   /// \brief If the consumer is interested in entities being deserialized from
    142   /// AST files, it should return a pointer to a ASTDeserializationListener here
    143   virtual ASTDeserializationListener *GetASTDeserializationListener() {
    144     return 0;
    145   }
    146 
    147   /// PrintStats - If desired, print any statistics.
    148   virtual void PrintStats() {}
    149 
    150   /// \brief This callback is called for each function if the Parser was
    151   /// initialized with \c SkipFunctionBodies set to \c true.
    152   ///
    153   /// \return \c true if the function's body should be skipped. The function
    154   /// body may be parsed anyway if it is needed (for instance, if it contains
    155   /// the code completion point or is constexpr).
    156   virtual bool shouldSkipFunctionBody(Decl *D) { return true; }
    157 };
    158 
    159 } // end namespace clang.
    160 
    161 #endif
    162