Another step in the process of making the parser depend on Sema:

  - move DeclSpec &c into the Sema library
  - move ParseAST into the Parse library
Reflect this change in a thousand different includes.
Reflect this change in the link orders.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@111667 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 0 insertions, 3234 deletions

diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h
deleted file mode 100644
index 263dacb43d..0000000000
--- a/include/clang/Parse/Action.h
+++ /dev/null
@@ -1,3234 +0,0 @@
-//===--- Action.h - Parser Action Interface ---------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines the Action and EmptyAction interface.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_PARSE_ACTION_H
-#define LLVM_CLANG_PARSE_ACTION_H
-
-#include "clang/Basic/IdentifierTable.h"
-#include "clang/Basic/SourceLocation.h"
-#include "clang/Basic/Specifiers.h"
-#include "clang/Basic/TemplateKinds.h"
-#include "clang/Basic/TypeTraits.h"
-#include "clang/Parse/DeclSpec.h"
-#include "clang/Parse/Ownership.h"
-#include "llvm/Support/PrettyStackTrace.h"
-#include "llvm/ADT/PointerUnion.h"
-
-namespace clang {
-  // Semantic.
-  class DeclSpec;
-  class ObjCDeclSpec;
-  class CXXScopeSpec;
-  class Declarator;
-  class AttributeList;
-  struct FieldDeclarator;
-  // Parse.
-  class Scope;
-  class Action;
-  class Selector;
-  class Designation;
-  class InitListDesignations;
-  // Lex.
-  class Preprocessor;
-  class Token;
-
-  // We can re-use the low bit of expression, statement, base, and
-  // member-initializer pointers for the "invalid" flag of
-  // ActionResult.
-  template<> struct IsResultPtrLowBitFree<0> { static const bool value = true;};
-  template<> struct IsResultPtrLowBitFree<1> { static const bool value = true;};
-  template<> struct IsResultPtrLowBitFree<3> { static const bool value = true;};
-  template<> struct IsResultPtrLowBitFree<4> { static const bool value = true;};
-  template<> struct IsResultPtrLowBitFree<5> { static const bool value = true;};
-
-/// Action - As the parser reads the input file and recognizes the productions
-/// of the grammar, it invokes methods on this class to turn the parsed input
-/// into something useful: e.g. a parse tree.
-///
-/// The callback methods that this class provides are phrased as actions that
-/// the parser has just done or is about to do when the method is called.  They
-/// are not requests that the actions module do the specified action.
-///
-/// All of the methods here are optional except getTypeName() and
-/// isCurrentClassName(), which must be specified in order for the
-/// parse to complete accurately.
-class Action : public ActionBase {
-  /// \brief The parser's current scope.
-  ///
-  /// The parser maintains this state here so that is accessible to \c Action 
-  /// subclasses via \c getCurScope().
-  Scope *CurScope;
-  
-protected:
-  friend class Parser;
-  
-  /// \brief Retrieve the parser's current scope.
-  Scope *getCurScope() const { return CurScope; }
-  
-public:
-  Action() : CurScope(0) { }
-  
-  /// Out-of-line virtual destructor to provide home for this class.
-  virtual ~Action();
-
-  // Types - Though these don't actually enforce strong typing, they document
-  // what types are required to be identical for the actions.
-  typedef ActionBase::ExprTy ExprTy;
-  typedef ActionBase::StmtTy StmtTy;
-
-  /// Expr/Stmt/Type/BaseResult - Provide a unique type to wrap
-  /// ExprTy/StmtTy/TypeTy/BaseTy, providing strong typing and
-  /// allowing for failure.
-  typedef ActionResult<0> ExprResult;
-  typedef ActionResult<1> StmtResult;
-  typedef ActionResult<2> TypeResult;
-  typedef ActionResult<3> BaseResult;
-  typedef ActionResult<4> MemInitResult;
-  typedef ActionResult<5, DeclPtrTy> DeclResult;
-
-  /// Same, but with ownership.
-  typedef ASTOwningResult<&ActionBase::DeleteExpr> OwningExprResult;
-  typedef ASTOwningResult<&ActionBase::DeleteStmt> OwningStmtResult;
-  // Note that these will replace ExprResult and StmtResult when the transition
-  // is complete.
-
-  /// Single expressions or statements as arguments.
-  typedef ASTOwningPtr<&ActionBase::DeleteExpr> ExprArg;
-  typedef ASTOwningPtr<&ActionBase::DeleteStmt> StmtArg;
-
-  /// Multiple expressions or statements as arguments.
-  typedef ASTMultiPtr<&ActionBase::DeleteExpr> MultiExprArg;
-  typedef ASTMultiPtr<&ActionBase::DeleteStmt> MultiStmtArg;
-  typedef ASTMultiPtr<&ActionBase::DeleteTemplateParams> MultiTemplateParamsArg;
-
-  class FullExprArg {
-  public:
-    FullExprArg(ActionBase &actions) : Expr(actions) { }
-                
-    // FIXME: The const_cast here is ugly. RValue references would make this
-    // much nicer (or we could duplicate a bunch of the move semantics
-    // emulation code from Ownership.h).
-    FullExprArg(const FullExprArg& Other)
-      : Expr(move(const_cast<FullExprArg&>(Other).Expr)) {}
-
-    FullExprArg &operator=(const FullExprArg& Other) {
-      Expr.operator=(move(const_cast<FullExprArg&>(Other).Expr));
-      return *this;
-    }
-
-    OwningExprResult release() {
-      return move(Expr);
-    }
-
-    ExprArg* operator->() {
-      return &Expr;
-    }
-
-  private:
-    // FIXME: No need to make the entire Action class a friend when it's just
-    // Action::FullExpr that needs access to the constructor below.
-    friend class Action;
-
-    explicit FullExprArg(ExprArg expr)
-      : Expr(move(expr)) {}
-
-    ExprArg Expr;
-  };
-
-  template<typename T>
-  FullExprArg MakeFullExpr(T &Arg) {
-      return FullExprArg(ActOnFinishFullExpr(move(Arg)));
-  }
-
-  // Utilities for Action implementations to return smart results.
-
-  OwningExprResult ExprError() { return OwningExprResult(*this, true); }
-  OwningStmtResult StmtError() { return OwningStmtResult(*this, true); }
-
-  OwningExprResult ExprError(const DiagnosticBuilder&) { return ExprError(); }
-  OwningStmtResult StmtError(const DiagnosticBuilder&) { return StmtError(); }
-
-  OwningExprResult ExprEmpty() { return OwningExprResult(*this, false); }
-  OwningStmtResult StmtEmpty() { return OwningStmtResult(*this, false); }
-
-  /// Statistics.
-  virtual void PrintStats() const {}
-
-  /// getDeclName - Return a pretty name for the specified decl if possible, or
-  /// an empty string if not.  This is used for pretty crash reporting.
-  virtual std::string getDeclName(DeclPtrTy D) { return ""; }
-
-  //===--------------------------------------------------------------------===//
-  // Declaration Tracking Callbacks.
-  //===--------------------------------------------------------------------===//
-
-  typedef uintptr_t ParsingDeclStackState;
-
-  /// PushParsingDeclaration - Notes that the parser has begun
-  /// processing a declaration of some sort.  Guaranteed to be matched
-  /// by a call to PopParsingDeclaration with the value returned by
-  /// this method.
-  virtual ParsingDeclStackState PushParsingDeclaration() {
-    return ParsingDeclStackState();
-  }
-
-  /// PopParsingDeclaration - Notes that the parser has completed
-  /// processing a declaration of some sort.  The decl will be empty
-  /// if the declaration didn't correspond to a full declaration (or
-  /// if the actions module returned an empty decl for it).
-  virtual void PopParsingDeclaration(ParsingDeclStackState S, DeclPtrTy D) {
-  }
-
-  /// ConvertDeclToDeclGroup - If the parser has one decl in a context where it
-  /// needs a decl group, it calls this to convert between the two
-  /// representations.
-  virtual DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
-    return DeclGroupPtrTy();
-  }
-
-  virtual void DiagnoseUseOfUnimplementedSelectors() {}
-
-  /// getTypeName - Return non-null if the specified identifier is a type name
-  /// in the current scope.
-  ///
-  /// \param II the identifier for which we are performing name lookup
-  ///
-  /// \param NameLoc the location of the identifier
-  ///
-  /// \param S the scope in which this name lookup occurs
-  ///
-  /// \param SS if non-NULL, the C++ scope specifier that precedes the
-  /// identifier
-  ///
-  /// \param isClassName whether this is a C++ class-name production, in
-  /// which we can end up referring to a member of an unknown specialization
-  /// that we know (from the grammar) is supposed to be a type. For example,
-  /// this occurs when deriving from "std::vector<T>::allocator_type", where T
-  /// is a template parameter.
-  ///
-  /// \param ObjectType if we're checking whether an identifier is a type
-  /// within a C++ member access expression, this will be the type of the 
-  /// 
-  /// \returns the type referred to by this identifier, or NULL if the type
-  /// does not name an identifier.
-  virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
-                              Scope *S, CXXScopeSpec *SS = 0,
-                              bool isClassName = false,
-                              TypeTy *ObjectType = 0) = 0;
-
-  /// isTagName() - This method is called *for error recovery purposes only*
-  /// to determine if the specified name is a valid tag name ("struct foo").  If
-  /// so, this returns the TST for the tag corresponding to it (TST_enum,
-  /// TST_union, TST_struct, TST_class).  This is used to diagnose cases in C
-  /// where the user forgot to specify the tag.
-  virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S) {
-    return DeclSpec::TST_unspecified;
-  }
-
-  /// \brief Action called as part of error recovery when the parser has 
-  /// determined that the given name must refer to a type, but 
-  /// \c getTypeName() did not return a result.
-  ///
-  /// This callback permits the action to give a detailed diagnostic when an
-  /// unknown type name is encountered and, potentially, to try to recover
-  /// by producing a new type in \p SuggestedType.
-  ///
-  /// \param II the name that should be a type.
-  ///
-  /// \param IILoc the location of the name in the source.
-  ///
-  /// \param S the scope in which name lookup was performed.
-  ///
-  /// \param SS if non-NULL, the C++ scope specifier that preceded the name.
-  ///
-  /// \param SuggestedType if the action sets this type to a non-NULL type,
-  /// the parser will recovery by consuming the type name token and then 
-  /// pretending that the given type was the type it parsed.
-  ///
-  /// \returns true if a diagnostic was emitted, false otherwise. When false,
-  /// the parser itself will emit a generic "unknown type name" diagnostic.
-  virtual bool DiagnoseUnknownTypeName(const IdentifierInfo &II, 
-                                       SourceLocation IILoc,
-                                       Scope *S,
-                                       CXXScopeSpec *SS,
-                                       TypeTy *&SuggestedType) {
-    return false;
-  }
-                                       
-  /// isCurrentClassName - Return true if the specified name is the
-  /// name of the innermost C++ class type currently being defined.
-  virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
-                                  const CXXScopeSpec *SS = 0) = 0;
-
-  /// \brief Determine whether the given name refers to a template.
-  ///
-  /// This callback is used by the parser after it has seen a '<' to determine
-  /// whether the given name refers to a template and, if so, what kind of 
-  /// template.
-  ///
-  /// \param S the scope in which the name occurs.
-  ///
-  /// \param SS the C++ nested-name-specifier that precedes the template name,
-  /// if any.
-  ///
-  /// \param hasTemplateKeyword true if the template keyword was specified.
-  ///
-  /// \param Name the name that we are querying to determine whether it is
-  /// a template.
-  ///
-  /// \param ObjectType if we are determining whether the given name is a 
-  /// template name in the context of a member access expression (e.g., 
-  /// \c p->X<int>), this is the type of the object referred to by the
-  /// member access (e.g., \c p).
-  ///
-  /// \param EnteringContext whether we are potentially entering the context
-  /// referred to by the nested-name-specifier \p SS, which allows semantic
-  /// analysis to look into uninstantiated templates.
-  ///
-  /// \param Template if the name does refer to a template, the declaration
-  /// of the template that the name refers to.
-  ///
-  /// \param MemberOfUnknownSpecialization Will be set true if the resulting 
-  /// member would be a member of an unknown specialization, in which case this
-  /// lookup cannot possibly pass at this time.
-  ///
-  /// \returns the kind of template that this name refers to.
-  virtual TemplateNameKind isTemplateName(Scope *S,
-                                          CXXScopeSpec &SS,
-                                          bool hasTemplateKeyword,
-                                          UnqualifiedId &Name,
-                                          TypeTy *ObjectType,
-                                          bool EnteringContext,
-                                          TemplateTy &Template,
-                                      bool &MemberOfUnknownSpecialization) = 0;
-
-  /// \brief Action called as part of error recovery when the parser has 
-  /// determined that the given name must refer to a template, but 
-  /// \c isTemplateName() did not return a result.
-  ///
-  /// This callback permits the action to give a detailed diagnostic when an
-  /// unknown template name is encountered and, potentially, to try to recover
-  /// by producing a new template in \p SuggestedTemplate.
-  ///
-  /// \param II the name that should be a template.
-  ///
-  /// \param IILoc the location of the name in the source.
-  ///
-  /// \param S the scope in which name lookup was performed.
-  ///
-  /// \param SS the C++ scope specifier that preceded the name.
-  ///
-  /// \param SuggestedTemplate if the action sets this template to a non-NULL,
-  /// template, the parser will recover by consuming the template name token
-  /// and the template argument list that follows.
-  ///
-  /// \param SuggestedTemplateKind as input, the kind of template that we
-  /// expect (e.g., \c TNK_Type_template or \c TNK_Function_template). If the
-  /// action provides a suggested template, this should be set to the kind of
-  /// template.
-  ///
-  /// \returns true if a diagnostic was emitted, false otherwise. When false,
-  /// the parser itself will emit a generic "unknown template name" diagnostic.
-  virtual bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, 
-                                           SourceLocation IILoc,
-                                           Scope *S,
-                                           const CXXScopeSpec *SS,
-                                           TemplateTy &SuggestedTemplate,
-                                           TemplateNameKind &SuggestedKind) {
-    return false;
-  }
-  
-  /// \brief Determine whether the given name refers to a non-type nested name
-  /// specifier, e.g., the name of a namespace or namespace alias.
-  ///
-  /// This actual is used in the parsing of pseudo-destructor names to 
-  /// distinguish a nested-name-specifier and a "type-name ::" when we
-  /// see the token sequence "X :: ~".
-  virtual bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
-                                            SourceLocation IdLoc,
-                                            IdentifierInfo &II,
-                                            TypeTy *ObjectType) {
-    return false;
-  }
-  
-  /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
-  /// global scope ('::').
-  virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
-                                                   SourceLocation CCLoc) {
-    return 0;
-  }
-  
-  /// \brief Parsed an identifier followed by '::' in a C++
-  /// nested-name-specifier.
-  ///
-  /// \param S the scope in which the nested-name-specifier was parsed.
-  ///
-  /// \param SS the nested-name-specifier that precedes the identifier. For
-  /// example, if we are parsing "foo::bar::", \p SS will describe the "foo::"
-  /// that has already been parsed.
-  ///
-  /// \param IdLoc the location of the identifier we have just parsed (e.g.,
-  /// the "bar" in "foo::bar::".
-  ///
-  /// \param CCLoc the location of the '::' at the end of the
-  /// nested-name-specifier.
-  ///
-  /// \param II the identifier that represents the scope that this
-  /// nested-name-specifier refers to, e.g., the "bar" in "foo::bar::".
-  ///
-  /// \param ObjectType if this nested-name-specifier occurs as part of a
-  /// C++ member access expression such as "x->Base::f", the type of the base
-  /// object (e.g., *x in the example, if "x" were a pointer).
-  ///
-  /// \param EnteringContext if true, then we intend to immediately enter the
-  /// context of this nested-name-specifier, e.g., for an out-of-line
-  /// definition of a class member.
-  ///
-  /// \returns a CXXScopeTy* object representing the C++ scope.
-  virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
-                                                  CXXScopeSpec &SS,
-                                                  SourceLocation IdLoc,
-                                                  SourceLocation CCLoc,
-                                                  IdentifierInfo &II,
-                                                  TypeTy *ObjectType,
-                                                  bool EnteringContext) {
-    return 0;
-  }
-  
-  /// IsInvalidUnlessNestedName - This method is used for error recovery
-  /// purposes to determine whether the specified identifier is only valid as
-  /// a nested name specifier, for example a namespace name.  It is
-  /// conservatively correct to always return false from this method.
-  ///
-  /// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
-  virtual bool IsInvalidUnlessNestedName(Scope *S,
-                                         CXXScopeSpec &SS,
-                                         IdentifierInfo &II,
-                                         TypeTy *ObjectType,
-                                         bool EnteringContext) {
-    return false;
-  }
-
-  /// ActOnCXXNestedNameSpecifier - Called during parsing of a
-  /// nested-name-specifier that involves a template-id, e.g.,
-  /// "foo::bar<int, float>::", and now we need to build a scope
-  /// specifier. \p SS is empty or the previously parsed nested-name
-  /// part ("foo::"), \p Type is the already-parsed class template
-  /// specialization (or other template-id that names a type), \p
-  /// TypeRange is the source range where the type is located, and \p
-  /// CCLoc is the location of the trailing '::'.
-  virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
-                                                  const CXXScopeSpec &SS,
-                                                  TypeTy *Type,
-                                                  SourceRange TypeRange,
-                                                  SourceLocation CCLoc) {
-    return 0;
-  }
-
-  /// ShouldEnterDeclaratorScope - Called when a C++ scope specifier
-  /// is parsed as part of a declarator-id to determine whether a scope
-  /// should be entered.
-  ///
-  /// \param S the current scope
-  /// \param SS the scope being entered
-  /// \param isFriendDeclaration whether this is a friend declaration
-  virtual bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
-    return false;
-  }
-
-  /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
-  /// scope or nested-name-specifier) is parsed as part of a declarator-id.
-  /// After this method is called, according to [C++ 3.4.3p3], names should be
-  /// looked up in the declarator-id's scope, until the declarator is parsed and
-  /// ActOnCXXExitDeclaratorScope is called.
-  /// The 'SS' should be a non-empty valid CXXScopeSpec.
-  /// \returns true if an error occurred, false otherwise.
-  virtual bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS) {
-    return false;
-  }
-
-  /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
-  /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
-  /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
-  /// Used to indicate that names should revert to being looked up in the
-  /// defining scope.
-  virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
-  }
-
-  /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
-  /// initializer for the declaration 'Dcl'.
-  /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
-  /// static data member of class X, names should be looked up in the scope of
-  /// class X.
-  virtual void ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl) {
-  }
-
-  /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
-  /// initializer for the declaration 'Dcl'.
-  virtual void ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl) {
-  }
-
-  /// ActOnDeclarator - This callback is invoked when a declarator is parsed and
-  /// 'Init' specifies the initializer if any.  This is for things like:
-  /// "int X = 4" or "typedef int foo".
-  ///
-  virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
-    return DeclPtrTy();
-  }
-
-  /// ActOnParamDeclarator - This callback is invoked when a parameter
-  /// declarator is parsed. This callback only occurs for functions
-  /// with prototypes. S is the function prototype scope for the
-  /// parameters (C++ [basic.scope.proto]).
-  virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D) {
-    return DeclPtrTy();
-  }
-
-  /// \brief Parsed an exception object declaration within an Objective-C
-  /// @catch statement.
-  virtual DeclPtrTy ActOnObjCExceptionDecl(Scope *S, Declarator &D) {
-    return DeclPtrTy();
-  }
-
-  /// AddInitializerToDecl - This action is called immediately after
-  /// ActOnDeclarator (when an initializer is present). The code is factored
-  /// this way to make sure we are able to handle the following:
-  ///   void func() { int xx = xx; }
-  /// This allows ActOnDeclarator to register "xx" prior to parsing the
-  /// initializer. The declaration above should still result in a warning,
-  /// since the reference to "xx" is uninitialized.
-  virtual void AddInitializerToDecl(DeclPtrTy Dcl, ExprArg Init) {
-    return;
-  }
-
-  /// SetDeclDeleted - This action is called immediately after ActOnDeclarator
-  /// if =delete is parsed. C++0x [dcl.fct.def]p10
-  /// Note that this can be called even for variable declarations. It's the
-  /// action's job to reject it.
-  virtual void SetDeclDeleted(DeclPtrTy Dcl, SourceLocation DelLoc) {
-    return;
-  }
-
-  /// ActOnUninitializedDecl - This action is called immediately after
-  /// ActOnDeclarator (when an initializer is *not* present).
-  /// If TypeContainsUndeducedAuto is true, then the type of the declarator
-  /// has an undeduced 'auto' type somewhere.
-  virtual void ActOnUninitializedDecl(DeclPtrTy Dcl,
-                                      bool TypeContainsUndeducedAuto) {
-    return;
-  }
-
-  /// \brief Note that the given declaration had an initializer that could not
-  /// be parsed.
-  virtual void ActOnInitializerError(DeclPtrTy Dcl) {
-    return;
-  }
-  
-  /// FinalizeDeclaratorGroup - After a sequence of declarators are parsed, this
-  /// gives the actions implementation a chance to process the group as a whole.
-  virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec& DS,
-                                                 DeclPtrTy *Group,
-                                                 unsigned NumDecls) {
-    return DeclGroupPtrTy();
-  }
-
-
-  /// @brief Indicates that all K&R-style parameter declarations have
-  /// been parsed prior to a function definition.
-  /// @param S  The function prototype scope.
-  /// @param D  The function declarator.
-  virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
-                                               SourceLocation LocAfterDecls) {
-  }
-
-  /// ActOnStartOfFunctionDef - This is called at the start of a function
-  /// definition, instead of calling ActOnDeclarator.  The Declarator includes
-  /// information about formal arguments that are part of this function.
-  virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
-    // Default to ActOnDeclarator.
-    return ActOnStartOfFunctionDef(FnBodyScope,
-                                   ActOnDeclarator(FnBodyScope, D));
-  }
-
-  /// ActOnStartOfFunctionDef - This is called at the start of a function
-  /// definition, after the FunctionDecl has already been created.
-  virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
-    return D;
-  }
-
-  virtual void ActOnStartOfObjCMethodDef(Scope *FnBodyScope, DeclPtrTy D) {
-    return;
-  }
-
-  /// ActOnFinishFunctionBody - This is called when a function body has
-  /// completed parsing.  Decl is returned by ParseStartOfFunctionDef.
-  virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body) {
-    return Decl;
-  }
-
-  virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc,
-                                          ExprArg AsmString) {
-    return DeclPtrTy();
-  }
-
-  /// ActOnPopScope - This callback is called immediately before the specified
-  /// scope is popped and deleted.
-  virtual void ActOnPopScope(SourceLocation Loc, Scope *S) {}
-
-  /// ActOnTranslationUnitScope - This callback is called once, immediately
-  /// after creating the translation unit scope (in Parser::Initialize).
-  virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) {}
-
-  /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
-  /// no declarator (e.g. "struct foo;") is parsed.
-  virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S,
-                                               AccessSpecifier Access,
-                                               DeclSpec &DS) {
-    return DeclPtrTy();
-  }
-
-  /// ActOnStartLinkageSpecification - Parsed the beginning of a C++
-  /// linkage specification, including the language and (if present)
-  /// the '{'. ExternLoc is the location of the 'extern', LangLoc is
-  /// the location of the language string literal, which is provided
-  /// by Lang/StrSize. LBraceLoc, if valid, provides the location of
-  /// the '{' brace. Otherwise, this linkage specification does not
-  /// have any braces.
-  virtual DeclPtrTy ActOnStartLinkageSpecification(Scope *S,
-                                                   SourceLocation ExternLoc,
-                                                   SourceLocation LangLoc,
-                                                   llvm::StringRef Lang,
-                                                   SourceLocation LBraceLoc) {
-    return DeclPtrTy();
-  }
-
-  /// ActOnFinishLinkageSpecification - Completely the definition of
-  /// the C++ linkage specification LinkageSpec. If RBraceLoc is
-  /// valid, it's the position of the closing '}' brace in a linkage
-  /// specification that uses braces.
-  virtual DeclPtrTy ActOnFinishLinkageSpecification(Scope *S,
-                                                    DeclPtrTy LinkageSpec,
-                                                    SourceLocation RBraceLoc) {
-    return LinkageSpec;
-  }
-
-  /// ActOnEndOfTranslationUnit - This is called at the very end of the
-  /// translation unit when EOF is reached and all but the top-level scope is
-  /// popped.
-  virtual void ActOnEndOfTranslationUnit() {}
-
-  //===--------------------------------------------------------------------===//
-  // Type Parsing Callbacks.
-  //===--------------------------------------------------------------------===//
-
-  /// ActOnTypeName - A type-name (type-id in C++) was parsed.
-  virtual TypeResult ActOnTypeName(Scope *S, Declarator &D) {
-    return TypeResult();
-  }
-
-  enum TagUseKind {
-    TUK_Reference,   // Reference to a tag:  'struct foo *X;'
-    TUK_Declaration, // Fwd decl of a tag:   'struct foo;'
-    TUK_Definition,  // Definition of a tag: 'struct foo { int X; } Y;'
-    TUK_Friend       // Friend declaration:  'friend struct foo;'
-  };
-
-  /// \brief The parser has encountered a tag (e.g., "class X") that should be
-  /// turned into a declaration by the action module.
-  ///
-  /// \param S the scope in which this tag occurs.
-  ///
-  /// \param TagSpec an instance of DeclSpec::TST, indicating what kind of tag
-  /// this is (struct/union/enum/class).
-  ///
-  /// \param TUK how the tag we have encountered is being used, which
-  /// can be a reference to a (possibly pre-existing) tag, a
-  /// declaration of that tag, or the beginning of a definition of
-  /// that tag.
-  ///
-  /// \param KWLoc the location of the "struct", "class", "union", or "enum"
-  /// keyword.
-  ///
-  /// \param SS C++ scope specifier that precedes the name of the tag, e.g.,
-  /// the "std::" in "class std::type_info".
-  ///
-  /// \param Name the name of the tag, e.g., "X" in "struct X". This parameter
-  /// may be NULL, to indicate an anonymous class/struct/union/enum type.
-  ///
-  /// \param NameLoc the location of the name of the tag.
-  ///
-  /// \param Attr the set of attributes that appertain to the tag.
-  ///
-  /// \param AS when this tag occurs within a C++ class, provides the
-  /// current access specifier (AS_public, AS_private, AS_protected).
-  /// Otherwise, it will be AS_none.
-  ///
-  /// \param TemplateParameterLists the set of C++ template parameter lists
-  /// that apply to this tag, if the tag is a declaration or definition (see
-  /// the \p TK parameter). The action module is responsible for determining,
-  /// based on the template parameter lists and the scope specifier, whether
-  /// the declared tag is a class template or not.
-  ///
-  /// \param OwnedDecl the callee should set this flag true when the returned
-  /// declaration is "owned" by this reference. Ownership is handled entirely
-  /// by the action module.
-  ///
-  /// \returns the declaration to which this tag refers.
-  virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
-                             SourceLocation KWLoc, CXXScopeSpec &SS,
-                             IdentifierInfo *Name, SourceLocation NameLoc,
-                             AttributeList *Attr, AccessSpecifier AS,
-                             MultiTemplateParamsArg TemplateParameterLists,
-                             bool &OwnedDecl, bool &IsDependent) {
-    return DeclPtrTy();
-  }
-
-  /// Acts on a reference to a dependent tag name.  This arises in
-  /// cases like:
-  ///
-  ///    template <class T> class A;
-  ///    template <class T> class B {
-  ///      friend class A<T>::M;  // here
-  ///    };
-  ///
-  /// \param TagSpec an instance of DeclSpec::TST corresponding to the
-  /// tag specifier.
-  ///
-  /// \param TUK the tag use kind (either TUK_Friend or TUK_Reference)
-  ///
-  /// \param SS the scope specifier (always defined)
-  virtual TypeResult ActOnDependentTag(Scope *S,
-                                       unsigned TagSpec,
-                                       TagUseKind TUK,
-                                       const CXXScopeSpec &SS,
-                                       IdentifierInfo *Name,
-                                       SourceLocation KWLoc,
-                                       SourceLocation NameLoc) {
-    return TypeResult();
-  }
-
-  /// Act on @defs() element found when parsing a structure.  ClassName is the
-  /// name of the referenced class.
-  virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
-                         IdentifierInfo *ClassName,
-                         llvm::SmallVectorImpl<DeclPtrTy> &Decls) {}
-  virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
-                               SourceLocation DeclStart,
-                               Declarator &D, ExprTy *BitfieldWidth) {
-    return DeclPtrTy();
-  }
-
-  virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
-                              DeclPtrTy IntfDecl,
-                              Declarator &D, ExprTy *BitfieldWidth,
-                              tok::ObjCKeywordKind visibility) {
-    return DeclPtrTy();
-  }
-
-  virtual void ActOnFields(Scope* S, SourceLocation RecLoc, DeclPtrTy TagDecl,
-                           DeclPtrTy *Fields, unsigned NumFields,
-                           SourceLocation LBrac, SourceLocation RBrac,
-                           AttributeList *AttrList) {}
-
-  /// ActOnTagStartDefinition - Invoked when we have entered the
-  /// scope of a tag's definition (e.g., for an enumeration, class,
-  /// struct, or union).
-  virtual void ActOnTagStartDefinition(Scope *S, DeclPtrTy TagDecl) { }
-
-  /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
-  /// C++ record definition's base-specifiers clause and are starting its
-  /// member declarations.
-  virtual void ActOnStartCXXMemberDeclarations(Scope *S, DeclPtrTy TagDecl,
-                                               SourceLocation LBraceLoc) { }
-
-  /// ActOnTagFinishDefinition - Invoked once we have finished parsing
-  /// the definition of a tag (enumeration, class, struct, or union).
-  ///
-  /// The scope is the scope of the tag definition.
-  virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl,
-                                        SourceLocation RBraceLoc) { }
-
-  /// ActOnTagDefinitionError - Invoked if there's an unrecoverable
-  /// error parsing the definition of a tag.
-  ///
-  /// The scope is the scope of the tag definition.
-  virtual void ActOnTagDefinitionError(Scope *S, DeclPtrTy TagDecl) { }
-
-  virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
-                                      DeclPtrTy LastEnumConstant,
-                                      SourceLocation IdLoc, IdentifierInfo *Id,
-                                      SourceLocation EqualLoc, ExprTy *Val) {
-    return DeclPtrTy();
-  }
-  virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
-                             SourceLocation RBraceLoc, DeclPtrTy EnumDecl,
-                             DeclPtrTy *Elements, unsigned NumElements,
-                             Scope *S, AttributeList *AttrList) {}
-
-  //===--------------------------------------------------------------------===//
-  // Statement Parsing Callbacks.
-  //===--------------------------------------------------------------------===//
-
-  virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc) {
-    return StmtEmpty();
-  }
-
-  virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
-                                             MultiStmtArg Elts,
-                                             bool isStmtExpr) {
-    return StmtEmpty();
-  }
-  virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
-                                         SourceLocation StartLoc,
-                                         SourceLocation EndLoc) {
-    return StmtEmpty();
-  }
-
-  virtual void ActOnForEachDeclStmt(DeclGroupPtrTy Decl) {
-  }
-
-  virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr) {
-    return OwningStmtResult(*this, Expr->release());
-  }
-
-  /// ActOnCaseStmt - Note that this handles the GNU 'case 1 ... 4' extension,
-  /// which can specify an RHS value.  The sub-statement of the case is
-  /// specified in a separate action.
-  virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
-                                         SourceLocation DotDotDotLoc,
-                                         ExprArg RHSVal,
-                                         SourceLocation ColonLoc) {
-    return StmtEmpty();
-  }
-
-  /// ActOnCaseStmtBody - This installs a statement as the body of a case.
-  virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt) {}
-
-  virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
-                                            SourceLocation ColonLoc,
-                                            StmtArg SubStmt, Scope *CurScope){
-    return StmtEmpty();
-  }
-
-  virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
-                                          IdentifierInfo *II,
-                                          SourceLocation ColonLoc,
-                                          StmtArg SubStmt) {
-    return StmtEmpty();
-  }
-
-  /// \brief Parsed an "if" statement.
-  ///
-  /// \param IfLoc the location of the "if" keyword.
-  ///
-  /// \param CondVal if the "if" condition was parsed as an expression, 
-  /// the expression itself.
-  ///
-  /// \param CondVar if the "if" condition was parsed as a condition variable,
-  /// the condition variable itself.
-  ///
-  /// \param ThenVal the "then" statement.
-  ///
-  /// \param ElseLoc the location of the "else" keyword.
-  ///
-  /// \param ElseVal the "else" statement.
-  virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc,
-                                       FullExprArg CondVal, 
-                                       DeclPtrTy CondVar,
-                                       StmtArg ThenVal,
-                                       SourceLocation ElseLoc,
-                                       StmtArg ElseVal) {
-    return StmtEmpty();
-  }
-
-  /// \brief Parsed the start of a "switch" statement.
-  ///
-  /// \param SwitchLoc The location of the "switch" keyword.
-  ///
-  /// \param Cond if the "switch" condition was parsed as an expression, 
-  /// the expression itself.
-  ///
-  /// \param CondVar if the "switch" condition was parsed as a condition 
-  /// variable, the condition variable itself.
-  virtual OwningStmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
-                                                  ExprArg Cond,
-                                                  DeclPtrTy CondVar) {
-    return StmtEmpty();
-  }