3 files changed, 55 insertions, 24 deletions
diff --git a/include/clang/Serialization/ASTBitCodes.h b/include/clang/Serialization/ASTBitCodes.h
index 3156a36040..4a3fc59e2e 100644
--- a/include/clang/Serialization/ASTBitCodes.h
+++ b/include/clang/Serialization/ASTBitCodes.h
@@ -20,6 +20,7 @@
 #include "clang/AST/Type.h"
 #include "llvm/Bitcode/BitCodes.h"
 #include "llvm/System/DataTypes.h"
+#include "llvm/ADT/DenseMap.h"
 
 namespace clang {
   namespace serialization {
@@ -81,6 +82,36 @@ namespace clang {
       }
     };
 
+    /// A structure for putting "fast"-unqualified QualTypes into a
+    /// DenseMap.  This uses the standard pointer hash function.
+    struct UnsafeQualTypeDenseMapInfo {
+      static inline bool isEqual(QualType A, QualType B) { return A == B; }
+      static inline QualType getEmptyKey() {
+        return QualType::getFromOpaquePtr((void*) 1);
+      }
+      static inline QualType getTombstoneKey() {
+        return QualType::getFromOpaquePtr((void*) 2);
+      }
+      static inline unsigned getHashValue(QualType T) {
+        assert(!T.getLocalFastQualifiers() && 
+               "hash invalid for types with fast quals");
+        uintptr_t v = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
+        return (unsigned(v) >> 4) ^ (unsigned(v) >> 9);
+      }
+    };
+
+    /// \brief Map that provides the ID numbers of each type within the
+    /// output stream, plus those deserialized from a chained PCH.
+    ///
+    /// The ID numbers of types are consecutive (in order of discovery)
+    /// and start at 1. 0 is reserved for NULL. When types are actually
+    /// stored in the stream, the ID number is shifted by 2 bits to
+    /// allow for the const/volatile qualifiers.
+    ///
+    /// Keys in the map never have const/volatile qualifiers.
+    typedef llvm::DenseMap<QualType, TypeIdx, UnsafeQualTypeDenseMapInfo>
+        TypeIdxMap;
+
     /// \brief An ID number that refers to an identifier in an AST
     /// file.
     typedef uint32_t IdentID;
diff --git a/include/clang/Serialization/ASTReader.h b/include/clang/Serialization/ASTReader.h
index cbc3775cef..aff52195a9 100644
--- a/include/clang/Serialization/ASTReader.h
+++ b/include/clang/Serialization/ASTReader.h
@@ -27,7 +27,6 @@
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -315,6 +314,17 @@ private:
   /// ID = (I + 1) << FastQual::Width has already been loaded
   std::vector<QualType> TypesLoaded;
 
+  /// \brief Map that provides the ID numbers of each type within the
+  /// output stream, plus those deserialized from a chained PCH.
+  ///
+  /// The ID numbers of types are consecutive (in order of discovery)
+  /// and start at 1. 0 is reserved for NULL. When types are actually
+  /// stored in the stream, the ID number is shifted by 2 bits to
+  /// allow for the const/volatile qualifiers.
+  ///
+  /// Keys in the map never have const/volatile qualifiers.
+  serialization::TypeIdxMap TypeIdxs;
+
   /// \brief Declarations that have already been loaded from the chain.
   ///
   /// When the pointer at index I is non-NULL, the declaration with ID
@@ -720,6 +730,16 @@ public:
   /// type.
   QualType GetType(serialization::TypeID ID);
 
+  /// \brief Returns the type ID associated with the given type.
+  /// If the type didn't come from the AST file the ID that is returned is
+  /// marked as "doesn't exist in AST".
+  serialization::TypeID GetTypeID(QualType T) const;
+
+  /// \brief Returns the type index associated with the given type.
+  /// If the type didn't come from the AST file the index that is returned is
+  /// marked as "doesn't exist in AST".
+  serialization::TypeIdx GetTypeIdx(QualType T) const;
+
   /// \brief Resolve a declaration ID into a declaration, potentially
   /// building a new declaration.
   Decl *GetDecl(serialization::DeclID ID);
diff --git a/include/clang/Serialization/ASTWriter.h b/include/clang/Serialization/ASTWriter.h
index 15977efe76..9ef14925bc 100644
--- a/include/clang/Serialization/ASTWriter.h
+++ b/include/clang/Serialization/ASTWriter.h
@@ -20,7 +20,6 @@
 #include "clang/Serialization/ASTBitCodes.h"
 #include "clang/Serialization/ASTDeserializationListener.h"
 #include "clang/Sema/SemaConsumer.h"
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
@@ -50,24 +49,6 @@ class SourceManager;
 class SwitchCase;
 class TargetInfo;
 
-/// A structure for putting "fast"-unqualified QualTypes into a
-/// DenseMap.  This uses the standard pointer hash function.
-struct UnsafeQualTypeDenseMapInfo {
-  static inline bool isEqual(QualType A, QualType B) { return A == B; }
-  static inline QualType getEmptyKey() {
-    return QualType::getFromOpaquePtr((void*) 1);
-  }
-  static inline QualType getTombstoneKey() {
-    return QualType::getFromOpaquePtr((void*) 2);
-  }
-  static inline unsigned getHashValue(QualType T) {
-    assert(!T.getLocalFastQualifiers() && 
-           "hash invalid for types with fast quals");
-    uintptr_t v = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
-    return (unsigned(v) >> 4) ^ (unsigned(v) >> 9);
-  }
-};
-
 /// \brief Writes an AST file containing the contents of a translation unit.
 ///
 /// The ASTWriter class produces a bitstream containing the serialized
@@ -146,8 +127,7 @@ private:
   /// allow for the const/volatile qualifiers.
   ///
   /// Keys in the map never have const/volatile qualifiers.
-  llvm::DenseMap<QualType, serialization::TypeIdx, UnsafeQualTypeDenseMapInfo>
-      TypeIdxs;
+  serialization::TypeIdxMap TypeIdxs;
 
   /// \brief Offset of each type in the bitstream, indexed by
   /// the type's ID.
@@ -368,13 +348,13 @@ public:
   serialization::TypeID GetOrCreateTypeID(QualType T);
 
   /// \brief Determine the type ID of an already-emitted type.
-  serialization::TypeID getTypeID(QualType T);
+  serialization::TypeID getTypeID(QualType T) const;
 
   /// \brief Force a type to be emitted and get its index.
   serialization::TypeIdx GetOrCreateTypeIdx(QualType T);
 
   /// \brief Determine the type index of an already-emitted type.
-  serialization::TypeIdx getTypeIdx(QualType T);
+  serialization::TypeIdx getTypeIdx(QualType T) const;
 
   /// \brief Emits a reference to a declarator info.
   void AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordData &Record);