[cfe-commits] r112244 - in /cfe/trunk: include/clang/Parse/ include/clang/Sema/ lib/Parse/ lib/Sema/

John McCall rjmccall at apple.com
Thu Aug 26 16:41:50 PDT 2010


Author: rjmccall
Date: Thu Aug 26 18:41:50 2010
New Revision: 112244

URL: http://llvm.org/viewvc/llvm-project?rev=112244&view=rev
Log:
One who seeks knowledge learns something new every day.
One who seeks the Tao unlearns something new every day.
Less and less remains until you arrive at non-action.
When you arrive at non-action,
nothing will be left undone.


Added:
    cfe/trunk/include/clang/Sema/PrettyDeclStackTrace.h
Removed:
    cfe/trunk/include/clang/Sema/Action.h
    cfe/trunk/lib/Sema/Action.cpp
Modified:
    cfe/trunk/include/clang/Parse/Parser.h
    cfe/trunk/include/clang/Sema/AttributeList.h
    cfe/trunk/include/clang/Sema/Designator.h
    cfe/trunk/include/clang/Sema/Ownership.h
    cfe/trunk/include/clang/Sema/Sema.h
    cfe/trunk/lib/Parse/ParseCXXInlineMethods.cpp
    cfe/trunk/lib/Parse/ParseDecl.cpp
    cfe/trunk/lib/Parse/ParseDeclCXX.cpp
    cfe/trunk/lib/Parse/ParseExpr.cpp
    cfe/trunk/lib/Parse/ParseExprCXX.cpp
    cfe/trunk/lib/Parse/ParseInit.cpp
    cfe/trunk/lib/Parse/ParseObjc.cpp
    cfe/trunk/lib/Parse/ParsePragma.cpp
    cfe/trunk/lib/Parse/ParsePragma.h
    cfe/trunk/lib/Parse/ParseStmt.cpp
    cfe/trunk/lib/Parse/ParseTemplate.cpp
    cfe/trunk/lib/Parse/Parser.cpp
    cfe/trunk/lib/Sema/CMakeLists.txt
    cfe/trunk/lib/Sema/Sema.cpp
    cfe/trunk/lib/Sema/SemaAttr.cpp
    cfe/trunk/lib/Sema/SemaCXXCast.cpp
    cfe/trunk/lib/Sema/SemaCodeComplete.cpp
    cfe/trunk/lib/Sema/SemaDecl.cpp
    cfe/trunk/lib/Sema/SemaDeclAttr.cpp
    cfe/trunk/lib/Sema/SemaDeclCXX.cpp
    cfe/trunk/lib/Sema/SemaExprCXX.cpp
    cfe/trunk/lib/Sema/SemaExprObjC.cpp
    cfe/trunk/lib/Sema/SemaInit.cpp
    cfe/trunk/lib/Sema/SemaOverload.cpp
    cfe/trunk/lib/Sema/SemaTemplate.cpp
    cfe/trunk/lib/Sema/SemaTemplateInstantiate.cpp
    cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp
    cfe/trunk/lib/Sema/SemaType.cpp
    cfe/trunk/lib/Sema/TreeTransform.h

Modified: cfe/trunk/include/clang/Parse/Parser.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Parse/Parser.h?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/include/clang/Parse/Parser.h (original)
+++ cfe/trunk/include/clang/Parse/Parser.h Thu Aug 26 18:41:50 2010
@@ -17,8 +17,9 @@
 #include "clang/Basic/Specifiers.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/CodeCompletionHandler.h"
-#include "clang/Sema/Action.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/DeclSpec.h"
+#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/ADT/OwningPtr.h"
 #include <stack>
 #include <list>
@@ -93,7 +94,7 @@
 
   /// Actions - These are the callbacks we invoke as we parse various constructs
   /// in the file. 
-  Action &Actions;
+  Sema &Actions;
 
   Diagnostic &Diags;
 
@@ -134,13 +135,13 @@
   unsigned TemplateParameterDepth;
 
 public:
-  Parser(Preprocessor &PP, Action &Actions);
+  Parser(Preprocessor &PP, Sema &Actions);
   ~Parser();
 
   const LangOptions &getLang() const { return PP.getLangOptions(); }
   const TargetInfo &getTargetInfo() const { return PP.getTargetInfo(); }
   Preprocessor &getPreprocessor() const { return PP; }
-  Action &getActions() const { return Actions; }
+  Sema &getActions() const { return Actions; }
 
   const Token &getCurToken() const { return Tok; }
   Scope *getCurScope() const { return Actions.getCurScope(); }
@@ -166,7 +167,7 @@
 
   typedef Expr *ExprArg;
   typedef ASTMultiPtr<Stmt*> MultiStmtArg;
