diff --git a/Driver/ASTConsumers.cpp b/Driver/ASTConsumers.cpp
index cdfcb68..85e379f 100644
--- a/Driver/ASTConsumers.cpp
+++ b/Driver/ASTConsumers.cpp
@@ -944,12 +944,13 @@
   void HandleTranslationUnit(TranslationUnit& TU) {
     ASTContext& C = TU.getContext();
     for (ASTContext::type_iterator I=C.types_begin(),E=C.types_end(); I!=E; ++I)
-      if (CXXRecordType *T = dyn_cast<CXXRecordType>(*I)) {
-        CXXRecordDecl* D = T->getDecl();
-        // FIXME: This lookup needs to be generalized to handle namespaces and
-        // (when we support them) templates.
-        if (D->getNameAsString() == clsname) {
-          D->viewInheritance(C);      
+      if (RecordType *T = dyn_cast<RecordType>(*I)) {
+        if (CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(T->getDecl())) {
+          // FIXME: This lookup needs to be generalized to handle namespaces and
+          // (when we support them) templates.
+          if (D->getNameAsString() == clsname) {
+            D->viewInheritance(C);      
+          }
         }
       }
   }
diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 3ca695c..b6a1ec1 100644
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -1308,7 +1308,6 @@
   }
   static bool classof(const TagType *) { return true; }
   static bool classof(const RecordType *) { return true; }
-  static bool classof(const CXXRecordType *) { return true; } 
   static bool classof(const EnumType *) { return true; }
  
 protected:  
@@ -1348,25 +1347,6 @@
   static bool classof(const RecordType *) { return true; }
 };
 
-/// CXXRecordType - This is a helper class that allows the use of
-/// isa/cast/dyncast to detect TagType objects of C++ structs/unions/classes.
-class CXXRecordType : public RecordType {
-  explicit CXXRecordType(CXXRecordDecl *D)
-    : RecordType(CXXRecord, reinterpret_cast<RecordDecl*>(D)) { }
-  friend class ASTContext;   // ASTContext creates these.
-public:
-
-  CXXRecordDecl *getDecl() const {
-    return reinterpret_cast<CXXRecordDecl*>(RecordType::getDecl());
-  }
-
-  static bool classof(const TagType *T);
-  static bool classof(const Type *T) {
-    return isa<TagType>(T) && classof(cast<TagType>(T));
-  }
-  static bool classof(const CXXRecordType *) { return true; }
-};
-
 /// EnumType - This is a helper class that allows the use of isa/cast/dyncast
 /// to detect TagType objects of enums.
 class EnumType : public TagType {
diff --git a/include/clang/AST/TypeNodes.def b/include/clang/AST/TypeNodes.def
index 273475b..e071f64 100644
--- a/include/clang/AST/TypeNodes.def
+++ b/include/clang/AST/TypeNodes.def
@@ -68,7 +68,6 @@
 NON_CANONICAL_TYPE(TypeOf, Type)
 ABSTRACT_TYPE(Tag, Type)
 TYPE(Record, TagType)
-TYPE(CXXRecord, RecordType) // FIXME: kill this one
 TYPE(Enum, TagType)
 DEPENDENT_TYPE(TemplateTypeParm, Type)
 NON_CANONICAL_TYPE(ClassTemplateSpecialization, Type)
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 702dba2..749655d 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -448,7 +448,6 @@
     break;
   }
   case Type::Record:
-  case Type::CXXRecord:
   case Type::Enum: {
     const TagType *TT = cast<TagType>(T);
 
@@ -1231,13 +1230,7 @@
   } else if (ObjCInterfaceDecl *ObjCInterface = dyn_cast<ObjCInterfaceDecl>(Decl))
     return getObjCInterfaceType(ObjCInterface);
 
-  if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Decl)) {
-    if (PrevDecl)
-      Decl->TypeForDecl = PrevDecl->TypeForDecl;
-    else
-      Decl->TypeForDecl = new (*this,8) CXXRecordType(CXXRecord);
-  }
-  else if (RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) {
+  if (RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) {
     if (PrevDecl)
       Decl->TypeForDecl = PrevDecl->TypeForDecl;
     else
@@ -2841,7 +2834,6 @@
   case Type::FunctionNoProto:
     return mergeFunctionTypes(LHS, RHS);
   case Type::Record:
-  case Type::CXXRecord:
   case Type::Enum:
     // FIXME: Why are these compatible?
     if (isObjCIdStructType(LHS) && isObjCClassStructType(RHS)) return LHS;
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 06ae9eb..3b06b4e 100644
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -119,7 +119,6 @@
   case FunctionNoProto:
   case Reference:
   case Record:
-  case CXXRecord:
     return true;
   default:
     return false;
@@ -709,10 +708,13 @@
 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
 /// includes union types.
 bool Type::isAggregateType() const {
-  if (const CXXRecordType *CXXClassType = dyn_cast<CXXRecordType>(CanonicalType))
-    return CXXClassType->getDecl()->isAggregate();
-  if (isa<RecordType>(CanonicalType))
+  if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) {
+    if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
+      return ClassDecl->isAggregate();
+
     return true;
+  }
+
   if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType))
     return EXTQT->getBaseType()->isAggregateType();
   return isa<ArrayType>(CanonicalType);
