Added locations and type source info for DeclarationName.

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

31 files changed, 961 insertions, 454 deletions

diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
index aa1985a888..747c46e6f1 100644
--- a/include/clang/AST/ASTContext.h
+++ b/include/clang/AST/ASTContext.h
@@ -870,7 +870,8 @@ public:
     return getExtQualType(T, Qs);
   }
 
-  DeclarationName getNameForTemplate(TemplateName Name);
+  DeclarationNameInfo getNameForTemplate(TemplateName Name,
+                                         SourceLocation NameLoc);
 
   TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin,
                                          UnresolvedSetIterator End);
diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h
index b2f0e48204..ac9b0f74ab 100644
--- a/include/clang/AST/Decl.h
+++ b/include/clang/AST/Decl.h
@@ -1153,11 +1153,15 @@ private:
                       DependentFunctionTemplateSpecializationInfo *>
     TemplateOrSpecialization;
 
+  /// DNLoc - Provides source/type location info for the
+  /// declaration name embedded in the DeclaratorDecl base class.
+  DeclarationNameLoc DNLoc;
+
 protected:
-  FunctionDecl(Kind DK, DeclContext *DC, SourceLocation L,
-               DeclarationName N, QualType T, TypeSourceInfo *TInfo,
+  FunctionDecl(Kind DK, DeclContext *DC, const DeclarationNameInfo &NameInfo,
+               QualType T, TypeSourceInfo *TInfo,
                StorageClass S, StorageClass SCAsWritten, bool isInline)
-    : DeclaratorDecl(DK, DC, L, N, T, TInfo),
+    : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo),
       DeclContext(DK),
       ParamInfo(0), Body(),
       SClass(S), SClassAsWritten(SCAsWritten), IsInline(isInline),
@@ -1165,7 +1169,9 @@ protected:
       HasWrittenPrototype(true), IsDeleted(false), IsTrivial(false),
       IsCopyAssignment(false),
       HasImplicitReturnZero(false),
-      EndRangeLoc(L), TemplateOrSpecialization() {}
+      EndRangeLoc(NameInfo.getEndLoc()),
+      TemplateOrSpecialization(),
+      DNLoc(NameInfo.getInfo()) {}
 
   typedef Redeclarable<FunctionDecl> redeclarable_base;
   virtual FunctionDecl *getNextRedeclaration() { return RedeclLink.getNext(); }
@@ -1185,8 +1191,24 @@ public:
                               StorageClass S = None,
                               StorageClass SCAsWritten = None,
                               bool isInline = false,
+                              bool hasWrittenPrototype = true) {
+    DeclarationNameInfo NameInfo(N, L);
+    return FunctionDecl::Create(C, DC, NameInfo, T, TInfo, S, SCAsWritten,
+                                isInline, hasWrittenPrototype);
+  }
+
+  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
+                              const DeclarationNameInfo &NameInfo,
+                              QualType T, TypeSourceInfo *TInfo,
+                              StorageClass S = None,
+                              StorageClass SCAsWritten = None,
+                              bool isInline = false,
                               bool hasWrittenPrototype = true);
 
+  DeclarationNameInfo getNameInfo() const {
+    return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
+  }
+
   virtual void getNameForDiagnostic(std::string &S,
                                     const PrintingPolicy &Policy,
                                     bool Qualified) const;