-  typedef Action::FullExprArg FullExprArg;
+  typedef Sema::FullExprArg FullExprArg;
 
   /// Adorns a ExprResult with Actions to make it an ExprResult
   ExprResult Owned(ExprResult res) {
@@ -658,8 +659,8 @@
   /// variable's initializer, but not when parsing the body of a
   /// class or function definition.
   class ParsingDeclRAIIObject {
-    Action &Actions;
-    Action::ParsingDeclStackState State;
+    Sema &Actions;
+    Sema::ParsingDeclStackState State;
     bool Popped;
 
   public:
@@ -963,10 +964,10 @@
   /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
   bool ParseExpressionList(llvm::SmallVectorImpl<Expr*> &Exprs,
                            llvm::SmallVectorImpl<SourceLocation> &CommaLocs,
-                           void (Action::*Completer)(Scope *S,
-                                                     Expr *Data,
-                                                     Expr **Args,
-                                                     unsigned NumArgs) = 0,
+                           void (Sema::*Completer)(Scope *S,
+                                                   Expr *Data,
+                                                   Expr **Args,
+                                                   unsigned NumArgs) = 0,
                            Expr *Data = 0);
 
   /// ParenParseOption - Control what ParseParenExpression will parse.

Removed: cfe/trunk/include/clang/Sema/Action.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Action.h?rev=112243&view=auto
==============================================================================
--- cfe/trunk/include/clang/Sema/Action.h (original)
+++ cfe/trunk/include/clang/Sema/Action.h (removed)
@@ -1,3303 +0,0 @@
-//===--- Action.h - Parser Action Interface ---------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines the Action and EmptyAction interface.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_SEMA_ACTION_H
-#define LLVM_CLANG_SEMA_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/Sema/DeclSpec.h"
-#include "clang/Sema/Ownership.h"
-#include "llvm/Support/PrettyStackTrace.h"
-#include "llvm/ADT/PointerUnion.h"
-
-namespace clang {
-  // Semantic.
-  class AttributeList;
-  class CXXScopeSpec;
-  class Declarator;
-  class DeclSpec;
-  struct FieldDeclarator;
-  class ObjCDeclSpec;
-  class TemplateParameterList;
-
-  // Parse.
-  class Scope;
-  class Action;
-  class Selector;
-  class Designation;
-  class InitListDesignations;
-  // Lex.
-  class Preprocessor;
-  class Token;
-  class MacroInfo;
-  
-/// Action - As the parser reads the input file and recognizes the productions
-/// of the grammar, it invokes methods on this class to turn the parsed input
-/// into something useful: e.g. a parse tree.
-///
-/// The callback methods that this class provides are phrased as actions that
-/// the parser has just done or is about to do when the method is called.  They
-/// are not requests that the actions module do the specified action.
-///
-/// All of the methods here are optional except getTypeName() and
-/// isCurrentClassName(), which must be specified in order for the
-/// parse to complete accurately.
-class Action {
-  /// \brief The parser's current scope.
-  ///
-  /// The parser maintains this state here so that is accessible to \c Action 
-  /// subclasses via \c getCurScope().
-  Scope *CurScope;
-  
-protected:
-  friend class Parser;
-  
-  /// \brief Retrieve the parser's current scope.
-  Scope *getCurScope() const { return CurScope; }
-  
-public:
-  Action() : CurScope(0) { }
-  
-  /// Out-of-line virtual destructor to provide home for this class.
-  virtual ~Action();
-
-  // Types - Though these don't actually enforce strong typing, they document
-  // what types are required to be identical for the actions.
-  // Types - Though these don't actually enforce strong typing, they document
-  // what types are required to be identical for the actions.
-  typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
-  typedef OpaquePtr<TemplateName> TemplateTy;
-  typedef OpaquePtr<QualType> TypeTy;
-  typedef Attr AttrTy;
-  typedef CXXBaseSpecifier BaseTy;
-  typedef CXXBaseOrMemberInitializer MemInitTy;
-  typedef Expr ExprTy;
-  typedef Stmt StmtTy;
-  typedef TemplateParameterList TemplateParamsTy;
-  typedef NestedNameSpecifier CXXScopeTy;
-
-  /// Expr/Stmt/Type/BaseResult - Provide a unique type to wrap
-  /// ExprTy/StmtTy/TypeTy/BaseTy, providing strong typing and
-  /// allowing for failure.
-  typedef clang::ExprResult ExprResult;
-  typedef clang::StmtResult StmtResult;
-  typedef clang::TypeResult TypeResult;
-  typedef clang::BaseResult BaseResult;
-  typedef clang::DeclResult DeclResult;
-  typedef clang::MemInitResult MemInitResult;
-
-  /// Single expressions or statements as arguments.
-  typedef Expr *ExprArg;
-  typedef Stmt *StmtArg;
-
-  /// Multiple expressions or statements as arguments.
-  typedef ASTMultiPtr<Expr*> MultiExprArg;
-  typedef ASTMultiPtr<Stmt*> MultiStmtArg;
-  typedef ASTMultiPtr<TemplateParameterList*> MultiTemplateParamsArg;
-
-  class FullExprArg {
-  public:
-    FullExprArg(Action &actions) : E(0) { }
-                
-    // 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): E(Other.E) {}
-
-    ExprResult release() {
-      return move(E);
-    }
-
-    Expr *get() const { return E; }
-
-    Expr *operator->() {
-      return E;
-    }
-
-  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(Expr *expr) : E(expr) {}
-
-    Expr *E;
-  };
-
-  FullExprArg MakeFullExpr(Expr *Arg) {
-    return FullExprArg(ActOnFinishFullExpr(Arg).release());
-  }
-
-  // Utilities for Action implementations to return smart results.
-
-  ExprResult ExprError() { return ExprResult(true); }
-  StmtResult StmtError() { return StmtResult(true); }
-
-  ExprResult ExprError(const DiagnosticBuilder&) { return ExprError(); }
-  StmtResult StmtError(const DiagnosticBuilder&) { return StmtError(); }
-
-  ExprResult ExprEmpty() { return ExprResult(false); }
-  StmtResult StmtEmpty() { return StmtResult(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(Decl *D) { return ""; }
-
-  //===--------------------------------------------------------------------===//
-  // Declaration Tracking Callbacks.
-  //===--------------------------------------------------------------------===//
-
-  typedef uintptr_t ParsingDeclStackState;
-
-  /// PushParsingDeclaration - Notes that the parser has begun
-  /// processing a declaration of some sort.  Guaranteed to be matched
-  /// by a call to PopParsingDeclaration with the value returned by
-  /// this method.
-  virtual ParsingDeclStackState PushParsingDeclaration() {
-    return ParsingDeclStackState();
-  }
-
-  /// PopParsingDeclaration - Notes that the parser has completed
-  /// processing a declaration of some sort.  The decl will be empty
-  /// if the declaration didn't correspond to a full declaration (or
-  /// if the actions module returned an empty decl for it).
-  virtual void PopParsingDeclaration(ParsingDeclStackState S, Decl *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(Decl *Ptr) {
-    return DeclGroupPtrTy();
-  }
-
-  virtual void DiagnoseUseOfUnimplementedSelectors() {}
-
-  /// getTypeName - Return non-null if the specified identifier is a type name
-  /// in the current scope.
-  ///
-  /// \param II the identifier for which we are performing name lookup
-  ///
-  /// \param NameLoc the location of the identifier
-  ///
-  /// \param S the scope in which this name lookup occurs
-  ///
-  /// \param SS if non-NULL, the C++ scope specifier that precedes the
-  /// identifier
-  ///
-  /// \param isClassName whether this is a C++ class-name production, in
-  /// which we can end up referring to a member of an unknown specialization
-  /// that we know (from the grammar) is supposed to be a type. For example,
-  /// this occurs when deriving from "std::vector<T>::allocator_type", where T
-  /// is a template parameter.
-  ///
-  /// \param ObjectType if we're checking whether an identifier is a type
-  /// within a C++ member access expression, this will be the type of the 
-  /// 
-  /// \returns the type referred to by this identifier, or NULL if the type
-  /// does not name an identifier.
-  virtual ParsedType getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
-                                 Scope *S, CXXScopeSpec *SS = 0,
-                                 bool isClassName = false,
-                                 ParsedType ObjectType = ParsedType()) = 0;
-
-  /// isTagName() - This method is called *for error recovery purposes only*
-  /// to determine if the specified name is a valid tag name ("struct foo").  If
-  /// so, this returns the TST for the tag corresponding to it (TST_enum,
-  /// TST_union, TST_struct, TST_class).  This is used to diagnose cases in C
-  /// where the user forgot to specify the tag.
-  virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S) {
-    return DeclSpec::TST_unspecified;
-  }
-
-  /// \brief Action called as part of error recovery when the parser has 
-  /// determined that the given name must refer to a type, but 
-  /// \c getTypeName() did not return a result.
-  ///
-  /// This callback permits the action to give a detailed diagnostic when an
-  /// unknown type name is encountered and, potentially, to try to recover
-  /// by producing a new type in \p SuggestedType.
-  ///
-  /// \param II the name that should be a type.
-  ///
-  /// \param IILoc the location of the name in the source.
-  ///
-  /// \param S the scope in which name lookup was performed.
-  ///
-  /// \param SS if non-NULL, the C++ scope specifier that preceded the name.
-  ///
-  /// \param SuggestedType if the action sets this type to a non-NULL type,
-  /// the parser will recovery by consuming the type name token and then 
-  /// pretending that the given type was the type it parsed.
-  ///
-  /// \returns true if a diagnostic was emitted, false otherwise. When false,
-  /// the parser itself will emit a generic "unknown type name" diagnostic.
-  virtual bool DiagnoseUnknownTypeName(const IdentifierInfo &II, 
-                                       SourceLocation IILoc,
-                                       Scope *S,
-                                       CXXScopeSpec *SS,
-                                       ParsedType &SuggestedType) {
-    return false;
-  }
-                                       
-  /// isCurrentClassName - Return true if the specified name is the
-  /// name of the innermost C++ class type currently being defined.
-  virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
-                                  const CXXScopeSpec *SS = 0) = 0;
-
-  /// \brief Determine whether the given name refers to a template.
-  ///
-  /// This callback is used by the parser after it has seen a '<' to determine
-  /// whether the given name refers to a template and, if so, what kind of 
-  /// template.
-  ///
-  /// \param S the scope in which the name occurs.
-  ///
-  /// \param SS the C++ nested-name-specifier that precedes the template name,
-  /// if any.
-  ///
-  /// \param hasTemplateKeyword true if the template keyword was specified.
-  ///
-  /// \param Name the name that we are querying to determine whether it is
-  /// a template.
-  ///
-  /// \param ObjectType if we are determining whether the given name is a 
-  /// template name in the context of a member access expression (e.g., 
-  /// \c p->X<int>), this is the type of the object referred to by the
-  /// member access (e.g., \c p).
-  ///
-  /// \param EnteringContext whether we are potentially entering the context
-  /// referred to by the nested-name-specifier \p SS, which allows semantic
-  /// analysis to look into uninstantiated templates.
-  ///
-  /// \param Template if the name does refer to a template, the declaration
-  /// of the template that the name refers to.
-  ///
-  /// \param MemberOfUnknownSpecialization Will be set true if the resulting 
-  /// member would be a member of an unknown specialization, in which case this
-  /// lookup cannot possibly pass at this time.
-  ///
-  /// \returns the kind of template that this name refers to.
-  virtual TemplateNameKind isTemplateName(Scope *S,
-                                          CXXScopeSpec &SS,
-                                          bool hasTemplateKeyword,
-                                          UnqualifiedId &Name,
-                                          ParsedType ObjectType,
-                                          bool EnteringContext,
-                                          TemplateTy &Template,
-                                      bool &MemberOfUnknownSpecialization) = 0;
-
-  /// \brief Action called as part of error recovery when the parser has 
-  /// determined that the given name must refer to a template, but 
-  /// \c isTemplateName() did not return a result.
-  ///
-  /// This callback permits the action to give a detailed diagnostic when an
-  /// unknown template name is encountered and, potentially, to try to recover
-  /// by producing a new template in \p SuggestedTemplate.
-  ///
-  /// \param II the name that should be a template.
-  ///
-  /// \param IILoc the location of the name in the source.
-  ///
-  /// \param S the scope in which name lookup was performed.
-  ///
-  /// \param SS the C++ scope specifier that preceded the name.
-  ///
-  /// \param SuggestedTemplate if the action sets this template to a non-NULL,
-  /// template, the parser will recover by consuming the template name token
-  /// and the template argument list that follows.
-  ///
-  /// \param SuggestedTemplateKind as input, the kind of template that we
-  /// expect (e.g., \c TNK_Type_template or \c TNK_Function_template). If the
-  /// action provides a suggested template, this should be set to the kind of
-  /// template.
-  ///
-  /// \returns true if a diagnostic was emitted, false otherwise. When false,
-  /// the parser itself will emit a generic "unknown template name" diagnostic.
-  virtual bool DiagnoseUnknownTemplateName(const IdentifierInfo &II, 
-                                           SourceLocation IILoc,
-                                           Scope *S,
-                                           const CXXScopeSpec *SS,
-                                           TemplateTy &SuggestedTemplate,
-                                           TemplateNameKind &SuggestedKind) {
-    return false;
-  }
-  
-  /// \brief Determine whether the given name refers to a non-type nested name
-  /// specifier, e.g., the name of a namespace or namespace alias.
-  ///
-  /// This actual is used in the parsing of pseudo-destructor names to 
-  /// distinguish a nested-name-specifier and a "type-name ::" when we
-  /// see the token sequence "X :: ~".
-  virtual bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
-                                            SourceLocation IdLoc,
-                                            IdentifierInfo &II,
-                                            ParsedType ObjectType) {
-    return false;
-  }
-  
-  /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
-  /// global scope ('::').
-  virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
-                                                   SourceLocation CCLoc) {
-    return 0;
-  }
-  
-  /// \brief Parsed an identifier followed by '::' in a C++
-  /// nested-name-specifier.
-  ///
-  /// \param S the scope in which the nested-name-specifier was parsed.
-  ///
-  /// \param SS the nested-name-specifier that precedes the identifier. For
-  /// example, if we are parsing "foo::bar::", \p SS will describe the "foo::"
-  /// that has already been parsed.
-  ///
-  /// \param IdLoc the location of the identifier we have just parsed (e.g.,
-  /// the "bar" in "foo::bar::".
-  ///
-  /// \param CCLoc the location of the '::' at the end of the
-  /// nested-name-specifier.
-  ///
-  /// \param II the identifier that represents the scope that this
-  /// nested-name-specifier refers to, e.g., the "bar" in "foo::bar::".
-  ///
-  /// \param ObjectType if this nested-name-specifier occurs as part of a
-  /// C++ member access expression such as "x->Base::f", the type of the base
-  /// object (e.g., *x in the example, if "x" were a pointer).
-  ///
-  /// \param EnteringContext if true, then we intend to immediately enter the
-  /// context of this nested-name-specifier, e.g., for an out-of-line
-  /// definition of a class member.
-  ///
-  /// \returns a CXXScopeTy* object representing the C++ scope.
-  virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
-                                                  CXXScopeSpec &SS,
-                                                  SourceLocation IdLoc,
-                                                  SourceLocation CCLoc,
-                                                  IdentifierInfo &II,
-                                                  ParsedType ObjectType,
-                                                  bool EnteringContext) {
-    return 0;
-  }
-  
-  /// IsInvalidUnlessNestedName - This method is used for error recovery
-  /// purposes to determine whether the specified identifier is only valid as
-  /// a nested name specifier, for example a namespace name.  It is
-  /// conservatively correct to always return false from this method.
-  ///
-  /// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
-  virtual bool IsInvalidUnlessNestedName(Scope *S,
-                                         CXXScopeSpec &SS,
-                                         IdentifierInfo &II,
-                                         ParsedType 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,
-                                                  ParsedType Type,
-                                                  SourceRange TypeRange,
-                                                  SourceLocation CCLoc) {
-    return 0;
-  }
-
-  /// ShouldEnterDeclaratorScope - Called when a C++ scope specifier
-  /// is parsed as part of a declarator-id to determine whether a scope
-  /// should be entered.
-  ///
-  /// \param S the current scope
-  /// \param SS the scope being entered
-  /// \param isFriendDeclaration whether this is a friend declaration
-  virtual bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
-    return false;
-  }
-
-  /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
-  /// scope or nested-name-specifier) is parsed as part of a declarator-id.
-  /// After this method is called, according to [C++ 3.4.3p3], names should be
-  /// looked up in the declarator-id's scope, until the declarator is parsed and
-  /// ActOnCXXExitDeclaratorScope is called.
-  /// The 'SS' should be a non-empty valid CXXScopeSpec.
-  /// \returns true if an error occurred, false otherwise.
-  virtual bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS) {
-    return false;
-  }
-
-  /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
-  /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
-  /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
-  /// Used to indicate that names should revert to being looked up in the
-  /// defining scope.
-  virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
-  }
-
-  /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
-  /// initializer for the declaration 'Dcl'.
-  /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
-  /// static data member of class X, names should be looked up in the scope of
-  /// class X.
-  virtual void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl) {
-  }
-
-  /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
-  /// initializer for the declaration 'Dcl'.
-  virtual void ActOnCXXExitDeclInitializer(Scope *S, Decl *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 Decl *ActOnDeclarator(Scope *S, Declarator &D) {
-    return 0;
-  }
-
-  /// 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 Decl *ActOnParamDeclarator(Scope *S, Declarator &D) {
-    return 0;
-  }
-
-  /// \brief Parsed an exception object declaration within an Objective-C
-  /// @catch statement.
-  virtual Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D) {
-    return 0;
-  }
-
-  /// 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(Decl *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(Decl *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(Decl *Dcl,
-                                      bool TypeContainsUndeducedAuto) {
-    return;
-  }
-
-  /// \brief Note that the given declaration had an initializer that could not
-  /// be parsed.
-  virtual void ActOnInitializerError(Decl *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,
-                                                 Decl **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 Decl *ActOnStartOfFunctionDef(Scope *FnBodyScope,
-                                             Declarator &D) = 0;
-
-  /// ActOnStartOfFunctionDef - This is called at the start of a function
-  /// definition, after the FunctionDecl has already been created.
-  virtual Decl *ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) = 0;
-
-  virtual void ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {
-    return;
-  }
-
-  /// ActOnFinishFunctionBody - This is called when a function body has
-  /// completed parsing.  Decl is returned by ParseStartOfFunctionDef.
-  virtual Decl *ActOnFinishFunctionBody(Decl *Decl, StmtArg Body) {
-    return Decl;
-  }
-
-  virtual Decl *ActOnFileScopeAsmDecl(SourceLocation Loc,
-                                          ExprArg AsmString) {
-    return 0;
-  }
-
-  /// 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(Scope *S) {}
-
-  /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
-  /// no declarator (e.g. "struct foo;") is parsed.
-  virtual Decl *ParsedFreeStandingDeclSpec(Scope *S,
-                                                AccessSpecifier Access,
-                                                DeclSpec &DS) {
-    return 0;
-  }
-
-  /// 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 Decl *ActOnStartLinkageSpecification(Scope *S,
-                                                    SourceLocation ExternLoc,
-                                                    SourceLocation LangLoc,
-                                                    llvm::StringRef Lang,
-                                                    SourceLocation LBraceLoc) {
-    return 0;
-  }
-
-  /// 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 Decl *ActOnFinishLinkageSpecification(Scope *S,
-                                                    Decl *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 Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
-                             SourceLocation KWLoc, CXXScopeSpec &SS,
-                             IdentifierInfo *Name, SourceLocation NameLoc,
-                             AttributeList *Attr, AccessSpecifier AS,
-                             MultiTemplateParamsArg TemplateParameterLists,
-                             bool &OwnedDecl, bool &IsDependent) {
-    return 0;
-  }
-
-  /// 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, Decl *TagD, SourceLocation DeclStart,
-                         IdentifierInfo *ClassName,
-                         llvm::SmallVectorImpl<Decl *> &Decls) {}
-  virtual Decl *ActOnField(Scope *S, Decl *TagD,
-                           SourceLocation DeclStart,
-                           Declarator &D, ExprTy *BitfieldWidth) {
-    return 0;
-  }
-
-  virtual Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
-                              Decl *IntfDecl,
-                              Declarator &D, ExprTy *BitfieldWidth,
-                              tok::ObjCKeywordKind visibility) {
-    return 0;
-  }
-
-  virtual void ActOnLastBitfield(SourceLocation DeclStart, Decl *IntfDecl, 
-                         llvm::SmallVectorImpl<Decl *> &AllIvarDecls) {}
-
-  virtual void ActOnFields(Scope* S, SourceLocation RecLoc, Decl *TagDecl,
-                           Decl **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, Decl *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, Decl *TagDecl,
-                                               SourceLocation LBraceLoc) { }
-
-  /// ActOnTagFinishDefinition - Invoked once we have finished parsing
-  /// the definition of a tag (enumeration, class, struct, or union).
-  ///
-  /// The scope is the scope of the tag definition.
-  virtual void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
-                                        SourceLocation RBraceLoc) { }
-
-  /// ActOnTagDefinitionError - Invoked if there's an unrecoverable
-  /// error parsing the definition of a tag.
-  ///
-  /// The scope is the scope of the tag definition.
-  virtual void ActOnTagDefinitionError(Scope *S, Decl *TagDecl) { }
-
-  virtual Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl,
-                                      Decl *LastEnumConstant,
-                                      SourceLocation IdLoc, IdentifierInfo *Id,
-                                      SourceLocation EqualLoc, ExprTy *Val) {
-    return 0;
-  }
-  virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
-                             SourceLocation RBraceLoc, Decl *EnumDecl,
-                             Decl **Elements, unsigned NumElements,
-                             Scope *S, AttributeList *AttrList) {}
-
-  //===--------------------------------------------------------------------===//
-  // Statement Parsing Callbacks.
-  //===--------------------------------------------------------------------===//
-
-  virtual StmtResult ActOnNullStmt(SourceLocation SemiLoc) {
-    return StmtEmpty();
-  }
-
-  virtual StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
-                                             MultiStmtArg Elts,
-                                             bool isStmtExpr) {
-    return StmtEmpty();
-  }
-  virtual StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
-                                         SourceLocation StartLoc,
-                                         SourceLocation EndLoc) {
-    return StmtEmpty();
-  }
-
-  virtual void ActOnForEachDeclStmt(DeclGroupPtrTy Decl) {
-  }
-
-  virtual StmtResult ActOnExprStmt(FullExprArg Expr)  = 0;
-
-  /// 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 StmtResult 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 StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
-                                            SourceLocation ColonLoc,
-                                            StmtArg SubStmt, Scope *CurScope){
-    return StmtEmpty();
-  }
-
-  virtual StmtResult 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 StmtResult ActOnIfStmt(SourceLocation IfLoc,
-                                       FullExprArg CondVal, 
-                                       Decl *CondVar,
-                                       StmtArg ThenVal,
-                                       SourceLocation ElseLoc,
-                                       StmtArg ElseVal) {
-    return StmtEmpty();
-  }
-
-  /// \brief Parsed the start of a "switch" statement.
-  ///
-  /// \param SwitchLoc The location of the "switch" keyword.
-  ///
-  /// \param Cond if the "switch" condition was parsed as an expression, 
-  /// the expression itself.
-  ///
-  /// \param CondVar if the "switch" condition was parsed as a condition 
-  /// variable, the condition variable itself.
-  virtual StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
-                                                  ExprArg Cond,
-                                                  Decl *CondVar) {
-    return StmtEmpty();
-  }
-
-  virtual StmtResult 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 StmtResult ActOnWhileStmt(SourceLocation WhileLoc,
-                                          FullExprArg Cond, Decl *CondVar,
-                                          StmtArg Body) {
-    return StmtEmpty();
-  }
-  virtual StmtResult 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 StmtResult ActOnForStmt(SourceLocation ForLoc,
-                                        SourceLocation LParenLoc,
-                                        StmtArg First, FullExprArg Second,
-                                        Decl *SecondVar, FullExprArg Third, 
-                                        SourceLocation RParenLoc,
-                                        StmtArg Body) {
-    return StmtEmpty();
-  }
-  
-  virtual StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
-                                       SourceLocation LParenLoc,
-                                       StmtArg First, ExprArg Second,
-                                       SourceLocation RParenLoc, StmtArg Body) {
-    return StmtEmpty();
-  }
-  virtual StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
-                                         SourceLocation LabelLoc,
-                                         IdentifierInfo *LabelII) {
-    return StmtEmpty();
-  }
-  virtual StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
-                                                 SourceLocation StarLoc,
-                                                 ExprArg DestExp) {
-    return StmtEmpty();
-  }
-  virtual StmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
-                                             Scope *CurScope) {
-    return StmtEmpty();
-  }
-  virtual StmtResult ActOnBreakStmt(SourceLocation GotoLoc,
-                                          Scope *CurScope) {
-    return StmtEmpty();
-  }
-  virtual StmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
-                                           ExprArg RetValExp) {
-    return StmtEmpty();
-  }
-  virtual StmtResult 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
-  
-  /// \brief Parsed an Objective-C @catch statement.
-  ///
-  /// \param AtLoc The location of the '@' starting the '@catch'.
-  ///
-  /// \param RParen The location of the right parentheses ')' after the
-  /// exception variable.
-  ///
-  /// \param Parm The variable that will catch the exception. Will be NULL if 
-  /// this is a @catch(...) block.
-  ///
-  /// \param Body The body of the @catch block.
-  virtual StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
-                                                SourceLocation RParen,
-                                                Decl *Parm, StmtArg Body) {
-    return StmtEmpty();
-  }
-
-  /// \brief Parsed an Objective-C @finally statement.
-  ///
-  /// \param AtLoc The location of the '@' starting the '@finally'.
-  ///
-  /// \param Body The body of the @finally block.
-  virtual StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
-                                                  StmtArg Body) {
-    return StmtEmpty();
-  }
-
-  /// \brief Parsed an Objective-C @try- at catch-@finally statement.
-  ///
-  /// \param AtLoc The location of the '@' starting '@try'.
-  ///
-  /// \param Try The body of the '@try' statement.
-  ///
-  /// \param CatchStmts The @catch statements.
-  ///
-  /// \param Finally The @finally statement.
-  virtual StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
-                                              StmtArg Try, 
-                                              MultiStmtArg CatchStmts,
-                                              StmtArg Finally) {
-    return StmtEmpty();
-  }
-
-  virtual StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
-                                                ExprArg Throw,
-                                                Scope *CurScope) {
-    return StmtEmpty();
-  }
-
-  virtual StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
-                                                       ExprArg SynchExpr,
-                                                       StmtArg SynchBody) {
-    return StmtEmpty();
-  }
-
-  // C++ Statements
-  virtual Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D) {
-    return 0;
-  }
-
-  virtual StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
-                                              Decl *ExceptionDecl,
-                                              StmtArg HandlerBlock) {
-    return StmtEmpty();
-  }
-
-  virtual StmtResult 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 ExprResult ActOnIdExpression(Scope *S,
-                                             CXXScopeSpec &SS,
-                                             UnqualifiedId &Name,
-                                             bool HasTrailingLParen,
-                                             bool IsAddressOfOperand) {
-    return ExprEmpty();
-  }
-  
-  virtual ExprResult ActOnPredefinedExpr(SourceLocation Loc,
-                                               tok::TokenKind Kind) {
-    return ExprEmpty();
-  }
-  virtual ExprResult ActOnCharacterConstant(const Token &) {
-    return ExprEmpty();
-  }
-  virtual ExprResult ActOnNumericConstant(const Token &) {
-    return ExprEmpty();
-  }
-
-  /// ActOnStringLiteral - The specified tokens were lexed as pasted string
-  /// fragments (e.g. "foo" "bar" L"baz").
-  virtual ExprResult ActOnStringLiteral(const Token *Toks,
-                                              unsigned NumToks) {
-    return ExprEmpty();
-  }
-
-  virtual ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
-                                          ExprArg Val) {
-    return move(Val);  // Default impl returns operand.
-  }
-
-  virtual ExprResult ActOnParenOrParenListExpr(SourceLocation L,
-                                                     SourceLocation R,
-                                                     MultiExprArg Val,
-                                                     ParsedType TypeOfCast
-                                                       = ParsedType()) {
-    return ExprEmpty();
-  }
-
-  // Postfix Expressions.
-  virtual ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
-                                               tok::TokenKind Kind,
-                                               ExprArg Input) {
-    return ExprEmpty();
-  }
-  virtual ExprResult 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 ExprResult ActOnMemberAccessExpr(Scope *S, ExprArg Base,
-                                                 SourceLocation OpLoc,
-                                                 tok::TokenKind OpKind,
-                                                 CXXScopeSpec &SS,
-                                                 UnqualifiedId &Member,
-                                                 Decl *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 ExprResult 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 ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
-                                        tok::TokenKind Op, ExprArg Input) {
-    return ExprEmpty();
-  }
-  virtual ExprResult
-    ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
-                           void *TyOrEx, const SourceRange &ArgRange) {
-    return ExprEmpty();
-  }
-
-  virtual ExprResult ActOnCompoundLiteral(SourceLocation LParen,
-                                                ParsedType Ty,
-                                                SourceLocation RParen,
-                                                ExprArg Op) {
-    return ExprEmpty();
-  }
-  virtual ExprResult 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 ExprResult ActOnDesignatedInitializer(Designation &Desig,
-                                                      SourceLocation Loc,
-                                                      bool GNUSyntax,
-                                                      ExprResult Init) {
-    return ExprEmpty();
-  }
-
-  virtual ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
-                                         ParsedType Ty, SourceLocation RParenLoc,
-                                         ExprArg Op) {
-    return ExprEmpty();
-  }
-
-  virtual bool TypeIsVectorType(ParsedType Ty) {
-    return false;
-  }
-
-  virtual ExprResult 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 ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
-                                              SourceLocation ColonLoc,
-                                              ExprArg Cond, ExprArg LHS,
-                                              ExprArg RHS) {
-    return ExprEmpty();
-  }
-
-  //===---------------------- GNU Extension Expressions -------------------===//
-
-  virtual ExprResult ActOnAddrLabel(SourceLocation OpLoc,
-                                          SourceLocation LabLoc,
-                                          IdentifierInfo *LabelII) { // "&&foo"
-    return ExprEmpty();
-  }
-
-  virtual ExprResult 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 ExprResult ActOnBuiltinOffsetOf(Scope *S,
-                                                SourceLocation BuiltinLoc,
-                                                SourceLocation TypeLoc,
-                                                ParsedType Arg1,
-                                                OffsetOfComponent *CompPtr,
-                                                unsigned NumComponents,
-                                                SourceLocation RParenLoc) {
-    return ExprEmpty();
-  }
-
-  // __builtin_types_compatible_p(type1, type2)
-  virtual ExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
-                                                    ParsedType arg1,
-                                                    ParsedType arg2,
-                                                    SourceLocation RPLoc) {
-    return ExprEmpty();
-  }
-  // __builtin_choose_expr(constExpr, expr1, expr2)
-  virtual ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
-                                           ExprArg cond, ExprArg expr1,
-                                           ExprArg expr2, SourceLocation RPLoc){
-    return ExprEmpty();
-  }
-
-  // __builtin_va_arg(expr, type)
-  virtual ExprResult ActOnVAArg(SourceLocation BuiltinLoc,
-                                      ExprArg expr, ParsedType type,
-                                      SourceLocation RPLoc) {
-    return ExprEmpty();
-  }
-
-  /// ActOnGNUNullExpr - Parsed the GNU __null expression, the token
-  /// for which is at position TokenLoc.
-  virtual ExprResult 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 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
-                                              StmtArg Body,
-                                              Scope *CurScope) {
-    return ExprEmpty();
-  }
-
-  //===------------------------- C++ Declarations -------------------------===//
-
-  /// ActOnStartNamespaceDef - This is called at the start of a namespace
-  /// definition.
-  virtual Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
-                                           IdentifierInfo *Ident,
-                                           SourceLocation LBrace,
-                                           AttributeList *AttrList) {
-    return 0;
-  }
-
-  /// ActOnFinishNamespaceDef - This callback is called after a namespace is
-  /// exited. Decl is returned by ActOnStartNamespaceDef.
-  virtual void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) {
-    return;
-  }
-
-  /// ActOnUsingDirective - This is called when using-directive is parsed.
-  virtual Decl *ActOnUsingDirective(Scope *CurScope,
-                                        SourceLocation UsingLoc,
-                                        SourceLocation NamespcLoc,
-                                        CXXScopeSpec &SS,
-                                        SourceLocation IdentLoc,
-                                        IdentifierInfo *NamespcName,
-                                        AttributeList *AttrList) = 0;
-
-  /// ActOnNamespaceAliasDef - This is called when a namespace alias definition
-  /// is parsed.
-  virtual Decl *ActOnNamespaceAliasDef(Scope *CurScope,
-                                           SourceLocation NamespaceLoc,
-                                           SourceLocation AliasLoc,
-                                           IdentifierInfo *Alias,
-                                           CXXScopeSpec &SS,
-                                           SourceLocation IdentLoc,
-                                           IdentifierInfo *Ident) {
-    return 0;
-  }
-
-  /// \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 Decl *ActOnUsingDeclaration(Scope *CurScope,
-                                          AccessSpecifier AS,
-                                          bool HasUsingKeyword,
-                                          SourceLocation UsingLoc,
-                                          CXXScopeSpec &SS,
-                                          UnqualifiedId &Name,
-                                          AttributeList *AttrList,
-                                          bool IsTypeName,
-                                          SourceLocation TypenameLoc) = 0;
-
-  /// ActOnParamDefaultArgument - Parse default argument for function parameter
-  virtual void ActOnParamDefaultArgument(Decl *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(Decl *param,
-                                                 SourceLocation EqualLoc,
-                                                 SourceLocation ArgLoc) { }
-
-  /// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
-  /// the default argument for the parameter param failed.
-  virtual void ActOnParamDefaultArgumentError(Decl *param) { }
-
-  /// AddCXXDirectInitializerToDecl - This action is called immediately after
-  /// ActOnDeclarator, when a C++ direct initializer is present.
-  /// e.g: "int x(1);"
-  virtual void AddCXXDirectInitializerToDecl(Decl *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, Decl *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,
-                                                   Decl *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,
-                                                     Decl *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, Decl *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,
-                                                      Decl *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,
-                                                    Decl *Record) {
-  }
-
-  /// ActOnStaticAssertDeclaration - Parse a C++0x static_assert declaration.
-  virtual Decl *ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
-                                                 ExprArg AssertExpr,
-                                                 ExprArg AssertMessageExpr) {
-    return 0;
-  }
-
-  /// ActOnFriendFunctionDecl - Parsed a friend function declarator.
-  /// The name is actually a slight misnomer, because the declarator
-  /// is not necessarily a function declarator.
-  virtual Decl *ActOnFriendFunctionDecl(Scope *S,
-                                            Declarator &D,
-                                            bool IsDefinition,
-                                            MultiTemplateParamsArg TParams) {
-    return 0;
-  }
-
-  /// ActOnFriendTypeDecl - Parsed a friend type declaration.
-  virtual Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
-                                        MultiTemplateParamsArg TParams) {
-    return 0;
-  }
-
-  //===------------------------- C++ Expressions --------------------------===//
-
-  /// \brief Parsed a destructor name or pseudo-destructor name. 
-  ///
-  /// \returns the type being destructed.
-  virtual ParsedType getDestructorName(SourceLocation TildeLoc,
-                                    IdentifierInfo &II, SourceLocation NameLoc,
-                                    Scope *S, CXXScopeSpec &SS,
-                                    ParsedType ObjectType,
-                                    bool EnteringContext) {
-    return getTypeName(II, NameLoc, S, &SS, false, ObjectType);
-  }
-
-
-  /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
-  virtual ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
-                                             tok::TokenKind Kind,
-                                             SourceLocation LAngleBracketLoc,
-                                             ParsedType Ty,
-                                             SourceLocation RAngleBracketLoc,
-                                             SourceLocation LParenLoc,
-                                             ExprArg Op,
-                                             SourceLocation RParenLoc) {
-    return ExprEmpty();
-  }
-
-  /// ActOnCXXTypeidOfType - Parse typeid( type-id ).
-  virtual ExprResult ActOnCXXTypeid(SourceLocation OpLoc,
-                                          SourceLocation LParenLoc, bool isType,
-                                          void *TyOrExpr,
-                                          SourceLocation RParenLoc) {
-    return ExprEmpty();
-  }
-
-  /// ActOnCXXThis - Parse the C++ 'this' pointer.
-  virtual ExprResult ActOnCXXThis(SourceLocation ThisLoc) {
-    return ExprEmpty();
-  }
-
-  /// ActOnCXXBoolLiteral - Parse {true,false} literals.
-  virtual ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
-                                               tok::TokenKind Kind) {
-    return ExprEmpty();
-  }
-
-  /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
-  virtual ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc) {
-    return ExprEmpty();
-  }
-
-  /// ActOnCXXThrow - Parse throw expressions.
-  virtual ExprResult 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 ExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
-                                                     ParsedType 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) = 0;
-
-  /// \brief Parsed an expression that will be handled as the condition in
-  /// an if/while/for statement. 
-  ///
-  /// This routine handles the conversion of the expression to 'bool'.
-  ///
-  /// \param S The scope in which the expression occurs.
-  ///
-  /// \param Loc The location of the construct that requires the conversion to
-  /// a boolean value.
-  ///
-  /// \param SubExpr The expression that is being converted to bool.
-  virtual ExprResult ActOnBooleanCondition(Scope *S, SourceLocation Loc,
-                                                 ExprArg SubExpr) {
-    return move(SubExpr);
-  }
-  
-  /// \brief Parsed a C++ 'new' expression.
-  ///
-  /// \param StartLoc The start of the new expression, which is either the
-  /// "new" keyword or the "::" preceding it, depending on \p UseGlobal.
-  ///
-  /// \param UseGlobal True if the "new" was qualified with "::".
-  ///
-  /// \param PlacementLParen The location of the opening parenthesis ('(') for
-  /// the placement arguments, if any.
-  /// 
-  /// \param PlacementArgs The placement arguments, if any.
-  ///
-  /// \param PlacementRParen The location of the closing parenthesis (')') for
-  /// the placement arguments, if any.
-  ///
-  /// \param TypeIdParens If the type was expressed as a type-id in parentheses,
-  /// the source range covering the parenthesized type-id.
-  ///
-  /// \param D The parsed declarator, which may include an array size (for 
-  /// array new) as the first declarator.
-  ///
-  /// \param ConstructorLParen The location of the opening parenthesis ('(') for
-  /// the constructor arguments, if any.
-  ///
-  /// \param ConstructorArgs The constructor arguments, if any.
-  ///
-  /// \param ConstructorRParen The location of the closing parenthesis (')') for
-  /// the constructor arguments, if any.
-  virtual ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
-                                       SourceLocation PlacementLParen,
-                                       MultiExprArg PlacementArgs,
-                                       SourceLocation PlacementRParen,
-                                       SourceRange TypeIdParens, 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 ExprResult ActOnCXXDelete(SourceLocation StartLoc,
-                                          bool UseGlobal, bool ArrayForm,
-                                          ExprArg Operand) {
-    return ExprEmpty();
-  }
-
-  virtual ExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
-                                               SourceLocation KWLoc,
-                                               SourceLocation LParen,
-                                               ParsedType 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 ExprResult ActOnStartCXXMemberReference(Scope *S,
-                                                        ExprArg Base,
-                                                        SourceLocation OpLoc,
-                                                        tok::TokenKind OpKind,
-                                                        ParsedType &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 ExprResult ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
-                                                     SourceLocation OpLoc,
-                                                     tok::TokenKind OpKind,
-                                                     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 ExprResult ActOnFinishFullExpr(ExprArg Expr) {
-    return move(Expr);
-  }
-
-  //===---------------------------- C++ Classes ---------------------------===//
-  /// ActOnBaseSpecifier - Parsed a base specifier
-  virtual BaseResult ActOnBaseSpecifier(Decl *classdecl,
-                                        SourceRange SpecifierRange,
-                                        bool Virtual, AccessSpecifier Access,
-                                        ParsedType basetype,
-                                        SourceLocation BaseLoc) {
-    return BaseResult();
-  }
-
-  virtual void ActOnBaseSpecifiers(Decl *ClassDecl, BaseTy **Bases,
-                                   unsigned NumBases) {
-  }
-
-  /// ActOnAccessSpecifier - This is invoked when an access specifier
-  /// (and the colon following it) is found during the parsing of a
-  /// C++ class member declarator.
-  virtual Decl *ActOnAccessSpecifier(AccessSpecifier AS,
-                                         SourceLocation ASLoc,
-                                         SourceLocation ColonLoc) {
-    return 0;
-  }
-
-  /// 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 Decl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
-                                             Declarator &D,
-                                 MultiTemplateParamsArg TemplateParameterLists,
-                                             ExprTy *BitfieldWidth,
-                                             ExprTy *Init,
-                                             bool IsDefinition,
-                                             bool Deleted = false) {
-    return 0;
-  }
-
-  virtual MemInitResult ActOnMemInitializer(Decl *ConstructorDecl,
-                                            Scope *S,
-                                            CXXScopeSpec &SS,
-                                            IdentifierInfo *MemberOrBase,
-                                            ParsedType 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(Decl *ConstructorDecl,
-                                    SourceLocation ColonLoc,
-                                    MemInitTy **MemInits, unsigned NumMemInits,
-                                    bool AnyErrors){
-  }
-
- virtual void ActOnDefaultCtorInitializers(Decl *CDtorDecl) {}
-
-  /// ActOnFinishCXXMemberSpecification - Invoked after all member declarators
-  /// are parsed but *before* parsing of inline method definitions.
-  virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
-                                                 Decl *TagDecl,
-                                                 SourceLocation LBrac,
-                                                 SourceLocation RBrac,
-                                                 AttributeList *AttrList) {
-  }
-
-  //===---------------------------C++ Templates----------------------------===//
-
-  /// \brief Called when a C++ template type parameter(e.g., "typename T") has 
-  /// been parsed. 
-  ///
-  /// Given
-  ///
-  /// \code
-  /// template<typename T, typename U = T> struct pair;
-  /// \endcode
-  ///
-  /// this callback will be invoked twice: once for the type parameter \c T
-  /// with \p Depth=0 and \p Position=0, and once for the type parameter \c U
-  /// with \p Depth=0 and \p Position=1.
-  ///
-  /// \param Typename Specifies whether the keyword "typename" was used to 
-  /// declare the type parameter (otherwise, "class" was used).
-  ///
-  /// \param Ellipsis Specifies whether this is a C++0x parameter pack.
-  ///
-  /// \param EllipsisLoc Specifies the start of the ellipsis.
-  ///
-  /// \param KeyLoc The location of the "class" or "typename" keyword.
-  ///
-  /// \param ParamName The name of the parameter, where NULL indicates an 
-  /// unnamed template parameter.
-  ///
-  /// \param ParamNameLoc The location of the parameter name (if any).
-  ///
-  /// \param Depth The depth of this template parameter, e.g., the number of
-  /// template parameter lists that occurred outside the template parameter
-  /// list in which this template type parameter occurs.
-  ///
-  /// \param Position The zero-based position of this template parameter within
-  /// its template parameter list, which is also the number of template
-  /// parameters that precede this parameter in the template parameter list.
-  ///
-  /// \param EqualLoc The location of the '=' sign for the default template
-  /// argument, if any.
-  ///
-  /// \param DefaultArg The default argument, if provided.
-  virtual Decl *ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
-                                       SourceLocation EllipsisLoc,
-                                       SourceLocation KeyLoc,
-                                       IdentifierInfo *ParamName,
-                                       SourceLocation ParamNameLoc,
-                                       unsigned Depth, unsigned Position,
-                                       SourceLocation EqualLoc,
-                                       ParsedType DefaultArg) {
-    return 0;
-  }
-
-  /// \brief Called when a C++ non-type template parameter has been parsed.
-  ///
-  /// Given
-  ///
-  /// \code
-  /// template<int Size> class Array;
-  /// \endcode
-  ///
-  /// This callback will be invoked for the 'Size' non-type template parameter.
-  ///
-  /// \param S The current scope.
-  ///
-  /// \param D The parsed declarator.
-  ///
-  /// \param Depth The depth of this template parameter, e.g., the number of
-  /// template parameter lists that occurred outside the template parameter
-  /// list in which this template type parameter occurs.
-  ///
-  /// \param Position The zero-based position of this template parameter within
-  /// its template parameter list, which is also the number of template
-  /// parameters that precede this parameter in the template parameter list.
-  ///
-  /// \param EqualLoc The location of the '=' sign for the default template
-  /// argument, if any.
-  ///
-  /// \param DefaultArg The default argument, if provided.
-  virtual Decl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
-                                                  unsigned Depth,
-                                                  unsigned Position,
-                                                  SourceLocation EqualLoc,
-                                                  ExprArg DefaultArg) {
-    return 0;
-  }
-
-  /// \brief Adds a default argument to the given non-type template
-  /// parameter.
-  virtual void ActOnNonTypeTemplateParameterDefault(Decl *TemplateParam,
-                                                    SourceLocation EqualLoc,
-                                                    ExprArg Default) {
-  }
-
-  /// \brief Called when a C++ template template parameter has been parsed. 
-  ///
-  /// Given
-  ///
-  /// \code
-  /// template<template <typename> class T> class X;
-  /// \endcode
-  ///
-  /// this callback will be invoked for the template template parameter \c T.
-  ///
-  /// \param S The scope in which this template template parameter occurs.
-  ///
-  /// \param TmpLoc The location of the "template" keyword.
-  ///
-  /// \param TemplateParams The template parameters required by the template.
-  ///
-  /// \param ParamName The name of the parameter, or NULL if unnamed.
-  ///
-  /// \param ParamNameLoc The source location of the parameter name (if given).
-  ///
-  /// \param Depth The depth of this template parameter, e.g., the number of
-  /// template parameter lists that occurred outside the template parameter
-  /// list in which this template parameter occurs.
-  ///
-  /// \param Position The zero-based position of this template parameter within
-  /// its template parameter list, which is also the number of template
-  /// parameters that precede this parameter in the template parameter list.
-  ///
-  /// \param EqualLoc The location of the '=' sign for the default template
-  /// argument, if any.
-  ///
-  /// \param DefaultArg The default argument, if provided.
-  virtual Decl *ActOnTemplateTemplateParameter(Scope *S,
-                                                   SourceLocation TmpLoc,
-                                                   TemplateParamsTy *Params,
-                                                   IdentifierInfo *ParamName,
-                                                   SourceLocation ParamNameLoc,
-                                                   unsigned Depth,
-                                                   unsigned Position,
-                                                   SourceLocation EqualLoc,
-                                    const ParsedTemplateArgument &DefaultArg) {
-    return 0;
-  }
-
-  /// 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,
-                             Decl **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 S The scope in which the dependent template name was parsed.
-  ///
-  /// \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.
-  ///
-  /// \param Template Will be set to the dependent template name, on success.
-  ///
-  /// \returns The kind of template name that was produced. Generally, this will
-  /// be \c TNK_Dependent_template_name. However, if the nested-name-specifier
-  /// is not dependent, or refers to the current instantiation, then we may
-  /// be able to resolve the template kind more specifically.
-  virtual TemplateNameKind ActOnDependentTemplateName(Scope *S, 
-                                                SourceLocation TemplateKWLoc,
-                                                CXXScopeSpec &SS,
-                                                UnqualifiedId &Name,
-                                                ParsedType ObjectType,
-                                                bool EnteringContext,
-                                                TemplateTy &Template) {
-    return TNK_Non_template;
-  }
-
-  /// \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,
-                                   CXXScopeSpec &SS,
-                                   TemplateTy Template,
-                                   SourceLocation TemplateNameLoc,
-                                   SourceLocation LAngleLoc,
-                                   ASTTemplateArgsPtr TemplateArgs,
-                                   SourceLocation RAngleLoc,
-                                   AttributeList *Attr,
-                          MultiTemplateParamsArg TemplateParameterLists) = 0;
-
-  /// \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 Decl *ActOnTemplateDeclarator(Scope *S,
-                              MultiTemplateParamsArg TemplateParameterLists,
-                                            Declarator &D) {
-    return 0;
-  }
-
-  /// \brief Invoked when the parser is beginning to parse a function template
-  /// or function template specialization definition.
-  virtual Decl *ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
-                                MultiTemplateParamsArg TemplateParameterLists,
-                                                    Declarator &D) {
-    return 0;
-  }
-
-  /// \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,
-                             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(Scope *S, 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(Scope *S, SourceLocation TypenameLoc, 
-                    const CXXScopeSpec &SS, SourceLocation TemplateLoc, 
-                    ParsedType Ty) {
-    return TypeResult();
-  }
-
-  /// \brief Called when the parser begins parsing a construct which should not
-  /// have access control applied to it.
-  virtual void ActOnStartSuppressingAccessChecks() {
-  }
-
-  /// \brief Called when the parser finishes parsing a construct which should
-  /// not have access control applied to it.
-  virtual void ActOnStopSuppressingAccessChecks() {
-  }
-
-  //===----------------------- 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 Decl *ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
-                                             IdentifierInfo *ClassName,
-                                             SourceLocation ClassLoc,
-                                             IdentifierInfo *SuperName,
-                                             SourceLocation SuperLoc,
-                                             Decl * const *ProtoRefs,
-                                             unsigned NumProtoRefs,
-                                             const SourceLocation *ProtoLocs,
-                                             SourceLocation EndProtoLoc,
-                                             AttributeList *AttrList) {
-    return 0;
-  }
-
-  /// ActOnCompatiblityAlias - this action is called after complete parsing of
-  /// @compaatibility_alias declaration. It sets up the alias relationships.
-  virtual Decl *ActOnCompatiblityAlias(
-    SourceLocation AtCompatibilityAliasLoc,
-    IdentifierInfo *AliasName,  SourceLocation AliasLocation,
-    IdentifierInfo *ClassName, SourceLocation ClassLocation) {
-    return 0;
-  }
-
-  // ActOnStartProtocolInterface - this action is called immdiately after
-  // parsing the prologue for a protocol interface.
-  virtual Decl *ActOnStartProtocolInterface(SourceLocation AtProtoLoc,
-                                                IdentifierInfo *ProtocolName,
-                                                SourceLocation ProtocolLoc,
-                                                Decl * const *ProtoRefs,
-                                                unsigned NumProtoRefs,
-                                                const SourceLocation *ProtoLocs,
-                                                SourceLocation EndProtoLoc,
-                                                AttributeList *AttrList) {
-    return 0;
-  }
-  // ActOnStartCategoryInterface - this action is called immdiately after
-  // parsing the prologue for a category interface.
-  virtual Decl *ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
-                                                IdentifierInfo *ClassName,
-                                                SourceLocation ClassLoc,
-                                                IdentifierInfo *CategoryName,
-                                                SourceLocation CategoryLoc,
-                                                Decl * const *ProtoRefs,
-                                                unsigned NumProtoRefs,
-                                                const SourceLocation *ProtoLocs,
-                                                SourceLocation EndProtoLoc) {
-    return 0;
-  }
-  // ActOnStartClassImplementation - this action is called immdiately after
-  // parsing the prologue for a class implementation. Instance variables are
-  // processed by ActOnFields().
-  virtual Decl *ActOnStartClassImplementation(
-    SourceLocation AtClassImplLoc,
-    IdentifierInfo *ClassName,
-    SourceLocation ClassLoc,
-    IdentifierInfo *SuperClassname,
-    SourceLocation SuperClassLoc) {
-    return 0;
-  }
-  // ActOnStartCategoryImplementation - this action is called immdiately after
-  // parsing the prologue for a category implementation.
-  virtual Decl *ActOnStartCategoryImplementation(
-    SourceLocation AtCatImplLoc,
-    IdentifierInfo *ClassName,
-    SourceLocation ClassLoc,
-    IdentifierInfo *CatName,
-    SourceLocation CatLoc) {
-    return 0;
-  }
-  // ActOnPropertyImplDecl - called for every property implementation
-  virtual Decl *ActOnPropertyImplDecl(
-   Scope *S,
-   SourceLocation AtLoc,              // location of the @synthesize/@dynamic
-   SourceLocation PropertyNameLoc,    // location for the property name
-   bool ImplKind,                     // true for @synthesize, false for
-                                      // @dynamic
-   Decl *ClassImplDecl,           // class or category implementation
-   IdentifierInfo *propertyId,        // name of property
-   IdentifierInfo *propertyIvar) {    // name of the ivar
-    return 0;
-  }
-
-  struct ObjCArgInfo {
-    IdentifierInfo *Name;
-    SourceLocation NameLoc;
-    // The Type is null if no type was specified, and the DeclSpec is invalid
-    // in this case.
-    ParsedType Type;
-    ObjCDeclSpec DeclSpec;
-
-    /// ArgAttrs - Attribute list for this argument.
-    AttributeList *ArgAttrs;
-  };
-
-  // ActOnMethodDeclaration - called for all method declarations.
-  virtual Decl *ActOnMethodDeclaration(
-    SourceLocation BeginLoc,   // location of the + or -.
-    SourceLocation EndLoc,     // location of the ; or {.
-    tok::TokenKind MethodType, // tok::minus for instance, tok::plus for class.
-    Decl *ClassDecl,           // class this methods belongs to.
-    ObjCDeclSpec &ReturnQT,    // for return type's in inout etc.
-    ParsedType ReturnType,     // the method return type.
-    Selector Sel,              // a unique name for the method.
-    ObjCArgInfo *ArgInfo,      // ArgInfo: Has 'Sel.getNumArgs()' entries.
-    DeclaratorChunk::ParamInfo *CParamInfo, unsigned CNumArgs, // c-style args
-    AttributeList *MethodAttrList, // optional
-    // tok::objc_not_keyword, tok::objc_optional, tok::objc_required
-    tok::ObjCKeywordKind impKind,
-    bool isVariadic = false) {
-    return 0;
-  }
-  // 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(Scope *S, SourceRange AtEnd,
-                          Decl *classDecl,
-                          Decl **allMethods = 0,
-                          unsigned allNum = 0,
-                          Decl **allProperties = 0,
-                          unsigned pNum = 0,
-                          DeclGroupPtrTy *allTUVars = 0,
-                          unsigned tuvNum = 0) {
-  }
-  // ActOnProperty - called to build one property AST
-  virtual Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,
-                                  FieldDeclarator &FD, ObjCDeclSpec &ODS,
-                                  Selector GetterSel, Selector SetterSel,
-                                  Decl *ClassCategory,
-                                  bool *OverridingProperty,
-                                  tok::ObjCKeywordKind MethodImplKind) {
-    return 0;
-  }
-
-  virtual ExprResult
-  ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
-                            IdentifierInfo &propertyName,
-                            SourceLocation receiverNameLoc,
-                            SourceLocation propertyNameLoc) {
-    return ExprEmpty();
-  }
-
-  /// \brief Describes the kind of message expression indicated by a message
-  /// send that starts with an identifier.
-  enum ObjCMessageKind {
-    /// \brief The message is sent to 'super'.
-    ObjCSuperMessage,
-    /// \brief The message is an instance message.
-    ObjCInstanceMessage,
-    /// \brief The message is a class message, and the identifier is a type
-    /// name.
-    ObjCClassMessage
-  };
-  
-  /// \brief Determine the kind of Objective-C message send that we will be
-  /// performing based on the identifier given.
-  ///
-  /// This action determines how a message send that starts with [
-  /// identifier (followed by another identifier) will be parsed,
-  /// e.g., as a class message, instance message, super message. The
-  /// result depends on the meaning of the given identifier. If the
-  /// identifier is unknown, the action should indicate that the
-  /// message is an instance message.
-  ///
-  /// By default, this routine applies syntactic disambiguation and uses
-  /// \c getTypeName() to determine whether the identifier refers to a type.
-  /// However, \c Action subclasses may override this routine to improve
-  /// error recovery.
-  ///
-  /// \param S The scope in which the message send occurs.
-  ///
-  /// \param Name The identifier following the '['. 
-  ///
-  /// \param NameLoc The location of the identifier.
-  ///
-  /// \param IsSuper Whether the name is the pseudo-keyword "super".
-  ///
-  /// \param HasTrailingDot Whether the name is followed by a period.
-  /// 
-  /// \param ReceiverType If this routine returns \c ObjCClassMessage,
-  /// this argument will be set to the receiver type.
-  ///
-  /// \returns The kind of message send.
-  virtual ObjCMessageKind getObjCMessageKind(Scope *S,
-                                             IdentifierInfo *Name,
-                                             SourceLocation NameLoc,
-                                             bool IsSuper,
-                                             bool HasTrailingDot,
-                                             ParsedType &ReceiverType) = 0;
-
-  /// \brief Parsed a message send to 'super'.
-  ///
-  /// \param S The scope in which the message send occurs.
-  /// \param SuperLoc The location of the 'super' keyword.
-  /// \param Sel The selector to which the message is being sent.
-  /// \param LBracLoc The location of the opening square bracket ']'.
-  /// \param SelectorLoc The location of the first identifier in the selector.
-  /// \param RBrac The location of the closing square bracket ']'.
-  /// \param Args The message arguments.
-  virtual ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,
-                                             Selector Sel,
-                                             SourceLocation LBracLoc,
-                                             SourceLocation SelectorLoc,
-                                             SourceLocation RBracLoc,
-                                             MultiExprArg Args) = 0;
-
-  /// \brief Parsed a message send to a class.
-  ///
-  /// \param S The scope in which the message send occurs.
-  /// \param Receiver The type of the class receiving the message.
-  /// \param Sel The selector to which the message is being sent.
-  /// \param LBracLoc The location of the opening square bracket ']'.
-  /// \param SelectorLoc The location of the first identifier in the selector.
-  /// \param RBrac The location of the closing square bracket ']'.
-  /// \param Args The message arguments.
-  virtual ExprResult ActOnClassMessage(Scope *S,
-                                       ParsedType Receiver,
-                                       Selector Sel,
-                                       SourceLocation LBracLoc, 
-                                       SourceLocation SelectorLoc,
-                                       SourceLocation RBracLoc,
-                                       MultiExprArg Args) = 0;
-
-  /// \brief Parsed a message send to an object instance.
-  ///
-  /// \param S The scope in which the message send occurs.
-  /// \param Receiver The expression that computes the receiver object.
-  /// \param Sel The selector to which the message is being sent.
-  /// \param LBracLoc The location of the opening square bracket ']'.
-  /// \param SelectorLoc The location of the first identifier in the selector.
-  /// \param RBrac The location of the closing square bracket ']'.
-  /// \param Args The message arguments.
-  virtual ExprResult ActOnInstanceMessage(Scope *S,
-                                          ExprArg Receiver,
-                                          Selector Sel,
-                                          SourceLocation LBracLoc, 
-                                          SourceLocation SelectorLoc, 
-                                          SourceLocation RBracLoc,
-                                          MultiExprArg Args) = 0;
-
-  virtual Decl *ActOnForwardClassDeclaration(
-    SourceLocation AtClassLoc,
-    IdentifierInfo **IdentList,
-    SourceLocation *IdentLocs,
-    unsigned NumElts) {
-    return 0;
-  }
-  virtual Decl *ActOnForwardProtocolDeclaration(
-    SourceLocation AtProtocolLoc,
-    const IdentifierLocPair*IdentList,
-    unsigned NumElts,
-    AttributeList *AttrList) {
-    return 0;
-  }
-
-  /// 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<Decl *> &ResProtos) {
-  }
-
-  //===----------------------- Obj-C Expressions --------------------------===//
-
-  virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
-                                            ExprTy **Strings,
-                                            unsigned NumStrings) {
-    return ExprResult();
-  }
-
-  virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
-                                               SourceLocation EncLoc,
-                                               SourceLocation LParenLoc,
-                                               ParsedType 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 PragmaOptionsAlignKind {
-    POAK_Native,  // #pragma options align=native
-    POAK_Natural, // #pragma options align=natural
-    POAK_Packed,  // #pragma options align=packed
-    POAK_Power,   // #pragma options align=power
-    POAK_Mac68k,  // #pragma options align=mac68k
-    POAK_Reset    // #pragma options align=reset
-  };
-
-  /// ActOnPragmaOptionsAlign - Called on well formed #pragma options
-  /// align={...}.
-  virtual void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
-                                       SourceLocation PragmaLoc,
-                                       SourceLocation KindLoc) {
-    return;
-  }
-
-  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;
-  }
-
-
-  /// ActOnPragmaVisibility - Called on well formed #pragma GCC visibility... .
-  virtual void ActOnPragmaVisibility(bool IsPush, const IdentifierInfo* VisType,
-                                     SourceLocation PragmaLoc) {
-    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 ParserCompletionContext {
-    /// \brief Code completion occurs at top-level or namespace context.
-    PCC_Namespace,
-    /// \brief Code completion occurs within a class, struct, or union.
-    PCC_Class,
-    /// \brief Code completion occurs within an Objective-C interface, protocol,
-    /// or category.
-    PCC_ObjCInterface,
-    /// \brief Code completion occurs within an Objective-C implementation or
-    /// category implementation
-    PCC_ObjCImplementation,
-    /// \brief Code completion occurs within the list of instance variables
-    /// in an Objective-C interface, protocol, category, or implementation.
-    PCC_ObjCInstanceVariableList,
-    /// \brief Code completion occurs following one or more template
-    /// headers.
-    PCC_Template,
-    /// \brief Code completion occurs following one or more template
-    /// headers within a class.
-    PCC_MemberTemplate,
-    /// \brief Code completion occurs within an expression.
-    PCC_Expression,
-    /// \brief Code completion occurs within a statement, which may
-    /// also be an expression or a declaration.
-    PCC_Statement,
-    /// \brief Code completion occurs at the beginning of the
-    /// initialization statement (or expression) in a for loop.
-    PCC_ForInit,
-    /// \brief Code completion occurs within the condition of an if,
-    /// while, switch, or for statement.
-    PCC_Condition,
-    /// \brief Code completion occurs within the body of a function on a 
-    /// recovery path, where we do not have a specific handle on our position
-    /// in the grammar.
-    PCC_RecoveryInFunction,
-    /// \brief Code completion occurs where only a type is permitted.
-    PCC_Type
-  };
-    
-  /// \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, 
-                                    ParserCompletionContext CompletionContext) { }
-  
-  /// \brief Code completion for a declarator name.
-  ///
-  /// 
-  ///
-  /// \param S The scope in which code completion occurs.
-  ///
-  /// \param AllowNonIdentifiers Whether non-identifier names are allowed in
-  /// this context, e.g., operator+.
-  ///
-  /// \param AllowNestedNameSpecifiers Whether nested-name-specifiers are 
-  /// allowed in this context, e.g., because it is a top-level declaration or
-  /// a friend declaration.
-  virtual void CodeCompleteDeclarator(Scope *S,
-                                      bool AllowNonIdentifiers,
-                                      bool AllowNestedNameSpecifiers) { }
-  
-  /// \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, Expr *Fn,
-                                Expr **Args, unsigned NumArgs) { }
-                 
-  /// \brief Code completion for the initializer of a variable declaration.
-  ///
-  /// \param S The scope in which the initializer occurs.
-  ///
-  /// \param D The declaration being initialized.
-  virtual void CodeCompleteInitializer(Scope *S, Decl *D) { }
-  
-  /// \brief Code completion after the "return" keyword within a function.
-  ///
-  /// \param S The scope in which the return statement occurs.
-  virtual void CodeCompleteReturn(Scope *S) { }
-  
-  /// \brief Code completion for the right-hand side of an assignment or
-  /// compound assignment operator.
-  ///
-  /// \param S The scope in which the assignment occurs.
-  ///
-  /// \param LHS The left-hand side of the assignment expression.
-  virtual void CodeCompleteAssignmentRHS(Scope *S, ExprTy *LHS) { }
-  
-  /// \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, 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, Decl *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, Decl *ClassDecl,
-                                              Decl **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, Decl *ClassDecl,
-                                              Decl **Methods,
-                                              unsigned NumMethods) {
-  }
-
-  /// \brief Code completion for an Objective-C method parameter or return type.
-  ///
-  /// This code completion action is invoked when we are parsing the type of
-  /// an Objective-C method parameter or return type.
-  ///
-  /// \param S The scope in which the code-completion occurs.
-  /// \param DS The Objective-C declaration specifiers so far.
-  virtual void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS){
-  }
-  
-  /// \brief Code completion for the receiver in an Objective-C message send.
-  ///
-  /// This code completion action is invoked when we see a '[' that indicates
-  /// the start of an Objective-C message send.
-  ///
-  /// \param S The scope in which the Objective-C message send occurs.
-  virtual void CodeCompleteObjCMessageReceiver(Scope *S) { }
-  
-  /// \brief Code completion for an ObjC message expression that sends
-  /// a message to the superclass.
-  ///
-  /// 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 SuperLoc The location of the 'super' keyword.
-  /// \param SelIdents The identifiers that describe the selector (thus far).
-  /// \param NumSelIdents The number of identifiers in \p SelIdents.
-  virtual void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
-                                            IdentifierInfo **SelIdents,
-                                            unsigned NumSelIdents) { }
-
-  /// \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 Receiver The type of the class that is receiving a message.
-  /// \param SelIdents The identifiers that describe the selector (thus far).
-  /// \param NumSelIdents The number of identifiers in \p SelIdents.
-  virtual void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
-                                            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 the collection argument of an Objective-C
-  /// for-each statement.
-  ///
-  /// \param S The Scope in which the completion occurs.
-  ///
-  /// \param IterationBar The iteration variable declaration.
-  virtual void CodeCompleteObjCForCollection(Scope *S, 
-                                             DeclGroupPtrTy IterationVar) { }
-  
-  /// \brief Code completion for an Objective-C @selector expression, in which
-  /// we may have already parsed parts of the selector.
-  ///
-  /// \param S The scope in which the @selector expression occurs.
-  /// \param SelIdents The identifiers that describe the selector (thus far).
-  /// \param NumSelIdents The number of identifiers in \p SelIdents.
-  virtual void CodeCompleteObjCSelector(Scope *S,
-                                        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,
-                                          SourceLocation ClassNameLoc) {
-  }
-
-  /// \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,
-                                                 SourceLocation ClassNameLoc) {
-  }
-
-  /// \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,
-                                                  SourceLocation ClassNameLoc) {
-  }
-  
-  /// \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, 
-                                                  Decl *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,
-                                                  Decl *ObjCImpDecl) {
-  }
-
-  /// \brief Code completion for an Objective-C method declaration or
-  /// definition, which may occur within an interface, category,
-  /// extension, protocol, or implementation thereof (where applicable).
-  ///
-  /// This code completion action is invoked after the "-" or "+" that
-  /// starts a method declaration or definition, and after the return
-  /// type such a declaration (e.g., "- (id)").
-  ///
-  /// \param S The scope in which the completion occurs.
-  ///
-  /// \param IsInstanceMethod Whether this is an instance method
-  /// (introduced with '-'); otherwise, it's a class method
-  /// (introduced with '+').
-  ///
-  /// \param ReturnType If non-NULL, the specified return type of the method
-  /// being declared or defined.
-  ///
-  /// \param IDecl The interface, category, protocol, or
-  /// implementation, or category implementation in which this method
-  /// declaration or definition occurs.
-  virtual void CodeCompleteObjCMethodDecl(Scope *S, 
-                                          bool IsInstanceMethod,
-                                          ParsedType ReturnType,
-                                          Decl *IDecl) {
-  }
-  
-  /// \brief Code completion for a selector identifier or argument name within
-  /// an Objective-C method declaration.
-  ///
-  /// \param S The scope in which this code completion occurs.
-  ///
-  /// \param IsInstanceMethod Whether we are parsing an instance method (or, 
-  /// if false, a class method).
-  ///
-  /// \param AtParameterName Whether the actual code completion point is at the
-  /// argument name.
-  ///
-  /// \param ReturnType If non-NULL, the specified return type of the method
-  /// being declared or defined.
-  ///
-  /// \param SelIdents The identifiers that occurred in the selector for the
-  /// method declaration prior to the code completion point.
-  ///
-  /// \param NumSelIdents The number of identifiers provided by SelIdents.
-  virtual void CodeCompleteObjCMethodDeclSelector(Scope *S, 
-                                                  bool IsInstanceMethod,
-                                                  bool AtParameterName,
-                                                  ParsedType ReturnType,
-                                                  IdentifierInfo **SelIdents,
-                                                  unsigned NumSelIdents) { }
-  
-  /// \brief Code completion for a preprocessor directive.
-  ///
-  /// \brief InConditional Whether we're inside a preprocessor conditional.
-  virtual void CodeCompletePreprocessorDirective(bool InConditional) { 
-  }
-  
-  /// \brief Code completion while in an area of the translation unit that was
-  /// excluded due to preprocessor conditionals.
-  virtual void CodeCompleteInPreprocessorConditionalExclusion(Scope *S) { }
-  
-  /// \brief Code completion in the preprocessor where an already-defined
-  /// macro name is expected, e.g., an #ifdef or #undef.
-  ///
-  /// \param IsDefinition Whether this code completion for a macro name occurs
-  /// in a definition of the macro (#define) or in another use that already
-  /// expects that the macro is defined (e.g., #undef or #ifdef).
-  virtual void CodeCompletePreprocessorMacroName(bool IsDefinition) { 
-  }
-  
-  /// \brief Callback invoked when performing code completion in a preprocessor
-  /// expression, such as the condition of an #if or #elif directive.
-  virtual void CodeCompletePreprocessorExpression() { }
-  
-  /// \brief Callback invoked when performing code completion inside a 
-  /// function-like macro argument.
-  ///
-  /// \param S The scope in which this macro is being expanded.
-  ///
-  /// \param Macro The name of the macro that is going to be expanded.
-  ///
-  /// \param MacroInfo Information about the macro that is going to be
-  /// expanded.
-  ///
-  /// \param Argument The argument in which the code-completion token occurs.
-  virtual void CodeCompletePreprocessorMacroArgument(Scope *S,
-                                                     IdentifierInfo *Macro,
-                                                     MacroInfo *MacroInfo,
-                                                     unsigned Argument) { }
-  
-  /// \brief Callback invoked when performing code completion in a context where
-  /// we expect a natural language, e.g., inside a comment or string.
-  virtual void CodeCompleteNaturalLanguage() { }
-  //@}
-};
-
-/// 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 {
-  Decl *TheDecl;
-  SourceLocation Loc;
-  Action &Actions;
-  SourceManager &SM;
-  const char *Message;
-  
-public:
-  PrettyStackTraceActionsDecl(Decl *D, SourceLocation L,
-                              Action &actions, SourceManager &sm,
-                              const char *Msg)
-    : TheDecl(D), 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

