Google Git
Sign in
llvm / clang / 1571f048734190c5ed03d1a6083e579ec7b5801f / . / include / clang / Parse / Action.h
blob: f211b5ca3a69d89474f77dc5c62121e6013355d7 [file] [log] [blame]
//===--- 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. The MinimalAction class does this
/// bare-minimum of tracking to implement this functionality.
class Action : public ActionBase {
public:
/// 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.
#if !defined(DISABLE_SMART_POINTERS)
typedef ASTOwningResult<&ActionBase::DeleteExpr> ExprArg;
typedef ASTOwningResult<&ActionBase::DeleteStmt> StmtArg;
#else
typedef ASTOwningPtr<&ActionBase::DeleteExpr> ExprArg;
typedef ASTOwningPtr<&ActionBase::DeleteStmt> StmtArg;
#endif
/// Multiple expressions or statements as arguments.
typedef ASTMultiPtr<&ActionBase::DeleteExpr> MultiExprArg;
typedef ASTMultiPtr<&ActionBase::DeleteStmt> MultiStmtArg;
typedef ASTMultiPtr<&ActionBase::DeleteTemplateParams> MultiTemplateParamsArg;
class FullExprArg {
public:
// 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)) {}
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 ""; }
/// \brief Invoked for each comment in the source code, providing the source
/// range that contains the comment.
virtual void ActOnComment(SourceRange Comment) { }
//===--------------------------------------------------------------------===//
// 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();
}
/// 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, const 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,
const 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 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.
///
/// \returns the kind of template that this name refers to.
virtual TemplateNameKind isTemplateName(Scope *S,
const CXXScopeSpec &SS,
UnqualifiedId &Name,
TypeTy *ObjectType,
bool EnteringContext,
TemplateTy &Template) = 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, const 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,
const 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,
const 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, const 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();
}
virtual void ActOnObjCCatchParam(DeclPtrTy D) {
}
/// 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, 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,
const char *Lang,
unsigned StrSize,
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, const 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).
virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl,
SourceLocation RBraceLoc) { }
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 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(FullExprArg Cond,
DeclPtrTy CondVar) {
return StmtEmpty();
}
/// ActOnSwitchBodyError - This is called if there is an error parsing the
/// body of the switch stmt instead of ActOnFinishSwitchStmt.
virtual void ActOnSwitchBodyError(SourceLocation SwitchLoc, StmtArg Switch,
StmtArg Body) {}
virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
StmtArg Switch, StmtArg Body) {
return StmtEmpty();
}
/// \brief Parsed a "while" statement.
///
/// \param Cond if the "while" condition was parsed as an expression,
/// the expression itself.
///
/// \param CondVar if the "while" condition was parsed as a condition
/// variable, the condition variable itself.
///
/// \param Body the body of the "while" loop.
virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc,
FullExprArg Cond, DeclPtrTy CondVar,
StmtArg Body) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
SourceLocation WhileLoc,
SourceLocation CondLParen,
ExprArg Cond,
SourceLocation CondRParen) {
return StmtEmpty();
}
/// \brief Parsed a "for" statement.
///
/// \param ForLoc the location of the "for" keyword.
///
/// \param LParenLoc the location of the left parentheses.
///
/// \param First the statement used to initialize the for loop.
///
/// \param Second the condition to be checked during each iteration, if
/// that condition was parsed as an expression.
///
/// \param SecondArg the condition variable to be checked during each
/// iterator, if that condition was parsed as a variable declaration.
///
/// \param Third the expression that will be evaluated to "increment" any
/// values prior to the next iteration.
///
/// \param RParenLoc the location of the right parentheses.
///
/// \param Body the body of the "body" loop.
virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
SourceLocation LParenLoc,
StmtArg First, FullExprArg Second,
DeclPtrTy SecondVar, FullExprArg Third,
SourceLocation RParenLoc,
StmtArg Body) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
SourceLocation LParenLoc,
StmtArg First, ExprArg Second,
SourceLocation RParenLoc, StmtArg Body) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
SourceLocation LabelLoc,
IdentifierInfo *LabelII) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
SourceLocation StarLoc,
ExprArg DestExp) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
Scope *CurScope) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
Scope *CurScope) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
ExprArg RetValExp) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
bool IsSimple,
bool IsVolatile,
unsigned NumOutputs,
unsigned NumInputs,
IdentifierInfo **Names,
MultiExprArg Constraints,
MultiExprArg Exprs,
ExprArg AsmString,
MultiExprArg Clobbers,
SourceLocation RParenLoc,
bool MSAsm = false) {
return StmtEmpty();
}
// Objective-c statements
virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
SourceLocation RParen,
DeclPtrTy Parm, StmtArg Body,
StmtArg CatchList) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
StmtArg Body) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
StmtArg Try, StmtArg Catch,
StmtArg Finally) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
ExprArg Throw,
Scope *CurScope) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
ExprArg SynchExpr,
StmtArg SynchBody) {
return StmtEmpty();
}
// C++ Statements
virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D) {
return DeclPtrTy();
}
virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
DeclPtrTy ExceptionDecl,
StmtArg HandlerBlock) {
return StmtEmpty();
}
virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
StmtArg TryBlock,
MultiStmtArg Handlers) {
return StmtEmpty();
}
//===--------------------------------------------------------------------===//
// Expression Parsing Callbacks.
//===--------------------------------------------------------------------===//
/// \brief Describes how the expressions currently being parsed are
/// evaluated at run-time, if at all.
enum ExpressionEvaluationContext {
/// \brief The current expression and its subexpressions occur within an
/// unevaluated operand (C++0x [expr]p8), such as a constant expression
/// or the subexpression of \c sizeof, where the type or the value of the
/// expression may be significant but no code will be generated to evaluate
/// the value of the expression at run time.
Unevaluated,
/// \brief The current expression is potentially evaluated at run time,
/// which means that code may be generated to evaluate the value of the
/// expression at run time.
PotentiallyEvaluated,
/// \brief The current expression may be potentially evaluated or it may
/// be unevaluated, but it is impossible to tell from the lexical context.
/// This evaluation context is used primary for the operand of the C++
/// \c typeid expression, whose argument is potentially evaluated only when
/// it is an lvalue of polymorphic class type (C++ [basic.def.odr]p2).
PotentiallyPotentiallyEvaluated
};
/// \brief The parser is entering a new expression evaluation context.
///
/// \param NewContext is the new expression evaluation context.
virtual void
PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) { }
/// \brief The parser is exiting an expression evaluation context.
virtual void
PopExpressionEvaluationContext() { }
// Primary Expressions.
/// \brief Retrieve the source range that corresponds to the given
/// expression.
virtual SourceRange getExprRange(ExprTy *E) const {
return SourceRange();
}
/// \brief Parsed an id-expression (C++) or identifier (C) in expression
/// context, e.g., the expression "x" that refers to a variable named "x".
///
/// \param S the scope in which this id-expression or identifier occurs.
///
/// \param SS the C++ nested-name-specifier that qualifies the name of the
/// value, e.g., "std::" in "std::sort".
///
/// \param Name the name to which the id-expression refers. In C, this will
/// always be an identifier. In C++, it may also be an overloaded operator,
/// destructor name (if there is a nested-name-specifier), or template-id.
///
/// \param HasTrailingLParen whether the next token following the
/// id-expression or identifier is a left parentheses ('(').
///
/// \param IsAddressOfOperand whether the token that precedes this
/// id-expression or identifier was an ampersand ('&'), indicating that
/// we will be taking the address of this expression.
virtual OwningExprResult ActOnIdExpression(Scope *S,
const CXXScopeSpec &SS,
UnqualifiedId &Name,
bool HasTrailingLParen,
bool IsAddressOfOperand) {
return ExprEmpty();
}
virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
tok::TokenKind Kind) {
return ExprEmpty();
}
virtual OwningExprResult ActOnCharacterConstant(const Token &) {
return ExprEmpty();
}
virtual OwningExprResult ActOnNumericConstant(const Token &) {
return ExprEmpty();
}
/// ActOnStringLiteral - The specified tokens were lexed as pasted string
/// fragments (e.g. "foo" "bar" L"baz").
virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
unsigned NumToks) {
return ExprEmpty();
}
virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
ExprArg Val) {
return move(Val); // Default impl returns operand.
}
virtual OwningExprResult ActOnParenOrParenListExpr(SourceLocation L,
SourceLocation R,
MultiExprArg Val,
TypeTy *TypeOfCast=0) {
return ExprEmpty();
}
// Postfix Expressions.
virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
tok::TokenKind Kind,
ExprArg Input) {
return ExprEmpty();
}
virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
SourceLocation LLoc,
ExprArg Idx,
SourceLocation RLoc) {
return ExprEmpty();
}
/// \brief Parsed a member access expresion (C99 6.5.2.3, C++ [expr.ref])
/// of the form \c x.m or \c p->m.
///
/// \param S the scope in which the member access expression occurs.
///
/// \param Base the class or pointer to class into which this member
/// access expression refers, e.g., \c x in \c x.m.
///
/// \param OpLoc the location of the "." or "->" operator.
///
/// \param OpKind the kind of member access operator, which will be either
/// tok::arrow ("->") or tok::period (".").
///
/// \param SS in C++, the nested-name-specifier that precedes the member
/// name, if any.
///
/// \param Member the name of the member that we are referring to. In C,
/// this will always store an identifier; in C++, we may also have operator
/// names, conversion function names, destructors, and template names.
///
/// \param ObjCImpDecl the Objective-C implementation declaration.
/// FIXME: Do we really need this?
///
/// \param HasTrailingLParen whether this member name is immediately followed
/// by a left parentheses ('(').
virtual OwningExprResult ActOnMemberAccessExpr(Scope *S, ExprArg Base,
SourceLocation OpLoc,
tok::TokenKind OpKind,
const CXXScopeSpec &SS,
UnqualifiedId &Member,
DeclPtrTy ObjCImpDecl,
bool HasTrailingLParen) {
return ExprEmpty();
}
/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
/// This provides the location of the left/right parens and a list of comma
/// locations. There are guaranteed to be one fewer commas than arguments,
/// unless there are zero arguments.
virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
SourceLocation LParenLoc,
MultiExprArg Args,
SourceLocation *CommaLocs,
SourceLocation RParenLoc) {
return ExprEmpty();
}
// Unary Operators. 'Tok' is the token for the operator.
virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
tok::TokenKind Op, ExprArg Input) {
return ExprEmpty();
}
virtual OwningExprResult
ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
void *TyOrEx, const SourceRange &ArgRange) {
return ExprEmpty();
}
virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParen,
TypeTy *Ty,
SourceLocation RParen,
ExprArg Op) {
return ExprEmpty();
}
virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
MultiExprArg InitList,
SourceLocation RParenLoc) {
return ExprEmpty();
}
/// @brief Parsed a C99 designated initializer.
///
/// @param Desig Contains the designation with one or more designators.
///
/// @param Loc The location of the '=' or ':' prior to the
/// initialization expression.
///
/// @param GNUSyntax If true, then this designated initializer used
/// the deprecated GNU syntax @c fieldname:foo or @c [expr]foo rather
/// than the C99 syntax @c .fieldname=foo or @c [expr]=foo.
///
/// @param Init The value that the entity (or entities) described by
/// the designation will be initialized with.
virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
SourceLocation Loc,
bool GNUSyntax,
OwningExprResult Init) {
return ExprEmpty();
}
virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
TypeTy *Ty, SourceLocation RParenLoc,
ExprArg Op) {
return ExprEmpty();
}
virtual bool TypeIsVectorType(TypeTy *Ty) {
return false;
}
virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
tok::TokenKind Kind,
ExprArg LHS, ExprArg RHS) {
return ExprEmpty();
}
/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
/// in the case of a the GNU conditional expr extension.
virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
SourceLocation ColonLoc,
ExprArg Cond, ExprArg LHS,
ExprArg RHS) {
return ExprEmpty();
}
//===---------------------- GNU Extension Expressions -------------------===//
virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
SourceLocation LabLoc,
IdentifierInfo *LabelII) { // "&&foo"
return ExprEmpty();
}
virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
SourceLocation RPLoc) { // "({..})"
return ExprEmpty();
}
// __builtin_offsetof(type, identifier(.identifier|[expr])*)
struct OffsetOfComponent {
SourceLocation LocStart, LocEnd;
bool isBrackets; // true if [expr], false if .ident
union {
IdentifierInfo *IdentInfo;
ExprTy *E;
} U;
};
virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
SourceLocation BuiltinLoc,
SourceLocation TypeLoc,
TypeTy *Arg1,
OffsetOfComponent *CompPtr,
unsigned NumComponents,
SourceLocation RParenLoc) {
return ExprEmpty();
}
// __builtin_types_compatible_p(type1, type2)
virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
TypeTy *arg1, TypeTy *arg2,
SourceLocation RPLoc) {
return ExprEmpty();
}
// __builtin_choose_expr(constExpr, expr1, expr2)
virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
ExprArg cond, ExprArg expr1,
ExprArg expr2, SourceLocation RPLoc){
return ExprEmpty();
}
// __builtin_va_arg(expr, type)
virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
ExprArg expr, TypeTy *type,
SourceLocation RPLoc) {
return ExprEmpty();
}
/// ActOnGNUNullExpr - Parsed the GNU __null expression, the token
/// for which is at position TokenLoc.
virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc) {
return ExprEmpty();
}
//===------------------------- "Block" Extension ------------------------===//
/// ActOnBlockStart - This callback is invoked when a block literal is
/// started. The result pointer is passed into the block finalizers.
virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) {}
/// ActOnBlockArguments - This callback allows processing of block arguments.
/// If there are no arguments, this is still invoked.
virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) {}
/// ActOnBlockError - If there is an error parsing a block, this callback
/// is invoked to pop the information about the block from the action impl.
virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {}
/// ActOnBlockStmtExpr - This is called when the body of a block statement
/// literal was successfully completed. ^(int x){...}
virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
StmtArg Body,
Scope *CurScope) {
return ExprEmpty();
}
//===------------------------- C++ Declarations -------------------------===//
/// ActOnStartNamespaceDef - This is called at the start of a namespace
/// definition.
virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
IdentifierInfo *Ident,
SourceLocation LBrace,
AttributeList *AttrList) {
return DeclPtrTy();
}
/// ActOnFinishNamespaceDef - This callback is called after a namespace is
/// exited. Decl is returned by ActOnStartNamespaceDef.
virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace) {
return;
}
/// ActOnUsingDirective - This is called when using-directive is parsed.
virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
SourceLocation UsingLoc,
SourceLocation NamespcLoc,
const CXXScopeSpec &SS,
SourceLocation IdentLoc,
IdentifierInfo *NamespcName,
AttributeList *AttrList);
/// ActOnNamespaceAliasDef - This is called when a namespace alias definition
/// is parsed.
virtual DeclPtrTy ActOnNamespaceAliasDef(Scope *CurScope,
SourceLocation NamespaceLoc,
SourceLocation AliasLoc,
IdentifierInfo *Alias,
const CXXScopeSpec &SS,
SourceLocation IdentLoc,
IdentifierInfo *Ident) {
return DeclPtrTy();
}
/// \brief Parsed a C++ using-declaration.
///
/// This callback will be invoked when the parser has parsed a C++
/// using-declaration, e.g.,
///
/// \code
/// namespace std {
/// template<typename T, typename Alloc> class vector;
/// }
///
/// using std::vector; // using-declaration here
/// \endcode
///
/// \param CurScope the scope in which this using declaration was parsed.
///
/// \param AS the currently-active access specifier.
///
/// \param HasUsingKeyword true if this was declared with an
/// explicit 'using' keyword (i.e. if this is technically a using
/// declaration, not an access declaration)
///
/// \param UsingLoc the location of the 'using' keyword.
///
/// \param SS the nested-name-specifier that precedes the name.
///
/// \param Name the name to which the using declaration refers.
///
/// \param AttrList attributes applied to this using declaration, if any.
///
/// \param IsTypeName whether this using declaration started with the
/// 'typename' keyword. FIXME: This will eventually be split into a
/// separate action.
///
/// \param TypenameLoc the location of the 'typename' keyword, if present
///
/// \returns a representation of the using declaration.
virtual DeclPtrTy ActOnUsingDeclaration(Scope *CurScope,
AccessSpecifier AS,
bool HasUsingKeyword,
SourceLocation UsingLoc,
const CXXScopeSpec &SS,
UnqualifiedId &Name,
AttributeList *AttrList,
bool IsTypeName,
SourceLocation TypenameLoc);
/// ActOnParamDefaultArgument - Parse default argument for function parameter
virtual void ActOnParamDefaultArgument(DeclPtrTy param,
SourceLocation EqualLoc,
ExprArg defarg) {
}
/// ActOnParamUnparsedDefaultArgument - We've seen a default
/// argument for a function parameter, but we can't parse it yet
/// because we're inside a class definition. Note that this default
/// argument will be parsed later.
virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
SourceLocation EqualLoc,
SourceLocation ArgLoc) { }
/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
/// the default argument for the parameter param failed.
virtual void ActOnParamDefaultArgumentError(DeclPtrTy param) { }
/// AddCXXDirectInitializerToDecl - This action is called immediately after
/// ActOnDeclarator, when a C++ direct initializer is present.
/// e.g: "int x(1);"
virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
SourceLocation LParenLoc,
MultiExprArg Exprs,
SourceLocation *CommaLocs,
SourceLocation RParenLoc) {
return;
}
/// \brief Called when we re-enter a template parameter scope.
///
/// This action occurs when we are going to parse an member
/// function's default arguments or inline definition after the
/// outermost class definition has been completed, and when one or
/// more of the class definitions enclosing the member function is a
/// template. The "entity" in the given scope will be set as it was
/// when we entered the scope of the template initially, and should
/// be used to, e.g., reintroduce the names of template parameters
/// into the current scope so that they can be found by name lookup.
///
/// \param S The (new) template parameter scope.
///
/// \param Template the class template declaration whose template
/// parameters should be reintroduced into the current scope.
virtual void ActOnReenterTemplateScope(Scope *S, DeclPtrTy Template) {
}
/// ActOnStartDelayedMemberDeclarations - We have completed parsing
/// a C++ class, and we are about to start parsing any parts of
/// member declarations that could not be parsed earlier. Enter
/// the appropriate record scope.
virtual void ActOnStartDelayedMemberDeclarations(Scope *S,
DeclPtrTy Record) {
}
/// ActOnStartDelayedCXXMethodDeclaration - We have completed
/// parsing a top-level (non-nested) C++ class, and we are now
/// parsing those parts of the given Method declaration that could
/// not be parsed earlier (C++ [class.mem]p2), such as default
/// arguments. This action should enter the scope of the given
/// Method declaration as if we had just parsed the qualified method
/// name. However, it should not bring the parameters into scope;
/// that will be performed by ActOnDelayedCXXMethodParameter.
virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
DeclPtrTy Method) {
}
/// ActOnDelayedCXXMethodParameter - We've already started a delayed
/// C++ method declaration. We're (re-)introducing the given
/// function parameter into scope for use in parsing later parts of
/// the method declaration. For example, we could see an
/// ActOnParamDefaultArgument event for this parameter.
virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param) {
}
/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
/// processing the delayed method declaration for Method. The method
/// declaration is now considered finished. There may be a separate
/// ActOnStartOfFunctionDef action later (not necessarily
/// immediately!) for this method, if it was also defined inside the
/// class body.
virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
DeclPtrTy Method) {
}
/// ActOnFinishDelayedMemberDeclarations - We have finished parsing
/// a C++ class, and we are about to start parsing any parts of
/// member declarations that could not be parsed earlier. Enter the
/// appropriate record scope.
virtual void ActOnFinishDelayedMemberDeclarations(Scope *S,
DeclPtrTy Record) {
}
/// ActOnStaticAssertDeclaration - Parse a C++0x static_assert declaration.
virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
ExprArg AssertExpr,
ExprArg AssertMessageExpr) {
return DeclPtrTy();
}
/// ActOnFriendFunctionDecl - Parsed a friend function declarator.
/// The name is actually a slight misnomer, because the declarator
/// is not necessarily a function declarator.
virtual DeclPtrTy ActOnFriendFunctionDecl(Scope *S,
Declarator &D,
bool IsDefinition,
MultiTemplateParamsArg TParams) {
return DeclPtrTy();
}
/// ActOnFriendTypeDecl - Parsed a friend type declaration.
virtual DeclPtrTy ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
MultiTemplateParamsArg TParams) {
return DeclPtrTy();
}
//===------------------------- C++ Expressions --------------------------===//
/// \brief Parsed a destructor name or pseudo-destructor name.
///
/// \returns the type being destructed.
virtual TypeTy *getDestructorName(SourceLocation TildeLoc,
IdentifierInfo &II, SourceLocation NameLoc,
Scope *S, const CXXScopeSpec &SS,
TypeTy *ObjectType,
bool EnteringContext) {
return getTypeName(II, NameLoc, S, &SS, false, ObjectType);
}
/// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
tok::TokenKind Kind,
SourceLocation LAngleBracketLoc,
TypeTy *Ty,
SourceLocation RAngleBracketLoc,
SourceLocation LParenLoc,
ExprArg Op,
SourceLocation RParenLoc) {
return ExprEmpty();
}
/// ActOnCXXTypeidOfType - Parse typeid( type-id ).
virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
SourceLocation LParenLoc, bool isType,
void *TyOrExpr,
SourceLocation RParenLoc) {
return ExprEmpty();
}
/// ActOnCXXThis - Parse the C++ 'this' pointer.
virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc) {
return ExprEmpty();
}
/// ActOnCXXBoolLiteral - Parse {true,false} literals.
virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
tok::TokenKind Kind) {
return ExprEmpty();
}
/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
virtual OwningExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc) {
return ExprEmpty();
}
/// ActOnCXXThrow - Parse throw expressions.
virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc, ExprArg Op) {
return ExprEmpty();
}
/// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
/// Can be interpreted either as function-style casting ("int(x)")
/// or class type construction ("ClassType(x,y,z)")
/// or creation of a value-initialized type ("int()").
virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
TypeTy *TypeRep,
SourceLocation LParenLoc,
MultiExprArg Exprs,
SourceLocation *CommaLocs,
SourceLocation RParenLoc) {
return ExprEmpty();
}
/// \brief Parsed a condition declaration in a C++ if, switch, or while
/// statement.
///
/// This callback will be invoked after parsing the declaration of "x" in
///
/// \code
/// if (int x = f()) {
/// // ...
/// }
/// \endcode
///
/// \param S the scope of the if, switch, or while statement.
///
/// \param D the declarator that that describes the variable being declared.
virtual DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
return DeclResult();
}
/// ActOnCXXNew - Parsed a C++ 'new' expression. UseGlobal is true if the
/// new was qualified (::new). In a full new like
/// @code new (p1, p2) type(c1, c2) @endcode
/// the p1 and p2 expressions will be in PlacementArgs and the c1 and c2
/// expressions in ConstructorArgs. The type is passed as a declarator.
virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
SourceLocation PlacementLParen,
MultiExprArg PlacementArgs,
SourceLocation PlacementRParen,
bool ParenTypeId, Declarator &D,
SourceLocation ConstructorLParen,
MultiExprArg ConstructorArgs,
SourceLocation ConstructorRParen) {
return ExprEmpty();
}
/// ActOnCXXDelete - Parsed a C++ 'delete' expression. UseGlobal is true if
/// the delete was qualified (::delete). ArrayForm is true if the array form
/// was used (delete[]).
virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
bool UseGlobal, bool ArrayForm,
ExprArg Operand) {
return ExprEmpty();
}
virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
SourceLocation KWLoc,
SourceLocation LParen,
TypeTy *Ty,
SourceLocation RParen) {
return ExprEmpty();
}
/// \brief Invoked when the parser is starting to parse a C++ member access
/// expression such as x.f or x->f.
///
/// \param S the scope in which the member access expression occurs.
///
/// \param Base the expression in which a member is being accessed, e.g., the
/// "x" in "x.f".
///
/// \param OpLoc the location of the member access operator ("." or "->")
///
/// \param OpKind the kind of member access operator ("." or "->")
///
/// \param ObjectType originally NULL. The action should fill in this type
/// with the type into which name lookup should look to find the member in
/// the member access expression.
///
/// \param MayBePseudoDestructor Originally false. The action should
/// set this true if the expression may end up being a
/// pseudo-destructor expression, indicating to the parser that it
/// shoudl be parsed as a pseudo-destructor rather than as a member
/// access expression. Note that this should apply both when the
/// object type is a scalar and when the object type is dependent.
///
/// \returns the (possibly modified) \p Base expression
virtual OwningExprResult ActOnStartCXXMemberReference(Scope *S,
ExprArg Base,
SourceLocation OpLoc,
tok::TokenKind OpKind,
TypeTy *&ObjectType,
bool &MayBePseudoDestructor) {
return ExprEmpty();
}
/// \brief Parsed a C++ pseudo-destructor expression or a dependent
/// member access expression that has the same syntactic form as a
/// pseudo-destructor expression.
///
/// \param S The scope in which the member access expression occurs.
///
/// \param Base The expression in which a member is being accessed, e.g., the
/// "x" in "x.f".
///
/// \param OpLoc The location of the member access operator ("." or "->")
///
/// \param OpKind The kind of member access operator ("." or "->")
///
/// \param SS The nested-name-specifier that precedes the type names
/// in the grammar. Note that this nested-name-specifier will not
/// cover the last "type-name ::" in the grammar, because it isn't
/// necessarily a nested-name-specifier.
///
/// \param FirstTypeName The type name that follows the optional
/// nested-name-specifier but precedes the '::', e.g., the first
/// type-name in "type-name :: type-name". This type name may be
/// empty. This will be either an identifier or a template-id.
///
/// \param CCLoc The location of the '::' in "type-name ::
/// typename". May be invalid, if there is no \p FirstTypeName.
///
/// \param TildeLoc The location of the '~'.
///
/// \param SecondTypeName The type-name following the '~', which is
/// the name of the type being destroyed. This will be either an
/// identifier or a template-id.
///
/// \param HasTrailingLParen Whether the next token in the stream is
/// a left parentheses.
virtual OwningExprResult ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
SourceLocation OpLoc,
tok::TokenKind OpKind,
const CXXScopeSpec &SS,
UnqualifiedId &FirstTypeName,
SourceLocation CCLoc,
SourceLocation TildeLoc,
UnqualifiedId &SecondTypeName,
bool HasTrailingLParen) {
return ExprEmpty();
}
/// ActOnFinishFullExpr - Called whenever a full expression has been parsed.
/// (C++ [intro.execution]p12).
virtual OwningExprResult ActOnFinishFullExpr(ExprArg Expr) {
return move(Expr);
}
//===---------------------------- C++ Classes ---------------------------===//
/// ActOnBaseSpecifier - Parsed a base specifier
virtual BaseResult ActOnBaseSpecifier(DeclPtrTy classdecl,
SourceRange SpecifierRange,
bool Virtual, AccessSpecifier Access,
TypeTy *basetype,
SourceLocation BaseLoc) {
return BaseResult();
}
virtual void ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
unsigned NumBases) {
}
/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
/// declarator is parsed. 'AS' is the access specifier, 'BitfieldWidth'
/// specifies the bitfield width if there is one and 'Init' specifies the
/// initializer if any. 'Deleted' is true if there's a =delete
/// specifier on the function.
virtual DeclPtrTy ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
Declarator &D,
MultiTemplateParamsArg TemplateParameterLists,
ExprTy *BitfieldWidth,
ExprTy *Init,
bool IsDefinition,
bool Deleted = false) {
return DeclPtrTy();
}
virtual MemInitResult ActOnMemInitializer(DeclPtrTy ConstructorDecl,
Scope *S,
const CXXScopeSpec &SS,
IdentifierInfo *MemberOrBase,
TypeTy *TemplateTypeTy,
SourceLocation IdLoc,
SourceLocation LParenLoc,
ExprTy **Args, unsigned NumArgs,
SourceLocation *CommaLocs,
SourceLocation RParenLoc) {
return true;
}
/// ActOnMemInitializers - This is invoked when all of the member
/// initializers of a constructor have been parsed. ConstructorDecl
/// is the function declaration (which will be a C++ constructor in
/// a well-formed program), ColonLoc is the location of the ':' that
/// starts the constructor initializer, and MemInit/NumMemInits
/// contains the individual member (and base) initializers.
/// AnyErrors will be true if there were any invalid member initializers
/// that are not represented in the list.
virtual void ActOnMemInitializers(DeclPtrTy ConstructorDecl,
SourceLocation ColonLoc,
MemInitTy **MemInits, unsigned NumMemInits,
bool AnyErrors){
}
virtual void ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl) {}
/// ActOnFinishCXXMemberSpecification - Invoked after all member declarators
/// are parsed but *before* parsing of inline method definitions.
virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
DeclPtrTy TagDecl,
SourceLocation LBrac,
SourceLocation RBrac) {
}
//===---------------------------C++ Templates----------------------------===//
/// ActOnTypeParameter - Called when a C++ template type parameter
/// (e.g., "typename T") has been parsed. Typename specifies whether
/// the keyword "typename" was used to declare the type parameter
/// (otherwise, "class" was used), ellipsis specifies whether this is a
/// C++0x parameter pack, EllipsisLoc specifies the start of the ellipsis,
/// and KeyLoc is the location of the "class" or "typename" keyword.
// ParamName is the name of the parameter (NULL indicates an unnamed template
// parameter) and ParamNameLoc is the location of the parameter name (if any)
/// If the type parameter has a default argument, it will be added
/// later via ActOnTypeParameterDefault. Depth and Position provide
/// the number of enclosing templates (see
/// ActOnTemplateParameterList) and the number of previous
/// parameters within this template parameter list.
virtual DeclPtrTy ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
SourceLocation EllipsisLoc,
SourceLocation KeyLoc,
IdentifierInfo *ParamName,
SourceLocation ParamNameLoc,
unsigned Depth, unsigned Position) {
return DeclPtrTy();
}
/// ActOnTypeParameterDefault - Adds a default argument (the type
/// Default) to the given template type parameter (TypeParam).
virtual void ActOnTypeParameterDefault(DeclPtrTy TypeParam,
SourceLocation EqualLoc,
SourceLocation DefaultLoc,
TypeTy *Default) {
}
/// ActOnNonTypeTemplateParameter - Called when a C++ non-type
/// template parameter (e.g., "int Size" in "template<int Size>
/// class Array") has been parsed. S is the current scope and D is
/// the parsed declarator. Depth and Position provide the number of
/// enclosing templates (see
/// ActOnTemplateParameterList) and the number of previous
/// parameters within this template parameter list.
virtual DeclPtrTy ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
unsigned Depth,
unsigned Position) {
return DeclPtrTy();
}
/// \brief Adds a default argument to the given non-type template
/// parameter.
virtual void ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParam,
SourceLocation EqualLoc,
ExprArg Default) {
}
/// ActOnTemplateTemplateParameter - Called when a C++ template template
/// parameter (e.g., "int T" in "template<template <typename> class T> class
/// Array") has been parsed. TmpLoc is the location of the "template" keyword,
/// TemplateParams is the sequence of parameters required by the template,
/// ParamName is the name of the parameter (null if unnamed), and ParamNameLoc
/// is the source location of the identifier (if given).
virtual DeclPtrTy ActOnTemplateTemplateParameter(Scope *S,
SourceLocation TmpLoc,
TemplateParamsTy *Params,
IdentifierInfo *ParamName,
SourceLocation ParamNameLoc,
unsigned Depth,
unsigned Position) {
return DeclPtrTy();
}
/// \brief Adds a default argument to the given template template
/// parameter.
virtual void ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParam,
SourceLocation EqualLoc,
const ParsedTemplateArgument &Default) {
}
/// ActOnTemplateParameterList - Called when a complete template
/// parameter list has been parsed, e.g.,
///
/// @code
/// export template<typename T, T Size>
/// @endcode
///
/// Depth is the number of enclosing template parameter lists. This
/// value does not include templates from outer scopes. For example:
///
/// @code
/// template<typename T> // depth = 0
/// class A {
/// template<typename U> // depth = 0
/// class B;
/// };
///
/// template<typename T> // depth = 0
/// template<typename U> // depth = 1
/// class A<T>::B { ... };
/// @endcode
///
/// ExportLoc, if valid, is the position of the "export"
/// keyword. Otherwise, "export" was not specified.
/// TemplateLoc is the position of the template keyword, LAngleLoc
/// is the position of the left angle bracket, and RAngleLoc is the
/// position of the corresponding right angle bracket.
/// Params/NumParams provides the template parameters that were
/// parsed as part of the template-parameter-list.
virtual TemplateParamsTy *
ActOnTemplateParameterList(unsigned Depth,
SourceLocation ExportLoc,
SourceLocation TemplateLoc,
SourceLocation LAngleLoc,
DeclPtrTy *Params, unsigned NumParams,
SourceLocation RAngleLoc) {
return 0;
}
/// \brief Form a type from a template and a list of template
/// arguments.
///
/// This action merely forms the type for the template-id, possibly
/// checking well-formedness of the template arguments. It does not
/// imply the declaration of any entity.
///
/// \param Template A template whose specialization results in a
/// type, e.g., a class template or template template parameter.
virtual TypeResult ActOnTemplateIdType(TemplateTy Template,
SourceLocation TemplateLoc,
SourceLocation LAngleLoc,
ASTTemplateArgsPtr TemplateArgs,
SourceLocation RAngleLoc) {
return TypeResult();
}
/// \brief Note that a template ID was used with a tag.
///
/// \param Type The result of ActOnTemplateIdType.
///
/// \param TUK Either TUK_Reference or TUK_Friend. Declarations and
/// definitions are interpreted as explicit instantiations or
/// specializations.
///
/// \param TagSpec The tag keyword that was provided as part of the
/// elaborated-type-specifier; either class, struct, union, or enum.
///
/// \param TagLoc The location of the tag keyword.
virtual TypeResult ActOnTagTemplateIdType(TypeResult Type,
TagUseKind TUK,
DeclSpec::TST TagSpec,
SourceLocation TagLoc) {
return TypeResult();
}
/// \brief Form a dependent template name.
///
/// This action forms a dependent template name given the template
/// name and its (presumably dependent) scope specifier. For
/// example, given "MetaFun::template apply", the scope specifier \p
/// SS will be "MetaFun::", \p TemplateKWLoc contains the location
/// of the "template" keyword, and "apply" is the \p Name.
///
/// \param TemplateKWLoc the location of the "template" keyword (if any).
///
/// \param SS the nested-name-specifier that precedes the "template" keyword
/// or the template name. If the dependent template name occurs in
/// a member access expression, e.g., "x.template f<T>", this
/// nested-name-specifier will be empty.
///
/// \param Name the name of the template.
///
/// \param ObjectType if this dependent template name occurs in the
/// context of a member access expression, the type of the object being
/// accessed.
///
/// \param EnteringContext whether we are entering the context of this
/// template.
virtual TemplateTy ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
const CXXScopeSpec &SS,
UnqualifiedId &Name,
TypeTy *ObjectType,
bool EnteringContext) {
return TemplateTy();
}
/// \brief Process the declaration or definition of an explicit
/// class template specialization or a class template partial
/// specialization.
///
/// This routine is invoked when an explicit class template
/// specialization or a class template partial specialization is
/// declared or defined, to introduce the (partial) specialization
/// and produce a declaration for it. In the following example,
/// ActOnClassTemplateSpecialization will be invoked for the
/// declarations at both A and B:
///
/// \code
/// template<typename T> class X;
/// template<> class X<int> { }; // A: explicit specialization
/// template<typename T> class X<T*> { }; // B: partial specialization
/// \endcode
///
/// Note that it is the job of semantic analysis to determine which
/// of the two cases actually occurred in the source code, since
/// they are parsed through the same path. The formulation of the
/// template parameter lists describes which case we are in.
///
/// \param S the current scope
///
/// \param TagSpec whether this declares a class, struct, or union
/// (template)
///
/// \param TUK whether this is a declaration or a definition
///
/// \param KWLoc the location of the 'class', 'struct', or 'union'
/// keyword.
///
/// \param SS the scope specifier preceding the template-id
///
/// \param Template the declaration of the class template that we
/// are specializing.
///
/// \param Attr attributes on the specialization
///
/// \param TemplateParameterLists the set of template parameter
/// lists that apply to this declaration. In a well-formed program,
/// the number of template parameter lists will be one more than the
/// number of template-ids in the scope specifier. However, it is
/// common for users to provide the wrong number of template
/// parameter lists (such as a missing \c template<> prior to a
/// specialization); the parser does not check this condition.
virtual DeclResult
ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
SourceLocation KWLoc,
const CXXScopeSpec &SS,
TemplateTy Template,
SourceLocation TemplateNameLoc,
SourceLocation LAngleLoc,
ASTTemplateArgsPtr TemplateArgs,
SourceLocation RAngleLoc,
AttributeList *Attr,
MultiTemplateParamsArg TemplateParameterLists) {
return DeclResult();
}
/// \brief Invoked when a declarator that has one or more template parameter
/// lists has been parsed.
///
/// This action is similar to ActOnDeclarator(), except that the declaration
/// being created somehow involves a template, e.g., it is a template
/// declaration or specialization.
virtual DeclPtrTy ActOnTemplateDeclarator(Scope *S,
MultiTemplateParamsArg TemplateParameterLists,
Declarator &D) {
return DeclPtrTy();
}
/// \brief Invoked when the parser is beginning to parse a function template
/// or function template specialization definition.
virtual DeclPtrTy ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
MultiTemplateParamsArg TemplateParameterLists,
Declarator &D) {
return DeclPtrTy();
}
/// \brief Process the explicit instantiation of a class template
/// specialization.
///
/// This routine is invoked when an explicit instantiation of a
/// class template specialization is encountered. In the following
/// example, ActOnExplicitInstantiation will be invoked to force the
/// instantiation of X<int>:
///
/// \code
/// template<typename T> class X { /* ... */ };
/// template class X<int>; // explicit instantiation
/// \endcode
///
/// \param S the current scope
///
/// \param ExternLoc the location of the 'extern' keyword that specifies that
/// this is an extern template (if any).
///
/// \param TemplateLoc the location of the 'template' keyword that
/// specifies that this is an explicit instantiation.
///
/// \param TagSpec whether this declares a class, struct, or union
/// (template).
///
/// \param KWLoc the location of the 'class', 'struct', or 'union'
/// keyword.
///
/// \param SS the scope specifier preceding the template-id.
///
/// \param Template the declaration of the class template that we
/// are instantiation.
///
/// \param LAngleLoc the location of the '<' token in the template-id.
///
/// \param TemplateArgs the template arguments used to form the
/// template-id.
///
/// \param TemplateArgLocs the locations of the template arguments.
///
/// \param RAngleLoc the location of the '>' token in the template-id.
///
/// \param Attr attributes that apply to this instantiation.
virtual DeclResult
ActOnExplicitInstantiation(Scope *S,
SourceLocation ExternLoc,
SourceLocation TemplateLoc,
unsigned TagSpec,
SourceLocation KWLoc,
const CXXScopeSpec &SS,
TemplateTy Template,
SourceLocation TemplateNameLoc,
SourceLocation LAngleLoc,
ASTTemplateArgsPtr TemplateArgs,
SourceLocation RAngleLoc,
AttributeList *Attr) {
return DeclResult();
}
/// \brief Process the explicit instantiation of a member class of a
/// class template specialization.
///
/// This routine is invoked when an explicit instantiation of a
/// member class of a class template specialization is
/// encountered. In the following example,
/// ActOnExplicitInstantiation will be invoked to force the
/// instantiation of X<int>::Inner:
///
/// \code
/// template<typename T> class X { class Inner { /* ... */}; };
/// template class X<int>::Inner; // explicit instantiation
/// \endcode
///
/// \param S the current scope
///
/// \param ExternLoc the location of the 'extern' keyword that specifies that
/// this is an extern template (if any).
///
/// \param TemplateLoc the location of the 'template' keyword that
/// specifies that this is an explicit instantiation.
///
/// \param TagSpec whether this declares a class, struct, or union
/// (template).
///
/// \param KWLoc the location of the 'class', 'struct', or 'union'
/// keyword.
///
/// \param SS the scope specifier preceding the template-id.
///
/// \param Template the declaration of the class template that we
/// are instantiation.
///
/// \param LAngleLoc the location of the '<' token in the template-id.
///
/// \param TemplateArgs the template arguments used to form the
/// template-id.
///
/// \param TemplateArgLocs the locations of the template arguments.
///
/// \param RAngleLoc the location of the '>' token in the template-id.
///
/// \param Attr attributes that apply to this instantiation.
virtual DeclResult
ActOnExplicitInstantiation(Scope *S,
SourceLocation ExternLoc,
SourceLocation TemplateLoc,
unsigned TagSpec,
SourceLocation KWLoc,
const CXXScopeSpec &SS,
IdentifierInfo *Name,
SourceLocation NameLoc,
AttributeList *Attr) {
return DeclResult();
}
/// \brief Process the explicit instantiation of a function template or a
/// member of a class template.
///
/// This routine is invoked when an explicit instantiation of a
/// function template or member function of a class template specialization
/// is encountered. In the following example,
/// ActOnExplicitInstantiation will be invoked to force the
/// instantiation of X<int>:
///
/// \code
/// template<typename T> void f(T);
/// template void f(int); // explicit instantiation
/// \endcode
///
/// \param S the current scope
///
/// \param ExternLoc the location of the 'extern' keyword that specifies that
/// this is an extern template (if any).
///
/// \param TemplateLoc the location of the 'template' keyword that
/// specifies that this is an explicit instantiation.
///
/// \param D the declarator describing the declaration to be implicitly
/// instantiated.
virtual DeclResult ActOnExplicitInstantiation(Scope *S,
SourceLocation ExternLoc,
SourceLocation TemplateLoc,
Declarator &D) {
return DeclResult();
}
/// \brief Called when the parser has parsed a C++ typename
/// specifier that ends in an identifier, e.g., "typename T::type".
///
/// \param TypenameLoc the location of the 'typename' keyword
/// \param SS the nested-name-specifier following the typename (e.g., 'T::').
/// \param II the identifier we're retrieving (e.g., 'type' in the example).
/// \param IdLoc the location of the identifier.
virtual TypeResult
ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
const IdentifierInfo &II, SourceLocation IdLoc) {
return TypeResult();
}
/// \brief Called when the parser has parsed a C++ typename
/// specifier that ends in a template-id, e.g.,
/// "typename MetaFun::template apply<T1, T2>".
///
/// \param TypenameLoc the location of the 'typename' keyword
/// \param SS the nested-name-specifier following the typename (e.g., 'T::').
/// \param TemplateLoc the location of the 'template' keyword, if any.
/// \param Ty the type that the typename specifier refers to.
virtual TypeResult
ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
SourceLocation TemplateLoc, TypeTy *Ty) {
return TypeResult();
}
//===----------------------- Obj-C Declarations -------------------------===//
// ActOnStartClassInterface - this action is called immediately after parsing
// the prologue for a class interface (before parsing the instance
// variables). Instance variables are processed by ActOnFields().
virtual DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
IdentifierInfo *ClassName,
SourceLocation ClassLoc,
IdentifierInfo *SuperName,
SourceLocation SuperLoc,
const DeclPtrTy *ProtoRefs,
unsigned NumProtoRefs,
const SourceLocation *ProtoLocs,
SourceLocation EndProtoLoc,
AttributeList *AttrList) {
return DeclPtrTy();
}
/// ActOnCompatiblityAlias - this action is called after complete parsing of
/// @compaatibility_alias declaration. It sets up the alias relationships.
virtual DeclPtrTy ActOnCompatiblityAlias(
SourceLocation AtCompatibilityAliasLoc,
IdentifierInfo *AliasName, SourceLocation AliasLocation,
IdentifierInfo *ClassName, SourceLocation ClassLocation) {
return DeclPtrTy();
}
// ActOnStartProtocolInterface - this action is called immdiately after
// parsing the prologue for a protocol interface.
virtual DeclPtrTy ActOnStartProtocolInterface(SourceLocation AtProtoLoc,
IdentifierInfo *ProtocolName,
SourceLocation ProtocolLoc,
const DeclPtrTy *ProtoRefs,
unsigned NumProtoRefs,
const SourceLocation *ProtoLocs,
SourceLocation EndProtoLoc,
AttributeList *AttrList) {
return DeclPtrTy();
}
// ActOnStartCategoryInterface - this action is called immdiately after
// parsing the prologue for a category interface.
virtual DeclPtrTy ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
IdentifierInfo *ClassName,
SourceLocation ClassLoc,
IdentifierInfo *CategoryName,
SourceLocation CategoryLoc,
const DeclPtrTy *ProtoRefs,
unsigned NumProtoRefs,
const SourceLocation *ProtoLocs,
SourceLocation EndProtoLoc) {
return DeclPtrTy();
}
// ActOnStartClassImplementation - this action is called immdiately after
// parsing the prologue for a class implementation. Instance variables are
// processed by ActOnFields().
virtual DeclPtrTy ActOnStartClassImplementation(
SourceLocation AtClassImplLoc,
IdentifierInfo *ClassName,
SourceLocation ClassLoc,
IdentifierInfo *SuperClassname,
SourceLocation SuperClassLoc) {
return DeclPtrTy();
}
// ActOnStartCategoryImplementation - this action is called immdiately after
// parsing the prologue for a category implementation.
virtual DeclPtrTy ActOnStartCategoryImplementation(
SourceLocation AtCatImplLoc,
IdentifierInfo *ClassName,
SourceLocation ClassLoc,
IdentifierInfo *CatName,
SourceLocation CatLoc) {
return DeclPtrTy();
}
// ActOnPropertyImplDecl - called for every property implementation
virtual DeclPtrTy ActOnPropertyImplDecl(
SourceLocation AtLoc, // location of the @synthesize/@dynamic
SourceLocation PropertyNameLoc, // location for the property name
bool ImplKind, // true for @synthesize, false for
// @dynamic
DeclPtrTy ClassImplDecl, // class or category implementation
IdentifierInfo *propertyId, // name of property
IdentifierInfo *propertyIvar) { // name of the ivar
return DeclPtrTy();
}
struct ObjCArgInfo {
IdentifierInfo *Name;
SourceLocation NameLoc;
// The Type is null if no type was specified, and the DeclSpec is invalid
// in this case.
TypeTy *Type;
ObjCDeclSpec DeclSpec;
/// ArgAttrs - Attribute list for this argument.
AttributeList *ArgAttrs;
};
// ActOnMethodDeclaration - called for all method declarations.
virtual DeclPtrTy ActOnMethodDeclaration(
SourceLocation BeginLoc, // location of the + or -.
SourceLocation EndLoc, // location of the ; or {.
tok::TokenKind MethodType, // tok::minus for instance, tok::plus for class.
DeclPtrTy ClassDecl, // class this methods belongs to.
ObjCDeclSpec &ReturnQT, // for return type's in inout etc.
TypeTy *ReturnType, // the method return type.
Selector Sel, // a unique name for the method.
ObjCArgInfo *ArgInfo, // ArgInfo: Has 'Sel.getNumArgs()' entries.
llvm::SmallVectorImpl<Declarator> &Cdecls, // c-style args
AttributeList *MethodAttrList, // optional
// tok::objc_not_keyword, tok::objc_optional, tok::objc_required
tok::ObjCKeywordKind impKind,
bool isVariadic = false) {
return DeclPtrTy();
}
// ActOnAtEnd - called to mark the @end. For declarations (interfaces,
// protocols, categories), the parser passes all methods/properties.
// For class implementations, these values default to 0. For implementations,
// methods are processed incrementally (by ActOnMethodDeclaration above).
virtual void ActOnAtEnd(SourceRange AtEnd,
DeclPtrTy classDecl,
DeclPtrTy *allMethods = 0,
unsigned allNum = 0,
DeclPtrTy *allProperties = 0,
unsigned pNum = 0,
DeclGroupPtrTy *allTUVars = 0,
unsigned tuvNum = 0) {
}
// ActOnProperty - called to build one property AST
virtual DeclPtrTy ActOnProperty(Scope *S, SourceLocation AtLoc,
FieldDeclarator &FD, ObjCDeclSpec &ODS,
Selector GetterSel, Selector SetterSel,
DeclPtrTy ClassCategory,
bool *OverridingProperty,
tok::ObjCKeywordKind MethodImplKind) {
return DeclPtrTy();
}
virtual OwningExprResult ActOnClassPropertyRefExpr(
IdentifierInfo &receiverName,
IdentifierInfo &propertyName,
SourceLocation &receiverNameLoc,
SourceLocation &propertyNameLoc) {
return ExprEmpty();
}
// ActOnClassMessage - used for both unary and keyword messages.
// ArgExprs is optional - if it is present, the number of expressions
// is obtained from NumArgs.
virtual ExprResult ActOnClassMessage(
Scope *S,
IdentifierInfo *receivingClassName,
Selector Sel,
SourceLocation lbrac, SourceLocation receiverLoc,
SourceLocation selectorLoc,
SourceLocation rbrac,
ExprTy **ArgExprs, unsigned NumArgs) {
return ExprResult();
}
// ActOnInstanceMessage - used for both unary and keyword messages.
// ArgExprs is optional - if it is present, the number of expressions
// is obtained from NumArgs.
virtual ExprResult ActOnInstanceMessage(
ExprTy *receiver, Selector Sel,
SourceLocation lbrac, SourceLocation selectorLoc, SourceLocation rbrac,
ExprTy **ArgExprs, unsigned NumArgs) {
return ExprResult();
}
virtual DeclPtrTy ActOnForwardClassDeclaration(
SourceLocation AtClassLoc,
IdentifierInfo **IdentList,
SourceLocation *IdentLocs,
unsigned NumElts) {
return DeclPtrTy();
}
virtual DeclPtrTy ActOnForwardProtocolDeclaration(
SourceLocation AtProtocolLoc,
const IdentifierLocPair*IdentList,
unsigned NumElts,
AttributeList *AttrList) {
return DeclPtrTy();
}
/// FindProtocolDeclaration - This routine looks up protocols and
/// issues error if they are not declared. It returns list of valid
/// protocols found.
virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
const IdentifierLocPair *ProtocolId,
unsigned NumProtocols,
llvm::SmallVectorImpl<DeclPtrTy> &ResProtos) {
}
//===----------------------- Obj-C Expressions --------------------------===//
virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
ExprTy **Strings,
unsigned NumStrings) {
return ExprResult();
}
virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
SourceLocation EncLoc,
SourceLocation LParenLoc,
TypeTy *Ty,
SourceLocation RParenLoc) {
return ExprResult();
}
virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
SourceLocation AtLoc,
SourceLocation SelLoc,
SourceLocation LParenLoc,
SourceLocation RParenLoc) {
return ExprResult();
}
virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
SourceLocation AtLoc,
SourceLocation ProtoLoc,
SourceLocation LParenLoc,
SourceLocation RParenLoc) {
return ExprResult();
}
//===---------------------------- Pragmas -------------------------------===//
enum PragmaPackKind {
PPK_Default, // #pragma pack([n])
PPK_Show, // #pragma pack(show), only supported by MSVC.
PPK_Push, // #pragma pack(push, [identifier], [n])
PPK_Pop // #pragma pack(pop, [identifier], [n])
};
/// ActOnPragmaPack - Called on well formed #pragma pack(...).
virtual void ActOnPragmaPack(PragmaPackKind Kind,
IdentifierInfo *Name,
ExprTy *Alignment,
SourceLocation PragmaLoc,
SourceLocation LParenLoc,
SourceLocation RParenLoc) {
return;
}
/// ActOnPragmaUnused - Called on well formed #pragma unused(...).
virtual void ActOnPragmaUnused(const Token *Identifiers,
unsigned NumIdentifiers, Scope *CurScope,
SourceLocation PragmaLoc,
SourceLocation LParenLoc,
SourceLocation RParenLoc) {
return;
}
/// ActOnPragmaWeakID - Called on well formed #pragma weak ident.
virtual void ActOnPragmaWeakID(IdentifierInfo* WeakName,
SourceLocation PragmaLoc,
SourceLocation WeakNameLoc) {
return;
}
/// ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
virtual void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
IdentifierInfo* AliasName,
SourceLocation PragmaLoc,
SourceLocation WeakNameLoc,
SourceLocation AliasNameLoc) {
return;
}
/// \name Code completion actions
///
/// These actions are used to signal that a code-completion token has been
/// found at a point in the grammar where the Action implementation is
/// likely to be able to provide a list of possible completions, e.g.,
/// after the "." or "->" of a member access expression.
///
/// \todo Code completion for designated field initializers
/// \todo Code completion for call arguments after a function template-id
/// \todo Code completion within a call expression, object construction, etc.
/// \todo Code completion within a template argument list.
/// \todo Code completion for attributes.
//@{
/// \brief Describes the context in which code completion occurs.
enum CodeCompletionContext {
/// \brief Code completion occurs at top-level or namespace context.
CCC_Namespace,
/// \brief Code completion occurs within a class, struct, or union.
CCC_Class,
/// \brief Code completion occurs within an Objective-C interface, protocol,
/// or category.
CCC_ObjCInterface,
/// \brief Code completion occurs within an Objective-C implementation or
/// category implementation
CCC_ObjCImplementation,
/// \brief Code completion occurs within the list of instance variables
/// in an Objective-C interface, protocol, category, or implementation.
CCC_ObjCInstanceVariableList,
/// \brief Code completion occurs following one or more template
/// headers.
CCC_Template,
/// \brief Code completion occurs following one or more template
/// headers within a class.
CCC_MemberTemplate,
/// \brief Code completion occurs within an expression.
CCC_Expression,
/// \brief Code completion occurs within a statement, which may
/// also be an expression or a declaration.
CCC_Statement,
/// \brief Code completion occurs at the beginning of the
/// initialization statement (or expression) in a for loop.
CCC_ForInit,
/// \brief Code completion ocurs within the condition of an if,
/// while, switch, or for statement.
CCC_Condition
};
/// \brief Code completion for an ordinary name that occurs within the given
/// scope.
///
/// \param S the scope in which the name occurs.
///
/// \param CompletionContext the context in which code completion
/// occurs.
virtual void CodeCompleteOrdinaryName(Scope *S,
CodeCompletionContext CompletionContext) { }
/// \brief Code completion for a member access expression.
///
/// This code completion action is invoked when the code-completion token
/// is found after the "." or "->" of a member access expression.
///
/// \param S the scope in which the member access expression occurs.
///
/// \param Base the base expression (e.g., the x in "x.foo") of the member
/// access.
///
/// \param OpLoc the location of the "." or "->" operator.
///
/// \param IsArrow true when the operator is "->", false when it is ".".
virtual void CodeCompleteMemberReferenceExpr(Scope *S, ExprTy *Base,
SourceLocation OpLoc,
bool IsArrow) { }
/// \brief Code completion for a reference to a tag.
///
/// This code completion action is invoked when the code-completion
/// token is found after a tag keyword (struct, union, enum, or class).
///
/// \param S the scope in which the tag reference occurs.
///
/// \param TagSpec an instance of DeclSpec::TST, indicating what kind of tag
/// this is (struct/union/enum/class).
virtual void CodeCompleteTag(Scope *S, unsigned TagSpec) { }
/// \brief Code completion for a case statement.
///
/// \brief S the scope in which the case statement occurs.
virtual void CodeCompleteCase(Scope *S) { }
/// \brief Code completion for a call.
///
/// \brief S the scope in which the call occurs.
///
/// \param Fn the expression describing the function being called.
///
/// \param Args the arguments to the function call (so far).
///
/// \param NumArgs the number of arguments in \p Args.
virtual void CodeCompleteCall(Scope *S, ExprTy *Fn,
ExprTy **Args, unsigned NumArgs) { }
/// \brief Code completion for a C++ nested-name-specifier that precedes a
/// qualified-id of some form.
///
/// This code completion action is invoked when the code-completion token
/// is found after the "::" of a nested-name-specifier.
///
/// \param S the scope in which the nested-name-specifier occurs.
///
/// \param SS the scope specifier ending with "::".
///
/// \parame EnteringContext whether we're entering the context of this
/// scope specifier.
virtual void CodeCompleteQualifiedId(Scope *S, const CXXScopeSpec &SS,
bool EnteringContext) { }
/// \brief Code completion for a C++ "using" declaration or directive.
///
/// This code completion action is invoked when the code-completion token is
/// found after the "using" keyword.
///
/// \param S the scope in which the "using" occurs.
virtual void CodeCompleteUsing(Scope *S) { }
/// \brief Code completion for a C++ using directive.
///
/// This code completion action is invoked when the code-completion token is
/// found after "using namespace".
///
/// \param S the scope in which the "using namespace" occurs.
virtual void CodeCompleteUsingDirective(Scope *S) { }
/// \brief Code completion for a C++ namespace declaration or namespace
/// alias declaration.
///
/// This code completion action is invoked when the code-completion token is
/// found after "namespace".
///
/// \param S the scope in which the "namespace" token occurs.
virtual void CodeCompleteNamespaceDecl(Scope *S) { }
/// \brief Code completion for a C++ namespace alias declaration.
///
/// This code completion action is invoked when the code-completion token is
/// found after "namespace identifier = ".
///
/// \param S the scope in which the namespace alias declaration occurs.
virtual void CodeCompleteNamespaceAliasDecl(Scope *S) { }
/// \brief Code completion for an operator name.
///
/// This code completion action is invoked when the code-completion token is
/// found after the keyword "operator".
///
/// \param S the scope in which the operator keyword occurs.
virtual void CodeCompleteOperatorName(Scope *S) { }
/// \brief Code completion after the '@' at the top level.
///
/// \param S the scope in which the '@' occurs.
///
/// \param ObjCImpDecl the Objective-C implementation or category
/// implementation.
///
/// \param InInterface whether we are in an Objective-C interface or
/// protocol.
virtual void CodeCompleteObjCAtDirective(Scope *S, DeclPtrTy ObjCImpDecl,
bool InInterface) { }
/// \brief Code completion after the '@' in the list of instance variables.
virtual void CodeCompleteObjCAtVisibility(Scope *S) { }
/// \brief Code completion after the '@' in a statement.
virtual void CodeCompleteObjCAtStatement(Scope *S) { }
/// \brief Code completion after the '@' in an expression.
virtual void CodeCompleteObjCAtExpression(Scope *S) { }
/// \brief Code completion for an ObjC property decl.
///
/// This code completion action is invoked when the code-completion token is
/// found after the left paren.
///
/// \param S the scope in which the operator keyword occurs.
virtual void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { }
/// \brief Code completion for the getter of an Objective-C property
/// declaration.
///
/// This code completion action is invoked when the code-completion
/// token is found after the "getter = " in a property declaration.
///
/// \param S the scope in which the property is being declared.
///
/// \param ClassDecl the Objective-C class or category in which the property
/// is being defined.
///
/// \param Methods the set of methods declared thus far within \p ClassDecl.
///
/// \param NumMethods the number of methods in \p Methods
virtual void CodeCompleteObjCPropertyGetter(Scope *S, DeclPtrTy ClassDecl,
DeclPtrTy *Methods,
unsigned NumMethods) {
}
/// \brief Code completion for the setter of an Objective-C property
/// declaration.
///
/// This code completion action is invoked when the code-completion
/// token is found after the "setter = " in a property declaration.
///
/// \param S the scope in which the property is being declared.
///
/// \param ClassDecl the Objective-C class or category in which the property
/// is being defined.
///
/// \param Methods the set of methods declared thus far within \p ClassDecl.
///
/// \param NumMethods the number of methods in \p Methods
virtual void CodeCompleteObjCPropertySetter(Scope *S, DeclPtrTy ClassDecl,
DeclPtrTy *Methods,
unsigned NumMethods) {
}
/// \brief Code completion for an ObjC message expression that refers to
/// a class method.
///
/// This code completion action is invoked when the code-completion token is
/// found after the class name and after each argument.
///
/// \param S the scope in which the message expression occurs.
/// \param FName the factory name.
/// \param FNameLoc the source location of the factory name.
/// \param SelIdents the identifiers that describe the selector (thus far).
/// \param NumSelIdents the number of identifiers in \p SelIdents.
virtual void CodeCompleteObjCClassMessage(Scope *S, IdentifierInfo *FName,
SourceLocation FNameLoc,
IdentifierInfo **SelIdents,
unsigned NumSelIdents){ }
/// \brief Code completion for an ObjC message expression that refers to
/// an instance method.
///
/// This code completion action is invoked when the code-completion token is
/// found after the receiver expression and after each argument.
///
/// \param S the scope in which the operator keyword occurs.
/// \param Receiver an expression for the receiver of the message.
/// \param SelIdents the identifiers that describe the selector (thus far).
/// \param NumSelIdents the number of identifiers in \p SelIdents.
virtual void CodeCompleteObjCInstanceMessage(Scope *S, ExprTy *Receiver,
IdentifierInfo **SelIdents,
unsigned NumSelIdents) { }
/// \brief Code completion for a list of protocol references in Objective-C,
/// such as P1 and P2 in \c id<P1,P2>.
///
/// This code completion action is invoked prior to each identifier
/// in the protocol list.
///
/// \param Protocols the set of protocols that have already been parsed.
///
/// \param NumProtocols the number of protocols that have already been
/// parsed.
virtual void CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
unsigned NumProtocols) { }
/// \brief Code completion for a protocol declaration or definition, after
/// the @protocol but before any identifier.
///
/// \param S the scope in which the protocol declaration occurs.
virtual void CodeCompleteObjCProtocolDecl(Scope *S) { }
/// \brief Code completion for an Objective-C interface, after the
/// @interface but before any identifier.
virtual void CodeCompleteObjCInterfaceDecl(Scope *S) { }
/// \brief Code completion for the superclass of an Objective-C
/// interface, after the ':'.
///
/// \param S the scope in which the interface declaration occurs.
///
/// \param ClassName the name of the class being defined.
virtual void CodeCompleteObjCSuperclass(Scope *S,
IdentifierInfo *ClassName) {
}
/// \brief Code completion for an Objective-C implementation, after the
/// @implementation but before any identifier.
virtual void CodeCompleteObjCImplementationDecl(Scope *S) { }
/// \brief Code completion for the category name in an Objective-C interface
/// declaration.
///
/// This code completion action is invoked after the '(' that indicates
/// a category name within an Objective-C interface declaration.
virtual void CodeCompleteObjCInterfaceCategory(Scope *S,
IdentifierInfo *ClassName) {
}
/// \brief Code completion for the category name in an Objective-C category
/// implementation.
///
/// This code completion action is invoked after the '(' that indicates
/// the category name within an Objective-C category implementation.
virtual void CodeCompleteObjCImplementationCategory(Scope *S,
IdentifierInfo *ClassName) {
}
/// \brief Code completion for the property names when defining an
/// Objective-C property.
///
/// This code completion action is invoked after @synthesize or @dynamic and
/// after each "," within one of those definitions.
virtual void CodeCompleteObjCPropertyDefinition(Scope *S,
DeclPtrTy ObjCImpDecl) {
}
/// \brief Code completion for the instance variable name that should
/// follow an '=' when synthesizing an Objective-C property.
///
/// This code completion action is invoked after each '=' that occurs within
/// an @synthesized definition.
virtual void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
IdentifierInfo *PropertyName,
DeclPtrTy ObjCImpDecl) {
}
//@}
};
/// MinimalAction - Minimal actions are used by light-weight clients of the
/// parser that do not need name resolution or significant semantic analysis to
/// be performed. The actions implemented here are in the form of unresolved
/// identifiers. By using a simpler interface than the SemanticAction class,
/// the parser doesn't have to build complex data structures and thus runs more
/// quickly.
class MinimalAction : public Action {
/// Translation Unit Scope - useful to Objective-C actions that need
/// to lookup file scope declarations in the "ordinary" C decl namespace.
/// For example, user-defined classes, built-in "id" type, etc.
Scope *TUScope;
IdentifierTable &Idents;
Preprocessor &PP;
void *TypeNameInfoTablePtr;
public:
MinimalAction(Preprocessor &pp);
~MinimalAction();
/// getTypeName - This looks at the IdentifierInfo::FETokenInfo field to
/// determine whether the name is a typedef or not in this 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.
///
/// \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, const CXXScopeSpec *SS,
bool isClassName = false,
TypeTy *ObjectType = 0);
/// isCurrentClassName - Always returns false, because MinimalAction
/// does not support C++ classes with constructors.
virtual bool isCurrentClassName(const IdentifierInfo& II, Scope *S,
const CXXScopeSpec *SS);
virtual TemplateNameKind isTemplateName(Scope *S,
const CXXScopeSpec &SS,
UnqualifiedId &Name,
TypeTy *ObjectType,
bool EnteringContext,
TemplateTy &Template);
/// ActOnDeclarator - If this is a typedef declarator, we modify the
/// IdentifierInfo::FETokenInfo field to keep track of this fact, until S is
/// popped.
virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D);
/// ActOnPopScope - When a scope is popped, if any typedefs are now
/// out-of-scope, they are removed from the IdentifierInfo::FETokenInfo field.
virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
virtual DeclPtrTy ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
IdentifierInfo **IdentList,
SourceLocation *SLocs,
unsigned NumElts);
virtual DeclPtrTy ActOnStartClassInterface(SourceLocation interLoc,
IdentifierInfo *ClassName,
SourceLocation ClassLoc,
IdentifierInfo *SuperName,
SourceLocation SuperLoc,
const DeclPtrTy *ProtoRefs,
unsigned NumProtoRefs,
const SourceLocation *ProtoLocs,
SourceLocation EndProtoLoc,
AttributeList *AttrList);
};
/// PrettyStackTraceActionsDecl - If a crash occurs in the parser while parsing
/// something related to a virtualized decl, include that virtualized decl in
/// the stack trace.
class PrettyStackTraceActionsDecl : public llvm::PrettyStackTraceEntry {
Action::DeclPtrTy TheDecl;
SourceLocation Loc;
Action &Actions;
SourceManager &SM;
const char *Message;
public:
PrettyStackTraceActionsDecl(Action::DeclPtrTy Decl, SourceLocation L,
Action &actions, SourceManager &sm,
const char *Msg)
: TheDecl(Decl), Loc(L), Actions(actions), SM(sm), Message(Msg) {}
virtual void print(llvm::raw_ostream &OS) const;
};
/// \brief RAII object that enters a new expression evaluation context.
class EnterExpressionEvaluationContext {
/// \brief The action object.
Action &Actions;
public:
EnterExpressionEvaluationContext(Action &Actions,
Action::ExpressionEvaluationContext NewContext)
: Actions(Actions) {
Actions.PushExpressionEvaluationContext(NewContext);
}
~EnterExpressionEvaluationContext() {
Actions.PopExpressionEvaluationContext();
}
};
} // end namespace clang
#endif