1 files changed, 37 insertions, 21 deletions

diff --git a/include/clang/AST/DeclarationName.h b/include/clang/AST/DeclarationName.h
index db140999b045..ed4ac6b5d4e7 100644
--- a/include/clang/AST/DeclarationName.h
+++ b/include/clang/AST/DeclarationName.h
@@ -15,6 +15,8 @@
 
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/AST/Type.h"
+#include "clang/AST/CanonicalType.h"
+#include "clang/Basic/PartialDiagnostic.h"
 
 namespace llvm {
   template <typename T> struct DenseMapInfo;
@@ -100,7 +102,7 @@ private:
   /// CXXSpecialName, returns a pointer to it. Otherwise, returns
   /// a NULL pointer.
   CXXSpecialName *getAsCXXSpecialName() const {
-    if (getNameKind() >= CXXConstructorName && 
+    if (getNameKind() >= CXXConstructorName &&
         getNameKind() <= CXXConversionFunctionName)
       return reinterpret_cast<CXXSpecialName *>(Ptr & ~PtrMask);
     return 0;
@@ -115,16 +117,16 @@ private:
 
   // Construct a declaration name from the name of a C++ constructor,
   // destructor, or conversion function.
-  DeclarationName(CXXSpecialName *Name) 
-    : Ptr(reinterpret_cast<uintptr_t>(Name)) { 
+  DeclarationName(CXXSpecialName *Name)
+    : Ptr(reinterpret_cast<uintptr_t>(Name)) {
     assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXSpecialName");
     Ptr |= StoredDeclarationNameExtra;
   }
 
   // Construct a declaration name from the name of a C++ overloaded
   // operator.
-  DeclarationName(CXXOperatorIdName *Name) 
-    : Ptr(reinterpret_cast<uintptr_t>(Name)) { 
+  DeclarationName(CXXOperatorIdName *Name)
+    : Ptr(reinterpret_cast<uintptr_t>(Name)) {
     assert((Ptr & PtrMask) == 0 && "Improperly aligned CXXOperatorId");
     Ptr |= StoredDeclarationNameExtra;
   }
@@ -144,8 +146,8 @@ public:
   DeclarationName() : Ptr(0) { }
 
   // Construct a declaration name from an IdentifierInfo *.
-  DeclarationName(const IdentifierInfo *II) 
-    : Ptr(reinterpret_cast<uintptr_t>(II)) { 
+  DeclarationName(const IdentifierInfo *II)
+    : Ptr(reinterpret_cast<uintptr_t>(II)) {
     assert((Ptr & PtrMask) == 0 && "Improperly aligned IdentifierInfo");
   }
 
@@ -157,8 +159,8 @@ public:
 
   // operator bool() - Evaluates true when this declaration name is
   // non-empty.
-  operator bool() const { 
-    return ((Ptr & PtrMask) != 0) || 
+  operator bool() const {
+    return ((Ptr & PtrMask) != 0) ||
            (reinterpret_cast<IdentifierInfo *>(Ptr & ~PtrMask));
   }
 
@@ -170,10 +172,10 @@ public:
   bool isObjCOneArgSelector() const {
     return getStoredNameKind() == StoredObjCOneArgSelector;
   }
-  
+
   /// getNameKind - Determine what kind of name this is.
   NameKind getNameKind() const;
-  
+
 
   /// getName - Retrieve the human-readable string for this name.
   std::string getAsString() const;
@@ -181,7 +183,7 @@ public:
   /// getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in
   /// this declaration name, or NULL if this declaration name isn't a
   /// simple identifier.
-  IdentifierInfo *getAsIdentifierInfo() const { 
+  IdentifierInfo *getAsIdentifierInfo() const {
     if (isIdentifier())
       return reinterpret_cast<IdentifierInfo *>(Ptr);
     return 0;
@@ -195,12 +197,18 @@ public:
   /// an opaque pointer.
   void *getAsOpaquePtr() const { return reinterpret_cast<void*>(Ptr); }
 
+  static DeclarationName getFromOpaquePtr(void *P) {
+    DeclarationName N;
+    N.Ptr = reinterpret_cast<uintptr_t> (P);
+    return N;
+  }
+  
   static DeclarationName getFromOpaqueInteger(uintptr_t P) {
     DeclarationName N;
     N.Ptr = P;
     return N;
   }
-  
+
   /// getCXXNameType - If this name is one of the C++ names (of a
   /// constructor, destructor, or conversion function), return the
   /// type associated with that name.
@@ -290,32 +298,32 @@ public:
 
   /// getCXXConstructorName - Returns the name of a C++ constructor
   /// for the given Type.
-  DeclarationName getCXXConstructorName(QualType Ty) {
+  DeclarationName getCXXConstructorName(CanQualType Ty) {
     return getCXXSpecialName(DeclarationName::CXXConstructorName, Ty);
   }
 
   /// getCXXDestructorName - Returns the name of a C++ destructor
   /// for the given Type.
-  DeclarationName getCXXDestructorName(QualType Ty) {
+  DeclarationName getCXXDestructorName(CanQualType Ty) {
     return getCXXSpecialName(DeclarationName::CXXDestructorName, Ty);
   }
 
   /// getCXXConversionFunctionName - Returns the name of a C++
   /// conversion function for the given Type.
-  DeclarationName getCXXConversionFunctionName(QualType Ty) {
+  DeclarationName getCXXConversionFunctionName(CanQualType Ty) {
     return getCXXSpecialName(DeclarationName::CXXConversionFunctionName, Ty);
   }
 
   /// getCXXSpecialName - Returns a declaration name for special kind
   /// of C++ name, e.g., for a constructor, destructor, or conversion
   /// function.
-  DeclarationName getCXXSpecialName(DeclarationName::NameKind Kind, 
-                                    QualType Ty);
+  DeclarationName getCXXSpecialName(DeclarationName::NameKind Kind,
+                                    CanQualType Ty);
 
   /// getCXXOperatorName - Get the name of the overloadable C++
   /// operator corresponding to Op.
   DeclarationName getCXXOperatorName(OverloadedOperatorKind Op);
-};  
+};
 
 /// Insertion operator for diagnostics.  This allows sending DeclarationName's
 /// into a diagnostic with <<.
@@ -325,7 +333,15 @@ inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                   Diagnostic::ak_declarationname);
   return DB;
 }
-  
+
+/// Insertion operator for partial diagnostics.  This allows binding
+/// DeclarationName's into a partial diagnostic with <<.
+inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
+                                           DeclarationName N) {
+  PD.AddTaggedVal(N.getAsOpaqueInteger(),
+                  Diagnostic::ak_declarationname);
+  return PD;
+}
   
 }  // end namespace clang
 
@@ -344,7 +360,7 @@ struct DenseMapInfo<clang::DeclarationName> {
 
   static unsigned getHashValue(clang::DeclarationName);
 
-  static inline bool 
+  static inline bool
   isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) {
     return LHS == RHS;
   }