Modified: cfe/trunk/include/clang/Sema/AttributeList.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/AttributeList.h?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/AttributeList.h (original)
+++ cfe/trunk/include/clang/Sema/AttributeList.h Thu Aug 26 18:41:50 2010
@@ -21,7 +21,6 @@
 
 namespace clang {
   class IdentifierInfo;
-  class Action;
   class Expr;
 
 /// AttributeList - Represents GCC's __attribute__ declaration. There are

Modified: cfe/trunk/include/clang/Sema/Designator.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Designator.h?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/Designator.h (original)
+++ cfe/trunk/include/clang/Sema/Designator.h Thu Aug 26 18:41:50 2010
@@ -15,10 +15,15 @@
 #ifndef LLVM_CLANG_SEMA_DESIGNATOR_H
 #define LLVM_CLANG_SEMA_DESIGNATOR_H
 
-#include "clang/Sema/Action.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace clang {
 
+class Expr;
+class IdentifierInfo;
+class Sema;
+
 /// Designator - A designator in a C99 designated initializer.
 ///
 /// This class is a discriminated union which holds the various
@@ -163,11 +168,11 @@
 
   /// ClearExprs - Null out any expression references, which prevents
   /// them from being 'delete'd later.
-  void ClearExprs(Action &Actions) {}
+  void ClearExprs(Sema &Actions) {}
 
   /// FreeExprs - Release any unclaimed memory for the expressions in
   /// this designator.
-  void FreeExprs(Action &Actions) {}
+  void FreeExprs(Sema &Actions) {}
 };
 
 
@@ -201,11 +206,11 @@
 
   /// ClearExprs - Null out any expression references, which prevents them from
   /// being 'delete'd later.
-  void ClearExprs(Action &Actions) {}
+  void ClearExprs(Sema &Actions) {}
 
   /// FreeExprs - Release any unclaimed memory for the expressions in this
   /// designation.
-  void FreeExprs(Action &Actions) {}
+  void FreeExprs(Sema &Actions) {}
 };
 
 } // end namespace clang

Modified: cfe/trunk/include/clang/Sema/Ownership.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Ownership.h?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/Ownership.h (original)
+++ cfe/trunk/include/clang/Sema/Ownership.h Thu Aug 26 18:41:50 2010
@@ -22,7 +22,6 @@
 //===----------------------------------------------------------------------===//
 
 namespace clang {
-  class Action;
   class Attr;
   class CXXBaseOrMemberInitializer;
   class CXXBaseSpecifier;
@@ -31,6 +30,7 @@
   class Expr;
   class NestedNameSpecifier;
   class QualType;
+  class Sema;
   class Stmt;
   class TemplateName;
   class TemplateParameterList;
@@ -307,8 +307,9 @@
 
   public:
     // Normal copying implicitly defined
-    explicit ASTMultiPtr(Action &) : Nodes(0), Count(0) {}
-    ASTMultiPtr(Action &, PtrTy *nodes, unsigned count)
+    ASTMultiPtr() : Nodes(0), Count(0) {}
+    explicit ASTMultiPtr(Sema &) : Nodes(0), Count(0) {}
+    ASTMultiPtr(Sema &, PtrTy *nodes, unsigned count)
       : Nodes(nodes), Count(count) {}
     // Fake mover in Parse/AstGuard.h needs this:
     ASTMultiPtr(PtrTy *nodes, unsigned count) : Nodes(nodes), Count(count) {}
@@ -331,7 +332,7 @@
     mutable unsigned Count;
 
   public:
-    ASTTemplateArgsPtr(Action &actions, ParsedTemplateArgument *args,
+    ASTTemplateArgsPtr(Sema &actions, ParsedTemplateArgument *args,
                        unsigned count) :
       Args(args), Count(count) { }
 
@@ -369,7 +370,7 @@
     ASTOwningVector &operator=(ASTOwningVector &); // do not implement
 
   public:
-    explicit ASTOwningVector(Action &Actions)
+    explicit ASTOwningVector(Sema &Actions)
     { }
 
     PtrTy *take() {
@@ -435,8 +436,18 @@
   inline Stmt *move(Stmt *S) { return S; }
 
   typedef ASTMultiPtr<Expr*> MultiExprArg;
+  typedef ASTMultiPtr<Stmt*> MultiStmtArg;
   typedef ASTMultiPtr<TemplateParameterList*> MultiTemplateParamsArg;
 
+  inline ExprResult ExprError() { return ExprResult(true); }
+  inline StmtResult StmtError() { return StmtResult(true); }
+
+  inline ExprResult ExprError(const DiagnosticBuilder&) { return ExprError(); }
+  inline StmtResult StmtError(const DiagnosticBuilder&) { return StmtError(); }
+
+  inline ExprResult ExprEmpty() { return ExprResult(false); }
+  inline StmtResult StmtEmpty() { return StmtResult(false); }
+
   inline Expr *AssertSuccess(ExprResult R) {
     assert(!R.isInvalid() && "operation was asserted to never fail!");
     return R.get();

Added: cfe/trunk/include/clang/Sema/PrettyDeclStackTrace.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/PrettyDeclStackTrace.h?rev=112244&view=auto
==============================================================================
--- cfe/trunk/include/clang/Sema/PrettyDeclStackTrace.h (added)
+++ cfe/trunk/include/clang/Sema/PrettyDeclStackTrace.h Thu Aug 26 18:41:50 2010
@@ -0,0 +1,46 @@
+//===- PrettyDeclStackTrace.h - Stack trace for decl processing -*- 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 an llvm::PrettyStackTraceEntry object for showing
+// that a particular declaration was being processed when a crash
+// occurred.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_SEMA_PRETTY_DECL_STACK_TRACE_H
+#define LLVM_CLANG_SEMA_PRETTY_DECL_STACK_TRACE_H
+
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/Support/PrettyStackTrace.h"
+
+namespace clang {
+
+class Decl;
+class Sema;
+class SourceManager;
+
+/// PrettyDeclStackTraceEntry - If a crash occurs in the parser while
+/// parsing something related to a declaration, include that
+/// declaration in the stack trace.
+class PrettyDeclStackTraceEntry : public llvm::PrettyStackTraceEntry {
+  Sema &S;
+  Decl *TheDecl;
+  SourceLocation Loc;
+  const char *Message;
+  
+public:
+  PrettyDeclStackTraceEntry(Sema &S, Decl *D, SourceLocation Loc, const char *Msg)
+    : S(S), TheDecl(D), Loc(Loc), Message(Msg) {}
+
+  virtual void print(llvm::raw_ostream &OS) const;
+};
+
+}
+
+#endif

Modified: cfe/trunk/include/clang/Sema/Sema.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Sema.h?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/Sema.h (original)
+++ cfe/trunk/include/clang/Sema/Sema.h Thu Aug 26 18:41:50 2010
@@ -15,13 +15,17 @@
 #ifndef LLVM_CLANG_SEMA_SEMA_H
 #define LLVM_CLANG_SEMA_SEMA_H
 
-#include "clang/Sema/Action.h"
+#include "clang/Sema/Ownership.h"
 #include "clang/Sema/AnalysisBasedWarnings.h"
 #include "clang/Sema/IdentifierResolver.h"
 #include "clang/Sema/ObjCMethodList.h"
+#include "clang/Sema/DeclSpec.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExternalASTSource.h"
+#include "clang/Basic/Specifiers.h"
+#include "clang/Basic/TemplateKinds.h"
+#include "clang/Basic/TypeTraits.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -39,6 +43,7 @@
   class ASTConsumer;
   class ASTContext;
   class ArrayType;
+  class AttributeList;
   class BlockDecl;
   class CXXBasePath;
   class CXXBasePaths;
@@ -49,6 +54,7 @@
   class CXXFieldCollector;
   class CXXMemberCallExpr;
   class CXXMethodDecl;
+  class CXXScopeSpec;
   class CXXTemporary;
   class CXXTryStmt;
   class CallExpr;
@@ -61,11 +67,11 @@
   class DeclAccessPair;
   class DeclContext;
   class DeclRefExpr;
-  class DeclSpec;
   class DeclaratorDecl;
   class DeducedTemplateArgument;
   class DependentDiagnostic;
   class DesignatedInitExpr;
+  class Designation;
   class EnumConstantDecl;
   class Expr;
   class ExtVectorType;
@@ -86,6 +92,7 @@
   class LangOptions;
   class LocalInstantiationScope;
   class LookupResult;
+  class MacroInfo;
   class MultiLevelTemplateArgumentList;
   class NamedDecl;
   class NonNullAttr;
@@ -122,6 +129,7 @@
   class TemplateTemplateParmDecl;
   class Token;
   class TypedefDecl;
+  class UnqualifiedId;
   class UnresolvedLookupExpr;
   class UnresolvedMemberExpr;
   class UnresolvedSetImpl;
@@ -139,7 +147,7 @@
   class DelayedDiagnostic;
   class FunctionScopeInfo;
   class TemplateDeductionInfo;
-}  
+}
 
 /// \brief Holds a QualType and a TypeSourceInfo* that came out of a declarator
 /// parsing.
@@ -176,11 +184,22 @@
 };
 
 /// Sema - This implements semantic analysis and AST building for C.
-class Sema : public Action {
+class Sema {
   Sema(const Sema&);           // DO NOT IMPLEMENT
   void operator=(const Sema&); // DO NOT IMPLEMENT
   mutable const TargetAttributesSema* TheTargetAttributesSema;
 public:
+  typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
+  typedef OpaquePtr<TemplateName> TemplateTy;
+  typedef OpaquePtr<QualType> TypeTy;
+  typedef Attr AttrTy;
+  typedef CXXBaseSpecifier BaseTy;
+  typedef CXXBaseOrMemberInitializer MemInitTy;
+  typedef Expr ExprTy;
+  typedef Stmt StmtTy;
+  typedef TemplateParameterList TemplateParamsTy;
+  typedef NestedNameSpecifier CXXScopeTy;
+
   const LangOptions &LangOpts;
   Preprocessor &PP;
   ASTContext &Context;
@@ -359,6 +378,29 @@
   typedef llvm::SmallVector<std::pair<SourceLocation, PartialDiagnostic>, 10>
     PotentiallyEmittedDiagnostics;
 
+  /// \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 Data structure used to record current or nested
   /// expression evaluation contexts.
   struct ExpressionEvaluationContextRecord {
@@ -494,8 +536,8 @@
   /// \brief Build a partial diagnostic.
   PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
 
-  virtual void DeleteExpr(ExprTy *E);
-  virtual void DeleteStmt(StmtTy *S);
+  virtual void DeleteExpr(Expr *E);
+  virtual void DeleteStmt(Stmt *S);
 
   ExprResult Owned(Expr* E) { return E; }
   ExprResult Owned(ExprResult R) { return R; }
@@ -537,7 +579,7 @@
   QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
                           Expr *ArraySize, unsigned Quals,
                           SourceRange Brackets, DeclarationName Entity);
-  QualType BuildExtVectorType(QualType T, ExprArg ArraySize,
+  QualType BuildExtVectorType(QualType T, Expr *ArraySize,
                               SourceLocation AttrLoc);
   QualType BuildFunctionType(QualType T,
                              QualType *ParamTypes, unsigned NumParamTypes,
@@ -598,10 +640,6 @@
   // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
   //
 
-  /// 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(Decl *D);
-
   DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr);
 
   void DiagnoseUseOfUnimplementedSelectors();
@@ -610,7 +648,7 @@
                                  Scope *S, CXXScopeSpec *SS = 0,
                                  bool isClassName = false,
                                  ParsedType ObjectType = ParsedType());
-  virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
+  virtual TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
   virtual bool DiagnoseUnknownTypeName(const IdentifierInfo &II,
                                        SourceLocation IILoc,
                                        Scope *S,
@@ -664,12 +702,12 @@
                               StorageClass SCAsWritten);
   virtual void ActOnParamDefaultArgument(Decl *param,
                                          SourceLocation EqualLoc,
-                                         ExprArg defarg);
+                                         Expr *defarg);
   virtual void ActOnParamUnparsedDefaultArgument(Decl *param,
                                                  SourceLocation EqualLoc,
                                                  SourceLocation ArgLoc);
   virtual void ActOnParamDefaultArgumentError(Decl *param);
-  bool SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
+  bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
                                SourceLocation EqualLoc);
 
 
@@ -677,8 +715,8 @@
   // argument locations.
   llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs;
 
-  virtual void AddInitializerToDecl(Decl *dcl, ExprArg init);
-  void AddInitializerToDecl(Decl *dcl, ExprArg init, bool DirectInit);
+  virtual void AddInitializerToDecl(Decl *dcl, Expr *init);
+  void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
   void ActOnUninitializedDecl(Decl *dcl, bool TypeContainsUndeducedAuto);
   virtual void ActOnInitializerError(Decl *Dcl);
   virtual void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
@@ -691,8 +729,8 @@
   virtual Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D);
   virtual void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
 
-  virtual Decl *ActOnFinishFunctionBody(Decl *Decl, StmtArg Body);
-  Decl *ActOnFinishFunctionBody(Decl *Decl, StmtArg Body,
+  virtual Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
+  Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body,
                                     bool IsInstantiation);
 
   /// \brief Diagnose any unused parameters in the given sequence of
@@ -701,7 +739,7 @@
                                 ParmVarDecl * const *End);
 
   void DiagnoseInvalidJumps(Stmt *Body);
-  virtual Decl *ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
+  virtual Decl *ActOnFileScopeAsmDecl(SourceLocation Loc, Expr *expr);
 
   /// Scope actions.
   virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
@@ -721,6 +759,13 @@
                                     SourceLocation NewTagLoc,
                                     const IdentifierInfo &Name);
 
+  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;'
+  };
+
   virtual Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                              SourceLocation KWLoc, CXXScopeSpec &SS,
                              IdentifierInfo *Name, SourceLocation NameLoc,
@@ -741,7 +786,7 @@
                          llvm::SmallVectorImpl<Decl *> &Decls);
   virtual Decl *ActOnField(Scope *S, Decl *TagD,
                                SourceLocation DeclStart,
-                               Declarator &D, ExprTy *BitfieldWidth);
+                               Declarator &D, Expr *BitfieldWidth);
 
   FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
                          Declarator &D, Expr *BitfieldWidth,
@@ -769,7 +814,7 @@
                          llvm::SmallVectorImpl<Decl *> &AllIvarDecls);
   virtual Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
                               Decl *IntfDecl,
-                              Declarator &D, ExprTy *BitfieldWidth,
+                              Declarator &D, Expr *BitfieldWidth,
                               tok::ObjCKeywordKind visibility);
 
   // This is used for both record definitions and ObjC interface declarations.
@@ -803,12 +848,12 @@
                                       EnumConstantDecl *LastEnumConst,
                                       SourceLocation IdLoc,
                                       IdentifierInfo *Id,
-                                      ExprArg val);
+                                      Expr *val);
 
   virtual Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl,
                                       Decl *LastEnumConstant,
                                       SourceLocation IdLoc, IdentifierInfo *Id,
-                                      SourceLocation EqualLoc, ExprTy *Val);
+                                      SourceLocation EqualLoc, Expr *Val);
   virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
                              SourceLocation RBraceLoc, Decl *EnumDecl,
                              Decl **Elements, unsigned NumElements,
@@ -941,7 +986,7 @@
   bool PerformContextuallyConvertToObjCId(Expr *&From);
 
   ExprResult 
-  ConvertToIntegralOrEnumerationType(SourceLocation Loc, ExprArg FromE,
+  ConvertToIntegralOrEnumerationType(SourceLocation Loc, Expr *FromE,
                                      const PartialDiagnostic &NotIntDiag,
                                      const PartialDiagnostic &IncompleteDiag,
                                      const PartialDiagnostic &ExplicitConvDiag,
@@ -1066,7 +1111,7 @@
   ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
                                            unsigned Opc,
                                            const UnresolvedSetImpl &Fns,
-                                           ExprArg input);
+                                           Expr *input);
 
   ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
                                          unsigned Opc,
@@ -1075,7 +1120,7 @@
 
   ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
                                                       SourceLocation RLoc,
-                                                      ExprArg Base,ExprArg Idx);
+                                                      Expr *Base,Expr *Idx);
 
   ExprResult
   BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
@@ -1088,7 +1133,7 @@
                                SourceLocation *CommaLocs,
                                SourceLocation RParenLoc);
 
-  ExprResult BuildOverloadedArrowExpr(Scope *S, ExprArg Base,
+  ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
                                             SourceLocation OpLoc);
 
   /// CheckCallReturnType - Checks that a call expression's return type is
@@ -1440,85 +1485,118 @@
   //===--------------------------------------------------------------------===//
   // Statement Parsing Callbacks: SemaStmt.cpp.
 public:
+  class FullExprArg {
+  public:
+    FullExprArg(Sema &actions) : E(0) { }
+                
+    // 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): E(Other.E) {}
+
+    ExprResult release() {
+      return move(E);
+    }
+
+    Expr *get() const { return E; }
+
+    Expr *operator->() {
+      return E;
+    }
+
+  private:
+    // FIXME: No need to make the entire Sema class a friend when it's just
+    // Sema::FullExpr that needs access to the constructor below.
+    friend class Sema;
+
+    explicit FullExprArg(Expr *expr) : E(expr) {}
+
+    Expr *E;
+  };
+
+  FullExprArg MakeFullExpr(Expr *Arg) {
+    return FullExprArg(ActOnFinishFullExpr(Arg).release());
+  }
+
   virtual StmtResult ActOnExprStmt(FullExprArg Expr);
 
   virtual StmtResult ActOnNullStmt(SourceLocation SemiLoc);
   virtual StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
-                                             MultiStmtArg Elts,
-                                             bool isStmtExpr);
+                                       MultiStmtArg Elts,
+                                       bool isStmtExpr);
   virtual StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
-                                         SourceLocation StartLoc,
-                                         SourceLocation EndLoc);
+                                   SourceLocation StartLoc,
+                                   SourceLocation EndLoc);
   virtual void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