diff --git a/include/clang/AST/DeclCXX.h b/include/clang/AST/DeclCXX.h
index 93653c4635..c3b71b9542 100644
--- a/include/clang/AST/DeclCXX.h
+++ b/include/clang/AST/DeclCXX.h
@@ -1065,19 +1065,20 @@ public:
 /// struct/union/class.
 class CXXMethodDecl : public FunctionDecl {
 protected:
-  CXXMethodDecl(Kind DK, CXXRecordDecl *RD, SourceLocation L,
-                DeclarationName N, QualType T, TypeSourceInfo *TInfo,
+  CXXMethodDecl(Kind DK, CXXRecordDecl *RD,
+                const DeclarationNameInfo &NameInfo,
+                QualType T, TypeSourceInfo *TInfo,
                 bool isStatic, StorageClass SCAsWritten, bool isInline)
-    : FunctionDecl(DK, RD, L, N, T, TInfo, (isStatic ? Static : None),
+    : FunctionDecl(DK, RD, NameInfo, T, TInfo, (isStatic ? Static : None),
                    SCAsWritten, isInline) {}
 
 public:
   static CXXMethodDecl *Create(ASTContext &C, CXXRecordDecl *RD,
-                              SourceLocation L, DeclarationName N,
-                              QualType T, TypeSourceInfo *TInfo,
-                              bool isStatic = false,
-                              StorageClass SCAsWritten = FunctionDecl::None,
-                              bool isInline = false);
+                               const DeclarationNameInfo &NameInfo,
+                               QualType T, TypeSourceInfo *TInfo,
+                               bool isStatic = false,
+                               StorageClass SCAsWritten = FunctionDecl::None,
+                               bool isInline = false);
 
   bool isStatic() const { return getStorageClass() == Static; }
   bool isInstance() const { return !isStatic(); }
@@ -1392,11 +1393,11 @@ class CXXConstructorDecl : public CXXMethodDecl {
   CXXBaseOrMemberInitializer **BaseOrMemberInitializers;
   unsigned NumBaseOrMemberInitializers;
 
-  CXXConstructorDecl(CXXRecordDecl *RD, SourceLocation L,
-                     DeclarationName N, QualType T, TypeSourceInfo *TInfo,
+  CXXConstructorDecl(CXXRecordDecl *RD, const DeclarationNameInfo &NameInfo,
+                     QualType T, TypeSourceInfo *TInfo,
                      bool isExplicitSpecified, bool isInline, 
                      bool isImplicitlyDeclared)
-    : CXXMethodDecl(CXXConstructor, RD, L, N, T, TInfo, false,
+    : CXXMethodDecl(CXXConstructor, RD, NameInfo, T, TInfo, false,
                     FunctionDecl::None, isInline),
       IsExplicitSpecified(isExplicitSpecified), ImplicitlyDefined(false),
       BaseOrMemberInitializers(0), NumBaseOrMemberInitializers(0) {
@@ -1406,7 +1407,7 @@ class CXXConstructorDecl : public CXXMethodDecl {
 public:
   static CXXConstructorDecl *Create(ASTContext &C, EmptyShell Empty);
   static CXXConstructorDecl *Create(ASTContext &C, CXXRecordDecl *RD,
-                                    SourceLocation L, DeclarationName N,
+                                    const DeclarationNameInfo &NameInfo,
                                     QualType T, TypeSourceInfo *TInfo,
                                     bool isExplicit,
                                     bool isInline, bool isImplicitlyDeclared);
@@ -1540,10 +1541,9 @@ class CXXDestructorDecl : public CXXMethodDecl {
 
   FunctionDecl *OperatorDelete;
   
-  CXXDestructorDecl(CXXRecordDecl *RD, SourceLocation L,
-                    DeclarationName N, QualType T,
-                    bool isInline, bool isImplicitlyDeclared)
-    : CXXMethodDecl(CXXDestructor, RD, L, N, T, /*TInfo=*/0, false,
+  CXXDestructorDecl(CXXRecordDecl *RD, const DeclarationNameInfo &NameInfo,
+                    QualType T, bool isInline, bool isImplicitlyDeclared)
+    : CXXMethodDecl(CXXDestructor, RD, NameInfo, T, /*TInfo=*/0, false,
                     FunctionDecl::None, isInline),
       ImplicitlyDefined(false), OperatorDelete(0) {
     setImplicit(isImplicitlyDeclared);
@@ -1552,7 +1552,7 @@ class CXXDestructorDecl : public CXXMethodDecl {
 public:
   static CXXDestructorDecl *Create(ASTContext& C, EmptyShell Empty);
   static CXXDestructorDecl *Create(ASTContext &C, CXXRecordDecl *RD,
-                                   SourceLocation L, DeclarationName N,
+                                   const DeclarationNameInfo &NameInfo,
                                    QualType T, bool isInline,
                                    bool isImplicitlyDeclared);
 
@@ -1601,17 +1601,17 @@ class CXXConversionDecl : public CXXMethodDecl {
   /// explicitly wrote a cast. This is a C++0x feature.
   bool IsExplicitSpecified : 1;
 
-  CXXConversionDecl(CXXRecordDecl *RD, SourceLocation L,
-                    DeclarationName N, QualType T, TypeSourceInfo *TInfo,
+  CXXConversionDecl(CXXRecordDecl *RD, const DeclarationNameInfo &NameInfo,
+                    QualType T, TypeSourceInfo *TInfo,
                     bool isInline, bool isExplicitSpecified)
-    : CXXMethodDecl(CXXConversion, RD, L, N, T, TInfo, false,
+    : CXXMethodDecl(CXXConversion, RD, NameInfo, T, TInfo, false,
                     FunctionDecl::None, isInline),
       IsExplicitSpecified(isExplicitSpecified) { }
 
 public:
   static CXXConversionDecl *Create(ASTContext &C, EmptyShell Empty);
   static CXXConversionDecl *Create(ASTContext &C, CXXRecordDecl *RD,
-                                   SourceLocation L, DeclarationName N,
+                                   const DeclarationNameInfo &NameInfo,
                                    QualType T, TypeSourceInfo *TInfo,
                                    bool isInline, bool isExplicit);
 
diff --git a/include/clang/AST/DeclarationName.h b/include/clang/AST/DeclarationName.h
index 8a771d513c..8bb6275975 100644
--- a/include/clang/AST/DeclarationName.h
+++ b/include/clang/AST/DeclarationName.h
@@ -30,6 +30,7 @@ namespace clang {
   class IdentifierInfo;
   class MultiKeywordSelector;
   class UsingDirectiveDecl;
+  class TypeSourceInfo;
 
 /// DeclarationName - The name of a declaration. In the common case,
 /// this just stores an IdentifierInfo pointer to a normal
@@ -367,6 +368,146 @@ public:
   DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II);
 };
 
+/// DeclarationNameLoc - Additional source/type location info
+/// for a declaration name. Needs a DeclarationName in order
+/// to be interpreted correctly.
+struct DeclarationNameLoc {
+  union {
+    // The source location for identifier stored elsewhere.
+    // struct {} Identifier;
+
+    // Type info for constructors, destructors and conversion functions.
+    // Locations (if any) for the tilde (destructor) or operator keyword
+    // (conversion) are stored elsewhere.
+    struct {
+      TypeSourceInfo* TInfo;
+    } NamedType;
+
+    // The location (if any) of the operator keyword is stored elsewhere.
+    struct {
+      unsigned BeginOpNameLoc;
+      unsigned EndOpNameLoc;
+    } CXXOperatorName;
+
+    // The location (if any) of the operator keyword is stored elsewhere.
+    struct {
+      unsigned OpNameLoc;
+    } CXXLiteralOperatorName;
+
+    // struct {} CXXUsingDirective;
+    // struct {} ObjCZeroArgSelector;
+    // struct {} ObjCOneArgSelector;
+    // struct {} ObjCMultiArgSelector;
+  };
+
+  DeclarationNameLoc(DeclarationName Name);
+  // FIXME: this should go away once all DNLocs are properly initialized.
+  DeclarationNameLoc() { NamedType.TInfo = 0; }
+}; // struct DeclarationNameLoc
+
+
+/// DeclarationNameInfo - A collector data type for bundling together
+/// a DeclarationName and the correspnding source/type location info.
+struct DeclarationNameInfo {
+private:
+  /// Name - The declaration name, also encoding name kind.
+  DeclarationName Name;
+  /// Loc - The main source location for the declaration name.
+  SourceLocation NameLoc;
+  /// Info - Further source/type location info for special kinds of names.
+  DeclarationNameLoc LocInfo;
+
+public:
+  // FIXME: remove it.
+  DeclarationNameInfo() {}
+
+  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc)
+    : Name(Name), NameLoc(NameLoc), LocInfo(Name) {}
+
+  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc,
+                      DeclarationNameLoc LocInfo)
+    : Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {}
+
+  /// getName - Returns the embedded declaration name.
+  DeclarationName getName() const { return Name; }
+  /// setName - Sets the embedded declaration name.
+  void setName(DeclarationName N) { Name = N; }
+
+  /// getLoc - Returns the main location of the declaration name.
+  SourceLocation getLoc() const { return NameLoc; }
+  /// setLoc - Sets the main location of the declaration name.
+  void setLoc(SourceLocation L) { NameLoc = L; }
+
+  const DeclarationNameLoc &getInfo() const { return LocInfo; }
+  DeclarationNameLoc &getInfo() { return LocInfo; }
+  void setInfo(const DeclarationNameLoc &Info) { LocInfo = Info; }
+
+  /// getNamedTypeInfo - Returns the source type info associated to
+  /// the name. Assumes it is a constructor, destructor or conversion.
+  TypeSourceInfo *getNamedTypeInfo() const {
+    assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||
+           Name.getNameKind() == DeclarationName::CXXDestructorName ||
+           Name.getNameKind() == DeclarationName::CXXConversionFunctionName);
+    return LocInfo.NamedType.TInfo;
+  }
+  /// setNamedTypeInfo - Sets the source type info associated to
+  /// the name. Assumes it is a constructor, destructor or conversion.
+  void setNamedTypeInfo(TypeSourceInfo *TInfo) {
+    assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||
+           Name.getNameKind() == DeclarationName::CXXDestructorName ||
+           Name.getNameKind() == DeclarationName::CXXConversionFunctionName);
+    LocInfo.NamedType.TInfo = TInfo;
+  }
+
+  /// getCXXOperatorNameRange - Gets the range of the operator name
+  /// (without the operator keyword). Assumes it is a (non-literal) operator.
+  SourceRange getCXXOperatorNameRange() const {
+    assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
+    return SourceRange(
+     SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.BeginOpNameLoc),
+     SourceLocation::getFromRawEncoding(LocInfo.CXXOperatorName.EndOpNameLoc)
+                       );
+  }
+  /// setCXXOperatorNameRange - Sets the range of the operator name
+  /// (without the operator keyword). Assumes it is a C++ operator.
+  void setCXXOperatorNameRange(SourceRange R) {
+    assert(Name.getNameKind() == DeclarationName::CXXOperatorName);
+    LocInfo.CXXOperatorName.BeginOpNameLoc = R.getBegin().getRawEncoding();
+    LocInfo.CXXOperatorName.EndOpNameLoc = R.getEnd().getRawEncoding();
+  }
+
+  /// getCXXLiteralOperatorNameLoc - Returns the location of the literal
+  /// operator name (not the operator keyword).
+  /// Assumes it is a literal operator.
+  SourceLocation getCXXLiteralOperatorNameLoc() const {
+    assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
+    return SourceLocation::
+      getFromRawEncoding(LocInfo.CXXLiteralOperatorName.OpNameLoc);
+  }
+  /// setCXXLiteralOperatorNameLoc - Sets the location of the literal
+  /// operator name (not the operator keyword).
+  /// Assumes it is a literal operator.
+  void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {
+    assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);
+    LocInfo.CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();
+  }
+
+  /// getAsString - Retrieve the human-readable string for this name.
+  std::string getAsString() const;
+
+  /// printName - Print the human-readable name to a stream.
+  void printName(llvm::raw_ostream &OS) const;
+
+  /// getBeginLoc - Retrieve the location of the first token.
+  SourceLocation getBeginLoc() const { return NameLoc; }
+  /// getEndLoc - Retrieve the location of the last token.
+  SourceLocation getEndLoc() const;
+  /// getSourceRange - The range of the declaration name.
+  SourceRange getSourceRange() const {
+    return SourceRange(getBeginLoc(), getEndLoc());
+  }
+};
+
 /// Insertion operator for diagnostics.  This allows sending DeclarationName's
 /// into a diagnostic with <<.
 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
@@ -385,6 +526,12 @@ inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
   return PD;
 }
 
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     DeclarationNameInfo DNInfo) {
+  DNInfo.printName(OS);
+  return OS;
+}
+
 }  // end namespace clang
 
 namespace llvm {
diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 521353a31e..1c6ae84900 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -522,10 +522,14 @@ class DeclRefExpr : public Expr {
   // (2) the declaration's name was followed by an explicit template 
   // argument list.
   llvm::PointerIntPair<ValueDecl *, 2> DecoratedD;
-  
+
   // Loc - The location of the declaration name itself.
   SourceLocation Loc;
 
+  /// DNLoc - Provides source/type location info for the
+  /// declaration name embedded in DecoratedD.
+  DeclarationNameLoc DNLoc;
+
   /// \brief Retrieve the qualifier that preceded the declaration name, if any.
   NameQualifier *getNameQualifier() {
     if ((DecoratedD.getInt() & HasQualifierFlag) == 0)
@@ -563,6 +567,11 @@ class DeclRefExpr : public Expr {
               const TemplateArgumentListInfo *TemplateArgs,
               QualType T);
 
+  DeclRefExpr(NestedNameSpecifier *Qualifier, SourceRange QualifierRange,
+              ValueDecl *D, const DeclarationNameInfo &NameInfo,
+              const TemplateArgumentListInfo *TemplateArgs,
+              QualType T);
+
   /// \brief Construct an empty declaration reference expression.
   explicit DeclRefExpr(EmptyShell Empty)
     : Expr(DeclRefExprClass, Empty) { }
@@ -585,6 +594,14 @@ public:
                              QualType T,
                              const TemplateArgumentListInfo *TemplateArgs = 0);
 
+  static DeclRefExpr *Create(ASTContext &Context,
+                             NestedNameSpecifier *Qualifier,
+                             SourceRange QualifierRange,
+                             ValueDecl *D,
+                             const DeclarationNameInfo &NameInfo,
+                             QualType T,
+                             const TemplateArgumentListInfo *TemplateArgs = 0);
+
   /// \brief Construct an empty declaration reference expression.
   static DeclRefExpr *CreateEmpty(ASTContext &Context,
                                   bool HasQualifier, unsigned NumTemplateArgs);
@@ -593,6 +610,10 @@ public:
   const ValueDecl *getDecl() const { return DecoratedD.getPointer(); }
   void setDecl(ValueDecl *NewD) { DecoratedD.setPointer(NewD); }
 
+  DeclarationNameInfo getNameInfo() const {
+    return DeclarationNameInfo(getDecl()->getDeclName(), Loc, DNLoc);
+  }
+
   SourceLocation getLocation() const { return Loc; }
   void setLocation(SourceLocation L) { Loc = L; }
   virtual SourceRange getSourceRange() const;
@@ -1586,6 +1607,10 @@ class MemberExpr : public Expr {
   /// MemberLoc - This is the location of the member name.
   SourceLocation MemberLoc;
 
+  /// MemberDNLoc - Provides source/type location info for the
+  /// declaration name embedded in MemberDecl.
+  DeclarationNameLoc MemberDNLoc;
+
   /// IsArrow - True if this is "X->F", false if this is "X.F".
   bool IsArrow : 1;
 
@@ -1634,16 +1659,31 @@ class MemberExpr : public Expr {
 
 public:
   MemberExpr(Expr *base, bool isarrow, ValueDecl *memberdecl,
+             const DeclarationNameInfo &NameInfo, QualType ty)
+    : Expr(MemberExprClass, ty,
+           base->isTypeDependent(), base->isValueDependent()),
+      Base(base), MemberDecl(memberdecl), MemberLoc(NameInfo.getLoc()),
+      MemberDNLoc(NameInfo.getInfo()), IsArrow(isarrow),
+      HasQualifierOrFoundDecl(false), HasExplicitTemplateArgumentList(false) {
+    assert(memberdecl->getDeclName() == NameInfo.getName());
+  }
+
+  // NOTE: this constructor should be used only when it is known that
+  // the member name can not provide additional syntactic info
+  // (i.e., source locations for C++ operator names or type source info
+  // for constructors, destructors and conversion oeprators).
+  MemberExpr(Expr *base, bool isarrow, ValueDecl *memberdecl,
              SourceLocation l, QualType ty)
     : Expr(MemberExprClass, ty,
            base->isTypeDependent(), base->isValueDependent()),
-      Base(base), MemberDecl(memberdecl), MemberLoc(l), IsArrow(isarrow),
+      Base(base), MemberDecl(memberdecl), MemberLoc(l), MemberDNLoc(),
+      IsArrow(isarrow),
       HasQualifierOrFoundDecl(false), HasExplicitTemplateArgumentList(false) {}
 
   static MemberExpr *Create(ASTContext &C, Expr *base, bool isarrow,
                             NestedNameSpecifier *qual, SourceRange qualrange,
                             ValueDecl *memberdecl, DeclAccessPair founddecl,
-                            SourceLocation l,
+                            DeclarationNameInfo MemberNameInfo,
                             const TemplateArgumentListInfo *targs,
                             QualType ty);
 
@@ -1739,6 +1779,12 @@ public:
     return getExplicitTemplateArgumentList()->RAngleLoc;
   }
 
+  /// \brief Retrieve the member declaration name info.
+  DeclarationNameInfo getMemberNameInfo() const {
+    return DeclarationNameInfo(MemberDecl->getDeclName(),
+                               MemberLoc, MemberDNLoc);
+  }
+
   bool isArrow() const { return IsArrow; }
   void setArrow(bool A) { IsArrow = A; }
 
@@ -1750,9 +1796,8 @@ public:
   virtual SourceRange getSourceRange() const {
     // If we have an implicit base (like a C++ implicit this),
     // make sure not to return its location
-    SourceLocation EndLoc = MemberLoc;
-    if (HasExplicitTemplateArgumentList)
-      EndLoc = getRAngleLoc();
+    SourceLocation EndLoc = (HasExplicitTemplateArgumentList)
+      ? getRAngleLoc() : getMemberNameInfo().getEndLoc();
 
     SourceLocation BaseLoc = getBase()->getLocStart();
     if (BaseLoc.isInvalid())
diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h
index 3b59bb513a..184edcdc28 100644
--- a/include/clang/AST/ExprCXX.h
+++ b/include/clang/AST/ExprCXX.h
@@ -1411,7 +1411,7 @@ class OverloadExpr : public Expr {
   unsigned NumResults;
 
   /// The common name of these declarations.
-  DeclarationName Name;
+  DeclarationNameInfo NameInfo;
 
   /// The scope specifier, if any.
   NestedNameSpecifier *Qualifier;
@@ -1419,16 +1419,13 @@ class OverloadExpr : public Expr {
   /// The source range of the scope specifier.
   SourceRange QualifierRange;
 
-  /// The location of the name.
-  SourceLocation NameLoc;
-
 protected:
   /// True if the name was a template-id.
   bool HasExplicitTemplateArgs;
 
   OverloadExpr(StmtClass K, ASTContext &C, QualType T, bool Dependent,
                NestedNameSpecifier *Qualifier, SourceRange QRange,
-               DeclarationName Name, SourceLocation NameLoc,
+               const DeclarationNameInfo &NameInfo,
                bool HasTemplateArgs,
                UnresolvedSetIterator Begin, UnresolvedSetIterator End);
 
@@ -1473,13 +1470,17 @@ public:
   /// Gets the number of declarations in the unresolved set.
   unsigned getNumDecls() const { return NumResults; }
 
+  /// Gets the full name info.
+  const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
+  void setNameInfo(const DeclarationNameInfo &N) { NameInfo = N; }
+
   /// Gets the name looked up.
-  DeclarationName getName() const { return Name; }
-  void setName(DeclarationName N) { Name = N; }
+  DeclarationName getName() const { return NameInfo.getName(); }
+  void setName(DeclarationName N) { NameInfo.setName(N); }
 
   /// Gets the location of the name.
-  SourceLocation getNameLoc() const { return NameLoc; }
-  void setNameLoc(SourceLocation Loc) { NameLoc = Loc; }
+  SourceLocation getNameLoc() const { return NameInfo.getLoc(); }
+  void setNameLoc(SourceLocation Loc) { NameInfo.setLoc(Loc); }
 
   /// Fetches the nested-name qualifier, if one was given.
   NestedNameSpecifier *getQualifier() const { return Qualifier; }
@@ -1542,11 +1543,11 @@ class UnresolvedLookupExpr : public OverloadExpr {
   UnresolvedLookupExpr(ASTContext &C, QualType T, bool Dependent, 
                        CXXRecordDecl *NamingClass,
                        NestedNameSpecifier *Qualifier, SourceRange QRange,
-                       DeclarationName Name, SourceLocation NameLoc,
+                       const DeclarationNameInfo &NameInfo,
                        bool RequiresADL, bool Overloaded, bool HasTemplateArgs,
                        UnresolvedSetIterator Begin, UnresolvedSetIterator End)
     : OverloadExpr(UnresolvedLookupExprClass, C, T, Dependent, Qualifier, 
-                   QRange, Name, NameLoc, HasTemplateArgs, Begin, End),
+                   QRange, NameInfo, HasTemplateArgs, Begin, End),
       RequiresADL(RequiresADL), Overloaded(Overloaded), NamingClass(NamingClass)
   {}
 
@@ -1561,16 +1562,15 @@ public:
                                       CXXRecordDecl *NamingClass,
                                       NestedNameSpecifier *Qualifier,
                                       SourceRange QualifierRange,
-                                      DeclarationName Name,
-                                      SourceLocation NameLoc,
+                                      const DeclarationNameInfo &NameInfo,
                                       bool ADL, bool Overloaded,
                                       UnresolvedSetIterator Begin, 
                                       UnresolvedSetIterator End) {
     return new(C) UnresolvedLookupExpr(C,
                                        Dependent ? C.DependentTy : C.OverloadTy,
                                        Dependent, NamingClass,
-                                       Qualifier, QualifierRange,
-                                       Name, NameLoc, ADL, Overloaded, false,
+                                       Qualifier, QualifierRange, NameInfo,
+                                       ADL, Overloaded, false,
                                        Begin, End);
   }
 
@@ -1579,8 +1579,7 @@ public:
                                       CXXRecordDecl *NamingClass,
                                       NestedNameSpecifier *Qualifier,
                                       SourceRange QualifierRange,
-                                      DeclarationName Name,
-                                      SourceLocation NameLoc,
+                                      const DeclarationNameInfo &NameInfo,
                                       bool ADL,
                                       const TemplateArgumentListInfo &Args,
                                       UnresolvedSetIterator Begin, 
@@ -1642,7 +1641,7 @@ public:
   }
 
   virtual SourceRange getSourceRange() const {
-    SourceRange Range(getNameLoc());
+    SourceRange Range(getNameInfo().getSourceRange());
     if (getQualifier()) Range.setBegin(getQualifierRange().getBegin());
     if (hasExplicitTemplateArgs()) Range.setEnd(getRAngleLoc());
     return Range;
@@ -1673,10 +1672,7 @@ public:
 /// declaration can be found.
 class DependentScopeDeclRefExpr : public Expr {
   /// The name of the entity we will be referencing.
-  DeclarationName Name;
-
-  /// Location of the name of the declaration we're referencing.
-  SourceLocation Loc;
+  DeclarationNameInfo NameInfo;
 
   /// QualifierRange - The source range that covers the
   /// nested-name-specifier.
@@ -1692,12 +1688,10 @@ class DependentScopeDeclRefExpr : public Expr {
   DependentScopeDeclRefExpr(QualType T,
                             NestedNameSpecifier *Qualifier,
                             SourceRange QualifierRange,
-                            DeclarationName Name,
-                            SourceLocation NameLoc,
+                            const DeclarationNameInfo &NameInfo,
                             bool HasExplicitTemplateArgs)
     : Expr(DependentScopeDeclRefExprClass, T, true, true),
-      Name(Name), Loc(NameLoc),
-      QualifierRange(QualifierRange), Qualifier(Qualifier),
+      NameInfo(NameInfo), QualifierRange(QualifierRange), Qualifier(Qualifier),
       HasExplicitTemplateArgs(HasExplicitTemplateArgs)
   {}
 
@@ -1705,20 +1699,23 @@ public:
   static DependentScopeDeclRefExpr *Create(ASTContext &C,
                                            NestedNameSpecifier *Qualifier,
                                            SourceRange QualifierRange,
-                                           DeclarationName Name,
-                                           SourceLocation NameLoc,
+                                           const DeclarationNameInfo &NameInfo,
                               const TemplateArgumentListInfo *TemplateArgs = 0);
 
   static DependentScopeDeclRefExpr *CreateEmpty(ASTContext &C,
                                                 unsigned NumTemplateArgs);
 
   /// \brief Retrieve the name that this expression refers to.
-  DeclarationName getDeclName() const { return Name; }
-  void setDeclName(DeclarationName N) { Name =  N; }
+  const DeclarationNameInfo &getNameInfo() const { return NameInfo; }
+  void setNameInfo(const DeclarationNameInfo &N) { NameInfo =  N; }
+
+  /// \brief Retrieve the name that this expression refers to.
+  DeclarationName getDeclName() const { return NameInfo.getName(); }
+  void setDeclName(DeclarationName N) { NameInfo.setName(N); }
 
   /// \brief Retrieve the location of the name within the expression.
-  SourceLocation getLocation() const { return Loc; }
-  void setLocation(SourceLocation L) { Loc = L; }
+  SourceLocation getLocation() const { return NameInfo.getLoc(); }
+  void setLocation(SourceLocation L) { NameInfo.setLoc(L); }
 
   /// \brief Retrieve the source range of the nested-name-specifier.
   SourceRange getQualifierRange() const { return QualifierRange; }
@@ -2003,10 +2000,7 @@ class CXXDependentScopeMemberExpr : public Expr {
   /// \brief The member to which this member expression refers, which
   /// can be name, overloaded operator, or destructor.
   /// FIXME: could also be a template-id
-  DeclarationName Member;
-
-  /// \brief The location of the member name.
-  SourceLocation MemberLoc;
+  DeclarationNameInfo MemberNameInfo;
 
   CXXDependentScopeMemberExpr(ASTContext &C,
                           Expr *Base, QualType BaseType, bool IsArrow,
@@ -2014,8 +2008,7 @@ class CXXDependentScopeMemberExpr : public Expr {
                           NestedNameSpecifier *Qualifier,
                           SourceRange QualifierRange,
                           NamedDecl *FirstQualifierFoundInScope,
-                          DeclarationName Member,
-