@@ -743,7 +745,6 @@
     // be completed.
     return isVoidType();
   case Record:
-  case CXXRecord:
   case Enum:
     // A tagged type (struct/union/enum/class) is incomplete if the decl is a
     // forward declaration, but not a full definition (C99 6.2.5p22).
@@ -784,11 +785,12 @@
     return true;
 
   case Record:
+    if (CXXRecordDecl *ClassDecl 
+          = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
+      return ClassDecl->isPOD();
+
     // C struct/union is POD.
     return true;
-
-  case CXXRecord:
-    return cast<CXXRecordType>(CanonicalType)->getDecl()->isPOD();
   }
 }
 
@@ -915,10 +917,6 @@
   return isa<RecordDecl>(TT->getDecl());
 }
 
-bool CXXRecordType::classof(const TagType *TT) {
-  return isa<CXXRecordDecl>(TT->getDecl());
-}
-
 bool EnumType::classof(const TagType *TT) {
   return isa<EnumDecl>(TT->getDecl());
 }
diff --git a/lib/AST/TypeSerialization.cpp b/lib/AST/TypeSerialization.cpp
index 2d052aa..b7a8f1a 100644
--- a/lib/AST/TypeSerialization.cpp
+++ b/lib/AST/TypeSerialization.cpp
@@ -112,7 +112,6 @@
       break;
 
     case Type::Record:
-    case Type::CXXRecord:
     case Type::Enum:
       // FIXME: Implement this!
       assert(false && "Can't deserialize tag types!");
diff --git a/lib/CodeGen/CGDebugInfo.cpp b/lib/CodeGen/CGDebugInfo.cpp
index 62b9f4a..101dae0 100644
--- a/lib/CodeGen/CGDebugInfo.cpp
+++ b/lib/CodeGen/CGDebugInfo.cpp
@@ -508,7 +508,6 @@
   case Type::Pointer: Slot = CreateType(cast<PointerType>(Ty), Unit); break;
   case Type::Typedef: Slot = CreateType(cast<TypedefType>(Ty), Unit); break;
   case Type::Record:
-  case Type::CXXRecord:
   case Type::Enum:
     Slot = CreateType(cast<TagType>(Ty), Unit); 
     break;
diff --git a/lib/CodeGen/CodeGenTypes.cpp b/lib/CodeGen/CodeGenTypes.cpp
index 7713133..4d92f5c 100644
--- a/lib/CodeGen/CodeGenTypes.cpp
+++ b/lib/CodeGen/CodeGenTypes.cpp
@@ -302,7 +302,6 @@
     return ConvertTypeRecursive(Context.getObjCIdType());
 
   case Type::Record:
-  case Type::CXXRecord:
   case Type::Enum: {
     const TagDecl *TD = cast<TagType>(Ty).getDecl();
     const llvm::Type *Res = ConvertTagDeclType(TD);
diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 6023469..37e4fdb 100644
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -402,8 +402,8 @@
   DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName(
                                         IsArray ? OO_Array_New : OO_New);
   if (AllocType->isRecordType() && !UseGlobal) {
-    CXXRecordDecl *Record = cast<CXXRecordType>(AllocType->getAsRecordType())
-                                ->getDecl();
+    CXXRecordDecl *Record 
+      = cast<CXXRecordDecl>(AllocType->getAsRecordType()->getDecl());
     // FIXME: We fail to find inherited overloads.
     if (FindAllocationOverload(StartLoc, Range, NewName, &AllocArgs[0],
                           AllocArgs.size(), Record, /*AllowMissing=*/true,
diff --git a/lib/Sema/SemaInherit.cpp b/lib/Sema/SemaInherit.cpp
index fe1c96b..a9135a3 100644
--- a/lib/Sema/SemaInherit.cpp
+++ b/lib/Sema/SemaInherit.cpp
@@ -87,7 +87,7 @@
     return false;
 
   Paths.setOrigin(Derived);
-  return LookupInBases(cast<CXXRecordType>(Derived->getAsRecordType())->getDecl(),
+  return LookupInBases(cast<CXXRecordDecl>(Derived->getAsRecordType()->getDecl()),
                        MemberLookupCriteria(Base), Paths);
 }
 
@@ -123,7 +123,7 @@
       if (Paths.isDetectingVirtual() && Paths.DetectedVirtual == 0) {
         // If this is the first virtual we find, remember it. If it turns out
         // there is no base path here, we'll reset it later.
-        Paths.DetectedVirtual = cast<CXXRecordType>(BaseType->getAsRecordType());
+        Paths.DetectedVirtual = BaseType->getAsRecordType();
         SetVirtual = true;
       }
     } else
diff --git a/lib/Sema/SemaInherit.h b/lib/Sema/SemaInherit.h
index 311c136..8d008a2 100644
--- a/lib/Sema/SemaInherit.h
+++ b/lib/Sema/SemaInherit.h
@@ -27,7 +27,6 @@
 
 namespace clang {
   class CXXBaseSpecifier;
-  class CXXRecordType;
 
   /// BasePathElement - An element in a path from a derived class to a
   /// base class. Each step in the path references the link from a
@@ -128,7 +127,7 @@
     BasePath ScratchPath;
 
     /// DetectedVirtual - The base class that is virtual.
-    const CXXRecordType *DetectedVirtual;
+    const RecordType *DetectedVirtual;
 
     friend class Sema;
 
@@ -167,7 +166,7 @@
     bool isDetectingVirtual() const { return DetectVirtual; }
 
     /// getDetectedVirtual - The virtual base discovered on the path.
-    const CXXRecordType* getDetectedVirtual() const {
+    const RecordType* getDetectedVirtual() const {
       return DetectedVirtual;
     }
 
diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index c4edbba..5b02221 100644
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -1612,12 +1612,12 @@
     return CheckValueInitialization(AT->getElementType(), Loc);
 
   if (const RecordType *RT = Type->getAsRecordType()) {
-    if (const CXXRecordType *CXXRec = dyn_cast<CXXRecordType>(RT)) {
+    if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
       // -- if T is a class type (clause 9) with a user-declared
       //    constructor (12.1), then the default constructor for T is
       //    called (and the initialization is ill-formed if T has no
       //    accessible default constructor);
-      if (CXXRec->getDecl()->hasUserDeclaredConstructor())
+      if (ClassDecl->hasUserDeclaredConstructor())
         // FIXME: Eventually, we'll need to put the constructor decl
         // into the AST.
         return PerformInitializationByConstructor(Type, 0, 0, Loc,
diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp
index 00849a6..dd9c850 100644
--- a/lib/Sema/SemaLookup.cpp
+++ b/lib/Sema/SemaLookup.cpp
@@ -1232,13 +1232,14 @@
   //        member, if any; and its direct and indirect base
   //        classes. Its associated namespaces are the namespaces in
   //        which its associated classes are defined. 
-  if (const CXXRecordType *ClassType 
-        = dyn_cast_or_null<CXXRecordType>(T->getAsRecordType())) {
-    addAssociatedClassesAndNamespaces(ClassType->getDecl(), 
-                                      Context, AssociatedNamespaces, 
-                                      AssociatedClasses);
-    return;
-  }
+  if (const RecordType *ClassType = T->getAsRecordType())
+    if (CXXRecordDecl *ClassDecl 
+        = dyn_cast<CXXRecordDecl>(ClassType->getDecl())) {
+      addAssociatedClassesAndNamespaces(ClassDecl, Context, 
+                                        AssociatedNamespaces, 
+                                        AssociatedClasses);
+      return;
+    }
 
   //     -- If T is an enumeration type, its associated namespace is
   //        the namespace in which it is defined. If it is class
diff --git a/lib/Sema/SemaNamedCast.cpp b/lib/Sema/SemaNamedCast.cpp
index c5bee98..166ed24 100644
--- a/lib/Sema/SemaNamedCast.cpp
+++ b/lib/Sema/SemaNamedCast.cpp
@@ -706,7 +706,7 @@
     return TSC_Failed;
   }
 
-  if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
+  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
     Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
       << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
     return TSC_Failed;
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index c33389e..fe12eb7 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -1233,7 +1233,7 @@
     return true;
   }
 
-  if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
+  if (const RecordType *VBase = Paths.getDetectedVirtual()) {
     Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
       << FromClass << ToClass << QualType(VBase, 0)
       << From->getSourceRange();
@@ -1317,46 +1317,48 @@
                                    bool AllowExplicit)
 {
   OverloadCandidateSet CandidateSet;
-  if (const CXXRecordType *ToRecordType 
-        = dyn_cast_or_null<CXXRecordType>(ToType->getAsRecordType())) {
-    // C++ [over.match.ctor]p1:
-    //   When objects of class type are direct-initialized (8.5), or
-    //   copy-initialized from an expression of the same or a
-    //   derived class type (8.5), overload resolution selects the
-    //   constructor. [...] For copy-initialization, the candidate
-    //   functions are all the converting constructors (12.3.1) of
-    //   that class. The argument list is the expression-list within
-    //   the parentheses of the initializer.
-    CXXRecordDecl *ToRecordDecl = ToRecordType->getDecl();
-    DeclarationName ConstructorName 
-      = Context.DeclarationNames.getCXXConstructorName(
-                        Context.getCanonicalType(ToType).getUnqualifiedType());
-    DeclContext::lookup_iterator Con, ConEnd;
-    for (llvm::tie(Con, ConEnd) = ToRecordDecl->lookup(ConstructorName);
-         Con != ConEnd; ++Con) {
-      CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
-      if (Constructor->isConvertingConstructor())
-        AddOverloadCandidate(Constructor, &From, 1, CandidateSet,
-                             /*SuppressUserConversions=*/true);
+  if (const RecordType *ToRecordType = ToType->getAsRecordType()) {
+    if (CXXRecordDecl *ToRecordDecl 
+          = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
+      // C++ [over.match.ctor]p1:
+      //   When objects of class type are direct-initialized (8.5), or
+      //   copy-initialized from an expression of the same or a
+      //   derived class type (8.5), overload resolution selects the
+      //   constructor. [...] For copy-initialization, the candidate
+      //   functions are all the converting constructors (12.3.1) of
+      //   that class. The argument list is the expression-list within
+      //   the parentheses of the initializer.
+      DeclarationName ConstructorName 
+        = Context.DeclarationNames.getCXXConstructorName(
+                          Context.getCanonicalType(ToType).getUnqualifiedType());
+      DeclContext::lookup_iterator Con, ConEnd;
+      for (llvm::tie(Con, ConEnd) = ToRecordDecl->lookup(ConstructorName);
+           Con != ConEnd; ++Con) {
+        CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
+        if (Constructor->isConvertingConstructor())
+          AddOverloadCandidate(Constructor, &From, 1, CandidateSet,
+                               /*SuppressUserConversions=*/true);
+      }
     }
   }
 
   if (!AllowConversionFunctions) {
     // Don't allow any conversion functions to enter the overload set.
-  } else if (const CXXRecordType *FromRecordType
-               = dyn_cast_or_null<CXXRecordType>(
-                                        From->getType()->getAsRecordType())) {
-    // Add all of the conversion functions as candidates.
-    // FIXME: Look for conversions in base classes!
-    CXXRecordDecl *FromRecordDecl = FromRecordType->getDecl();
-    OverloadedFunctionDecl *Conversions 
-      = FromRecordDecl->getConversionFunctions();
-    for (OverloadedFunctionDecl::function_iterator Func 
-           = Conversions->function_begin();
-         Func != Conversions->function_end(); ++Func) {
-      CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
-      if (AllowExplicit || !Conv->isExplicit())
-        AddConversionCandidate(Conv, From, ToType, CandidateSet);
+  } else if (const RecordType *FromRecordType 
+               = From->getType()->getAsRecordType()) {
+    if (CXXRecordDecl *FromRecordDecl 
+          = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
+      // Add all of the conversion functions as candidates.
+      // FIXME: Look for conversions in base classes!
+      OverloadedFunctionDecl *Conversions 
+        = FromRecordDecl->getConversionFunctions();
+      for (OverloadedFunctionDecl::function_iterator Func 
+             = Conversions->function_begin();
+           Func != Conversions->function_end(); ++Func) {
+        CXXConversionDecl *Conv = cast<CXXConversionDecl>(*Func);
+        if (AllowExplicit || !Conv->isExplicit())
+          AddConversionCandidate(Conv, From, ToType, CandidateSet);
+      }
     }
   }
 
diff --git a/lib/Sema/SemaTemplateInstantiate.cpp b/lib/Sema/SemaTemplateInstantiate.cpp
index d2e8419..6b43463 100644
--- a/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/lib/Sema/SemaTemplateInstantiate.cpp
@@ -255,14 +255,6 @@
 }
 
 QualType 
-TemplateTypeInstantiator::InstantiateCXXRecordType(const CXXRecordType *T,
-                                                   unsigned Quals) const {
-  // FIXME: Implement this
-  assert(false && "Cannot instantiate CXXRecordType yet");
-  return QualType();
-}
-
-QualType 
 TemplateTypeInstantiator::InstantiateEnumType(const EnumType *T,
                                               unsigned Quals) const {
   // FIXME: Implement this