-  virtual StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
-                                    SourceLocation DotDotDotLoc, ExprArg RHSVal,
-                                    SourceLocation ColonLoc);
-  virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
+  virtual StmtResult ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
+                                   SourceLocation DotDotDotLoc, Expr *RHSVal,
+                                   SourceLocation ColonLoc);
+  virtual void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
 
   virtual StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
-                                            SourceLocation ColonLoc,
-                                            StmtArg SubStmt, Scope *CurScope);
+                                      SourceLocation ColonLoc,
+                                      Stmt *SubStmt, Scope *CurScope);
   virtual StmtResult ActOnLabelStmt(SourceLocation IdentLoc,
-                                          IdentifierInfo *II,
-                                          SourceLocation ColonLoc,
-                                          StmtArg SubStmt);
+                                    IdentifierInfo *II,
+                                    SourceLocation ColonLoc,
+                                    Stmt *SubStmt);
   virtual StmtResult ActOnIfStmt(SourceLocation IfLoc,
-                                       FullExprArg CondVal, Decl *CondVar,
-                                       StmtArg ThenVal,
-                                       SourceLocation ElseLoc, StmtArg ElseVal);
+                                 FullExprArg CondVal, Decl *CondVar,
+                                 Stmt *ThenVal,
+                                 SourceLocation ElseLoc, Stmt *ElseVal);
   virtual StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
-                                                  ExprArg Cond,
-                                                  Decl *CondVar);
+                                            Expr *Cond,
+                                            Decl *CondVar);
   virtual StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
-                                                 StmtArg Switch, StmtArg Body);
+                                           Stmt *Switch, Stmt *Body);
   virtual StmtResult ActOnWhileStmt(SourceLocation WhileLoc,
-                                          FullExprArg Cond,
-                                          Decl *CondVar, StmtArg Body);
-  virtual StmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
-                                       SourceLocation WhileLoc,
-                                       SourceLocation CondLParen, ExprArg Cond,
-                                       SourceLocation CondRParen);
+                                    FullExprArg Cond,
+                                    Decl *CondVar, Stmt *Body);
+  virtual StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
+                                 SourceLocation WhileLoc,
+                                 SourceLocation CondLParen, Expr *Cond,
+                                 SourceLocation CondRParen);
 
   virtual StmtResult ActOnForStmt(SourceLocation ForLoc,
-                                        SourceLocation LParenLoc,
-                                        StmtArg First, FullExprArg Second,
-                                        Decl *SecondVar,
-                                        FullExprArg Third,
-                                        SourceLocation RParenLoc,
-                                        StmtArg Body);
+                                  SourceLocation LParenLoc,
+                                  Stmt *First, FullExprArg Second,
+                                  Decl *SecondVar,
+                                  FullExprArg Third,
+                                  SourceLocation RParenLoc,
+                                  Stmt *Body);
   virtual StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
                                        SourceLocation LParenLoc,
-                                       StmtArg First, ExprArg Second,
-                                       SourceLocation RParenLoc, StmtArg Body);
+                                       Stmt *First, Expr *Second,
+                                       SourceLocation RParenLoc, Stmt *Body);
 
   virtual StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
-                                         SourceLocation LabelLoc,
-                                         IdentifierInfo *LabelII);
+                                   SourceLocation LabelLoc,
+                                   IdentifierInfo *LabelII);
   virtual StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
-                                                 SourceLocation StarLoc,
-                                                 ExprArg DestExp);
+                                           SourceLocation StarLoc,
+                                           Expr *DestExp);
   virtual StmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
-                                             Scope *CurScope);
+                                       Scope *CurScope);
   virtual StmtResult ActOnBreakStmt(SourceLocation GotoLoc,
-                                          Scope *CurScope);
+                                    Scope *CurScope);
 
   virtual StmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
-                                           ExprArg RetValExp);
+                                     Expr *RetValExp);
   StmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
-                                        Expr *RetValExp);
+                                  Expr *RetValExp);
 
   virtual StmtResult 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);
+                                  bool IsSimple,
+                                  bool IsVolatile,
+                                  unsigned NumOutputs,
+                                  unsigned NumInputs,
+                                  IdentifierInfo **Names,
+                                  MultiExprArg Constraints,
+                                  MultiExprArg Exprs,
+                                  Expr *AsmString,
+                                  MultiExprArg Clobbers,
+                                  SourceLocation RParenLoc,
+                                  bool MSAsm = false);
 
 
   VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
@@ -1528,25 +1606,25 @@
   virtual Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
 
   virtual StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
-                                                SourceLocation RParen,
-                                                Decl *Parm, StmtArg Body);
+                                          SourceLocation RParen,
+                                          Decl *Parm, Stmt *Body);
 
   virtual StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
-                                                  StmtArg Body);
+                                            Stmt *Body);
 
   virtual StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
-                                              StmtArg Try,
-                                              MultiStmtArg Catch,
-                                              StmtArg Finally);
+                                        Stmt *Try,
+                                        MultiStmtArg Catch,
+                                        Stmt *Finally);
 
   virtual StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc,
-                                                ExprArg Throw);
+                                          Expr *Throw);
   virtual StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
-                                                ExprArg Throw,
-                                                Scope *CurScope);
+                                          Expr *Throw,
+                                          Scope *CurScope);
   virtual StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
-                                                       ExprArg SynchExpr,
-                                                       StmtArg SynchBody);
+                                                 Expr *SynchExpr,
+                                                 Stmt *SynchBody);
 
   VarDecl *BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
                                      TypeSourceInfo *TInfo,
@@ -1556,11 +1634,11 @@
   virtual Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);
 
   virtual StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
-                                              Decl *ExDecl,
-                                              StmtArg HandlerBlock);
+                                        Decl *ExDecl,
+                                        Stmt *HandlerBlock);
   virtual StmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
-                                            StmtArg TryBlock,
-                                            MultiStmtArg Handlers);
+                                      Stmt *TryBlock,
+                                      MultiStmtArg Handlers);
   void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
 
   bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
@@ -1574,6 +1652,8 @@
   void DiagnoseUnusedExprResult(const Stmt *S);
   void DiagnoseUnusedDecl(const NamedDecl *ND);
   
+  typedef uintptr_t ParsingDeclStackState;
+
   ParsingDeclStackState PushParsingDeclaration();
   void PopParsingDeclaration(ParsingDeclStackState S, Decl *D);
   void EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc);
@@ -1600,7 +1680,7 @@
   bool DiagRuntimeBehavior(SourceLocation Loc, const PartialDiagnostic &PD);
 
   // Primary Expressions.
-  virtual SourceRange getExprRange(ExprTy *E) const;
+  virtual SourceRange getExprRange(Expr *E) const;
 
   virtual ExprResult ActOnIdExpression(Scope *S,
                                              CXXScopeSpec &SS,
@@ -1663,7 +1743,7 @@
   virtual ExprResult ActOnNumericConstant(const Token &);
   virtual ExprResult ActOnCharacterConstant(const Token &);
   virtual ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
-                                          ExprArg Val);
+                                          Expr *Val);
   virtual ExprResult ActOnParenOrParenListExpr(SourceLocation L,
                                                      SourceLocation R,
                                                      MultiExprArg Val,
@@ -1680,9 +1760,9 @@
                                   unsigned OpcIn,
                                   Expr *InputArg);
   ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
-                          UnaryOperatorKind Opc, ExprArg input);
+                          UnaryOperatorKind Opc, Expr *input);
   virtual ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
-                                  tok::TokenKind Op, ExprArg Input);
+                                  tok::TokenKind Op, Expr *Input);
 
   ExprResult CreateSizeOfAlignOfExpr(TypeSourceInfo *T,
                                      SourceLocation OpLoc,
@@ -1699,18 +1779,18 @@
 
   virtual ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
                                                tok::TokenKind Kind,
-                                               ExprArg Input);
+                                               Expr *Input);
 
-  virtual ExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
+  virtual ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base,
                                                    SourceLocation LLoc,
-                                                   ExprArg Idx,
+                                                   Expr *Idx,
                                                    SourceLocation RLoc);
-  ExprResult CreateBuiltinArraySubscriptExpr(ExprArg Base,
+  ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base,
                                                    SourceLocation LLoc,
-                                                   ExprArg Idx,
+                                                   Expr *Idx,
                                                    SourceLocation RLoc);
 
-  ExprResult BuildMemberReferenceExpr(ExprArg Base,
+  ExprResult BuildMemberReferenceExpr(Expr *Base,
                                             QualType BaseType,
                                             SourceLocation OpLoc,
                                             bool IsArrow,
@@ -1719,7 +1799,7 @@
                                 const DeclarationNameInfo &NameInfo,
                                 const TemplateArgumentListInfo *TemplateArgs);
 
-  ExprResult BuildMemberReferenceExpr(ExprArg Base,
+  ExprResult BuildMemberReferenceExpr(Expr *Base,
                                             QualType BaseType,
                                             SourceLocation OpLoc, bool IsArrow,
                                             const CXXScopeSpec &SS,
@@ -1738,7 +1818,7 @@
                                      const CXXScopeSpec &SS,
                                      const LookupResult &R);
 
-  ExprResult ActOnDependentMemberExpr(ExprArg Base,
+  ExprResult ActOnDependentMemberExpr(Expr *Base,
                                             QualType BaseType,
                                             bool IsArrow,
                                             SourceLocation OpLoc,
@@ -1747,7 +1827,7 @@
                                const DeclarationNameInfo &NameInfo,
                                const TemplateArgumentListInfo *TemplateArgs);
 
-  virtual ExprResult ActOnMemberAccessExpr(Scope *S, ExprArg Base,
+  virtual ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
                                                  SourceLocation OpLoc,
                                                  tok::TokenKind OpKind,
                                                  CXXScopeSpec &SS,
@@ -1765,7 +1845,7 @@
   /// 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.
-  virtual ExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
+  virtual ExprResult ActOnCallExpr(Scope *S, Expr *Fn,
                                          SourceLocation LParenLoc,
                                          MultiExprArg Args,
                                          SourceLocation *CommaLocs,
@@ -1778,11 +1858,11 @@
 
   virtual ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
                                          ParsedType Ty, SourceLocation RParenLoc,
-                                         ExprArg Op);
+                                         Expr *Op);
   ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
                                        TypeSourceInfo *Ty,
                                        SourceLocation RParenLoc,
-                                       ExprArg Op);
+                                       Expr *Op);
 
   virtual bool TypeIsVectorType(ParsedType Ty) {
     return GetTypeFromParser(Ty)->isVectorType();
@@ -1790,31 +1870,31 @@
 
   ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
   ExprResult ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc,
-                                            SourceLocation RParenLoc, ExprArg E,
+                                            SourceLocation RParenLoc, Expr *E,
                                             TypeSourceInfo *TInfo);
 
   virtual ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
                                                 ParsedType Ty,
                                                 SourceLocation RParenLoc,
-                                                ExprArg Op);
+                                                Expr *Op);
 
   ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
                                             TypeSourceInfo *TInfo,
                                             SourceLocation RParenLoc,
-                                            ExprArg InitExpr);
+                                            Expr *InitExpr);
 
   virtual ExprResult ActOnInitList(SourceLocation LParenLoc,
                                          MultiExprArg InitList,
                                          SourceLocation RParenLoc);
 
   virtual ExprResult ActOnDesignatedInitializer(Designation &Desig,
-                                                      SourceLocation Loc,
-                                                      bool GNUSyntax,
-                                                      ExprResult Init);
+                                                SourceLocation Loc,
+                                                bool GNUSyntax,
+                                                ExprResult Init);
 
   virtual ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
                                 tok::TokenKind Kind,
-                                ExprArg LHS, ExprArg RHS);
+                                Expr *LHS, Expr *RHS);
   ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
                         BinaryOperatorKind Opc,
                         Expr *lhs, Expr *rhs);
@@ -1825,17 +1905,27 @@
   /// in the case of a the GNU conditional expr extension.
   virtual ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
                                         SourceLocation ColonLoc,
-                                        ExprArg Cond, ExprArg LHS,
-                                        ExprArg RHS);
+                                        Expr *Cond, Expr *LHS,
+                                        Expr *RHS);
 
   /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
   virtual ExprResult ActOnAddrLabel(SourceLocation OpLoc,
                                     SourceLocation LabLoc,
                                     IdentifierInfo *LabelII);
 
-  virtual ExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
+  virtual ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
                                    SourceLocation RPLoc); // "({..})"
 
+  // __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;
+  };
+
   /// __builtin_offsetof(type, a.b[123][456].c)
   ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
                                   TypeSourceInfo *TInfo,
@@ -1867,10 +1957,10 @@
 
   // __builtin_va_arg(expr, type)
   virtual ExprResult ActOnVAArg(SourceLocation BuiltinLoc,
-                                      ExprArg expr, ParsedType type,
+                                      Expr *expr, ParsedType type,
                                       SourceLocation RPLoc);
   ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc,
-                                  ExprArg expr, TypeSourceInfo *TInfo,
+                                  Expr *expr, TypeSourceInfo *TInfo,
                                   SourceLocation RPLoc);
 
   // __null
@@ -1893,7 +1983,7 @@
   /// ActOnBlockStmtExpr - This is called when the body of a block statement
   /// literal was successfully completed.  ^(int x){...}
   virtual ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
-                                              StmtArg Body, Scope *CurScope);
+                                        Stmt *Body, Scope *CurScope);
 
   //===---------------------------- C++ Features --------------------------===//
 
@@ -2089,13 +2179,13 @@
                                              ParsedType Ty,
                                              SourceLocation RAngleBracketLoc,
                                              SourceLocation LParenLoc,
-                                             ExprArg E,
+                                             Expr *E,
                                              SourceLocation RParenLoc);
 
   ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
                                      tok::TokenKind Kind,
                                      TypeSourceInfo *Ty,
-                                     ExprArg E,
+                                     Expr *E,
                                      SourceRange AngleBrackets,
                                      SourceRange Parens);
 
@@ -2105,7 +2195,7 @@
                                   SourceLocation RParenLoc);
   ExprResult BuildCXXTypeId(QualType TypeInfoType,
                                   SourceLocation TypeidLoc,
-                                  ExprArg Operand,
+                                  Expr *Operand,
                                   SourceLocation RParenLoc);
 
   /// ActOnCXXTypeid - Parse typeid( something ).
@@ -2126,7 +2216,7 @@
 
   //// ActOnCXXThrow -  Parse throw expressions.
   virtual ExprResult ActOnCXXThrow(SourceLocation OpLoc,
-                                         ExprArg expr);
+                                         Expr *expr);
   bool CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E);
 
   /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
@@ -2157,7 +2247,7 @@
                                QualType AllocType,
                                SourceLocation TypeLoc,
                                SourceRange TypeRange,
-                               ExprArg ArraySize,
+                               Expr *ArraySize,
                                SourceLocation ConstructorLParen,
                                MultiExprArg ConstructorArgs,
                                SourceLocation ConstructorRParen);
@@ -2184,7 +2274,7 @@
   /// ActOnCXXDelete - Parsed a C++ 'delete' expression
   virtual ExprResult ActOnCXXDelete(SourceLocation StartLoc,
                                           bool UseGlobal, bool ArrayForm,
-                                          ExprArg Operand);
+                                          Expr *Operand);
 
   virtual DeclResult ActOnCXXConditionDeclaration(Scope *S,
                                                   Declarator &D);
@@ -2201,16 +2291,16 @@
                                                SourceLocation RParen);
 
   virtual ExprResult ActOnStartCXXMemberReference(Scope *S,
-                                                        ExprArg Base,
+                                                        Expr *Base,
                                                         SourceLocation OpLoc,
                                                         tok::TokenKind OpKind,
                                                         ParsedType &ObjectType,
                                                    bool &MayBePseudoDestructor);
 
   ExprResult DiagnoseDtorReference(SourceLocation NameLoc,
-                                         ExprArg MemExpr);
+                                         Expr *MemExpr);
 
-  ExprResult BuildPseudoDestructorExpr(ExprArg Base,
+  ExprResult BuildPseudoDestructorExpr(Expr *Base,
                                              SourceLocation OpLoc,
                                              tok::TokenKind OpKind,
                                              const CXXScopeSpec &SS,
@@ -2220,7 +2310,7 @@
                                      PseudoDestructorTypeStorage DestroyedType,
                                              bool HasTrailingLParen);
 
-  virtual ExprResult ActOnPseudoDestructorExpr(Scope *S, ExprArg Base,
+  virtual ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
                                                      SourceLocation OpLoc,
                                                      tok::TokenKind OpKind,
                                                      CXXScopeSpec &SS,
@@ -2237,7 +2327,7 @@
   ExprResult MaybeCreateCXXExprWithTemporaries(ExprResult SubExpr);
   FullExpr CreateFullExpr(Expr *SubExpr);
 
-  virtual ExprResult ActOnFinishFullExpr(ExprArg Expr);
+  virtual ExprResult ActOnFinishFullExpr(Expr *Expr);
 
   // Marks SS invalid if it represents an incomplete type.
   bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
@@ -2251,8 +2341,8 @@
 
   /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
   /// global scope ('::').
-  virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
-                                                   SourceLocation CCLoc);
+  virtual NestedNameSpecifier *
+  ActOnCXXGlobalScopeSpecifier(Scope *S, SourceLocation CCLoc);
 
   bool isAcceptableNestedNameSpecifier(NamedDecl *SD);
   NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
@@ -2262,23 +2352,23 @@
                                             IdentifierInfo &II,
                                             ParsedType ObjectType);
 
-  CXXScopeTy *BuildCXXNestedNameSpecifier(Scope *S,
-                                          CXXScopeSpec &SS,
-                                          SourceLocation IdLoc,
-                                          SourceLocation CCLoc,
-                                          IdentifierInfo &II,
-                                          QualType ObjectType,
-                                          NamedDecl *ScopeLookupResult,
-                                          bool EnteringContext,
-                                          bool ErrorRecoveryLookup);
-
-  virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
-                                                  CXXScopeSpec &SS,
-                                                  SourceLocation IdLoc,
-                                                  SourceLocation CCLoc,
-                                                  IdentifierInfo &II,
-                                                  ParsedType ObjectType,
-                                                  bool EnteringContext);
+  NestedNameSpecifier *BuildCXXNestedNameSpecifier(Scope *S,
+                                                   CXXScopeSpec &SS,
+                                                   SourceLocation IdLoc,
+                                                   SourceLocation CCLoc,
+                                                   IdentifierInfo &II,
+                                                   QualType ObjectType,
+                                                   NamedDecl *ScopeLookupResult,
+                                                   bool EnteringContext,
+                                                   bool ErrorRecoveryLookup);
+
+  virtual NestedNameSpecifier *ActOnCXXNestedNameSpecifier(Scope *S,
+                                                           CXXScopeSpec &SS,
+                                                           SourceLocation IdLoc,
+                                                           SourceLocation CCLoc,
+                                                           IdentifierInfo &II,
+                                                          ParsedType ObjectType,
+                                                          bool EnteringContext);
 
   virtual bool IsInvalidUnlessNestedName(Scope *S,
                                          CXXScopeSpec &SS,
@@ -2330,7 +2420,7 @@
 
   // ParseObjCStringLiteral - Parse Objective-C string literals.
   virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
-                                            ExprTy **Strings,
+                                            Expr **Strings,
                                             unsigned NumStrings);
 
   Expr *BuildObjCEncodeExpression(SourceLocation AtLoc,
@@ -2386,8 +2476,8 @@
   virtual Decl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
                                              Declarator &D,
                                  MultiTemplateParamsArg TemplateParameterLists,
-                                             ExprTy *BitfieldWidth,
-                                             ExprTy *Init, bool IsDefinition,
+                                             Expr *BitfieldWidth,
+                                             Expr *Init, bool IsDefinition,
                                              bool Deleted = false);
 
   virtual MemInitResult ActOnMemInitializer(Decl *ConstructorD,
@@ -2397,7 +2487,7 @@
                                             ParsedType TemplateTypeTy,
                                             SourceLocation IdLoc,
                                             SourceLocation LParenLoc,
-                                            ExprTy **Args, unsigned NumArgs,
+                                            Expr **Args, unsigned NumArgs,
                                             SourceLocation *CommaLocs,
                                             SourceLocation RParenLoc);
 
@@ -2485,8 +2575,8 @@
                                                     Decl *Record);
 
   virtual Decl *ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
-                                                 ExprArg AssertExpr,
-                                                 ExprArg AssertMessageExpr);
+                                                 Expr *AssertExpr,
+                                                 Expr *AssertMessageExpr);
 
   FriendDecl *CheckFriendTypeDecl(SourceLocation FriendLoc,
                                   TypeSourceInfo *TSInfo);
@@ -2696,7 +2786,7 @@
                                                   unsigned Depth,
                                                   unsigned Position,
                                                   SourceLocation EqualLoc,
-                                                  ExprArg DefaultArg);
+                                                  Expr *DefaultArg);
   virtual Decl *ActOnTemplateTemplateParameter(Scope *S,
                                                    SourceLocation TmpLoc,
                                                    TemplateParamsTy *Params,
@@ -2758,7 +2848,7 @@
 
   virtual TypeResult ActOnTagTemplateIdType(TypeResult Type,
                                             TagUseKind TUK,
-                                            DeclSpec::TST TagSpec,
+                                            TypeSpecifierType TagSpec,
                                             SourceLocation TagLoc);
 
   ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
@@ -3643,6 +3733,18 @@
                                           IdentifierInfo *PropertyId,
                                           IdentifierInfo *PropertyIvar);
 
+  struct ObjCArgInfo {
+    IdentifierInfo *Name;
+    SourceLocation NameLoc;
+    // The Type is null if no type was specified, and the DeclSpec is invalid
+    // in this case.
+    ParsedType Type;
+    ObjCDeclSpec DeclSpec;
+
+    /// ArgAttrs - Attribute list for this argument.
+    AttributeList *ArgAttrs;
+  };
+
   virtual Decl *ActOnMethodDeclaration(
     SourceLocation BeginLoc, // location of the + or -.
     SourceLocation EndLoc,   // location of the ; or {.
@@ -3677,6 +3779,18 @@
                             SourceLocation receiverNameLoc,
                             SourceLocation propertyNameLoc);
 
+  /// \brief Describes the kind of message expression indicated by a message
+  /// send that starts with an identifier.
+  enum ObjCMessageKind {
+    /// \brief The message is sent to 'super'.
+    ObjCSuperMessage,
+    /// \brief The message is an instance message.
+    ObjCInstanceMessage,
+    /// \brief The message is a class message, and the identifier is a type
+    /// name.
+    ObjCClassMessage
+  };
+  
   virtual ObjCMessageKind getObjCMessageKind(Scope *S,
                                              IdentifierInfo *Name,
                                              SourceLocation NameLoc,
@@ -3708,7 +3822,7 @@
                                              SourceLocation RBracLoc,
                                              MultiExprArg Args);
 
-  ExprResult BuildInstanceMessage(ExprArg Receiver,
+  ExprResult BuildInstanceMessage(Expr *Receiver,
                                         QualType ReceiverType,
                                         SourceLocation SuperLoc,
                                         Selector Sel,
@@ -3718,7 +3832,7 @@
                                         MultiExprArg Args);
 
   virtual ExprResult ActOnInstanceMessage(Scope *S,
-                                                ExprArg Receiver,
+                                                Expr *Receiver,
                                                 Selector Sel,
                                                 SourceLocation LBracLoc,
                                                 SourceLocation SelectorLoc,
@@ -3726,15 +3840,31 @@
                                                 MultiExprArg Args);
 
 
+  enum PragmaOptionsAlignKind {
+    POAK_Native,  // #pragma options align=native
+    POAK_Natural, // #pragma options align=natural
+    POAK_Packed,  // #pragma options align=packed
+    POAK_Power,   // #pragma options align=power
+    POAK_Mac68k,  // #pragma options align=mac68k
+    POAK_Reset    // #pragma options align=reset
+  };
+
   /// ActOnPragmaOptionsAlign - Called on well formed #pragma options align.
   virtual void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
                                        SourceLocation PragmaLoc,
                                        SourceLocation KindLoc);
 
+  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,
+                               Expr *Alignment,
                                SourceLocation PragmaLoc,
                                SourceLocation LParenLoc,
                                SourceLocation RParenLoc);
@@ -4111,7 +4241,7 @@
   bool CheckBooleanCondition(Expr *&CondExpr, SourceLocation Loc);
 
   virtual ExprResult ActOnBooleanCondition(Scope *S, SourceLocation Loc,
-                                                 ExprArg SubExpr);
+                                           Expr *SubExpr);
   
   /// DiagnoseAssignmentAsCondition - Given that an expression is
   /// being used as a boolean condition, warn if it's an assignment.
@@ -4149,6 +4279,46 @@
 
   /// \name Code completion
   //@{
+  /// \brief Describes the context in which code completion occurs.
+  enum ParserCompletionContext {
+    /// \brief Code completion occurs at top-level or namespace context.
+    PCC_Namespace,
+    /// \brief Code completion occurs within a class, struct, or union.
+    PCC_Class,
+    /// \brief Code completion occurs within an Objective-C interface, protocol,
+    /// or category.
+    PCC_ObjCInterface,
+    /// \brief Code completion occurs within an Objective-C implementation or
+    /// category implementation
+    PCC_ObjCImplementation,
+    /// \brief Code completion occurs within the list of instance variables
+    /// in an Objective-C interface, protocol, category, or implementation.
+    PCC_ObjCInstanceVariableList,
+    /// \brief Code completion occurs following one or more template
+    /// headers.
+    PCC_Template,
+    /// \brief Code completion occurs following one or more template
+    /// headers within a class.
+    PCC_MemberTemplate,
+    /// \brief Code completion occurs within an expression.
+    PCC_Expression,
+    /// \brief Code completion occurs within a statement, which may
+    /// also be an expression or a declaration.
+    PCC_Statement,
+    /// \brief Code completion occurs at the beginning of the
+    /// initialization statement (or expression) in a for loop.
+    PCC_ForInit,
+    /// \brief Code completion occurs within the condition of an if,
+    /// while, switch, or for statement.
+    PCC_Condition,
+    /// \brief Code completion occurs within the body of a function on a 
+    /// recovery path, where we do not have a specific handle on our position
+    /// in the grammar.
+    PCC_RecoveryInFunction,
+    /// \brief Code completion occurs where only a type is permitted.
+    PCC_Type
+  };
+
   virtual void CodeCompleteOrdinaryName(Scope *S,
                                      ParserCompletionContext CompletionContext);
   virtual void CodeCompleteDeclarator(Scope *S,
@@ -4158,16 +4328,16 @@
   struct CodeCompleteExpressionData;
   virtual void CodeCompleteExpression(Scope *S, 
                                       const CodeCompleteExpressionData &Data);
-  virtual void CodeCompleteMemberReferenceExpr(Scope *S, ExprTy *Base,
+  virtual void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
                                                SourceLocation OpLoc,
                                                bool IsArrow);
   virtual void CodeCompleteTag(Scope *S, unsigned TagSpec);
   virtual void CodeCompleteCase(Scope *S);
-  virtual void CodeCompleteCall(Scope *S, ExprTy *Fn,
-                                ExprTy **Args, unsigned NumArgs);
+  virtual void CodeCompleteCall(Scope *S, Expr *Fn,
+                                Expr **Args, unsigned NumArgs);
   virtual void CodeCompleteInitializer(Scope *S, Decl *D);
   virtual void CodeCompleteReturn(Scope *S);
-  virtual void CodeCompleteAssignmentRHS(Scope *S, ExprTy *LHS);
+  virtual void CodeCompleteAssignmentRHS(Scope *S, Expr *LHS);
   
   virtual void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
                                        bool EnteringContext);
@@ -4197,7 +4367,7 @@
   virtual void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
                                             IdentifierInfo **SelIdents,
                                             unsigned NumSelIdents);
-  virtual void CodeCompleteObjCInstanceMessage(Scope *S, ExprTy *Receiver,
+  virtual void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
                                                IdentifierInfo **SelIdents,
                                                unsigned NumSelIdents);
   virtual void CodeCompleteObjCForCollection(Scope *S, 
@@ -4247,6 +4417,8 @@
                   llvm::SmallVectorImpl<CodeCompletionResult> &Results);
   //@}
 
+  void PrintStats() const {}
+
   //===--------------------------------------------------------------------===//
   // Extra semantic analysis beyond the C type system
 
@@ -4302,6 +4474,33 @@
                             SourceLocation ReturnLoc);
   void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
   void CheckImplicitConversions(Expr *E);
+
+  /// \brief The parser's current scope.
+  ///
+  /// The parser maintains this state here.
+  Scope *CurScope;
+  
+protected:
+  friend class Parser;
+  
+  /// \brief Retrieve the parser's current scope.
+  Scope *getCurScope() const { return CurScope; }  
+};
+
+/// \brief RAII object that enters a new expression evaluation context.
+class EnterExpressionEvaluationContext {
+  Sema &Actions;
+
+public:
+  EnterExpressionEvaluationContext(Sema &Actions,
+                                   Sema::ExpressionEvaluationContext NewContext)
+    : Actions(Actions) {
+    Actions.PushExpressionEvaluationContext(NewContext);
+  }
+
+  ~EnterExpressionEvaluationContext() {
+    Actions.PopExpressionEvaluationContext();
+  }
 };
 
 }  // end namespace clang

Modified: cfe/trunk/lib/Parse/ParseCXXInlineMethods.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseCXXInlineMethods.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseCXXInlineMethods.cpp (original)
+++ cfe/trunk/lib/Parse/ParseCXXInlineMethods.cpp Thu Aug 26 18:41:50 2010
@@ -27,7 +27,7 @@
   assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) &&
          "Current token not a '{', ':' or 'try'!");
 
-  Action::MultiTemplateParamsArg TemplateParams(Actions,
+  MultiTemplateParamsArg TemplateParams(Actions,
           TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->data() : 0,
           TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->size() : 0);
 

Modified: cfe/trunk/lib/Parse/ParseDecl.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseDecl.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseDecl.cpp (original)
+++ cfe/trunk/lib/Parse/ParseDecl.cpp Thu Aug 26 18:41:50 2010
@@ -15,6 +15,7 @@
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ParsedTemplate.h"
+#include "clang/Sema/PrettyDeclStackTrace.h"
 #include "RAIIObjectsForParser.h"
 #include "llvm/ADT/SmallSet.h"
 using namespace clang;
@@ -28,7 +29,7 @@
 ///         specifier-qualifier-list abstract-declarator[opt]
 ///
 /// Called type-id in C++.
-Action::TypeResult Parser::ParseTypeName(SourceRange *Range) {
+TypeResult Parser::ParseTypeName(SourceRange *Range) {
   // Parse the common declaration-specifiers piece.
   DeclSpec DS;
   ParseSpecifierQualifierList(DS);
@@ -541,7 +542,7 @@
   case ParsedTemplateInfo::Template:
   case ParsedTemplateInfo::ExplicitSpecialization:
     ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
-                             Action::MultiTemplateParamsArg(Actions,
+                             MultiTemplateParamsArg(Actions,
                                           TemplateInfo.TemplateParams->data(),
                                           TemplateInfo.TemplateParams->size()),
                                                D);
@@ -870,7 +871,7 @@
       return;
 
     case tok::code_completion: {
-      Action::ParserCompletionContext CCC = Action::PCC_Namespace;
+      Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
       if (DS.hasTypeSpecifier()) {
         bool AllowNonIdentifiers
           = (getCurScope()->getFlags() & (Scope::ControlScope |
@@ -889,12 +890,12 @@
       } 
       
       if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
-        CCC = DSContext == DSC_class? Action::PCC_MemberTemplate 
-                                    : Action::PCC_Template;
+        CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate 
+                                    : Sema::PCC_Template;
       else if (DSContext == DSC_class)
-        CCC = Action::PCC_Class;
+        CCC = Sema::PCC_Class;
       else if (ObjCImpDecl)
-        CCC = Action::PCC_ObjCImplementation;
+        CCC = Sema::PCC_ObjCImplementation;
       
       Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
       ConsumeCodeCompletionToken();
@@ -1798,9 +1799,8 @@
 ///
 void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
                                   unsigned TagType, Decl *TagDecl) {
-  PrettyStackTraceActionsDecl CrashInfo(TagDecl, RecordLoc, Actions,
-                                        PP.getSourceManager(),
-                                        "parsing struct/union body");
+  PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
+                                      "parsing struct/union body");
 
   SourceLocation LBraceLoc = ConsumeBrace();
 
@@ -1972,18 +1972,18 @@
   // enum foo {..};  void bar() { enum foo; }    <- new foo in bar.
   // enum foo {..};  void bar() { enum foo x; }  <- use of old foo.
   //
-  Action::TagUseKind TUK;
+  Sema::TagUseKind TUK;
   if (Tok.is(tok::l_brace))
-    TUK = Action::TUK_Definition;
+    TUK = Sema::TUK_Definition;
   else if (Tok.is(tok::semi))
-    TUK = Action::TUK_Declaration;
+    TUK = Sema::TUK_Declaration;
   else
-    TUK = Action::TUK_Reference;
+    TUK = Sema::TUK_Reference;
   
   // enums cannot be templates, although they can be referenced from a 
   // template.
   if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
-      TUK != Action::TUK_Reference) {
+      TUK != Sema::TUK_Reference) {
     Diag(Tok, diag::err_enum_template);
     
     // Skip the rest of this declarator, up until the comma or semicolon.
@@ -1999,7 +1999,7 @@
   Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
                                    StartLoc, SS, Name, NameLoc, Attr.get(),
                                    AS,
-                                   Action::MultiTemplateParamsArg(Actions),
+                                   MultiTemplateParamsArg(Actions),
                                    Owned, IsDependent);
   if (IsDependent) {
     // This enum has a dependent nested-name-specifier. Handle it as a 

Modified: cfe/trunk/lib/Parse/ParseDeclCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseDeclCXX.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseDeclCXX.cpp (original)
+++ cfe/trunk/lib/Parse/ParseDeclCXX.cpp Thu Aug 26 18:41:50 2010
@@ -17,6 +17,7 @@
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ParsedTemplate.h"
+#include "clang/Sema/PrettyDeclStackTrace.h"
 #include "RAIIObjectsForParser.h"
 using namespace clang;
 
@@ -102,9 +103,8 @@
     Actions.ActOnStartNamespaceDef(getCurScope(), IdentLoc, Ident, LBrace,
                                    AttrList.get());
 
-  PrettyStackTraceActionsDecl CrashInfo(NamespcDecl, NamespaceLoc, Actions,
-                                        PP.getSourceManager(),
-                                        "parsing namespace");
+  PrettyDeclStackTraceEntry CrashInfo(Actions, NamespcDecl, NamespaceLoc,
+                                      "parsing namespace");
 
   while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
     CXX0XAttributeList Attr;
@@ -439,7 +439,7 @@
   // C++0x [dcl.type.simple]p4:
   //   The operand of the decltype specifier is an unevaluated operand.
   EnterExpressionEvaluationContext Unevaluated(Actions,
-                                               Action::Unevaluated);
+                                               Sema::Unevaluated);
   ExprResult Result = ParseExpression();
   if (Result.isInvalid()) {
     SkipUntil(tok::r_paren);
@@ -784,9 +784,9 @@
   // or
   // &T::operator struct s;
   // For these, SuppressDeclarations is true.
-  Action::TagUseKind TUK;
+  Sema::TagUseKind TUK;
   if (SuppressDeclarations)
-    TUK = Action::TUK_Reference;
+    TUK = Sema::TUK_Reference;
   else if (Tok.is(tok::l_brace) || (getLang().CPlusPlus && Tok.is(tok::colon))){
     if (DS.isFriendSpecified()) {
       // C++ [class.friend]p2:
@@ -797,18 +797,18 @@
       // Skip everything up to the semicolon, so that this looks like a proper
       // friend class (or template thereof) declaration.
       SkipUntil(tok::semi, true, true);
-      TUK = Action::TUK_Friend;
+      TUK = Sema::TUK_Friend;
     } else {
       // Okay, this is a class definition.
-      TUK = Action::TUK_Definition;
+      TUK = Sema::TUK_Definition;
     }
   } else if (Tok.is(tok::semi))
-    TUK = DS.isFriendSpecified() ? Action::TUK_Friend : Action::TUK_Declaration;
+    TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
   else
-    TUK = Action::TUK_Reference;
+    TUK = Sema::TUK_Reference;
 
   if (!Name && !TemplateId && (DS.getTypeSpecType() == DeclSpec::TST_error ||
-                               TUK != Action::TUK_Definition)) {
+                               TUK != Sema::TUK_Definition)) {
     if (DS.getTypeSpecType() != DeclSpec::TST_error) {
       // We have a declaration or reference to an anonymous class.
       Diag(StartLoc, diag::err_anon_type_definition)
@@ -834,7 +834,7 @@
                                        TemplateId->getTemplateArgs(),
                                        TemplateId->NumArgs);
     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
-        TUK == Action::TUK_Declaration) {
+        TUK == Sema::TUK_Declaration) {
       // This is an explicit instantiation of a class template.
       TagOrTempResult
         = Actions.ActOnExplicitInstantiation(getCurScope(),
@@ -854,8 +854,8 @@
     // they have template headers, in which case they're ill-formed
     // (FIXME: "template <class T> friend class A<T>::B<int>;").
     // We diagnose this error in ActOnClassTemplateSpecialization.
-    } else if (TUK == Action::TUK_Reference ||
-               (TUK == Action::TUK_Friend &&
+    } else if (TUK == Sema::TUK_Reference ||
+               (TUK == Sema::TUK_Friend &&
                 TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {
       TypeResult
         = Actions.ActOnTemplateIdType(TemplateId->Template,
@@ -880,7 +880,7 @@
         // but it actually has a definition. Most likely, this was
         // meant to be an explicit specialization, but the user forgot
         // the '<>' after 'template'.
-        assert(TUK == Action::TUK_Definition && "Expected a definition here");
+        assert(TUK == Sema::TUK_Definition && "Expected a definition here");
 
         SourceLocation LAngleLoc
           = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
@@ -911,13 +911,13 @@
                        TemplateArgsPtr,
                        TemplateId->RAngleLoc,
                        AttrList,
-                       Action::MultiTemplateParamsArg(Actions,
+                       MultiTemplateParamsArg(Actions,
                                     TemplateParams? &(*TemplateParams)[0] : 0,
                                  TemplateParams? TemplateParams->size() : 0));
     }
     TemplateId->Destroy();
   } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
-             TUK == Action::TUK_Declaration) {
+             TUK == Sema::TUK_Declaration) {
     // Explicit instantiation of a member of a class template
     // specialization, e.g.,
     //
@@ -931,7 +931,7 @@
                                            NameLoc, AttrList);
   } else {
     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
-        TUK == Action::TUK_Definition) {
+        TUK == Sema::TUK_Definition) {
       // FIXME: Diagnose this particular error.
     }
 
@@ -940,7 +940,7 @@
     // Declaration or definition of a class type
     TagOrTempResult = Actions.ActOnTag(getCurScope(), TagType, TUK, StartLoc, SS,
                                        Name, NameLoc, AttrList, AS,
-                                  Action::MultiTemplateParamsArg(Actions,
+                                       MultiTemplateParamsArg(Actions,
                                     TemplateParams? &(*TemplateParams)[0] : 0,
                                     TemplateParams? TemplateParams->size() : 0),
                                        Owned, IsDependent);
@@ -953,7 +953,7 @@
   }
 
   // If there is a body, parse it and inform the actions module.
-  if (TUK == Action::TUK_Definition) {
+  if (TUK == Sema::TUK_Definition) {
     assert(Tok.is(tok::l_brace) ||
            (getLang().CPlusPlus && Tok.is(tok::colon)));
     if (getLang().CPlusPlus)
@@ -990,7 +990,7 @@
   // the end of the declaration and recover that way.
   //
   // This switch enumerates the valid "follow" set for definition.
-  if (TUK == Action::TUK_Definition) {
+  if (TUK == Sema::TUK_Definition) {
     bool ExpectedSemi = true;
     switch (Tok.getKind()) {
     default: break;
@@ -1337,7 +1337,7 @@
   DS.AddAttributes(AttrList.AttrList);
   ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DSC_class);
 
-  Action::MultiTemplateParamsArg TemplateParams(Actions,
+  MultiTemplateParamsArg TemplateParams(Actions,
       TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->data() : 0,
       TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->size() : 0);
 
@@ -1538,9 +1538,8 @@
          TagType == DeclSpec::TST_union  ||
          TagType == DeclSpec::TST_class) && "Invalid TagType!");
 
-  PrettyStackTraceActionsDecl CrashInfo(TagDecl, RecordLoc, Actions,
-                                        PP.getSourceManager(),
-                                        "parsing struct/union/class body");
+  PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
+                                      "parsing struct/union/class body");
 
   // Determine whether this is a non-nested class. Note that local
   // classes are *not* considered to be nested classes.
@@ -2062,8 +2061,7 @@
 /// [C++0x] 'align' '(' assignment-expression ')'
 ExprResult Parser::ParseCXX0XAlignArgument(SourceLocation Start) {
   if (isTypeIdInParens()) {
-    EnterExpressionEvaluationContext Unevaluated(Actions,
-                                                  Action::Unevaluated);
+    EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
     SourceLocation TypeLoc = Tok.getLocation();
     ParsedType Ty = ParseTypeName().get();
     SourceRange TypeRange(Start, Tok.getLocation());

Modified: cfe/trunk/lib/Parse/ParseExpr.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseExpr.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseExpr.cpp (original)
+++ cfe/trunk/lib/Parse/ParseExpr.cpp Thu Aug 26 18:41:50 2010
@@ -220,7 +220,7 @@
 ///
 ExprResult Parser::ParseAssignmentExpression() {
   if (Tok.is(tok::code_completion)) {
-    Actions.CodeCompleteOrdinaryName(getCurScope(), Action::PCC_Expression);
+    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
     ConsumeCodeCompletionToken();
   }
 
@@ -261,7 +261,7 @@
   //   An expression is potentially evaluated unless it appears where an
   //   integral constant expression is required (see 5.19) [...].
   EnterExpressionEvaluationContext Unevaluated(Actions,
-                                               Action::Unevaluated);
+                                               Sema::Unevaluated);
 
   ExprResult LHS(ParseCastExpression(false));
   if (LHS.isInvalid()) return move(LHS);
@@ -905,7 +905,7 @@
   case tok::caret:
     return ParsePostfixExpressionSuffix(ParseBlockLiteralExpression());
   case tok::code_completion:
-    Actions.CodeCompleteOrdinaryName(getCurScope(), Action::PCC_Expression);
+    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
     ConsumeCodeCompletionToken();
     return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 
                                NotCastExpr, TypeOfCast);
@@ -995,7 +995,7 @@
       }
       
       if (Tok.isNot(tok::r_paren)) {
-        if (ParseExpressionList(ArgExprs, CommaLocs, &Action::CodeCompleteCall,
+        if (ParseExpressionList(ArgExprs, CommaLocs, &Sema::CodeCompleteCall,
                                 LHS.get())) {
           SkipUntil(tok::r_paren);
           return ExprError();
@@ -1132,7 +1132,7 @@
     // The GNU typeof and alignof extensions also behave as unevaluated
     // operands.
     EnterExpressionEvaluationContext Unevaluated(Actions,
-                                                 Action::Unevaluated);
+                                                 Sema::Unevaluated);
     Operand = ParseCastExpression(true/*isUnaryExpression*/);
   } else {
     // If it starts with a '(', we know that it is either a parenthesized
@@ -1149,7 +1149,7 @@
     // The GNU typeof and alignof extensions also behave as unevaluated
     // operands.
     EnterExpressionEvaluationContext Unevaluated(Actions,
-                                                 Action::Unevaluated);
+                                                 Sema::Unevaluated);
     Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/, 
                                    ParsedType(), CastTy, RParenLoc);
     CastRange = SourceRange(LParenLoc, RParenLoc);
@@ -1287,9 +1287,9 @@
     }
 
     // Keep track of the various subcomponents we see.
-    llvm::SmallVector<Action::OffsetOfComponent, 4> Comps;
+    llvm::SmallVector<Sema::OffsetOfComponent, 4> Comps;
 
-    Comps.push_back(Action::OffsetOfComponent());
+    Comps.push_back(Sema::OffsetOfComponent());
     Comps.back().isBrackets = false;
     Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
     Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
@@ -1298,7 +1298,7 @@
     while (1) {
       if (Tok.is(tok::period)) {
         // offsetof-member-designator: offsetof-member-designator '.' identifier
-        Comps.push_back(Action::OffsetOfComponent());
+        Comps.push_back(Sema::OffsetOfComponent());
         Comps.back().isBrackets = false;
         Comps.back().LocStart = ConsumeToken();
 
@@ -1312,7 +1312,7 @@
 
       } else if (Tok.is(tok::l_square)) {
         // offsetof-member-designator: offsetof-member-design '[' expression ']'
-        Comps.push_back(Action::OffsetOfComponent());
+        Comps.push_back(Sema::OffsetOfComponent());
         Comps.back().isBrackets = true;
         Comps.back().LocStart = ConsumeBracket();
         Res = ParseExpression();
@@ -1579,7 +1579,7 @@
 ///
 bool Parser::ParseExpressionList(llvm::SmallVectorImpl<Expr*> &Exprs,
                             llvm::SmallVectorImpl<SourceLocation> &CommaLocs,
-                                 void (Action::*Completer)(Scope *S, 
+                                 void (Sema::*Completer)(Scope *S, 
                                                            Expr *Data,
                                                            Expr **Args,
                                                            unsigned NumArgs),

Modified: cfe/trunk/lib/Parse/ParseExprCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseExprCXX.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseExprCXX.cpp (original)
+++ cfe/trunk/lib/Parse/ParseExprCXX.cpp Thu Aug 26 18:41:50 2010
@@ -530,7 +530,7 @@
     // polymorphic class type until after we've parsed the expression, so
     // we the expression is potentially potentially evaluated.
     EnterExpressionEvaluationContext Unevaluated(Actions,
-                                       Action::PotentiallyPotentiallyEvaluated);
+                                       Sema::PotentiallyPotentiallyEvaluated);
     Result = ParseExpression();
 
     // Match the ')'.
@@ -735,7 +735,7 @@
                                SourceLocation Loc,
                                bool ConvertToBoolean) {
   if (Tok.is(tok::code_completion)) {
-    Actions.CodeCompleteOrdinaryName(getCurScope(), Action::PCC_Condition);
+    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
     ConsumeCodeCompletionToken();
   }
 
@@ -1147,7 +1147,7 @@
                                      TemplateArgs.size());
   
   // Constructor and destructor names.
-  Action::TypeResult Type
+  TypeResult Type
     = Actions.ActOnTemplateIdType(Template, NameLoc,
                                   LAngleLoc, TemplateArgsPtr,
                                   RAngleLoc);
@@ -1339,7 +1339,7 @@
   ParseDeclaratorInternal(D, /*DirectDeclParser=*/0);
   
   // Finish up the type.
-  Action::TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
+  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
   if (Ty.isInvalid())
     return true;
   

Modified: cfe/trunk/lib/Parse/ParseInit.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseInit.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseInit.cpp (original)
+++ cfe/trunk/lib/Parse/ParseInit.cpp Thu Aug 26 18:41:50 2010
@@ -184,15 +184,15 @@
       // Three cases. This is a message send to a type: [type foo]
       // This is a message send to super:  [super foo]
       // This is a message sent to an expr:  [super.bar foo]
-      switch (Action::ObjCMessageKind Kind
+      switch (Sema::ObjCMessageKind Kind
                 = Actions.getObjCMessageKind(getCurScope(), II, IILoc, 
                                              II == Ident_super,
                                              NextToken().is(tok::period),
                                              ReceiverType)) {
-      case Action::ObjCSuperMessage:
-      case Action::ObjCClassMessage:
+      case Sema::ObjCSuperMessage:
+      case Sema::ObjCClassMessage:
         CheckArrayDesignatorSyntax(*this, StartLoc, Desig);
-        if (Kind == Action::ObjCSuperMessage)
+        if (Kind == Sema::ObjCSuperMessage)
           return ParseAssignmentExprWithObjCMessageExprStart(StartLoc,
                                                              ConsumeToken(),
                                                              ParsedType(),
@@ -208,7 +208,7 @@
                                                            ReceiverType, 
                                                            0);
 
-      case Action::ObjCInstanceMessage:
+      case Sema::ObjCInstanceMessage:
         // Fall through; we'll just parse the expression and
         // (possibly) treat this like an Objective-C message send
         // later.
@@ -321,7 +321,7 @@
     if (!getLang().CPlusPlus)
       Diag(LBraceLoc, diag::ext_gnu_empty_initializer);
     // Match the '}'.
-    return Actions.ActOnInitList(LBraceLoc, Action::MultiExprArg(Actions),
+    return Actions.ActOnInitList(LBraceLoc, MultiExprArg(Actions),
                                  ConsumeBrace());
   }
 

Modified: cfe/trunk/lib/Parse/ParseObjc.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseObjc.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseObjc.cpp (original)
+++ cfe/trunk/lib/Parse/ParseObjc.cpp Thu Aug 26 18:41:50 2010
@@ -14,6 +14,7 @@
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/DeclSpec.h"
+#include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Scope.h"
 #include "llvm/ADT/SmallVector.h"
 using namespace clang;
@@ -348,8 +349,8 @@
     // Code completion within an Objective-C interface.
     if (Tok.is(tok::code_completion)) {
       Actions.CodeCompleteOrdinaryName(getCurScope(), 
-                                  ObjCImpDecl? Action::PCC_ObjCImplementation
-                                             : Action::PCC_ObjCInterface);
+                                  ObjCImpDecl? Sema::PCC_ObjCImplementation
+                                             : Sema::PCC_ObjCInterface);
       ConsumeCodeCompletionToken();
     }
     
@@ -840,10 +841,10 @@
   }
 
   llvm::SmallVector<IdentifierInfo *, 12> KeyIdents;
-  llvm::SmallVector<Action::ObjCArgInfo, 12> ArgInfos;
+  llvm::SmallVector<Sema::ObjCArgInfo, 12> ArgInfos;
 
   while (1) {
-    Action::ObjCArgInfo ArgInfo;
+    Sema::ObjCArgInfo ArgInfo;
 
     // Each iteration parses a single keyword argument.
     if (Tok.isNot(tok::colon)) {
@@ -951,7 +952,7 @@
   PD.complete(Result);
   
   // Delete referenced AttributeList objects.
-  for (llvm::SmallVectorImpl<Action::ObjCArgInfo>::iterator
+  for (llvm::SmallVectorImpl<Sema::ObjCArgInfo>::iterator
        I = ArgInfos.begin(), E = ArgInfos.end(); I != E; ++I)
     delete I->ArgAttrs;
   
@@ -1076,7 +1077,7 @@
 
     if (Tok.is(tok::code_completion)) {
       Actions.CodeCompleteOrdinaryName(getCurScope(), 
-                                       Action::PCC_ObjCInstanceVariableList);
+                                       Sema::PCC_ObjCInstanceVariableList);
       ConsumeCodeCompletionToken();
     }
     
@@ -1634,9 +1635,8 @@
 Decl *Parser::ParseObjCMethodDefinition() {
   Decl *MDecl = ParseObjCMethodPrototype(ObjCImpDecl);
 
-  PrettyStackTraceActionsDecl CrashInfo(MDecl, Tok.getLocation(), Actions,
-                                        PP.getSourceManager(),
-                                        "parsing Objective-C method");
+  PrettyDeclStackTraceEntry CrashInfo(Actions, MDecl, Tok.getLocation(),
+                                      "parsing Objective-C method");
 
   // parse optional ';'
   if (Tok.is(tok::semi)) {
@@ -1896,11 +1896,11 @@
                                        Name == Ident_super,
                                        NextToken().is(tok::period),
                                        ReceiverType)) {
-    case Action::ObjCSuperMessage:
+    case Sema::ObjCSuperMessage:
       return ParseObjCMessageExpressionBody(LBracLoc, ConsumeToken(),
                                             ParsedType(), 0);
 
-    case Action::ObjCClassMessage:
+    case Sema::ObjCClassMessage:
       if (!ReceiverType) {
         SkipUntil(tok::r_square);
         return ExprError();
@@ -1911,7 +1911,7 @@
       return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 
                                             ReceiverType, 0);
         
-    case Action::ObjCInstanceMessage:
+    case Sema::ObjCInstanceMessage:
       // Fall through to parse an expression.
       break;
     }
@@ -2090,20 +2090,20 @@
   if (SuperLoc.isValid())
     return Actions.ActOnSuperMessage(getCurScope(), SuperLoc, Sel,
                                      LBracLoc, SelectorLoc, RBracLoc,
-                                     Action::MultiExprArg(Actions, 
-                                                          KeyExprs.take(),
-                                                          KeyExprs.size()));
+                                     MultiExprArg(Actions, 
+                                                  KeyExprs.take(),
+                                                  KeyExprs.size()));
   else if (ReceiverType)
     return Actions.ActOnClassMessage(getCurScope(), ReceiverType, Sel,
                                      LBracLoc, SelectorLoc, RBracLoc,
-                                     Action::MultiExprArg(Actions, 
-                                                          KeyExprs.take(), 
-                                                          KeyExprs.size()));
+                                     MultiExprArg(Actions, 
+                                                  KeyExprs.take(), 
+                                                  KeyExprs.size()));
   return Actions.ActOnInstanceMessage(getCurScope(), ReceiverExpr, Sel,
                                       LBracLoc, SelectorLoc, RBracLoc,
-                                      Action::MultiExprArg(Actions, 
-                                                           KeyExprs.take(), 
-                                                           KeyExprs.size()));
+                                      MultiExprArg(Actions, 
+                                                   KeyExprs.take(), 
+                                                   KeyExprs.size()));
 }
 
 ExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) {

Modified: cfe/trunk/lib/Parse/ParsePragma.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParsePragma.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParsePragma.cpp (original)
+++ cfe/trunk/lib/Parse/ParsePragma.cpp Thu Aug 26 18:41:50 2010
@@ -15,7 +15,6 @@
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Lex/Preprocessor.h"
-#include "clang/Sema/Action.h"
 using namespace clang;
 
 
@@ -85,7 +84,7 @@
     return;
   }
 
-  Action::PragmaPackKind Kind = Action::PPK_Default;
+  Sema::PragmaPackKind Kind = Sema::PPK_Default;
   IdentifierInfo *Name = 0;
   ExprResult Alignment;
   SourceLocation LParenLoc = Tok.getLocation();
@@ -99,13 +98,13 @@
   } else if (Tok.is(tok::identifier)) {
     const IdentifierInfo *II = Tok.getIdentifierInfo();
     if (II->isStr("show")) {
-      Kind = Action::PPK_Show;
+      Kind = Sema::PPK_Show;
       PP.Lex(Tok);
     } else {
       if (II->isStr("push")) {
-        Kind = Action::PPK_Push;
+        Kind = Sema::PPK_Push;
       } else if (II->isStr("pop")) {
-        Kind = Action::PPK_Pop;
+        Kind = Sema::PPK_Pop;
       } else {
         PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_invalid_action);
         return;
@@ -165,7 +164,7 @@
 
 // #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
 // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
-static void ParseAlignPragma(Action &Actions, Preprocessor &PP, Token &FirstTok,
+static void ParseAlignPragma(Sema &Actions, Preprocessor &PP, Token &FirstTok,
                              bool IsOptions) {
   Token Tok;
 
@@ -192,20 +191,20 @@
     return;
   }
 
-  Action::PragmaOptionsAlignKind Kind = Action::POAK_Natural;
+  Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
   const IdentifierInfo *II = Tok.getIdentifierInfo();
   if (II->isStr("native"))
-    Kind = Action::POAK_Native;
+    Kind = Sema::POAK_Native;
   else if (II->isStr("natural"))
-    Kind = Action::POAK_Natural;
+    Kind = Sema::POAK_Natural;
   else if (II->isStr("packed"))
-    Kind = Action::POAK_Packed;
+    Kind = Sema::POAK_Packed;
   else if (II->isStr("power"))
-    Kind = Action::POAK_Power;
+    Kind = Sema::POAK_Power;
   else if (II->isStr("mac68k"))
-    Kind = Action::POAK_Mac68k;
+    Kind = Sema::POAK_Mac68k;
   else if (II->isStr("reset"))
-    Kind = Action::POAK_Reset;
+    Kind = Sema::POAK_Reset;
   else {
     PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
       << IsOptions;

Modified: cfe/trunk/lib/Parse/ParsePragma.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParsePragma.h?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParsePragma.h (original)
+++ cfe/trunk/lib/Parse/ParsePragma.h Thu Aug 26 18:41:50 2010
@@ -17,58 +17,58 @@
 #include "clang/Lex/Pragma.h"
 
 namespace clang {
-  class Action;
+  class Sema;
   class Parser;
 
 class PragmaAlignHandler : public PragmaHandler {
-  Action &Actions;
+  Sema &Actions;
 public:
-  explicit PragmaAlignHandler(Action &A) : PragmaHandler("align"), Actions(A) {}
+  explicit PragmaAlignHandler(Sema &A) : PragmaHandler("align"), Actions(A) {}
 
   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
 };
 
 class PragmaGCCVisibilityHandler : public PragmaHandler {
-  Action &Actions;
+  Sema &Actions;
 public:
-  explicit PragmaGCCVisibilityHandler(Action &A) : PragmaHandler("visibility"),
-                                                   Actions(A) {}
+  explicit PragmaGCCVisibilityHandler(Sema &A) : PragmaHandler("visibility"),
+                                                 Actions(A) {}
 
   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
 };
 
 class PragmaOptionsHandler : public PragmaHandler {
-  Action &Actions;
+  Sema &Actions;
 public:
-  explicit PragmaOptionsHandler(Action &A) : PragmaHandler("options"),
-                                             Actions(A) {}
+  explicit PragmaOptionsHandler(Sema &A) : PragmaHandler("options"),
+                                           Actions(A) {}
 
   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
 };
 
 class PragmaPackHandler : public PragmaHandler {
-  Action &Actions;
+  Sema &Actions;
 public:
-  explicit PragmaPackHandler(Action &A) : PragmaHandler("pack"),
-                                          Actions(A) {}
+  explicit PragmaPackHandler(Sema &A) : PragmaHandler("pack"),
+                                        Actions(A) {}
 
   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
 };
 
 class PragmaUnusedHandler : public PragmaHandler {
-  Action &Actions;
+  Sema &Actions;
   Parser &parser;
 public:
-  PragmaUnusedHandler(Action &A, Parser& p)
+  PragmaUnusedHandler(Sema &A, Parser& p)
     : PragmaHandler("unused"), Actions(A), parser(p) {}
 
   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);
 };
 
 class PragmaWeakHandler : public PragmaHandler {
-  Action &Actions;
+  Sema &Actions;
 public:
-  explicit PragmaWeakHandler(Action &A)
+  explicit PragmaWeakHandler(Sema &A)
     : PragmaHandler("weak"), Actions(A) {}
 
   virtual void HandlePragma(Preprocessor &PP, Token &FirstToken);

Modified: cfe/trunk/lib/Parse/ParseStmt.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseStmt.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseStmt.cpp (original)
+++ cfe/trunk/lib/Parse/ParseStmt.cpp Thu Aug 26 18:41:50 2010
@@ -15,6 +15,7 @@
 #include "clang/Parse/Parser.h"
 #include "RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
+#include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/PrettyStackTrace.h"
@@ -98,7 +99,7 @@
     }
 
   case tok::code_completion:
-    Actions.CodeCompleteOrdinaryName(getCurScope(), Action::PCC_Statement);
+    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Statement);
     ConsumeCodeCompletionToken();
     return ParseStatementOrDeclaration(OnlyStatement);
       
@@ -994,8 +995,8 @@
   
   if (Tok.is(tok::code_completion)) {
     Actions.CodeCompleteOrdinaryName(getCurScope(), 
-                                     C99orCXXorObjC? Action::PCC_ForInit
-                                                   : Action::PCC_Expression);
+                                     C99orCXXorObjC? Sema::PCC_ForInit
+                                                   : Sema::PCC_Expression);
     ConsumeCodeCompletionToken();
   }
   
@@ -1468,9 +1469,8 @@
   assert(Tok.is(tok::l_brace));
   SourceLocation LBraceLoc = Tok.getLocation();
 
-  PrettyStackTraceActionsDecl CrashInfo(Decl, LBraceLoc, Actions,
-                                        PP.getSourceManager(),
-                                        "parsing function body");
+  PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, LBraceLoc,
+                                      "parsing function body");
 
   // Do not enter a scope for the brace, as the arguments are in the same scope
   // (the function body) as the body itself.  Instead, just read the statement
@@ -1494,9 +1494,8 @@
   assert(Tok.is(tok::kw_try) && "Expected 'try'");
   SourceLocation TryLoc = ConsumeToken();
 
-  PrettyStackTraceActionsDecl CrashInfo(Decl, TryLoc, Actions,
-                                        PP.getSourceManager(),
-                                        "parsing function try block");
+  PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, TryLoc,
+                                      "parsing function try block");
 
   // Constructor initializer list?
   if (Tok.is(tok::colon))

Modified: cfe/trunk/lib/Parse/ParseTemplate.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParseTemplate.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/ParseTemplate.cpp (original)
+++ cfe/trunk/lib/Parse/ParseTemplate.cpp Thu Aug 26 18:41:50 2010
@@ -772,7 +772,7 @@
 
   // Build the annotation token.
   if (TNK == TNK_Type_template && AllowTypeAnnotation) {
-    Action::TypeResult Type
+    TypeResult Type
       = Actions.ActOnTemplateIdType(Template, TemplateNameLoc,
                                     LAngleLoc, TemplateArgsPtr,
                                     RAngleLoc);
@@ -850,7 +850,7 @@
                                      TemplateId->getTemplateArgs(),
                                      TemplateId->NumArgs);
 
-  Action::TypeResult Type
+  TypeResult Type
     = Actions.ActOnTemplateIdType(TemplateId->Template,
                                   TemplateId->TemplateNameLoc,
                                   TemplateId->LAngleLoc,

Modified: cfe/trunk/lib/Parse/Parser.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/Parser.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Parse/Parser.cpp (original)
+++ cfe/trunk/lib/Parse/Parser.cpp Thu Aug 26 18:41:50 2010
@@ -21,7 +21,7 @@
 #include "ParsePragma.h"
 using namespace clang;
 
-Parser::Parser(Preprocessor &pp, Action &actions)
+Parser::Parser(Preprocessor &pp, Sema &actions)
   : CrashInfo(*this), PP(pp), Actions(actions), Diags(PP.getDiagnostics()),
     GreaterThanIsOperator(true), ColonIsSacred(false),
     TemplateParameterDepth(0) {
@@ -467,8 +467,8 @@
     break;
   case tok::code_completion:
       Actions.CodeCompleteOrdinaryName(getCurScope(), 
-                                   ObjCImpDecl? Action::PCC_ObjCImplementation
-                                              : Action::PCC_Namespace);
+                                   ObjCImpDecl? Sema::PCC_ObjCImplementation
+                                              : Sema::PCC_Namespace);
     ConsumeCodeCompletionToken();
     return ParseExternalDeclaration(Attr);
   case tok::kw_using:
@@ -680,7 +680,7 @@
   // specified Declarator for the function.
   Decl *Res = TemplateInfo.TemplateParams?
       Actions.ActOnStartOfFunctionTemplateDef(getCurScope(),
-                              Action::MultiTemplateParamsArg(Actions,
+                              MultiTemplateParamsArg(Actions,
                                           TemplateInfo.TemplateParams->data(),
                                          TemplateInfo.TemplateParams->size()),
                                               D)
@@ -1110,17 +1110,17 @@
 void Parser::CodeCompletionRecovery() {
   for (Scope *S = getCurScope(); S; S = S->getParent()) {
     if (S->getFlags() & Scope::FnScope) {
-      Actions.CodeCompleteOrdinaryName(getCurScope(), Action::PCC_RecoveryInFunction);
+      Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_RecoveryInFunction);
       return;
     }
     
     if (S->getFlags() & Scope::ClassScope) {
-      Actions.CodeCompleteOrdinaryName(getCurScope(), Action::PCC_Class);
+      Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Class);
       return;
     }
   }
   
-  Actions.CodeCompleteOrdinaryName(getCurScope(), Action::PCC_Namespace);
+  Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Namespace);
 }
 
 // Anchor the Parser::FieldCallback vtable to this translation unit.

Removed: cfe/trunk/lib/Sema/Action.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/Action.cpp?rev=112243&view=auto
==============================================================================
--- cfe/trunk/lib/Sema/Action.cpp (original)
+++ cfe/trunk/lib/Sema/Action.cpp (removed)
@@ -1,38 +0,0 @@
-//===--- Action.cpp - Implement the Action class --------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file implements the Action interface.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Sema/Action.h"
-#include "clang/Sema/DeclSpec.h"
-#include "clang/Sema/Scope.h"
-#include "clang/Basic/TargetInfo.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/RecyclingAllocator.h"
-#include "llvm/Support/raw_ostream.h"
-using namespace clang;
-
-void PrettyStackTraceActionsDecl::print(llvm::raw_ostream &OS) const {
-  if (Loc.isValid()) {
-    Loc.print(OS, SM);
-    OS << ": ";
-  }
-  OS << Message;
-
-  std::string Name = Actions.getDeclName(TheDecl);
-  if (!Name.empty())
-    OS << " '" << Name << '\'';
-
-  OS << '\n';
-}
-
-///  Out-of-line virtual destructor to provide home for Action class.
-Action::~Action() {}

Modified: cfe/trunk/lib/Sema/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/CMakeLists.txt?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/CMakeLists.txt (original)
+++ cfe/trunk/lib/Sema/CMakeLists.txt Thu Aug 26 18:41:50 2010
@@ -1,7 +1,6 @@
 set(LLVM_NO_RTTI 1)
 
 add_clang_library(clangSema
-  Action.cpp
   AnalysisBasedWarnings.cpp
   AttributeList.cpp
   CodeCompleteConsumer.cpp

Modified: cfe/trunk/lib/Sema/Sema.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/Sema.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/Sema.cpp (original)
+++ cfe/trunk/lib/Sema/Sema.cpp Thu Aug 26 18:41:50 2010
@@ -20,6 +20,7 @@
 #include "llvm/ADT/APFloat.h"
 #include "clang/Sema/CXXFieldCollector.h"
 #include "clang/Sema/ExternalSemaSource.h"
+#include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaConsumer.h"
@@ -555,3 +556,21 @@
 
 // Pin this vtable to this file.
 ExternalSemaSource::~ExternalSemaSource() {}
+
+void PrettyDeclStackTraceEntry::print(llvm::raw_ostream &OS) const {
+  SourceLocation Loc = this->Loc;
+  if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
+  if (Loc.isValid()) {
+    Loc.print(OS, S.getSourceManager());
+    OS << ": ";
+  }
+  OS << Message;
+
+  if (TheDecl && isa<NamedDecl>(TheDecl)) {
+    std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
+    if (!Name.empty())
+      OS << " '" << Name << '\'';
+  }
+
+  OS << '\n';
+}

Modified: cfe/trunk/lib/Sema/SemaAttr.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaAttr.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaAttr.cpp (original)
+++ cfe/trunk/lib/Sema/SemaAttr.cpp Thu Aug 26 18:41:50 2010
@@ -139,7 +139,7 @@
 
   // Reset just pops the top of the stack, or resets the current alignment to
   // default.
-  if (Kind == Action::POAK_Reset) {
+  if (Kind == Sema::POAK_Reset) {
     if (!Context->pop(0, /*IsReset=*/true)) {
       Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
         << "stack empty";
@@ -212,11 +212,11 @@
   PragmaPackStack *Context = static_cast<PragmaPackStack*>(PackContext);
 
   switch (Kind) {
-  case Action::PPK_Default: // pack([n])
+  case Sema::PPK_Default: // pack([n])
     Context->setAlignment(AlignmentVal);
     break;
 
-  case Action::PPK_Show: // pack(show)
+  case Sema::PPK_Show: // pack(show)
     // Show the current alignment, making sure to show the right value
     // for the default.
     AlignmentVal = Context->getAlignment();
@@ -229,14 +229,14 @@
       Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
     break;
 
-  case Action::PPK_Push: // pack(push [, id] [, [n])
+  case Sema::PPK_Push: // pack(push [, id] [, [n])
     Context->push(Name);
     // Set the new alignment if specified.
     if (Alignment)
       Context->setAlignment(AlignmentVal);
     break;
 
-  case Action::PPK_Pop: // pack(pop [, id] [,  n])
+  case Sema::PPK_Pop: // pack(pop [, id] [,  n])
     // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
     // "#pragma pack(pop, identifier, n) is undefined"
     if (Alignment && Name)

Modified: cfe/trunk/lib/Sema/SemaCXXCast.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaCXXCast.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaCXXCast.cpp (original)
+++ cfe/trunk/lib/Sema/SemaCXXCast.cpp Thu Aug 26 18:41:50 2010
@@ -120,7 +120,7 @@
 Sema::ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
                         SourceLocation LAngleBracketLoc, ParsedType Ty,
                         SourceLocation RAngleBracketLoc,
-                        SourceLocation LParenLoc, ExprArg E,
+                        SourceLocation LParenLoc, Expr *E,
                         SourceLocation RParenLoc) {
   
   TypeSourceInfo *DestTInfo;
@@ -135,7 +135,7 @@
 
 ExprResult
 Sema::BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind,
-                        TypeSourceInfo *DestTInfo, ExprArg Ex,
+                        TypeSourceInfo *DestTInfo, Expr *Ex,
                         SourceRange AngleBrackets, SourceRange Parens) {
   QualType DestType = DestTInfo->getType();
 
@@ -965,8 +965,7 @@
     return TC_NotApplicable;
     
   ExprResult Result
-    = InitSeq.Perform(Self, Entity, InitKind,
-                      Action::MultiExprArg(Self, &SrcExpr, 1));
+    = InitSeq.Perform(Self, Entity, InitKind, MultiExprArg(Self, &SrcExpr, 1));
   if (Result.isInvalid()) {
     msg = 0;
     return TC_Failed;

Modified: cfe/trunk/lib/Sema/SemaCodeComplete.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaCodeComplete.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaCodeComplete.cpp (original)
+++ cfe/trunk/lib/Sema/SemaCodeComplete.cpp Thu Aug 26 18:41:50 2010
@@ -1113,7 +1113,7 @@
   }
 }
 
-static void AddStorageSpecifiers(Action::ParserCompletionContext CCC,
+static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
                                  const LangOptions &LangOpts, 
                                  ResultBuilder &Results) {
   typedef CodeCompletionResult Result;
@@ -1124,13 +1124,13 @@
   Results.AddResult(Result("static"));
 }
 
-static void AddFunctionSpecifiers(Action::ParserCompletionContext CCC,
+static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
                                   const LangOptions &LangOpts, 
                                   ResultBuilder &Results) {
   typedef CodeCompletionResult Result;
   switch (CCC) {
-  case Action::PCC_Class:
-  case Action::PCC_MemberTemplate:
+  case Sema::PCC_Class:
+  case Sema::PCC_MemberTemplate:
     if (LangOpts.CPlusPlus) {
       Results.AddResult(Result("explicit"));
       Results.AddResult(Result("friend"));
@@ -1139,21 +1139,21 @@
     }    
     // Fall through
 
-  case Action::PCC_ObjCInterface:
-  case Action::PCC_ObjCImplementation:
-  case Action::PCC_Namespace:
-  case Action::PCC_Template:
+  case Sema::PCC_ObjCInterface:
+  case Sema::PCC_ObjCImplementation:
+  case Sema::PCC_Namespace:
+  case Sema::PCC_Template:
     if (LangOpts.CPlusPlus || LangOpts.C99)
       Results.AddResult(Result("inline"));
     break;
 
-  case Action::PCC_ObjCInstanceVariableList:
-  case Action::PCC_Expression:
-  case Action::PCC_Statement:
-  case Action::PCC_ForInit:
-  case Action::PCC_Condition:
-  case Action::PCC_RecoveryInFunction:
-  case Action::PCC_Type:
+  case Sema::PCC_ObjCInstanceVariableList:
+  case Sema::PCC_Expression:
+  case Sema::PCC_Statement:
+  case Sema::PCC_ForInit:
+  case Sema::PCC_Condition:
+  case Sema::PCC_RecoveryInFunction:
+  case Sema::PCC_Type:
     break;
   }
 }
@@ -1181,29 +1181,29 @@
   Results.AddResult(CodeCompletionResult(Pattern));        
 }
 
-static bool WantTypesInContext(Action::ParserCompletionContext CCC,
+static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
                                const LangOptions &LangOpts) {
   if (LangOpts.CPlusPlus)
     return true;
   
   switch (CCC) {
-  case Action::PCC_Namespace:
-  case Action::PCC_Class:
-  case Action::PCC_ObjCInstanceVariableList:
-  case Action::PCC_Template:
-  case Action::PCC_MemberTemplate:
-  case Action::PCC_Statement:
-  case Action::PCC_RecoveryInFunction:
-  case Action::PCC_Type:
+  case Sema::PCC_Namespace:
+  case Sema::PCC_Class:
+  case Sema::PCC_ObjCInstanceVariableList:
+  case Sema::PCC_Template:
+  case Sema::PCC_MemberTemplate:
+  case Sema::PCC_Statement:
+  case Sema::PCC_RecoveryInFunction:
+  case Sema::PCC_Type:
     return true;
     
-  case Action::PCC_ObjCInterface:
-  case Action::PCC_ObjCImplementation:
-  case Action::PCC_Expression:
-  case Action::PCC_Condition:
+  case Sema::PCC_ObjCInterface:
+  case Sema::PCC_ObjCImplementation:
+  case Sema::PCC_Expression:
+  case Sema::PCC_Condition:
     return false;
     
-  case Action::PCC_ForInit:
+  case Sema::PCC_ForInit:
     return LangOpts.ObjC1 || LangOpts.C99;
   }
   
@@ -1211,13 +1211,13 @@
 }
 
 /// \brief Add language constructs that show up for "ordinary" names.
-static void AddOrdinaryNameResults(Action::ParserCompletionContext CCC,
+static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
                                    Scope *S,
                                    Sema &SemaRef,
                                    ResultBuilder &Results) {
   typedef CodeCompletionResult Result;
   switch (CCC) {
-  case Action::PCC_Namespace:
+  case Sema::PCC_Namespace:
     if (SemaRef.getLangOptions().CPlusPlus) {
       CodeCompletionString *Pattern = 0;
       
@@ -1276,7 +1276,7 @@
     AddTypedefResult(Results);
     // Fall through
 
-  case Action::PCC_Class:
+  case Sema::PCC_Class:
     if (SemaRef.getLangOptions().CPlusPlus) {
       // Using declaration
       CodeCompletionString *Pattern = new CodeCompletionString;
@@ -1300,7 +1300,7 @@
         Results.AddResult(Result(Pattern));
       }
 
-      if (CCC == Action::PCC_Class) {
+      if (CCC == Sema::PCC_Class) {
         AddTypedefResult(Results);
 
         // public:
@@ -1324,8 +1324,8 @@
     }
     // Fall through
 
-  case Action::PCC_Template:
-  case Action::PCC_MemberTemplate:
+  case Sema::PCC_Template:
+  case Sema::PCC_MemberTemplate:
     if (SemaRef.getLangOptions().CPlusPlus && Results.includeCodePatterns()) {
       // template < parameters >
       CodeCompletionString *Pattern = new CodeCompletionString;
@@ -1340,24 +1340,24 @@
     AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results);
     break;
 
-  case Action::PCC_ObjCInterface:
+  case Sema::PCC_ObjCInterface:
     AddObjCInterfaceResults(SemaRef.getLangOptions(), Results, true);
     AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results);
     AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results);
     break;
       
-  case Action::PCC_ObjCImplementation:
+  case Sema::PCC_ObjCImplementation:
     AddObjCImplementationResults(SemaRef.getLangOptions(), Results, true);
     AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results);
     AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results);
     break;
       
-  case Action::PCC_ObjCInstanceVariableList:
+  case Sema::PCC_ObjCInstanceVariableList:
     AddObjCVisibilityResults(SemaRef.getLangOptions(), Results, true);
     break;
       
-  case Action::PCC_RecoveryInFunction:
-  case Action::PCC_Statement: {
+  case Sema::PCC_RecoveryInFunction:
+  case Sema::PCC_Statement: {
     AddTypedefResult(Results);
 
     CodeCompletionString *Pattern = 0;
@@ -1529,12 +1529,12 @@
   }
 
   // Fall through (for statement expressions).
-  case Action::PCC_ForInit:
-  case Action::PCC_Condition:
+  case Sema::PCC_ForInit:
+  case Sema::PCC_Condition:
     AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results);
     // Fall through: conditions and statements can have expressions.
 
-  case Action::PCC_Expression: {
+  case Sema::PCC_Expression: {
     CodeCompletionString *Pattern = 0;
     if (SemaRef.getLangOptions().CPlusPlus) {
       // 'this', if we're in a non-static member function.
@@ -1670,14 +1670,14 @@
     break;
   }
       
-  case Action::PCC_Type:
+  case Sema::PCC_Type:
     break;
   }
 
   if (WantTypesInContext(CCC, SemaRef.getLangOptions()))
     AddTypeSpecifierResults(SemaRef.getLangOptions(), Results);
 
-  if (SemaRef.getLangOptions().CPlusPlus && CCC != Action::PCC_Type)
+  if (SemaRef.getLangOptions().CPlusPlus && CCC != Sema::PCC_Type)
     Results.AddResult(Result("operator"));
 }
 
@@ -2322,35 +2322,35 @@
 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S, 
                                             Sema::ParserCompletionContext PCC) {
   switch (PCC) {
-  case Action::PCC_Namespace:
+  case Sema::PCC_Namespace:
     return CodeCompletionContext::CCC_TopLevel;
       
-  case Action::PCC_Class:
+  case Sema::PCC_Class:
     return CodeCompletionContext::CCC_ClassStructUnion;
 
-  case Action::PCC_ObjCInterface:
+  case Sema::PCC_ObjCInterface:
     return CodeCompletionContext::CCC_ObjCInterface;
       
-  case Action::PCC_ObjCImplementation:
+  case Sema::PCC_ObjCImplementation:
     return CodeCompletionContext::CCC_ObjCImplementation;
 
-  case Action::PCC_ObjCInstanceVariableList:
+  case Sema::PCC_ObjCInstanceVariableList:
     return CodeCompletionContext::CCC_ObjCIvarList;
       
-  case Action::PCC_Template:
-  case Action::PCC_MemberTemplate:
-  case Action::PCC_RecoveryInFunction:
+  case Sema::PCC_Template:
+  case Sema::PCC_MemberTemplate:
+  case Sema::PCC_RecoveryInFunction:
     return CodeCompletionContext::CCC_Other;
       
-  case Action::PCC_Expression:
-  case Action::PCC_ForInit:
-  case Action::PCC_Condition:
+  case Sema::PCC_Expression:
+  case Sema::PCC_ForInit:
+  case Sema::PCC_Condition:
     return CodeCompletionContext::CCC_Expression;
       
-  case Action::PCC_Statement:
+  case Sema::PCC_Statement:
     return CodeCompletionContext::CCC_Statement;
 
-  case Action::PCC_Type:
+  case Sema::PCC_Type:
     return CodeCompletionContext::CCC_Type;
   }
   
@@ -4855,8 +4855,8 @@
 
 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
   CodeCompleteOrdinaryName(S,
-                           S->getFnParent()? Action::PCC_RecoveryInFunction 
-                                           : Action::PCC_Namespace);
+                           S->getFnParent()? Sema::PCC_RecoveryInFunction 
+                                           : Sema::PCC_Namespace);
 }
 
 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
@@ -4912,8 +4912,8 @@
   // do for function calls.
   
   CodeCompleteOrdinaryName(S,
-                           S->getFnParent()? Action::PCC_RecoveryInFunction 
-                                           : Action::PCC_Namespace);
+                           S->getFnParent()? Sema::PCC_RecoveryInFunction 
+                                           : Sema::PCC_Namespace);
 }
 
 void Sema::CodeCompleteNaturalLanguage() {

Modified: cfe/trunk/lib/Sema/SemaDecl.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDecl.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaDecl.cpp (original)
+++ cfe/trunk/lib/Sema/SemaDecl.cpp Thu Aug 26 18:41:50 2010
@@ -42,14 +42,6 @@
 using namespace clang;
 using namespace sema;
 
-/// getDeclName - Return a pretty name for the specified decl if possible, or
-/// an empty string if not.  This is used for pretty crash reporting.
-std::string Sema::getDeclName(Decl *D) {
-  if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(D))
-    return DN->getQualifiedNameAsString();
-  return "";
-}
-
 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr) {
   return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
 }
@@ -4921,7 +4913,7 @@
     const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true);
 }
 
-Decl *Sema::ActOnFinishFunctionBody(Decl *D, StmtArg BodyArg) {
+Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
   return ActOnFinishFunctionBody(D, move(BodyArg), false);
 }
 

Modified: cfe/trunk/lib/Sema/SemaDeclAttr.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclAttr.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaDeclAttr.cpp (original)
+++ cfe/trunk/lib/Sema/SemaDeclAttr.cpp Thu Aug 26 18:41:50 2010
@@ -2412,7 +2412,7 @@
 ///
 /// The state token we use is the start index of this scope
 /// on the warning stack.
-Action::ParsingDeclStackState Sema::PushParsingDeclaration() {
+Sema::ParsingDeclStackState Sema::PushParsingDeclaration() {
   ParsingDeclDepth++;
   return (ParsingDeclStackState) DelayedDiagnostics.size();
 }

Modified: cfe/trunk/lib/Sema/SemaDeclCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclCXX.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaDeclCXX.cpp (original)
+++ cfe/trunk/lib/Sema/SemaDeclCXX.cpp Thu Aug 26 18:41:50 2010
@@ -584,7 +584,7 @@
 /// example:
 ///    class foo : public bar, virtual private baz {
 /// 'public bar' and 'virtual private baz' are each base-specifiers.
-Sema::BaseResult
+BaseResult
 Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
                          bool Virtual, AccessSpecifier Access,
                          ParsedType basetype, SourceLocation BaseLoc) {
@@ -1056,7 +1056,7 @@
 }
 
 /// ActOnMemInitializer - Handle a C++ member initializer.
-Sema::MemInitResult
+MemInitResult
 Sema::ActOnMemInitializer(Decl *ConstructorD,
                           Scope *S,
                           CXXScopeSpec &SS,
@@ -1262,7 +1262,7 @@
   return false;
 }
 
-Sema::MemInitResult
+MemInitResult
 Sema::BuildMemberInitializer(FieldDecl *Member, Expr **Args,
                              unsigned NumArgs, SourceLocation IdLoc,
                              SourceLocation LParenLoc,
@@ -1359,7 +1359,7 @@
                                                   RParenLoc);
 }
 
-Sema::MemInitResult
+MemInitResult
 Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
                            Expr **Args, unsigned NumArgs, 
                            SourceLocation LParenLoc, SourceLocation RParenLoc, 
@@ -1519,7 +1519,7 @@
       = InitializationKind::CreateDefault(Constructor->getLocation());
     InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0);
     BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind,
-                               Sema::MultiExprArg(SemaRef, 0, 0));
+                               MultiExprArg(SemaRef, 0, 0));
     break;
   }
 
@@ -1548,8 +1548,7 @@
     InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 
                                    &CopyCtorArg, 1);
     BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind,
-                               Sema::MultiExprArg(SemaRef, 
-                                                  &CopyCtorArg, 1));
+                               MultiExprArg(&CopyCtorArg, 1));
     break;
   }
 
@@ -1673,7 +1672,7 @@
     
     ExprResult MemberInit
       = InitSeq.Perform(SemaRef, Entities.back(), InitKind, 
-                        Sema::MultiExprArg(SemaRef, &CopyCtorArgE, 1));
+                        MultiExprArg(&CopyCtorArgE, 1));
     MemberInit = SemaRef.MaybeCreateCXXExprWithTemporaries(MemberInit.get());
     if (MemberInit.isInvalid())
       return true;
@@ -1698,8 +1697,7 @@
     
     InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0);
     ExprResult MemberInit = 
-      InitSeq.Perform(SemaRef, InitEntity, InitKind, 
-                      Sema::MultiExprArg(SemaRef, 0, 0));
+      InitSeq.Perform(SemaRef, InitEntity, InitKind, MultiExprArg());
     if (MemberInit.isInvalid())
       return true;
 
@@ -4621,7 +4619,7 @@
                                    /*TemplateArgs=*/0,
                                    /*SuppressQualifierCheck=*/true);
     if (OpEqualRef.isInvalid())
-      return S.StmtError();
+      return StmtError();
     
     // Build the call to the assignment operator.
 
@@ -4629,7 +4627,7 @@
                                                       OpEqualRef.takeAs<Expr>(),
                                                         Loc, &From, 1, 0, Loc);
     if (Call.isInvalid())
-      return S.StmtError();
+      return StmtError();
     
     return S.Owned(Call.takeAs<Stmt>());
   }
@@ -4640,7 +4638,7 @@
   if (!ArrayTy) {
     ExprResult Assignment = S.CreateBuiltinBinOp(Loc, BO_Assign, To, From);
     if (Assignment.isInvalid())
-      return S.StmtError();
+      return StmtError();
     
     return S.Owned(Assignment.takeAs<Stmt>());
   }
@@ -4707,7 +4705,7 @@
                                                 To, From, 
                                                 CopyingBaseSubobject, Depth+1);
   if (Copy.isInvalid())
-    return S.StmtError();
+    return StmtError();
   
   // Construct the loop that copies all elements of this array.
   return S.ActOnForStmt(Loc, Loc, InitStmt, 
@@ -6947,8 +6945,7 @@
       
       InitializationSequence InitSeq(*this, InitEntity, InitKind, 0, 0);
       ExprResult MemberInit = 
-        InitSeq.Perform(*this, InitEntity, InitKind, 
-                        Sema::MultiExprArg(*this, 0, 0));
+        InitSeq.Perform(*this, InitEntity, InitKind, MultiExprArg());
       MemberInit = MaybeCreateCXXExprWithTemporaries(MemberInit.get());
       // Note, MemberInit could actually come back empty if no initialization 
       // is required (e.g., because it would call a trivial default constructor)

Modified: cfe/trunk/lib/Sema/SemaExprCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaExprCXX.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaExprCXX.cpp (original)
+++ cfe/trunk/lib/Sema/SemaExprCXX.cpp Thu Aug 26 18:41:50 2010
@@ -1587,16 +1587,16 @@
     ASTOwningVector<Expr*> ConstructorArgs(S);
     
     if (S.CompleteConstructorCall(cast<CXXConstructorDecl>(Method),
-                                  Sema::MultiExprArg(S, &From, 1),
+                                  MultiExprArg(&From, 1),
                                   CastLoc, ConstructorArgs))
-      return S.ExprError();
+      return ExprError();
     
     ExprResult Result = 
     S.BuildCXXConstructExpr(CastLoc, Ty, cast<CXXConstructorDecl>(Method), 
                             move_arg(ConstructorArgs),
                             /*ZeroInit*/ false, CXXConstructExpr::CK_Complete);
     if (Result.isInvalid())
-      return S.ExprError();
+      return ExprError();
     
     return S.MaybeBindToTemporary(Result.takeAs<Expr>());
   }
@@ -2182,8 +2182,7 @@
   InitializationKind Kind = InitializationKind::CreateCopy(E->getLocStart(),
                                                            SourceLocation());
   InitializationSequence InitSeq(Self, Entity, Kind, &E, 1);
-  ExprResult Result = InitSeq.Perform(Self, Entity, Kind, 
-                                    Sema::MultiExprArg(Self, &E, 1));
+  ExprResult Result = InitSeq.Perform(Self, Entity, Kind, MultiExprArg(&E, 1));
   if (Result.isInvalid())
     return true;
   
@@ -2784,7 +2783,7 @@
   return ActOnCallExpr(/*Scope*/ 0,
                        MemExpr,
                        /*LPLoc*/ ExpectedLParenLoc,
-                       Sema::MultiExprArg(*this, 0, 0),
+                       MultiExprArg(),
                        /*CommaLocs*/ 0,
                        /*RPLoc*/ ExpectedLParenLoc);
 }

Modified: cfe/trunk/lib/Sema/SemaExprObjC.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaExprObjC.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaExprObjC.cpp (original)
+++ cfe/trunk/lib/Sema/SemaExprObjC.cpp Thu Aug 26 18:41:50 2010
@@ -24,9 +24,9 @@
 
 using namespace clang;
 
-Sema::ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
-                                              ExprTy **strings,
-                                              unsigned NumStrings) {
+ExprResult Sema::ParseObjCStringLiteral(SourceLocation *AtLocs,
+                                        Expr **strings,
+                                        unsigned NumStrings) {
   StringLiteral **Strings = reinterpret_cast<StringLiteral**>(strings);
 
   // Most ObjC strings are formed out of a single piece.  However, we *can*
@@ -133,11 +133,11 @@
   return new (Context) ObjCEncodeExpr(StrTy, EncodedTypeInfo, AtLoc, RParenLoc);
 }
 
-Sema::ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
-                                                 SourceLocation EncodeLoc,
-                                                 SourceLocation LParenLoc,
-                                                 ParsedType ty,
-                                                 SourceLocation RParenLoc) {
+ExprResult Sema::ParseObjCEncodeExpression(SourceLocation AtLoc,
+                                           SourceLocation EncodeLoc,
+                                           SourceLocation LParenLoc,
+                                           ParsedType ty,
+                                           SourceLocation RParenLoc) {
   // FIXME: Preserve type source info ?
   TypeSourceInfo *TInfo;
   QualType EncodedType = GetTypeFromParser(ty, &TInfo);
@@ -148,11 +148,11 @@
   return BuildObjCEncodeExpression(AtLoc, TInfo, RParenLoc);
 }
 
-Sema::ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
-                                                   SourceLocation AtLoc,
-                                                   SourceLocation SelLoc,
-                                                   SourceLocation LParenLoc,
-                                                   SourceLocation RParenLoc) {
+ExprResult Sema::ParseObjCSelectorExpression(Selector Sel,
+                                             SourceLocation AtLoc,
+                                             SourceLocation SelLoc,
+                                             SourceLocation LParenLoc,
+                                             SourceLocation RParenLoc) {
   ObjCMethodDecl *Method = LookupInstanceMethodInGlobalPool(Sel,
                              SourceRange(LParenLoc, RParenLoc), false, false);
   if (!Method)
@@ -170,11 +170,11 @@
   return new (Context) ObjCSelectorExpr(Ty, Sel, AtLoc, RParenLoc);
 }
 
-Sema::ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
-                                                   SourceLocation AtLoc,
-                                                   SourceLocation ProtoLoc,
-                                                   SourceLocation LParenLoc,
-                                                   SourceLocation RParenLoc) {
+ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId,
+                                             SourceLocation AtLoc,
+                                             SourceLocation ProtoLoc,
+                                             SourceLocation LParenLoc,
+                                             SourceLocation RParenLoc) {
   ObjCProtocolDecl* PDecl = LookupProtocol(ProtocolId, ProtoLoc);
   if (!PDecl) {
     Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;

Modified: cfe/trunk/lib/Sema/SemaInit.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaInit.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaInit.cpp (original)
+++ cfe/trunk/lib/Sema/SemaInit.cpp Thu Aug 26 18:41:50 2010
@@ -265,8 +265,7 @@
     }
     
     ExprResult MemberInit
-      = InitSeq.Perform(SemaRef, MemberEntity, Kind, 
-                        Sema::MultiExprArg(SemaRef, 0, 0));
+      = InitSeq.Perform(SemaRef, MemberEntity, Kind, MultiExprArg());
     if (MemberInit.isInvalid()) {
       hadError = true;
       return;
@@ -375,8 +374,7 @@
       }
 
       ExprResult ElementInit
-        = InitSeq.Perform(SemaRef, ElementEntity, Kind, 
-                          Sema::MultiExprArg(SemaRef, 0, 0));
+        = InitSeq.Perform(SemaRef, ElementEntity, Kind, MultiExprArg());
       if (ElementInit.isInvalid()) {
         hadError = true;
         return;
@@ -680,8 +678,7 @@
       
       if (Seq) {
         ExprResult Result = 
-          Seq.Perform(SemaRef, Entity, Kind,
-                      Sema::MultiExprArg(SemaRef, &expr, 1));
+          Seq.Perform(SemaRef, Entity, Kind, MultiExprArg(&expr, 1));
         if (Result.isInvalid())
           hadError = true;
         
@@ -3369,7 +3366,7 @@
       << CurInitExpr->getSourceRange();
     CandidateSet.NoteCandidates(S, OCD_AllCandidates, &CurInitExpr, 1);
     if (!IsExtraneousCopy || S.isSFINAEContext())
-      return S.ExprError();
+      return ExprError();
     return move(CurInit);
       
   case OR_Ambiguous:
@@ -3377,7 +3374,7 @@
       << (int)Entity.getKind() << CurInitExpr->getType()
       << CurInitExpr->getSourceRange();
     CandidateSet.NoteCandidates(S, OCD_ViableCandidates, &CurInitExpr, 1);
-    return S.ExprError();
+    return ExprError();
     
   case OR_Deleted:
     S.Diag(Loc, diag::err_temp_copy_deleted)
@@ -3385,7 +3382,7 @@
       << CurInitExpr->getSourceRange();
     S.Diag(Best->Function->getLocation(), diag::note_unavailable_here)
       << Best->Function->isDeleted();
-    return S.ExprError();
+    return ExprError();
   }
 
   CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
@@ -3424,10 +3421,9 @@
   // Determine the arguments required to actually perform the
   // constructor call (we might have derived-to-base conversions, or
   // the copy constructor may have default arguments).
-  if (S.CompleteConstructorCall(Constructor,
-                                Sema::MultiExprArg(S, &CurInitExpr, 1),
+  if (S.CompleteConstructorCall(Constructor, MultiExprArg(&CurInitExpr, 1),
                                 Loc, ConstructorArgs))
-    return S.ExprError();
+    return ExprError();
 
   // Actually perform the constructor call.
   CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
@@ -3459,12 +3455,12 @@
 InitializationSequence::Perform(Sema &S,
                                 const InitializedEntity &Entity,
                                 const InitializationKind &Kind,
-                                Action::MultiExprArg Args,
+                                MultiExprArg Args,
                                 QualType *ResultType) {
   if (SequenceKind == FailedSequence) {
     unsigned NumArgs = Args.size();
     Diagnose(S, Entity, Kind, (Expr **)Args.release(), NumArgs);
-    return S.ExprError();
+    return ExprError();
   }
   
   if (SequenceKind == DependentSequence) {
@@ -3559,7 +3555,7 @@
     assert(Args.size() == 1);
     CurInit = ExprResult(((Expr **)(Args.get()))[0]->Retain());
     if (CurInit.isInvalid())
-      return S.ExprError();
+      return ExprError();
     break;
     
   case SK_ConstructorInitialization:
@@ -3573,7 +3569,7 @@
   for (step_iterator Step = step_begin(), StepEnd = step_end();
        Step != StepEnd; ++Step) {
     if (CurInit.isInvalid())
-      return S.ExprError();
+      return ExprError();
     
     Expr *CurInitExpr = (Expr *)CurInit.get();
     QualType SourceType = CurInitExpr? CurInitExpr->getType() : QualType();
@@ -3603,7 +3599,7 @@
                                          CurInitExpr->getLocStart(),
                                          CurInitExpr->getSourceRange(), 
                                          &BasePath, IgnoreBaseAccess))
-        return S.ExprError();
+        return ExprError();
         
       if (S.BasePathInvolvesVirtualBase(BasePath)) {
         QualType T = SourceType;
@@ -3636,7 +3632,7 @@
           << BitField->getDeclName()
           << CurInitExpr->getSourceRange();
         S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
-        return S.ExprError();
+        return ExprError();
       }
 
       if (CurInitExpr->refersToVectorElement()) {
@@ -3645,14 +3641,14 @@
           << Entity.getType().isVolatileQualified()
           << CurInitExpr->getSourceRange();
         PrintInitLocationNote(S, Entity);
-        return S.ExprError();
+        return ExprError();
       }
         
       // Reference binding does not have any corresponding ASTs.
 
       // Check exception specifications
       if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
-        return S.ExprError();
+        return ExprError();
 
       break;
 
@@ -3661,7 +3657,7 @@
 
       // Check exception specifications
       if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
-        return S.ExprError();
+        return ExprError();
 
       break;
         
@@ -3688,9 +3684,9 @@
         // Determine the arguments required to actually perform the constructor
         // call.
         if (S.CompleteConstructorCall(Constructor,
-                                      Sema::MultiExprArg(S, &CurInitExpr, 1),
+                                      MultiExprArg(&CurInitExpr, 1),
                                       Loc, ConstructorArgs))
-          return S.ExprError();
+          return ExprError();
         
         // Build the an expression that constructs a temporary.
         CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor, 
@@ -3698,7 +3694,7 @@
                                           /*ZeroInit*/ false,
                                           CXXConstructExpr::CK_Complete);
         if (CurInit.isInvalid())
-          return S.ExprError();
+          return ExprError();
 
         S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
                                  FoundFn.getAccess());
@@ -3724,7 +3720,7 @@
         // we don't want to turn off access control here for c-style casts.
         if (S.PerformObjectArgumentInitialization(CurInitExpr, /*Qualifier=*/0,
                                                   FoundFn, Conversion))
-          return S.ExprError();
+          return ExprError();
 
         // Do a little dance to make sure that CurInit has the proper
         // pointer.
@@ -3734,7 +3730,7 @@
         CurInit = S.Owned(S.BuildCXXMemberCallExpr(CurInitExpr, FoundFn,
                                                    Conversion));
         if (CurInit.isInvalid() || !CurInit.get())
-          return S.ExprError();
+          return ExprError();
         
         CastKind = CK_UserDefinedConversion;
         
@@ -3792,7 +3788,7 @@
 
       if (S.PerformImplicitConversion(CurInitExpr, Step->Type, *Step->ICS,
                                       Sema::AA_Converting, IgnoreBaseAccess))
-        return S.ExprError();
+        return ExprError();
         
       CurInit.release();
       CurInit = S.Owned(CurInitExpr);
@@ -3803,7 +3799,7 @@
       InitListExpr *InitList = cast<InitListExpr>(CurInitExpr);
       QualType Ty = Step->Type;
       if (S.CheckInitList(Entity, InitList, ResultType? *ResultType : Ty))
-        return S.ExprError();
+        return ExprError();
 
       CurInit.release();
       CurInit = S.Owned(InitList);
@@ -3836,7 +3832,7 @@
       // call.
       if (S.CompleteConstructorCall(Constructor, move(Args), 
                                     Loc, ConstructorArgs))
-        return S.ExprError();
+        return ExprError();
           
       
       if (Entity.getKind() == InitializedEntity::EK_Temporary &&
@@ -3881,7 +3877,7 @@
                                             ConstructKind);
       }
       if (CurInit.isInvalid())
-        return S.ExprError();
+        return ExprError();
 
       // Only check access if all of that succeeded.
       S.CheckConstructorAccess(Loc, Constructor, Entity,
@@ -3933,7 +3929,7 @@
                                      getAssignmentAction(Entity),
                                      &Complained)) {
         PrintInitLocationNote(S, Entity);
-        return S.ExprError();
+        return ExprError();
       } else if (Complained)
         PrintInitLocationNote(S, Entity);
 
@@ -4448,5 +4444,5 @@
                                                            EqualLoc);
   InitializationSequence Seq(*this, Entity, Kind, &InitE, 1);
   Init.release();
-  return Seq.Perform(*this, Entity, Kind, MultiExprArg(*this, &InitE, 1));
+  return Seq.Perform(*this, Entity, Kind, MultiExprArg(&InitE, 1));
 }

Modified: cfe/trunk/lib/Sema/SemaOverload.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaOverload.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaOverload.cpp (original)
+++ cfe/trunk/lib/Sema/SemaOverload.cpp Thu Aug 26 18:41:50 2010
@@ -3423,7 +3423,7 @@
     return;
 
   // Overload resolution is always an unevaluated context.
-  EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
 
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function)){
     // C++ [class.copy]p3:
@@ -3586,7 +3586,7 @@
     return;
 
   // Overload resolution is always an unevaluated context.
-  EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
 
   // Add this candidate
   CandidateSet.push_back(OverloadCandidate());
@@ -3784,7 +3784,7 @@
     return;
 
   // Overload resolution is always an unevaluated context.
-  EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
 
   // Add this candidate
   CandidateSet.push_back(OverloadCandidate());
@@ -3945,7 +3945,7 @@
     return;
 
   // Overload resolution is always an unevaluated context.
-  EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
 
   CandidateSet.push_back(OverloadCandidate());
   OverloadCandidate& Candidate = CandidateSet.back();
@@ -4090,7 +4090,7 @@
                                bool IsAssignmentOperator,
                                unsigned NumContextualBoolArguments) {
   // Overload resolution is always an unevaluated context.
-  EnterExpressionEvaluationContext Unevaluated(*this, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
 
   // Add this candidate
   CandidateSet.push_back(OverloadCandidate());
@@ -6618,13 +6618,13 @@
   LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
                  Sema::LookupOrdinaryName);
   if (SemaRef.DiagnoseEmptyLookup(S, SS, R, Sema::CTC_Expression))
-    return SemaRef.ExprError();
+    return ExprError();
 
   assert(!R.empty() && "lookup results empty despite recovery");
 
   // Build an implicit member call if appropriate.  Just drop the
   // casts and such from the call, we don't really care.
-  ExprResult NewFn = SemaRef.ExprError();
+  ExprResult NewFn = ExprError();
   if ((*R.begin())->isCXXClassMember())
     NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, R, ExplicitTemplateArgs);
   else if (ExplicitTemplateArgs)
@@ -6633,13 +6633,13 @@
     NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
 
   if (NewFn.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // This shouldn't cause an infinite loop because we're giving it
   // an expression with non-empty lookup results, which should never
   // end up here.
   return SemaRef.ActOnCallExpr(/*Scope*/ 0, NewFn.take(), LParenLoc,
-                         Sema::MultiExprArg(SemaRef, Args, NumArgs),
+                               MultiExprArg(Args, NumArgs),
                                CommaLocs, RParenLoc);
 }
 
@@ -7421,7 +7421,7 @@
 /// type (C++ [over.call.object]), which can end up invoking an
 /// overloaded function call operator (@c operator()) or performing a
 /// user-defined conversion on the object argument.
-Sema::ExprResult
+ExprResult
 Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object,
                                    SourceLocation LParenLoc,
                                    Expr **Args, unsigned NumArgs,
@@ -7560,8 +7560,7 @@
     CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(Object, Best->FoundDecl,
                                                    Conv);
       
-    return ActOnCallExpr(S, CE, LParenLoc,
-                         MultiExprArg(*this, (ExprTy**)Args, NumArgs),
+    return ActOnCallExpr(S, CE, LParenLoc, MultiExprArg(Args, NumArgs),
                          CommaLocs, RParenLoc);
   }
 

Modified: cfe/trunk/lib/Sema/SemaTemplate.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaTemplate.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaTemplate.cpp (original)
+++ cfe/trunk/lib/Sema/SemaTemplate.cpp Thu Aug 26 18:41:50 2010
@@ -712,7 +712,7 @@
                         SS.getRange());
 }
 
-Sema::DeclResult
+DeclResult
 Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
                          SourceLocation KWLoc, CXXScopeSpec &SS,
                          IdentifierInfo *Name, SourceLocation NameLoc,
@@ -1518,7 +1518,7 @@
   return Context.getTemplateSpecializationType(Name, TemplateArgs, CanonType);
 }
 
-Action::TypeResult
+TypeResult
 Sema::ActOnTemplateIdType(TemplateTy TemplateD, SourceLocation TemplateLoc,
                           SourceLocation LAngleLoc,
                           ASTTemplateArgsPtr TemplateArgsIn,
@@ -1547,12 +1547,12 @@
   return CreateParsedType(Result, DI);
 }
 
-Sema::TypeResult Sema::ActOnTagTemplateIdType(TypeResult TypeResult,
-                                              TagUseKind TUK,
-                                              DeclSpec::TST TagSpec,
-                                              SourceLocation TagLoc) {
+TypeResult Sema::ActOnTagTemplateIdType(TypeResult TypeResult,
+                                        TagUseKind TUK,
+                                        TypeSpecifierType TagSpec,
+                                        SourceLocation TagLoc) {
   if (TypeResult.isInvalid())
-    return Sema::TypeResult();
+    return ::TypeResult();
 
   // FIXME: preserve source info, ideally without copying the DI.
   TypeSourceInfo *DI;
@@ -4634,7 +4634,7 @@
 }
 
 // Explicit instantiation of a class template specialization
-Sema::DeclResult
+DeclResult
 Sema::ActOnExplicitInstantiation(Scope *S,
                                  SourceLocation ExternLoc,
                                  SourceLocation TemplateLoc,
@@ -4839,7 +4839,7 @@
 
   bool Owned = false;
   bool IsDependent = false;
-  Decl *TagD = ActOnTag(S, TagSpec, Action::TUK_Reference,
+  Decl *TagD = ActOnTag(S, TagSpec, Sema::TUK_Reference,
                         KWLoc, SS, Name, NameLoc, Attr, AS_none,
                         MultiTemplateParamsArg(*this, 0, 0),
                         Owned, IsDependent);
@@ -4951,10 +4951,10 @@
   return TagD;
 }
 
-Sema::DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
-                                                  SourceLocation ExternLoc,
-                                                  SourceLocation TemplateLoc,
-                                                  Declarator &D) {
+DeclResult Sema::ActOnExplicitInstantiation(Scope *S,
+                                            SourceLocation ExternLoc,
+                                            SourceLocation TemplateLoc,
+                                            Declarator &D) {
   // Explicit instantiations always require a name.
   // TODO: check if/when DNInfo should replace Name.
   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
@@ -5204,7 +5204,7 @@
   return (Decl*) 0;
 }
 
-Sema::TypeResult
+TypeResult
 Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                         const CXXScopeSpec &SS, IdentifierInfo *Name,
                         SourceLocation TagLoc, SourceLocation NameLoc) {
@@ -5228,7 +5228,7 @@
   return ParsedType::make(Context.getDependentNameType(Kwd, NNS, Name));
 }
 
-Sema::TypeResult
+TypeResult
 Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, 
                         const CXXScopeSpec &SS, const IdentifierInfo &II, 
                         SourceLocation IdLoc) {
@@ -5263,7 +5263,7 @@
   return CreateParsedType(T, TSI);
 }
 
-Sema::TypeResult
+TypeResult
 Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc, 
                         const CXXScopeSpec &SS, SourceLocation TemplateLoc, 
                         ParsedType Ty) {

Modified: cfe/trunk/lib/Sema/SemaTemplateInstantiate.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaTemplateInstantiate.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaTemplateInstantiate.cpp (original)
+++ cfe/trunk/lib/Sema/SemaTemplateInstantiate.cpp Thu Aug 26 18:41:50 2010
@@ -821,7 +821,7 @@
                             getSema().FindInstantiatedDecl(E->getLocation(),
                                                            VD, TemplateArgs));
     if (!VD)
-      return SemaRef.ExprError();
+      return ExprError();
 
     // Derive the type we want the substituted decl to have.  This had
     // better be non-dependent, or these checks will have serious problems.
@@ -1201,7 +1201,7 @@
   // PushDeclContext because we don't have a scope.
   ContextRAII SavedContext(*this, Instantiation);
   EnterExpressionEvaluationContext EvalContext(*this, 
-                                               Action::PotentiallyEvaluated);
+                                               Sema::PotentiallyEvaluated);
 
   // If this is an instantiation of a local class, merge this local
   // instantiation scope with the enclosing scope. Otherwise, every

Modified: cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp (original)
+++ cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp Thu Aug 26 18:41:50 2010
@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===/
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Lookup.h"
+#include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Template.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
@@ -20,7 +21,6 @@
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/TypeLoc.h"
-#include "clang/Basic/PrettyStackTrace.h"
 #include "clang/Lex/Preprocessor.h"
 
 using namespace clang;
@@ -147,7 +147,7 @@
       if (Aligned->isAlignmentDependent()) {
         // The alignment expression is not potentially evaluated.
         EnterExpressionEvaluationContext Unevaluated(*this,
-                                                     Action::Unevaluated);
+                                                     Sema::Unevaluated);
 
         if (Aligned->isAlignmentExpr()) {
           ExprResult Result = SubstExpr(Aligned->getAlignmentExpr(),
@@ -493,7 +493,7 @@
     BitWidth = 0;
   else if (BitWidth) {
     // The bit-width expression is not potentially evaluated.
-    EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+    EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
     ExprResult InstantiatedBitWidth
       = SemaRef.SubstExpr(BitWidth, TemplateArgs);
@@ -581,7 +581,7 @@
   Expr *AssertExpr = D->getAssertExpr();
 
   // The expression in a static assertion is not potentially evaluated.
-  EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
   ExprResult InstantiatedAssertExpr
     = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
@@ -620,7 +620,7 @@
     if (Expr *UninstValue = EC->getInitExpr()) {
       // The enumerator's value expression is not potentially evaluated.
       EnterExpressionEvaluationContext Unevaluated(SemaRef,
-                                                   Action::Unevaluated);
+                                                   Sema::Unevaluated);
 
       Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
     }
@@ -2070,7 +2070,7 @@
     PendingInstantiations.swap(SavedPendingInstantiations);
 
   EnterExpressionEvaluationContext EvalContext(*this, 
-                                               Action::PotentiallyEvaluated);
+                                               Sema::PotentiallyEvaluated);
   ActOnStartOfFunctionDef(0, Function);
 
   // Introduce a new scope where local variable instantiations will be
@@ -2718,10 +2718,8 @@
 
     // Instantiate function definitions
     if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Inst.first)) {
-      PrettyStackTraceActionsDecl CrashInfo(Function,
-                                            Function->getLocation(), *this,
-                                            Context.getSourceManager(),
-                                           "instantiating function definition");
+      PrettyDeclStackTraceEntry CrashInfo(*this, Function, SourceLocation(),
+                                          "instantiating function definition");
       bool DefinitionRequired = Function->getTemplateSpecializationKind() ==
                                 TSK_ExplicitInstantiationDefinition;
       InstantiateFunctionDefinition(/*FIXME:*/Inst.second, Function, true,
@@ -2754,10 +2752,9 @@
       break;
     }
 
-    PrettyStackTraceActionsDecl CrashInfo(Var, Var->getLocation(), *this,
-                                          Context.getSourceManager(),
-                                          "instantiating static data member "
-                                          "definition");
+    PrettyDeclStackTraceEntry CrashInfo(*this, Var, Var->getLocation(),
+                                        "instantiating static data member "
+                                        "definition");
 
     bool DefinitionRequired = Var->getTemplateSpecializationKind() ==
                               TSK_ExplicitInstantiationDefinition;
@@ -2779,3 +2776,4 @@
     }
   }
 }
+

Modified: cfe/trunk/lib/Sema/SemaType.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaType.cpp?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaType.cpp (original)
+++ cfe/trunk/lib/Sema/SemaType.cpp Thu Aug 26 18:41:50 2010
@@ -1700,7 +1700,7 @@
          " GetTypeFromParser");
 }
 
-Sema::TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
+TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
   // C99 6.7.6: Type names have no identifier.  This is already validated by
   // the parser.
   assert(D.getIdentifier() == 0 && "Type name should have no identifier!");

Modified: cfe/trunk/lib/Sema/TreeTransform.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/TreeTransform.h?rev=112244&r1=112243&r2=112244&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/TreeTransform.h (original)
+++ cfe/trunk/lib/Sema/TreeTransform.h Thu Aug 26 18:41:50 2010
@@ -92,9 +92,6 @@
   Sema &SemaRef;
 
 public:
-  typedef Sema::MultiExprArg MultiExprArg;
-  typedef Sema::MultiStmtArg MultiStmtArg;
-  
   /// \brief Initializes a new tree transformer.
   TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
 
@@ -964,11 +961,11 @@
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
-                                                SourceLocation LParenLoc,
-                                                Stmt *Element,
-                                                Expr *Collection,
-                                                SourceLocation RParenLoc,
-                                                Stmt *Body) {
+                                          SourceLocation LParenLoc,
+                                          Stmt *Element,
+                                          Expr *Collection,
+                                          SourceLocation RParenLoc,
+                                          Stmt *Body) {
     return getSema().ActOnObjCForCollectionStmt(ForLoc, LParenLoc,
                                                 Element, 
                                                 Collection,
@@ -994,8 +991,8 @@
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
-                                       VarDecl *ExceptionDecl,
-                                       Stmt *Handler) {
+                                 VarDecl *ExceptionDecl,
+                                 Stmt *Handler) {
     return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
                                                       Handler));
   }
@@ -1005,8 +1002,8 @@
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildCXXTryStmt(SourceLocation TryLoc,
-                                     Stmt *TryBlock,
-                                     MultiStmtArg Handlers) {
+                               Stmt *TryBlock,
+                               MultiStmtArg Handlers) {
     return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, move(Handlers));
   }
 
@@ -1015,8 +1012,8 @@
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
-                                              LookupResult &R,
-                                              bool RequiresADL) {
+                                        LookupResult &R,
+                                        bool RequiresADL) {
     return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
   }
 
@@ -1026,10 +1023,10 @@
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildDeclRefExpr(NestedNameSpecifier *Qualifier,
-                                      SourceRange QualifierRange,
-                                      ValueDecl *VD,
-                                      const DeclarationNameInfo &NameInfo,
-                                      TemplateArgumentListInfo *TemplateArgs) {
+                                SourceRange QualifierRange,
+                                ValueDecl *VD,
+                                const DeclarationNameInfo &NameInfo,
+                                TemplateArgumentListInfo *TemplateArgs) {
     CXXScopeSpec SS;
     SS.setScopeRep(Qualifier);
     SS.setRange(QualifierRange);
@@ -1078,7 +1075,7 @@
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
                                        TypeSourceInfo *Type,
-                                       Action::OffsetOfComponent *Components,
+                                       Sema::OffsetOfComponent *Components,
                                        unsigned NumComponents,
                                        SourceLocation RParenLoc) {
     return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
@@ -1105,7 +1102,7 @@
     ExprResult Result
       = getSema().CreateSizeOfAlignOfExpr(SubExpr, OpLoc, isSizeOf, R);
     if (Result.isInvalid())
-      return getSema().ExprError();
+      return ExprError();
 
     return move(Result);
   }
@@ -1154,7 +1151,7 @@
 
       if (getSema().PerformObjectMemberConversion(Base, Qualifier,
                                                   FoundDecl, Member))
-        return getSema().ExprError();
+        return ExprError();
 
       MemberExpr *ME =
         new (getSema().Context) MemberExpr(Base, isArrow,
@@ -1281,7 +1278,7 @@
       = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
                                            Init);
     if (Result.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArrayExprs.release();
     return move(Result);
@@ -1420,7 +1417,7 @@
       break;
     }
 
-    return getSema().ExprError();
+    return ExprError();
   }
 
   /// \brief Build a new C++ static_cast expression.
@@ -1503,7 +1500,7 @@
     return getSema().ActOnCXXTypeConstructExpr(TypeRange,
                                              ParsedType::make(TInfo->getType()),
                                                LParenLoc,
-                                         Sema::MultiExprArg(getSema(), &Sub, 1),
+                                               MultiExprArg(&Sub, 1),
                                                /*CommaLocs=*/0,
                                                RParenLoc);
   }
@@ -1679,7 +1676,7 @@
     ASTOwningVector<Expr*> ConvertedArgs(SemaRef);
     if (getSema().CompleteConstructorCall(Constructor, move(Args), Loc, 
                                           ConvertedArgs))
-      return getSema().ExprError();
+      return ExprError();
     
     return getSema().BuildCXXConstructExpr(Loc, T, Constructor, IsElidable,
                                            move_arg(ConvertedArgs),
@@ -1826,7 +1823,7 @@
                                                          SS, 0,
                                                          false);
     if (Result.isInvalid())
-      return getSema().ExprError();
+      return ExprError();
     
     if (Result.get())
       return move(Result);
@@ -1854,7 +1851,7 @@
                                                          /*FIME:*/PropertyLoc,
                                                          SS, 0, false);
     if (Result.isInvalid())
-      return getSema().ExprError();
+      return ExprError();
     
     if (Result.get())
       return move(Result);
@@ -1901,7 +1898,7 @@
                                                          /*FIME:*/IsaLoc,
                                                          SS, 0, false);
     if (Result.isInvalid())
-      return getSema().ExprError();
+      return ExprError();
     
     if (Result.get())
       return move(Result);
@@ -1946,7 +1943,7 @@
     // Type-check the __builtin_shufflevector expression.
     ExprResult Result = SemaRef.SemaBuiltinShuffleVector(TheCall);
     if (Result.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     OwnedCall.release();
     return move(Result);
@@ -1975,7 +1972,7 @@
     {
       ExprResult E = getDerived().TransformExpr(cast<Expr>(S));
       if (E.isInvalid())
-        return getSema().StmtError();
+        return StmtError();
 
       return getSema().ActOnExprStmt(getSema().MakeFullExpr(E.take()));
     }
@@ -2273,7 +2270,7 @@
     Expr *SourceExpr = Input.getSourceDeclExpression();
     if (SourceExpr) {
       EnterExpressionEvaluationContext Unevaluated(getSema(),
-                                                   Action::Unevaluated);
+                                                   Sema::Unevaluated);
       ExprResult E = getDerived().TransformExpr(SourceExpr);
       SourceExpr = (E.isInvalid() ? 0 : E.take());
     }
@@ -2298,7 +2295,7 @@
   case TemplateArgument::Expression: {
     // Template argument expressions are not potentially evaluated.
     EnterExpressionEvaluationContext Unevaluated(getSema(),
-                                                 Action::Unevaluated);
+                                                 Sema::Unevaluated);
 
     Expr *InputExpr = Input.getSourceExpression();
     if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();
@@ -2628,7 +2625,7 @@
 
   Expr *Size = TL.getSizeExpr();
   if (Size) {
-    EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+    EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
     Size = getDerived().TransformExpr(Size).template takeAs<Expr>();
   }
   NewTL.setSizeExpr(Size);
@@ -2676,7 +2673,7 @@
     return QualType();
 
   // Array bounds are not potentially evaluated contexts
-  EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
   ExprResult SizeResult
     = getDerived().TransformExpr(T->getSizeExpr());
@@ -2717,7 +2714,7 @@
     return QualType();
 
   // Array bounds are not potentially evaluated contexts
-  EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
   ExprResult SizeResult
     = getDerived().TransformExpr(T->getSizeExpr());
@@ -2763,7 +2760,7 @@
     return QualType();
 
   // Vector sizes are not potentially evaluated contexts
-  EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
   ExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
   if (Size.isInvalid())
@@ -3018,7 +3015,7 @@
                                                       TypeOfExprTypeLoc TL,
                                                        QualType ObjectType) {
   // typeof expressions are not potentially evaluated contexts
-  EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
   ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
   if (E.isInvalid())
@@ -3073,7 +3070,7 @@
   DecltypeType *T = TL.getTypePtr();
 
   // decltype expressions are not potentially evaluated contexts
-  EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+  EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
   ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
   if (E.isInvalid())
@@ -3449,7 +3446,7 @@
        B != BEnd; ++B) {
     StmtResult Result = getDerived().TransformStmt(*B);
     if (Result.isInvalid())
-      return getSema().StmtError();
+      return StmtError();
 
     SubStmtChanged = SubStmtChanged || Result.get() != *B;
     Statements.push_back(Result.takeAs<Stmt>());
@@ -3471,17 +3468,17 @@
   ExprResult LHS, RHS;
   {
     // The case value expressions are not potentially evaluated.
-    EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+    EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
     // Transform the left-hand case value.
     LHS = getDerived().TransformExpr(S->getLHS());
     if (LHS.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
 
     // Transform the right-hand case value (for the GNU case-range extension).
     RHS = getDerived().TransformExpr(S->getRHS());
     if (RHS.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
   }
 
   // Build the case statement.
@@ -3493,12 +3490,12 @@
                                                        RHS.get(),
                                                        S->getColonLoc());
   if (Case.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the statement following the case
   StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
   if (SubStmt.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Attach the body to the case statement
   return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
@@ -3510,7 +3507,7 @@
   // Transform the statement following the default case
   StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
   if (SubStmt.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Default statements are always rebuilt
   return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
@@ -3522,7 +3519,7 @@
 TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S) {
   StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt());
   if (SubStmt.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // FIXME: Pass the real colon location in.
   SourceLocation ColonLoc = SemaRef.PP.getLocForEndOfToken(S->getIdentLoc());
@@ -3543,12 +3540,12 @@
                                       S->getConditionVariable()->getLocation(),
                                                     S->getConditionVariable()));
     if (!ConditionVar)
-      return SemaRef.StmtError();
+      return StmtError();
   } else {
     Cond = getDerived().TransformExpr(S->getCond());
   
     if (Cond.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
     
     // Convert the condition to a boolean value.
     if (S->getCond()) {
@@ -3556,7 +3553,7 @@
                                                                S->getIfLoc(), 
                                                                Cond.get());
       if (CondE.isInvalid())
-        return getSema().StmtError();
+        return StmtError();
     
       Cond = CondE.get();
     }
@@ -3564,17 +3561,17 @@
   
   Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take()));
   if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // Transform the "then" branch.
   StmtResult Then = getDerived().TransformStmt(S->getThen());
   if (Then.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the "else" branch.
   StmtResult Else = getDerived().TransformStmt(S->getElse());
   if (Else.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   if (!getDerived().AlwaysRebuild() &&
       FullCond.get() == S->getCond() &&
@@ -3601,12 +3598,12 @@
                                       S->getConditionVariable()->getLocation(),
                                                     S->getConditionVariable()));
     if (!ConditionVar)
-      return SemaRef.StmtError();
+      return StmtError();
   } else {
     Cond = getDerived().TransformExpr(S->getCond());
     
     if (Cond.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
   }
 
   // Rebuild the switch statement.
@@ -3614,12 +3611,12 @@
     = getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), Cond.get(),
                                           ConditionVar);
   if (Switch.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the body of the switch statement.
   StmtResult Body = getDerived().TransformStmt(S->getBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Complete the switch statement.
   return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
@@ -3639,12 +3636,12 @@
                                       S->getConditionVariable()->getLocation(),
                                                     S->getConditionVariable()));
     if (!ConditionVar)
-      return SemaRef.StmtError();
+      return StmtError();
   } else {
     Cond = getDerived().TransformExpr(S->getCond());
     
     if (Cond.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
 
     if (S->getCond()) {
       // Convert the condition to a boolean value.
@@ -3652,19 +3649,19 @@
                                                              S->getWhileLoc(), 
                                                                Cond.get());
       if (CondE.isInvalid())
-        return getSema().StmtError();
+        return StmtError();
       Cond = CondE;
     }
   }
 
   Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take()));
   if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the body
   StmtResult Body = getDerived().TransformStmt(S->getBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   if (!getDerived().AlwaysRebuild() &&
       FullCond.get() == S->getCond() &&
@@ -3682,12 +3679,12 @@
   // Transform the body
   StmtResult Body = getDerived().TransformStmt(S->getBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the condition
   ExprResult Cond = getDerived().TransformExpr(S->getCond());
   if (Cond.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   if (!getDerived().AlwaysRebuild() &&
       Cond.get() == S->getCond() &&
@@ -3705,7 +3702,7 @@
   // Transform the initialization statement
   StmtResult Init = getDerived().TransformStmt(S->getInit());
   if (Init.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the condition
   ExprResult Cond;
@@ -3717,12 +3714,12 @@
                                       S->getConditionVariable()->getLocation(),
                                                     S->getConditionVariable()));
     if (!ConditionVar)
-      return SemaRef.StmtError();
+      return StmtError();
   } else {
     Cond = getDerived().TransformExpr(S->getCond());
     
     if (Cond.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
 
     if (S->getCond()) {
       // Convert the condition to a boolean value.
@@ -3730,7 +3727,7 @@
                                                                S->getForLoc(), 
                                                                Cond.get());
       if (CondE.isInvalid())
-        return getSema().StmtError();
+        return StmtError();
 
       Cond = CondE.get();
     }
@@ -3738,21 +3735,21 @@
 
   Sema::FullExprArg FullCond(getSema().MakeFullExpr(Cond.take()));  
   if (!S->getConditionVariable() && S->getCond() && !FullCond.get())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the increment
   ExprResult Inc = getDerived().TransformExpr(S->getInc());
   if (Inc.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   Sema::FullExprArg FullInc(getSema().MakeFullExpr(Inc.get()));
   if (S->getInc() && !FullInc.get())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the body
   StmtResult Body = getDerived().TransformStmt(S->getBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   if (!getDerived().AlwaysRebuild() &&
       Init.get() == S->getInit() &&
@@ -3779,7 +3776,7 @@
 TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
   ExprResult Target = getDerived().TransformExpr(S->getTarget());
   if (Target.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   if (!getDerived().AlwaysRebuild() &&
       Target.get() == S->getTarget())
@@ -3806,7 +3803,7 @@
 TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
   ExprResult Result = getDerived().TransformExpr(S->getRetValue());
   if (Result.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // FIXME: We always rebuild the return statement because there is no way
   // to tell whether the return type of the function has changed.
@@ -3823,7 +3820,7 @@
     Decl *Transformed = getDerived().TransformDefinition((*D)->getLocation(),
                                                          *D);
     if (!Transformed)
-      return SemaRef.StmtError();
+      return StmtError();
 
     if (Transformed != *D)
       DeclChanged = true;
@@ -3869,7 +3866,7 @@
     Expr *OutputExpr = S->getOutputExpr(I);
     ExprResult Result = getDerived().TransformExpr(OutputExpr);
     if (Result.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
     
     ExprsChanged |= Result.get() != OutputExpr;
     
@@ -3887,7 +3884,7 @@
     Expr *InputExpr = S->getInputExpr(I);
     ExprResult Result = getDerived().TransformExpr(InputExpr);
     if (Result.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
     
     ExprsChanged |= Result.get() != InputExpr;
     
@@ -3925,7 +3922,7 @@
   // Transform the body of the @try.
   StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
   if (TryBody.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // Transform the @catch statements (if present).
   bool AnyCatchChanged = false;
@@ -3933,7 +3930,7 @@
   for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
     StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
     if (Catch.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
     if (Catch.get() != S->getCatchStmt(I))
       AnyCatchChanged = true;
     CatchStmts.push_back(Catch.release());
@@ -3944,7 +3941,7 @@
   if (S->getFinallyStmt()) {
     Finally = getDerived().TransformStmt(S->getFinallyStmt());
     if (Finally.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
   }
 
   // If nothing changed, just retain this statement.
@@ -3969,7 +3966,7 @@
     if (FromVar->getTypeSourceInfo()) {
       TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
       if (!TSInfo)
-        return SemaRef.StmtError();
+        return StmtError();
     }
     
     QualType T;
@@ -3978,17 +3975,17 @@
     else {
       T = getDerived().TransformType(FromVar->getType());
       if (T.isNull())
-        return SemaRef.StmtError();        
+        return StmtError();        
     }
     
     Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
     if (!Var)
-      return SemaRef.StmtError();
+      return StmtError();
   }
   
   StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(), 
                                              S->getRParenLoc(),
@@ -4001,7 +3998,7 @@
   // Transform the body.
   StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // If nothing changed, just retain this statement.
   if (!getDerived().AlwaysRebuild() &&
@@ -4020,7 +4017,7 @@
   if (S->getThrowExpr()) {
     Operand = getDerived().TransformExpr(S->getThrowExpr());
     if (Operand.isInvalid())
-      return getSema().StmtError();
+      return StmtError();
   }
   
   if (!getDerived().AlwaysRebuild() &&
@@ -4037,12 +4034,12 @@
   // Transform the object we are locking.
   ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
   if (Object.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // Transform the body.
   StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // If nothing change, just retain the current statement.
   if (!getDerived().AlwaysRebuild() &&
@@ -4062,17 +4059,17 @@
   // Transform the element statement.
   StmtResult Element = getDerived().TransformStmt(S->getElement());
   if (Element.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // Transform the collection expression.
   ExprResult Collection = getDerived().TransformExpr(S->getCollection());
   if (Collection.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // Transform the body.
   StmtResult Body = getDerived().TransformStmt(S->getBody());
   if (Body.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
   
   // If nothing changed, just retain this statement.
   if (!getDerived().AlwaysRebuild() &&
@@ -4103,7 +4100,7 @@
 
     QualType T = getDerived().TransformType(ExceptionDecl->getType());
     if (T.isNull())
-      return SemaRef.StmtError();
+      return StmtError();
 
     Var = getDerived().RebuildExceptionDecl(ExceptionDecl,
                                             T,
@@ -4113,13 +4110,13 @@
                                             /*FIXME: Inaccurate*/
                                     SourceRange(ExceptionDecl->getLocation()));
     if (!Var || Var->isInvalidDecl())
-      return SemaRef.StmtError();
+      return StmtError();
   }
 
   // Transform the actual exception handler.
   StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
   if (Handler.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   if (!getDerived().AlwaysRebuild() &&
       !Var &&
@@ -4138,7 +4135,7 @@
   StmtResult TryBlock
     = getDerived().TransformCompoundStmt(S->getTryBlock());
   if (TryBlock.isInvalid())
-    return SemaRef.StmtError();
+    return StmtError();
 
   // Transform the handlers.
   bool HandlerChanged = false;
@@ -4147,7 +4144,7 @@
     StmtResult Handler
       = getDerived().TransformCXXCatchStmt(S->getHandler(I));
     if (Handler.isInvalid())
-      return SemaRef.StmtError();
+      return StmtError();
 
     HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(I);
     Handlers.push_back(Handler.takeAs<Stmt>());
@@ -4179,20 +4176,20 @@
     Qualifier = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
                                                        E->getQualifierRange());
     if (!Qualifier)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   ValueDecl *ND
     = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
                                                          E->getDecl()));
   if (!ND)
-    return SemaRef.ExprError();
+    return ExprError();
 
   DeclarationNameInfo NameInfo = E->getNameInfo();
   if (NameInfo.getName()) {
     NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
     if (!NameInfo.getName())
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   if (!getDerived().AlwaysRebuild() &&
@@ -4216,7 +4213,7 @@
     for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
       TemplateArgumentLoc Loc;
       if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
-        return SemaRef.ExprError();
+        return ExprError();
       TransArgs.addArgument(Loc);
     }
   }
@@ -4260,7 +4257,7 @@
 TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
   ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
     return SemaRef.Owned(E->Retain());
@@ -4274,7 +4271,7 @@
 TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
   ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
     return SemaRef.Owned(E->Retain());
@@ -4290,7 +4287,7 @@
   // Transform the type.
   TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
   if (!Type)
-    return getSema().ExprError();
+    return ExprError();
   
   // Transform all of the components into components similar to what the
   // parser uses.
@@ -4299,7 +4296,7 @@
   // the fields again. However, __builtin_offsetof is rare enough in 
   // template code that we don't care.
   bool ExprChanged = false;
-  typedef Action::OffsetOfComponent Component;
+  typedef Sema::OffsetOfComponent Component;
   typedef OffsetOfExpr::OffsetOfNode Node;
   llvm::SmallVector<Component, 4> Components;
   for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
@@ -4313,7 +4310,7 @@
       Expr *FromIndex = E->getIndexExpr(ON.getArrayExprIndex());
       ExprResult Index = getDerived().TransformExpr(FromIndex);
       if (Index.isInvalid())
-        return getSema().ExprError();
+        return ExprError();
       
       ExprChanged = ExprChanged || Index.get() != FromIndex;
       Comp.isBrackets = true;
@@ -4358,7 +4355,7 @@
 
     TypeSourceInfo *NewT = getDerived().TransformType(OldT);
     if (!NewT)
-      return SemaRef.ExprError();
+      return ExprError();
 
     if (!getDerived().AlwaysRebuild() && OldT == NewT)
       return SemaRef.Owned(E->Retain());
@@ -4373,11 +4370,11 @@
     // C++0x [expr.sizeof]p1:
     //   The operand is either an expression, which is an unevaluated operand
     //   [...]
-    EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
+    EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated);
 
     SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
     if (SubExpr.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
       return SemaRef.Owned(E->Retain());
@@ -4393,11 +4390,11 @@
 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
   ExprResult LHS = getDerived().TransformExpr(E->getLHS());
   if (LHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult RHS = getDerived().TransformExpr(E->getRHS());
   if (RHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
 
   if (!getDerived().AlwaysRebuild() &&
@@ -4417,7 +4414,7 @@
   // Transform the callee.
   ExprResult Callee = getDerived().TransformExpr(E->getCallee());
   if (Callee.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // Transform arguments.
   bool ArgChanged = false;
@@ -4426,7 +4423,7 @@
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
     ExprResult Arg = getDerived().TransformExpr(E->getArg(I));
     if (Arg.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     // FIXME: Wrong source location information for the ','.
     FakeCommaLocs.push_back(
@@ -4455,7 +4452,7 @@
 TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   NestedNameSpecifier *Qualifier = 0;
   if (E->hasQualifier()) {
@@ -4463,14 +4460,14 @@
       = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
                                                   E->getQualifierRange());
     if (Qualifier == 0)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   ValueDecl *Member
     = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
                                                          E->getMemberDecl()));
   if (!Member)
-    return SemaRef.ExprError();
+    return ExprError();
 
   NamedDecl *FoundDecl = E->getFoundDecl();
   if (FoundDecl == E->getMemberDecl()) {
@@ -4479,7 +4476,7 @@
     FoundDecl = cast_or_null<NamedDecl>(
                    getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
     if (!FoundDecl)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   if (!getDerived().AlwaysRebuild() &&
@@ -4502,7 +4499,7 @@
     for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
       TemplateArgumentLoc Loc;
       if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
-        return SemaRef.ExprError();
+        return ExprError();
       TransArgs.addArgument(Loc);
     }
   }
@@ -4534,11 +4531,11 @@
 TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
   ExprResult LHS = getDerived().TransformExpr(E->getLHS());
   if (LHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult RHS = getDerived().TransformExpr(E->getRHS());
   if (RHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       LHS.get() == E->getLHS() &&
@@ -4561,15 +4558,15 @@
 TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
   ExprResult Cond = getDerived().TransformExpr(E->getCond());
   if (Cond.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult LHS = getDerived().TransformExpr(E->getLHS());
   if (LHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult RHS = getDerived().TransformExpr(E->getRHS());
   if (RHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       Cond.get() == E->getCond() &&
@@ -4606,13 +4603,13 @@
     OldT = E->getTypeInfoAsWritten();
     NewT = getDerived().TransformType(OldT);
     if (!NewT)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   ExprResult SubExpr
     = getDerived().TransformExpr(E->getSubExprAsWritten());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       OldT == NewT &&
@@ -4631,11 +4628,11 @@
   TypeSourceInfo *OldT = E->getTypeSourceInfo();
   TypeSourceInfo *NewT = getDerived().TransformType(OldT);
   if (!NewT)
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult Init = getDerived().TransformExpr(E->getInitializer());
   if (Init.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       OldT == NewT &&
@@ -4656,7 +4653,7 @@
 TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       Base.get() == E->getBase())
@@ -4679,7 +4676,7 @@
   for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) {
     ExprResult Init = getDerived().TransformExpr(E->getInit(I));
     if (Init.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     InitChanged = InitChanged || Init.get() != E->getInit(I);
     Inits.push_back(Init.get());
@@ -4700,7 +4697,7 @@
   // transform the initializer value
   ExprResult Init = getDerived().TransformExpr(E->getInit());
   if (Init.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // transform the designators.
   ASTOwningVector<Expr*, 4> ArrayExprs(SemaRef);
@@ -4718,7 +4715,7 @@
     if (D->isArrayDesignator()) {
       ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(*D));
       if (Index.isInvalid())
-        return SemaRef.ExprError();
+        return ExprError();
 
       Desig.AddDesignator(Designator::getArray(Index.get(),
                                                D->getLBracketLoc()));
@@ -4732,11 +4729,11 @@
     ExprResult Start
       = getDerived().TransformExpr(E->getArrayRangeStart(*D));
     if (Start.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(*D));
     if (End.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     Desig.AddDesignator(Designator::getArrayRange(Start.get(),
                                                   End.get(),
@@ -4770,7 +4767,7 @@
   // need to transform the type?
   QualType T = getDerived().TransformType(E->getType());
   if (T.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       T == E->getType())
@@ -4784,11 +4781,11 @@
 TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
   TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
   if (!TInfo)
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       TInfo == E->getWrittenTypeInfo() &&
@@ -4807,7 +4804,7 @@
   for (unsigned I = 0, N = E->getNumExprs(); I != N; ++I) {
     ExprResult Init = getDerived().TransformExpr(E->getExpr(I));
     if (Init.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArgumentChanged = ArgumentChanged || Init.get() != E->getExpr(I);
     Inits.push_back(Init.get());
@@ -4836,7 +4833,7 @@
   StmtResult SubStmt
     = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
   if (SubStmt.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       SubStmt.get() == E->getSubStmt())
@@ -4855,11 +4852,11 @@
   
   TInfo1 = getDerived().TransformType(E->getArgTInfo1());
   if (!TInfo1)
-    return SemaRef.ExprError();
+    return ExprError();
 
   TInfo2 = getDerived().TransformType(E->getArgTInfo2());
   if (!TInfo2)
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       TInfo1 == E->getArgTInfo1() &&
@@ -4876,15 +4873,15 @@
 TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
   ExprResult Cond = getDerived().TransformExpr(E->getCond());
   if (Cond.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult LHS = getDerived().TransformExpr(E->getLHS());
   if (LHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult RHS = getDerived().TransformExpr(E->getRHS());
   if (RHS.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       Cond.get() == E->getCond() &&
@@ -4912,7 +4909,7 @@
   case OO_Array_New:
   case OO_Array_Delete:
     llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
-    return SemaRef.ExprError();
+    return ExprError();
     
   case OO_Call: {
     // This is a call to an object's operator().
@@ -4921,7 +4918,7 @@
     // Transform the object itself.
     ExprResult Object = getDerived().TransformExpr(E->getArg(0));
     if (Object.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     // FIXME: Poor location information
     SourceLocation FakeLParenLoc
@@ -4937,7 +4934,7 @@
       
       ExprResult Arg = getDerived().TransformExpr(E->getArg(I));
       if (Arg.isInvalid())
-        return SemaRef.ExprError();
+        return ExprError();
 
       // FIXME: Poor source location information.
       SourceLocation FakeCommaLoc
@@ -4963,27 +4960,27 @@
 
   case OO_Conditional:
     llvm_unreachable("conditional operator is not actually overloadable");
-    return SemaRef.ExprError();
+    return ExprError();
 
   case OO_None:
   case NUM_OVERLOADED_OPERATORS:
     llvm_unreachable("not an overloaded operator?");
-    return SemaRef.ExprError();
+    return ExprError();
   }
 
   ExprResult Callee = getDerived().TransformExpr(E->getCallee());
   if (Callee.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult First = getDerived().TransformExpr(E->getArg(0));
   if (First.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ExprResult Second;
   if (E->getNumArgs() == 2) {
     Second = getDerived().TransformExpr(E->getArg(1));
     if (Second.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   if (!getDerived().AlwaysRebuild() &&
@@ -5019,13 +5016,13 @@
     OldT = E->getTypeInfoAsWritten();
     NewT = getDerived().TransformType(OldT);
     if (!NewT)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   ExprResult SubExpr
     = getDerived().TransformExpr(E->getSubExprAsWritten());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       OldT == NewT &&
@@ -5086,13 +5083,13 @@
     OldT = E->getTypeInfoAsWritten();
     NewT = getDerived().TransformType(OldT);
     if (!NewT)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   ExprResult SubExpr
     = getDerived().TransformExpr(E->getSubExprAsWritten());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       OldT == NewT &&
@@ -5115,7 +5112,7 @@
     TypeSourceInfo *TInfo
       = getDerived().TransformType(E->getTypeOperandSourceInfo());
     if (!TInfo)
-      return SemaRef.ExprError();
+      return ExprError();
 
     if (!getDerived().AlwaysRebuild() &&
         TInfo == E->getTypeOperandSourceInfo())
@@ -5131,11 +5128,11 @@
   // after we perform semantic analysis, so the expression is potentially
   // potentially evaluated.
   EnterExpressionEvaluationContext Unevaluated(SemaRef,
-                                      Action::PotentiallyPotentiallyEvaluated);
+                                      Sema::PotentiallyPotentiallyEvaluated);
 
   ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       SubExpr.get() == E->getExprOperand())
@@ -5167,7 +5164,7 @@
 
   QualType T = getDerived().TransformType(E->getType());
   if (T.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       T == E->getType())
@@ -5181,7 +5178,7 @@
 TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
   ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
   if (SubExpr.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       SubExpr.get() == E->getSubExpr())
@@ -5197,7 +5194,7 @@
     = cast_or_null<ParmVarDecl>(getDerived().TransformDecl(E->getLocStart(),
                                                            E->getParam()));
   if (!Param)
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       Param == E->getParam())
@@ -5213,7 +5210,7 @@
 
   QualType T = getDerived().TransformType(E->getType());
   if (T.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       T == E->getType())
@@ -5232,12 +5229,12 @@
   TemporaryBase Rebase(*this, E->getLocStart(), DeclarationName());
   QualType AllocType = getDerived().TransformType(E->getAllocatedType());
   if (AllocType.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // Transform the size of the array we're allocating (if any).
   ExprResult ArraySize = getDerived().TransformExpr(E->getArraySize());
   if (ArraySize.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // Transform the placement arguments (if any).
   bool ArgumentChanged = false;
@@ -5245,7 +5242,7 @@
   for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
     ExprResult Arg = getDerived().TransformExpr(E->getPlacementArg(I));
     if (Arg.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArgumentChanged = ArgumentChanged || Arg.get() != E->getPlacementArg(I);
     PlacementArgs.push_back(Arg.take());
@@ -5259,7 +5256,7 @@
     
     ExprResult Arg = getDerived().TransformExpr(E->getConstructorArg(I));
     if (Arg.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArgumentChanged = ArgumentChanged || Arg.get() != E->getConstructorArg(I);
     ConstructorArgs.push_back(Arg.take());
@@ -5272,7 +5269,7 @@
                                    getDerived().TransformDecl(E->getLocStart(),
                                                          E->getConstructor()));
     if (!Constructor)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   FunctionDecl *OperatorNew = 0;
@@ -5281,7 +5278,7 @@
                                  getDerived().TransformDecl(E->getLocStart(),
                                                          E->getOperatorNew()));
     if (!OperatorNew)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   FunctionDecl *OperatorDelete = 0;
@@ -5290,7 +5287,7 @@
                                    getDerived().TransformDecl(E->getLocStart(),
                                                        E->getOperatorDelete()));
     if (!OperatorDelete)
-      return SemaRef.ExprError();
+      return ExprError();
   }
   
   if (!getDerived().AlwaysRebuild() &&
@@ -5356,7 +5353,7 @@
 TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
   ExprResult Operand = getDerived().TransformExpr(E->getArgument());
   if (Operand.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // Transform the delete operator, if known.
   FunctionDecl *OperatorDelete = 0;
@@ -5365,7 +5362,7 @@
                                    getDerived().TransformDecl(E->getLocStart(),
                                                        E->getOperatorDelete()));
     if (!OperatorDelete)
-      return SemaRef.ExprError();
+      return ExprError();
   }
   
   if (!getDerived().AlwaysRebuild() &&
@@ -5390,7 +5387,7 @@
                                                      CXXPseudoDestructorExpr *E) {
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   ParsedType ObjectTypePtr;
   bool MayBePseudoDestructor = false;
@@ -5400,7 +5397,7 @@
                                               ObjectTypePtr,
                                               MayBePseudoDestructor);
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
                                               
   QualType ObjectType = ObjectTypePtr.get();
   NestedNameSpecifier *Qualifier
@@ -5408,14 +5405,14 @@
                                                 E->getQualifierRange(),
                                                 ObjectType);
   if (E->getQualifier() && !Qualifier)
-    return SemaRef.ExprError();
+    return ExprError();
 
   PseudoDestructorTypeStorage Destroyed;
   if (E->getDestroyedTypeInfo()) {
     TypeSourceInfo *DestroyedTypeInfo
       = getDerived().TransformType(E->getDestroyedTypeInfo(), ObjectType);
     if (!DestroyedTypeInfo)
-      return SemaRef.ExprError();
+      return ExprError();
     Destroyed = DestroyedTypeInfo;
   } else if (ObjectType->isDependentType()) {
     // We aren't likely to be able to resolve the identifier down to a type
@@ -5437,7 +5434,7 @@
                                                 SS, ObjectTypePtr,
                                                 false);
     if (!T)
-      return SemaRef.ExprError();
+      return ExprError();
     
     Destroyed
       = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.GetTypeFromParser(T),
@@ -5449,7 +5446,7 @@
     ScopeTypeInfo = getDerived().TransformType(E->getScopeTypeInfo(), 
                                                ObjectType);
     if (!ScopeTypeInfo)
-      return SemaRef.ExprError();
+      return ExprError();
   }
   
   return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
@@ -5484,7 +5481,7 @@
       if (isa<UsingShadowDecl>(*I))
         continue;
       else
-        return SemaRef.ExprError();
+        return ExprError();
     }
 
     // Expand using declarations.
@@ -5510,7 +5507,7 @@
     Qualifier = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
                                                     Old->getQualifierRange());
     if (!Qualifier)
-      return SemaRef.ExprError();
+      return ExprError();
     
     SS.setScopeRep(Qualifier);
     SS.setRange(Old->getQualifierRange());
@@ -5522,7 +5519,7 @@
                                                             Old->getNameLoc(),
                                                         Old->getNamingClass()));
     if (!NamingClass)
-      return SemaRef.ExprError();
+      return ExprError();
     
     R.setNamingClass(NamingClass);
   }
@@ -5537,7 +5534,7 @@
   for (unsigned I = 0, N = Old->getNumTemplateArgs(); I != N; ++I) {
     TemplateArgumentLoc Loc;
     if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I], Loc))
-      return SemaRef.ExprError();
+      return ExprError();
     TransArgs.addArgument(Loc);
   }
 
@@ -5552,7 +5549,7 @@
 
   QualType T = getDerived().TransformType(E->getQueriedType());
   if (T.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       T == E->getQueriedType())
@@ -5577,12 +5574,12 @@
     = getDerived().TransformNestedNameSpecifier(E->getQualifier(),
                                                 E->getQualifierRange());
   if (!NNS)
-    return SemaRef.ExprError();
+    return ExprError();
 
   DeclarationNameInfo NameInfo
     = getDerived().TransformDeclarationNameInfo(E->getNameInfo());
   if (!NameInfo.getName())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!E->hasExplicitTemplateArgs()) {
     if (!getDerived().AlwaysRebuild() &&
@@ -5602,7 +5599,7 @@
   for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
     TemplateArgumentLoc Loc;
     if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
-      return SemaRef.ExprError();
+      return ExprError();
     TransArgs.addArgument(Loc);
   }
 
@@ -5625,14 +5622,14 @@
 
   QualType T = getDerived().TransformType(E->getType());
   if (T.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   CXXConstructorDecl *Constructor
     = cast_or_null<CXXConstructorDecl>(
                                 getDerived().TransformDecl(E->getLocStart(),
                                                          E->getConstructor()));
   if (!Constructor)
-    return SemaRef.ExprError();
+    return ExprError();
 
   bool ArgumentChanged = false;
   ASTOwningVector<Expr*> Args(SemaRef);
@@ -5646,7 +5643,7 @@
 
     ExprResult TransArg = getDerived().TransformExpr(*Arg);
     if (TransArg.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
     Args.push_back(TransArg.get());
@@ -5708,14 +5705,14 @@
   TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
   QualType T = getDerived().TransformType(E->getType());
   if (T.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   CXXConstructorDecl *Constructor
     = cast_or_null<CXXConstructorDecl>(
                                   getDerived().TransformDecl(E->getLocStart(), 
                                                          E->getConstructor()));
   if (!Constructor)
-    return SemaRef.ExprError();
+    return ExprError();
 
   bool ArgumentChanged = false;
   ASTOwningVector<Expr*> Args(SemaRef);
@@ -5730,7 +5727,7 @@
 
     ExprResult TransArg = getDerived().TransformExpr(*Arg);
     if (TransArg.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
     Args.push_back((Expr *)TransArg.release());
@@ -5767,7 +5764,7 @@
   TemporaryBase Rebase(*this, E->getTypeBeginLoc(), DeclarationName());
   QualType T = getDerived().TransformType(E->getTypeAsWritten());
   if (T.isNull())
-    return SemaRef.ExprError();
+    return ExprError();
 
   bool ArgumentChanged = false;
   ASTOwningVector<Expr*> Args(SemaRef);
@@ -5777,7 +5774,7 @@
        Arg != ArgEnd; ++Arg) {
     ExprResult TransArg = getDerived().TransformExpr(*Arg);
     if (TransArg.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArgumentChanged = ArgumentChanged || TransArg.get() != *Arg;
     FakeCommaLocs.push_back(
@@ -5812,7 +5809,7 @@
     OldBase = E->getBase();
     Base = getDerived().TransformExpr(OldBase);
     if (Base.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     // Start the member reference and compute the object's type.
     ParsedType ObjectTy;
@@ -5823,7 +5820,7 @@
                                                 ObjectTy,
                                                 MayBePseudoDestructor);
     if (Base.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ObjectType = ObjectTy.get();
     BaseType = ((Expr*) Base.get())->getType();
@@ -5847,14 +5844,14 @@
                                                       ObjectType,
                                                       FirstQualifierInScope);
     if (!Qualifier)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   DeclarationNameInfo NameInfo
     = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo(),
                                                 ObjectType);
   if (!NameInfo.getName())
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!E->hasExplicitTemplateArgs()) {
     // This is a reference to a member without an explicitly-specified
@@ -5882,7 +5879,7 @@
   for (unsigned I = 0, N = E->getNumTemplateArgs(); I != N; ++I) {
     TemplateArgumentLoc Loc;
     if (getDerived().TransformTemplateArgument(E->getTemplateArgs()[I], Loc))
-      return SemaRef.ExprError();
+      return ExprError();
     TransArgs.addArgument(Loc);
   }
 
@@ -5906,7 +5903,7 @@
   if (!Old->isImplicitAccess()) {
     Base = getDerived().TransformExpr(Old->getBase());
     if (Base.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
     BaseType = ((Expr*) Base.get())->getType();
   } else {
     BaseType = getDerived().TransformType(Old->getBaseType());
@@ -5918,7 +5915,7 @@
       = getDerived().TransformNestedNameSpecifier(Old->getQualifier(),
                                                   Old->getQualifierRange());
     if (Qualifier == 0)
-      return SemaRef.ExprError();
+      return ExprError();
   }
 
   LookupResult R(SemaRef, Old->getMemberNameInfo(),
@@ -5936,7 +5933,7 @@
       if (isa<UsingShadowDecl>(*I))
         continue;
       else
-        return SemaRef.ExprError();
+        return ExprError();
     }
 
     // Expand using declarations.
@@ -5960,7 +5957,7 @@
                                                           Old->getMemberLoc(),
                                                         Old->getNamingClass()));
     if (!NamingClass)
-      return SemaRef.ExprError();
+      return ExprError();
     
     R.setNamingClass(NamingClass);
   }
@@ -5973,7 +5970,7 @@
       TemplateArgumentLoc Loc;
       if (getDerived().TransformTemplateArgument(Old->getTemplateArgs()[I],
                                                  Loc))
-        return SemaRef.ExprError();
+        return ExprError();
       TransArgs.addArgument(Loc);
     }
   }
@@ -6008,7 +6005,7 @@
   TypeSourceInfo *EncodedTypeInfo
     = getDerived().TransformType(E->getEncodedTypeSourceInfo());
   if (!EncodedTypeInfo)
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       EncodedTypeInfo == E->getEncodedTypeSourceInfo())
@@ -6028,7 +6025,7 @@
   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
     ExprResult Arg = getDerived().TransformExpr(E->getArg(I));
     if (Arg.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
     
     ArgChanged = ArgChanged || Arg.get() != E->getArg(I);
     Args.push_back(Arg.get());
@@ -6039,7 +6036,7 @@
     TypeSourceInfo *ReceiverTypeInfo
       = getDerived().TransformType(E->getClassReceiverTypeInfo());
     if (!ReceiverTypeInfo)
-      return SemaRef.ExprError();
+      return ExprError();
     
     // If nothing changed, just retain the existing message send.
     if (!getDerived().AlwaysRebuild() &&
@@ -6061,7 +6058,7 @@
   ExprResult Receiver
     = getDerived().TransformExpr(E->getInstanceReceiver());
   if (Receiver.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // If nothing changed, just retain the existing message send.
   if (!getDerived().AlwaysRebuild() &&
@@ -6095,7 +6092,7 @@
   // Transform the base expression.
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   // We don't need to transform the ivar; it will never change.
   
@@ -6115,7 +6112,7 @@
   // Transform the base expression.
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
   
   // We don't need to transform the property; it will never change.
   
@@ -6140,7 +6137,7 @@
   // Transform the base expression.
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
   
   // We don't need to transform the getters/setters; they will never change.
   
@@ -6171,7 +6168,7 @@
   // Transform the base expression.
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
   
   // If nothing changed, just retain the existing expression.
   if (!getDerived().AlwaysRebuild() &&
@@ -6190,7 +6187,7 @@
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) {
     ExprResult SubExpr = getDerived().TransformExpr(E->getExpr(I));
     if (SubExpr.isInvalid())
-      return SemaRef.ExprError();
+      return ExprError();
 
     ArgumentChanged = ArgumentChanged || SubExpr.get() != E->getExpr(I);
     SubExprs.push_back(SubExpr.get());
@@ -6239,7 +6236,7 @@
   // Transform the body
   StmtResult Body = getDerived().TransformStmt(E->getBody());
   if (Body.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
   // Set the parameters on the block decl.
   if (!Params.empty())
     CurBlock->TheDecl->setParams(Params.data(), Params.size());
@@ -6265,7 +6262,7 @@
   = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
                                                        E->getDecl()));
   if (!ND)
-    return SemaRef.ExprError();
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       ND == E->getDecl()) {
@@ -6624,7 +6621,7 @@
       ExprResult Result
         = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, First, Second);
       if (Result.isInvalid())
-        return SemaRef.ExprError();
+        return ExprError();
 
       return move(Result);
     }
@@ -6666,7 +6663,7 @@
   ExprResult Result
     = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Functions, Args[0], Args[1]);
   if (Result.isInvalid())
-    return SemaRef.ExprError();
+    return ExprError();
 
   return move(Result);
 }





More information about the cfe-commits mailing list