Create a new TypeNodes.def file that enumerates all of the types,

giving them rough classifications (normal types, never-canonical
types, always-dependent types, abstract type representations) and
making it far easier to make sure that we've hit all of the cases when
decoding types. 

Switched some switch() statements on the type class over to using this
mechanism, and filtering out those things we don't care about. For
example, CodeGen should never see always-dependent or non-canonical
types, while debug info generation should never see always-dependent
types. More switch() statements on the type class need to be moved 
over to using this approach, so that we'll get warnings when we add a
new type then fail to account for it somewhere in the compiler.

As part of this, some types have been renamed:

  TypeOfExpr -> TypeOfExprType
  FunctionTypeProto -> FunctionProtoType
  FunctionTypeNoProto -> FunctionNoProtoType

There shouldn't be any functionality change...

llvm-svn: 65591

26 files changed, 248 insertions, 196 deletions

diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index d059201b5cd..53aaf513382 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -91,7 +91,7 @@ void ASTContext::PrintStats() const {
   unsigned NumTagStruct = 0, NumTagUnion = 0, NumTagEnum = 0, NumTagClass = 0;
   unsigned NumObjCInterfaces = 0, NumObjCQualifiedInterfaces = 0;
   unsigned NumObjCQualifiedIds = 0;
-  unsigned NumTypeOfTypes = 0, NumTypeOfExprs = 0;
+  unsigned NumTypeOfTypes = 0, NumTypeOfExprTypes = 0;
   
   for (unsigned i = 0, e = Types.size(); i != e; ++i) {
     Type *T = Types[i];
@@ -111,9 +111,9 @@ void ASTContext::PrintStats() const {
       ++NumArray;
     else if (isa<VectorType>(T))
       ++NumVector;
-    else if (isa<FunctionTypeNoProto>(T))
+    else if (isa<FunctionNoProtoType>(T))
       ++NumFunctionNP;
-    else if (isa<FunctionTypeProto>(T))
+    else if (isa<FunctionProtoType>(T))
       ++NumFunctionP;
     else if (isa<TypedefType>(T))
       ++NumTypeName;
@@ -134,8 +134,8 @@ void ASTContext::PrintStats() const {
       ++NumObjCQualifiedIds;
     else if (isa<TypeOfType>(T))
       ++NumTypeOfTypes;
-    else if (isa<TypeOfExpr>(T))
-      ++NumTypeOfExprs;
+    else if (isa<TypeOfExprType>(T))
+      ++NumTypeOfExprTypes;
     else {
       QualType(T, 0).dump();
       assert(0 && "Unknown type!");
@@ -164,16 +164,16 @@ void ASTContext::PrintStats() const {
   fprintf(stderr, "    %d protocol qualified id types\n",
           NumObjCQualifiedIds);
   fprintf(stderr, "    %d typeof types\n", NumTypeOfTypes);
-  fprintf(stderr, "    %d typeof exprs\n", NumTypeOfExprs);
+  fprintf(stderr, "    %d typeof exprs\n", NumTypeOfExprTypes);
   
   fprintf(stderr, "Total bytes = %d\n", int(NumBuiltin*sizeof(BuiltinType)+
     NumPointer*sizeof(PointerType)+NumArray*sizeof(ArrayType)+
     NumComplex*sizeof(ComplexType)+NumVector*sizeof(VectorType)+
     NumMemberPointer*sizeof(MemberPointerType)+
-    NumFunctionP*sizeof(FunctionTypeProto)+
-    NumFunctionNP*sizeof(FunctionTypeNoProto)+
+    NumFunctionP*sizeof(FunctionProtoType)+
+    NumFunctionNP*sizeof(FunctionNoProtoType)+
     NumTypeName*sizeof(TypedefType)+NumTagged*sizeof(TagType)+
-    NumTypeOfTypes*sizeof(TypeOfType)+NumTypeOfExprs*sizeof(TypeOfExpr)));
+    NumTypeOfTypes*sizeof(TypeOfType)+NumTypeOfExprTypes*sizeof(TypeOfExprType)));
 }
 
 
@@ -293,15 +293,20 @@ ASTContext::getTypeInfo(const Type *T) {
   uint64_t Width;
   unsigned Align;
   switch (T->getTypeClass()) {
-  case Type::TypeName: assert(0 && "Not a canonical type!");
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+    assert(false && "Should not see non-canonical or dependent types");
+    break;
+
   case Type::FunctionNoProto:
   case Type::FunctionProto:
-  default:
+  case Type::IncompleteArray:
     assert(0 && "Incomplete types have no size!");
   case Type::VariableArray:
     assert(0 && "VLAs not implemented yet!");
-  case Type::DependentSizedArray:
-    assert(0 && "Dependently-sized arrays don't have a known size");
   case Type::ConstantArray: {
     const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
     
@@ -390,6 +395,7 @@ ASTContext::getTypeInfo(const Type *T) {
     return getTypeInfo(QualType(cast<ExtQualType>(T)->getBaseType(), 0));
   case Type::ObjCQualifiedId:
   case Type::ObjCQualifiedClass:
+  case Type::ObjCQualifiedInterface:
     Width = Target.getPointerWidth(0);
     Align = Target.getPointerAlign(0);
     break;
@@ -441,7 +447,9 @@ ASTContext::getTypeInfo(const Type *T) {
     Align = Layout.getAlignment();
     break;
   }
-  case Type::Tagged: {
+  case Type::Record:
+  case Type::CXXRecord:
+  case Type::Enum: {
     const TagType *TT = cast<TagType>(T);
 
     if (TT->getDecl()->isInvalidDecl()) {
@@ -1127,32 +1135,32 @@ QualType ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) {
   return QualType(New, 0);
 }
 
-/// getFunctionTypeNoProto - Return a K&R style C function type like 'int()'.
+/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
 ///
-QualType ASTContext::getFunctionTypeNoProto(QualType ResultTy) {
+QualType ASTContext::getFunctionNoProtoType(QualType ResultTy) {
   // Unique functions, to guarantee there is only one function of a particular
   // structure.
   llvm::FoldingSetNodeID ID;
-  FunctionTypeNoProto::Profile(ID, ResultTy);
+  FunctionNoProtoType::Profile(ID, ResultTy);
   
   void *InsertPos = 0;
-  if (FunctionTypeNoProto *FT = 
-        FunctionTypeNoProtos.FindNodeOrInsertPos(ID, InsertPos))
+  if (FunctionNoProtoType *FT = 
+        FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(FT, 0);
   
   QualType Canonical;
   if (!ResultTy->isCanonical()) {
-    Canonical = getFunctionTypeNoProto(getCanonicalType(ResultTy));
+    Canonical = getFunctionNoProtoType(getCanonicalType(ResultTy));
     
     // Get the new insert position for the node we care about.
-    FunctionTypeNoProto *NewIP =
-      FunctionTypeNoProtos.FindNodeOrInsertPos(ID, InsertPos);
+    FunctionNoProtoType *NewIP =
+      FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
   }
   
-  FunctionTypeNoProto *New =new(*this,8)FunctionTypeNoProto(ResultTy,Canonical);
+  FunctionNoProtoType *New =new(*this,8)FunctionNoProtoType(ResultTy,Canonical);
   Types.push_back(New);
-  FunctionTypeNoProtos.InsertNode(New, InsertPos);
+  FunctionNoProtoTypes.InsertNode(New, InsertPos);
   return QualType(New, 0);
 }
 
@@ -1164,12 +1172,12 @@ QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray,
   // Unique functions, to guarantee there is only one function of a particular
   // structure.
   llvm::FoldingSetNodeID ID;
-  FunctionTypeProto::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic,
+  FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic,
                              TypeQuals);
 
   void *InsertPos = 0;
-  if (FunctionTypeProto *FTP = 
-        FunctionTypeProtos.FindNodeOrInsertPos(ID, InsertPos))
+  if (FunctionProtoType *FTP = 
+        FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(FTP, 0);
     
   // Determine whether the type being created is already canonical or not.  
@@ -1191,20 +1199,20 @@ QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray,
                                 isVariadic, TypeQuals);
     
     // Get the new insert position for the node we care about.
-    FunctionTypeProto *NewIP =
-      FunctionTypeProtos.FindNodeOrInsertPos(ID, InsertPos);
+    FunctionProtoType *NewIP =
+      FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
   }
   
-  // FunctionTypeProto objects are allocated with extra bytes after them
+  // FunctionProtoType objects are allocated with extra bytes after them
   // for a variable size array (for parameter types) at the end of them.
-  FunctionTypeProto *FTP = 
-    (FunctionTypeProto*)Allocate(sizeof(FunctionTypeProto) + 
+  FunctionProtoType *FTP = 
+    (FunctionProtoType*)Allocate(sizeof(FunctionProtoType) + 
                                  NumArgs*sizeof(QualType), 8);
-  new (FTP) FunctionTypeProto(ResultTy, ArgArray, NumArgs, isVariadic,
+  new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, isVariadic,
                               TypeQuals, Canonical);
   Types.push_back(FTP);
-  FunctionTypeProtos.InsertNode(FTP, InsertPos);
+  FunctionProtoTypes.InsertNode(FTP, InsertPos);
   return QualType(FTP, 0);
 }
 
@@ -1252,7 +1260,7 @@ QualType ASTContext::getTypedefType(TypedefDecl *Decl) {
   if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
   
   QualType Canonical = getCanonicalType(Decl->getUnderlyingType());
-  Decl->TypeForDecl = new(*this,8) TypedefType(Type::TypeName, Decl, Canonical);
+  Decl->TypeForDecl = new(*this,8) TypedefType(Type::Typedef, Decl, Canonical);
   Types.push_back(Decl->TypeForDecl);
   return QualType(Decl->TypeForDecl, 0);
 }
@@ -1401,14 +1409,14 @@ QualType ASTContext::getObjCQualifiedIdType(ObjCProtocolDecl **Protocols,
   return QualType(QType, 0);
 }
 
-/// getTypeOfExpr - Unlike many "get<Type>" functions, we can't unique
-/// TypeOfExpr AST's (since expression's are never shared). For example,
+/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
+/// TypeOfExprType AST's (since expression's are never shared). For example,
 /// multiple declarations that refer to "typeof(x)" all contain different
 /// DeclRefExpr's. This doesn't effect the type checker, since it operates 
 /// on canonical type's (which are always unique).
-QualType ASTContext::getTypeOfExpr(Expr *tofExpr) {
+QualType ASTContext::getTypeOfExprType(Expr *tofExpr) {
   QualType Canonical = getCanonicalType(tofExpr->getType());
-  TypeOfExpr *toe = new (*this,8) TypeOfExpr(tofExpr, Canonical);
+  TypeOfExprType *toe = new (*this,8) TypeOfExprType(tofExpr, Canonical);
   Types.push_back(toe);
   return QualType(toe, 0);
 }
@@ -2458,8 +2466,8 @@ QualType::GCAttrTypes ASTContext::getObjCGCAttrKind(const QualType &Ty) const {
 bool ASTContext::typesAreBlockCompatible(QualType lhs, QualType rhs) {
   const FunctionType *lbase = lhs->getAsFunctionType();
   const FunctionType *rbase = rhs->getAsFunctionType();
-  const FunctionTypeProto *lproto = dyn_cast<FunctionTypeProto>(lbase);
-  const FunctionTypeProto *rproto = dyn_cast<FunctionTypeProto>(rbase);
+  const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
+  const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
   if (lproto && rproto)
     return !mergeTypes(lhs, rhs).isNull();
   return false;
@@ -2561,8 +2569,8 @@ bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS) {
 QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) {
   const FunctionType *lbase = lhs->getAsFunctionType();
   const FunctionType *rbase = rhs->getAsFunctionType();
-  const FunctionTypeProto *lproto = dyn_cast<FunctionTypeProto>(lbase);
-  const FunctionTypeProto *rproto = dyn_cast<FunctionTypeProto>(rbase);
+  const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
+  const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
   bool allLTypes = true;
   bool allRTypes = true;
 
@@ -2611,7 +2619,7 @@ QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) {
   if (lproto) allRTypes = false;
   if (rproto) allLTypes = false;
 
-  const FunctionTypeProto *proto = lproto ? lproto : rproto;
+  const FunctionProtoType *proto = lproto ? lproto : rproto;
   if (proto) {
     if (proto->isVariadic()) return QualType();
     // Check that the types are compatible with the types that
@@ -2636,7 +2644,7 @@ QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) {
 
   if (allLTypes) return lhs;
   if (allRTypes) return rhs;
-  return getFunctionTypeNoProto(retType);
+  return getFunctionNoProtoType(retType);
 }
 
 QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
@@ -2739,6 +2747,27 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
 
   // The canonical type classes match.
   switch (LHSClass) {
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+    assert(false && "Non-canonical and dependent types shouldn't get here");
+    return QualType();
+
+  case Type::Reference:
+  case Type::MemberPointer:
+    assert(false && "C++ should never be in mergeTypes");
+    return QualType();
+
+  case Type::IncompleteArray:
+  case Type::VariableArray:
+  case Type::FunctionProto:
+  case Type::ExtVector:
+  case Type::ObjCQualifiedInterface:
+    assert(false && "Types are eliminated above");
+    return QualType();
+
   case Type::Pointer:
   {
     // Merge two pointer types, while trying to preserve typedef info
@@ -2808,7 +2837,9 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
   }
   case Type::FunctionNoProto:
     return mergeFunctionTypes(LHS, RHS);
-  case Type::Tagged:
+  case Type::Record:
+  case Type::CXXRecord:
+  case Type::Enum:
     // FIXME: Why are these compatible?
     if (isObjCIdStructType(LHS) && isObjCClassStructType(RHS)) return LHS;
     if (isObjCClassStructType(LHS) && isObjCIdStructType(RHS)) return LHS;
@@ -2836,10 +2867,9 @@ QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
   case Type::ObjCQualifiedId:
     // Distinct qualified id's are not compatible.
     return QualType();
-  default:
-    assert(0 && "unexpected type");
-    return QualType();
   }
+
+  return QualType();
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/clang/lib/AST/Builtins.cpp b/clang/lib/AST/Builtins.cpp
index b572e8e04b5..46b0346ca46 100644
--- a/clang/lib/AST/Builtins.cpp
+++ b/clang/lib/AST/Builtins.cpp
@@ -264,7 +264,7 @@ QualType Builtin::Context::GetBuiltinType(unsigned id, ASTContext &Context,
 
   // handle untyped/variadic arguments "T c99Style();" or "T cppStyle(...);".
   if (ArgTypes.size() == 0 && TypeStr[0] == '.')
-    return Context.getFunctionTypeNoProto(ResType);
+    return Context.getFunctionNoProtoType(ResType);
   return Context.getFunctionType(ResType, &ArgTypes[0], ArgTypes.size(),
                                  TypeStr[0] == '.', 0);
 }
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index ab654920238..b30b86980f6 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -320,9 +320,9 @@ unsigned FunctionDecl::getBuiltinID(ASTContext &Context) const {
 // Helper function for FunctionDecl::getNumParams and FunctionDecl::setParams()
 static unsigned getNumTypeParams(QualType T) {
   const FunctionType *FT = T->getAsFunctionType();
-  if (isa<FunctionTypeNoProto>(FT))
+  if (isa<FunctionNoProtoType>(FT))
     return 0;
-  return cast<FunctionTypeProto>(FT)->getNumArgs();
+  return cast<FunctionProtoType>(FT)->getNumArgs();
 }
 
 unsigned FunctionDecl::getNumParams() const {
diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp
index 294e94f5f4e..b1394fe788b 100644
--- a/clang/lib/AST/DeclCXX.cpp
+++ b/clang/lib/AST/DeclCXX.cpp
@@ -92,8 +92,8 @@ bool CXXRecordDecl::hasConstCopyAssignment(ASTContext &Context) const {
     if (Method->isStatic())
       continue;
     // TODO: Skip templates? Or is this implicitly done due to parameter types?
-    const FunctionTypeProto *FnType =
-      Method->getType()->getAsFunctionTypeProto();
+    const FunctionProtoType *FnType =
+      Method->getType()->getAsFunctionProtoType();
     assert(FnType && "Overloaded operator has no prototype.");
     // Don't assert on this; an invalid decl might have been left in the AST.
     if (FnType->getNumArgs() != 1 || FnType->isVariadic())
@@ -146,7 +146,7 @@ void CXXRecordDecl::addedAssignmentOperator(ASTContext &Context,
   // We're interested specifically in copy assignment operators.
   // Unlike addedConstructor, this method is not called for implicit
   // declarations.
-  const FunctionTypeProto *FnType = OpDecl->getType()->getAsFunctionTypeProto();
+  const FunctionProtoType *FnType = OpDecl->getType()->getAsFunctionProtoType();
   assert(FnType && "Overloaded operator has no proto function type.");
   assert(FnType->getNumArgs() == 1 && !FnType->isVariadic());
   QualType ArgType = FnType->getArgType(0);
@@ -290,7 +290,7 @@ bool CXXConstructorDecl::isConvertingConstructor() const {
     return false;
 
   return (getNumParams() == 0 && 
-          getType()->getAsFunctionTypeProto()->isVariadic()) ||
+          getType()->getAsFunctionProtoType()->isVariadic()) ||
          (getNumParams() == 1) ||
          (getNumParams() > 1 && getParamDecl(1)->getDefaultArg() != 0);
 }
diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp
index 1d563e246a0..4468c79e91b 100644
--- a/clang/lib/AST/StmtPrinter.cpp
+++ b/clang/lib/AST/StmtPrinter.cpp
@@ -1193,9 +1193,9 @@ void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
   
   const FunctionType *AFT = Node->getFunctionType();
   
-  if (isa<FunctionTypeNoProto>(AFT)) {
+  if (isa<FunctionNoProtoType>(AFT)) {
     OS << "()";
-  } else if (!BD->param_empty() || cast<FunctionTypeProto>(AFT)->isVariadic()) {
+  } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
     OS << '(';
     std::string ParamStr;
     for (BlockDecl::param_iterator AI = BD->param_begin(),
@@ -1206,7 +1206,7 @@ void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
       OS << ParamStr;
     }
     
-    const FunctionTypeProto *FT = cast<FunctionTypeProto>(AFT);
+    const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
     if (FT->isVariadic()) {
       if (!BD->param_empty()) OS << ", ";
       OS << "...";
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 31565080633..06ae9eb4e25 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -78,7 +78,7 @@ const Type *Type::getArrayElementTypeNoTypeQual() const {
 QualType Type::getDesugaredType() const {
   if (const TypedefType *TDT = dyn_cast<TypedefType>(this))
     return TDT->LookThroughTypedefs();
-  if (const TypeOfExpr *TOE = dyn_cast<TypeOfExpr>(this))
+  if (const TypeOfExprType *TOE = dyn_cast<TypeOfExprType>(this))
     return TOE->getUnderlyingExpr()->getType();
   if (const TypeOfType *TOT = dyn_cast<TypeOfType>(this))
     return TOT->getUnderlyingType();
@@ -118,9 +118,9 @@ bool Type::isDerivedType() const {
   case FunctionProto:
   case FunctionNoProto:
   case Reference:
+  case Record:
+  case CXXRecord:
     return true;
-  case Tagged:
-    return !cast<TagType>(CanonicalType)->getDecl()->isEnum();
   default:
     return false;
   }
@@ -216,12 +216,12 @@ const FunctionType *Type::getAsFunctionType() const {
   return getDesugaredType()->getAsFunctionType();
 }
 
-const FunctionTypeNoProto *Type::getAsFunctionTypeNoProto() const {
-  return dyn_cast_or_null<FunctionTypeNoProto>(getAsFunctionType());
+const FunctionNoProtoType *Type::getAsFunctionNoProtoType() const {
+  return dyn_cast_or_null<FunctionNoProtoType>(getAsFunctionType());
 }
 
-const FunctionTypeProto *Type::getAsFunctionTypeProto() const {
-  return dyn_cast_or_null<FunctionTypeProto>(getAsFunctionType());
+const FunctionProtoType *Type::getAsFunctionProtoType() const {
+  return dyn_cast_or_null<FunctionProtoType>(getAsFunctionType());
 }
 
 
@@ -742,7 +742,9 @@ bool Type::isIncompleteType() const {
     // Void is the only incomplete builtin type.  Per C99 6.2.5p19, it can never
     // be completed.
     return isVoidType();
-  case Tagged:
+  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).
     return !cast<TagType>(CanonicalType)->getDecl()->isDefinition();
@@ -778,14 +780,15 @@ bool Type::isPODType() const {
   case ObjCQualifiedId:
     return true;
 
-  case Tagged:
-    if (isEnumeralType())
-      return true;
-    if (CXXRecordDecl *RDecl = dyn_cast<CXXRecordDecl>(
-          cast<TagType>(CanonicalType)->getDecl()))
-      return RDecl->isPOD();
+  case Enum:
+    return true;
+
+  case Record:
     // C struct/union is POD.
     return true;
+
+  case CXXRecord:
+    return cast<CXXRecordType>(CanonicalType)->getDecl()->isPOD();
   }
 }
 
@@ -832,7 +835,7 @@ const char *BuiltinType::getName() const {
   }
 }
 
-void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
+void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                                 arg_type_iterator ArgTys,
                                 unsigned NumArgs, bool isVariadic,
                                 unsigned TypeQuals) {
@@ -843,7 +846,7 @@ void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
   ID.AddInteger(TypeQuals);
 }
 
-void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID) {
+void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID) {
   Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(),
           getTypeQuals());
 }
@@ -903,8 +906,8 @@ QualType TypedefType::LookThroughTypedefs() const {
   }
 }
 
-TypeOfExpr::TypeOfExpr(Expr *E, QualType can)
-  : Type(TypeOfExp, can, E->isTypeDependent()), TOExpr(E) {
+TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
+  : Type(TypeOfExpr, can, E->isTypeDependent()), TOExpr(E) {
   assert(!isa<TypedefType>(can) && "Invalid canonical type");
 }
 
@@ -1197,7 +1200,7 @@ void ExtVectorType::getAsStringInternal(std::string &S) const {
   ElementType.getAsStringInternal(S);
 }
 
-void TypeOfExpr::getAsStringInternal(std::string &InnerString) const {
+void TypeOfExprType::getAsStringInternal(std::string &InnerString) const {
   if (!InnerString.empty())    // Prefix the basic type, e.g. 'typeof(e) X'.
     InnerString = ' ' + InnerString;
   std::string Str;
@@ -1214,7 +1217,7 @@ void TypeOfType::getAsStringInternal(std::string &InnerString) const {
   InnerString = "typeof(" + Tmp + ")" + InnerString;
 }
 
-void FunctionTypeNoProto::getAsStringInternal(std::string &S) const {
+void FunctionNoProtoType::getAsStringInternal(std::string &S) const {
   // If needed for precedence reasons, wrap the inner part in grouping parens.
   if (!S.empty())
     S = "(" + S + ")";
@@ -1223,7 +1226,7 @@ void FunctionTypeNoProto::getAsStringInternal(std::string &S) const {
   getResultType().getAsStringInternal(S);
 }
 
-void FunctionTypeProto::getAsStringInternal(std::string &S) const {
+void FunctionProtoType::getAsStringInternal(std::string &S) const {
   // If needed for precedence reasons, wrap the inner part in grouping parens.
   if (!S.empty())
     S = "(" + S + ")";
diff --git a/clang/lib/AST/TypeSerialization.cpp b/clang/lib/AST/TypeSerialization.cpp
index a8580b0e4df..2d052aa270f 100644
--- a/clang/lib/AST/TypeSerialization.cpp
+++ b/clang/lib/AST/TypeSerialization.cpp
@@ -84,11 +84,11 @@ void Type::Create(ASTContext& Context, unsigned i, Deserializer& D) {
       break;
       
     case Type::FunctionNoProto:
-      D.RegisterPtr(PtrID,FunctionTypeNoProto::CreateImpl(Context,D));
+      D.RegisterPtr(PtrID,FunctionNoProtoType::CreateImpl(Context,D));
       break;
       
     case Type::FunctionProto:
-      D.RegisterPtr(PtrID,FunctionTypeProto::CreateImpl(Context,D));
+      D.RegisterPtr(PtrID,FunctionProtoType::CreateImpl(Context,D));
       break;
       
     case Type::IncompleteArray:
@@ -111,19 +111,22 @@ void Type::Create(ASTContext& Context, unsigned i, Deserializer& D) {
       D.RegisterPtr(PtrID, ReferenceType::CreateImpl(Context, D));
       break;
 
-    case Type::Tagged:
-      D.RegisterPtr(PtrID, TagType::CreateImpl(Context, D));
+    case Type::Record:
+    case Type::CXXRecord:
+    case Type::Enum:
+      // FIXME: Implement this!
+      assert(false && "Can't deserialize tag types!");
       break;
 
-    case Type::TypeName:
+    case Type::Typedef:
       D.RegisterPtr(PtrID, TypedefType::CreateImpl(Context, D));
       break;
 
-    case Type::TypeOfExp:
-      D.RegisterPtr(PtrID, TypeOfExpr::CreateImpl(Context, D));
+    case Type::TypeOfExpr:
+      D.RegisterPtr(PtrID, TypeOfExprType::CreateImpl(Context, D));
       break;
 
-    case Type::TypeOfTyp:
+    case Type::TypeOf:
       D.RegisterPtr(PtrID, TypeOfType::CreateImpl(Context, D));
       break;
 
@@ -199,22 +202,22 @@ Type* ConstantArrayType::CreateImpl(ASTContext& Context, Deserializer& D) {
 }
 
 //===----------------------------------------------------------------------===//
-// FunctionTypeNoProto
+// FunctionNoProtoType
 //===----------------------------------------------------------------------===//
 
-void FunctionTypeNoProto::EmitImpl(Serializer& S) const {
+void FunctionNoProtoType::EmitImpl(Serializer& S) const {
   S.Emit(getResultType());
 }
 
-Type* FunctionTypeNoProto::CreateImpl(ASTContext& Context, Deserializer& D) {
-  return Context.getFunctionTypeNoProto(QualType::ReadVal(D)).getTypePtr();
+Type* FunctionNoProtoType::CreateImpl(ASTContext& Context, Deserializer& D) {
+  return Context.getFunctionNoProtoType(QualType::ReadVal(D)).getTypePtr();
 }
 
 //===----------------------------------------------------------------------===//
-// FunctionTypeProto
+// FunctionProtoType
 //===----------------------------------------------------------------------===//
 
-void FunctionTypeProto::EmitImpl(Serializer& S) const {
+void FunctionProtoType::EmitImpl(Serializer& S) const {
   S.Emit(getResultType());
   S.EmitBool(isVariadic());
   S.EmitInt(getTypeQuals());
@@ -224,7 +227,7 @@ void FunctionTypeProto::EmitImpl(Serializer& S) const {
     S.Emit(*I);
 }
 
-Type* FunctionTypeProto::CreateImpl(ASTContext& Context, Deserializer& D) {
+Type* FunctionProtoType::CreateImpl(ASTContext& Context, Deserializer& D) {
   QualType ResultType = QualType::ReadVal(D);
   bool isVariadic = D.ReadBool();
   unsigned TypeQuals = D.ReadInt();
@@ -290,7 +293,9 @@ Type* TagType::CreateImpl(ASTContext& Context, Deserializer& D) {
   std::vector<Type*>& Types = 
     const_cast<std::vector<Type*>&>(Context.getTypes());
   
-  TagType* T = new TagType(NULL,QualType());
+  // FIXME: This is wrong: we need the subclasses to do the
+  // (de-)serialization.
+  TagType* T = new TagType(Record, NULL,QualType());
   Types.push_back(T);
   
   // Deserialize the decl.
@@ -313,7 +318,7 @@ Type* TypedefType::CreateImpl(ASTContext& Context, Deserializer& D) {
   std::vector<Type*>& Types = 
     const_cast<std::vector<Type*>&>(Context.getTypes());
   
-  TypedefType* T = new TypedefType(Type::TypeName, NULL, QualType::ReadVal(D));
+  TypedefType* T = new TypedefType(Type::Typedef, NULL, QualType::ReadVal(D));
   Types.push_back(T);
   
   D.ReadPtr(T->Decl); // May be backpatched.
@@ -321,20 +326,21 @@ Type* TypedefType::CreateImpl(ASTContext& Context, Deserializer& D) {
 }
 
 //===----------------------------------------------------------------------===//
-// TypeOfExpr
+// TypeOfExprType
 //===----------------------------------------------------------------------===//
 
-void TypeOfExpr::EmitImpl(llvm::Serializer& S) const {
+void TypeOfExprType::EmitImpl(llvm::Serializer& S) const {
   S.EmitOwnedPtr(TOExpr);
 }
 
-Type* TypeOfExpr::CreateImpl(ASTContext& Context, Deserializer& D) {
+Type* TypeOfExprType::CreateImpl(ASTContext& Context, Deserializer& D) {
   Expr* E = D.ReadOwnedPtr<Expr>(Context);
   
   std::vector<Type*>& Types = 
     const_cast<std::vector<Type*>&>(Context.getTypes());
 
-  TypeOfExpr* T = new TypeOfExpr(E, Context.getCanonicalType(E->getType()));
+  TypeOfExprType* T 
+    = new TypeOfExprType(E, Context.getCanonicalType(E->getType()));
   Types.push_back(T);
 
   return T;
diff --git a/clang/lib/Analysis/CFRefCount.cpp b/clang/lib/Analysis/CFRefCount.cpp
index 8f694fa946f..d42a936834d 100644
--- a/clang/lib/Analysis/CFRefCount.cpp
+++ b/clang/lib/Analysis/CFRefCount.cpp
@@ -956,7 +956,7 @@ RetainSummaryManager::getUnarySummary(const FunctionType* FT,
 
   // Sanity check that this is *really* a unary function.  This can
   // happen if people do weird things.
-  const FunctionTypeProto* FTP = dyn_cast<FunctionTypeProto>(FT);
+  const FunctionProtoType* FTP = dyn_cast<FunctionProtoType>(FT);
   if (!FTP || FTP->getNumArgs() != 1)
     return getPersistentStopSummary();
   
diff --git a/clang/lib/Analysis/GRExprEngine.cpp b/clang/lib/Analysis/GRExprEngine.cpp
index 25cd4f7eed4..8f7b674ead8 100644
--- a/clang/lib/Analysis/GRExprEngine.cpp
+++ b/clang/lib/Analysis/GRExprEngine.cpp
@@ -1127,10 +1127,10 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
                              NodeSet& Dst)
 {
   // Determine the type of function we're calling (if available).
-  const FunctionTypeProto *Proto = NULL;
+  const FunctionProtoType *Proto = NULL;
   QualType FnType = CE->getCallee()->IgnoreParens()->getType();
   if (const PointerType *FnTypePtr = FnType->getAsPointerType())
-    Proto = FnTypePtr->getPointeeType()->getAsFunctionTypeProto();
+    Proto = FnTypePtr->getPointeeType()->getAsFunctionProtoType();
 
   VisitCallRec(CE, Pred, AI, AE, Dst, Proto, /*ParamIdx=*/0);
 }
@@ -1138,7 +1138,7 @@ void GRExprEngine::VisitCall(CallExpr* CE, NodeTy* Pred,
 void GRExprEngine::VisitCallRec(CallExpr* CE, NodeTy* Pred,
                                 CallExpr::arg_iterator AI,
                                 CallExpr::arg_iterator AE,
-                                NodeSet& Dst, const FunctionTypeProto *Proto,
+                                NodeSet& Dst, const FunctionProtoType *Proto,
                                 unsigned ParamIdx) {
   
   // Process the arguments.
diff --git a/clang/lib/CodeGen/CGBlocks.cpp b/clang/lib/CodeGen/CGBlocks.cpp
index 65f6cb11e82..276c46fdb5a 100644
--- a/clang/lib/CodeGen/CGBlocks.cpp
+++ b/clang/lib/CodeGen/CGBlocks.cpp
@@ -321,12 +321,12 @@ CodeGenModule::getGenericExtendedBlockLiteralType() {
 /// function type for the block, including the first block literal argument.
 static QualType getBlockFunctionType(ASTContext &Ctx,
                                      const BlockPointerType *BPT) {
-  const FunctionTypeProto *FTy = cast<FunctionTypeProto>(BPT->getPointeeType());
+  const FunctionProtoType *FTy = cast<FunctionProtoType>(BPT->getPointeeType());
 
   llvm::SmallVector<QualType, 8> Types;
   Types.push_back(Ctx.getPointerType(Ctx.VoidTy));
 
-  for (FunctionTypeProto::arg_type_iterator i = FTy->arg_type_begin(),
+  for (FunctionProtoType::arg_type_iterator i = FTy->arg_type_begin(),
        e = FTy->arg_type_end(); i != e; ++i)
     Types.push_back(*i);
 
@@ -455,9 +455,9 @@ llvm::Function *CodeGenFunction::GenerateBlockFunction(const BlockExpr *Expr,
                                                        const BlockInfo& Info,
                                                        uint64_t &Size,
                                                        uint64_t &Align,
-                                                       llvm::SmallVector<ValueDecl *, 8> &subBlockDeclRefDecls) {
-  const FunctionTypeProto *FTy =
-    cast<FunctionTypeProto>(Expr->getFunctionType());
+                    llvm::SmallVector<ValueDecl *, 8> &subBlockDeclRefDecls) {
+  const FunctionProtoType *FTy =
+    cast<FunctionProtoType>(Expr->getFunctionType());
 
   FunctionArgList Args;
 
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 7a98b0c1c6b..38f6e96c140 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -37,13 +37,13 @@ using namespace CodeGen;
 // FIXME: Use iterator and sidestep silly type array creation.
 
 const 
-CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionTypeNoProto *FTNP) {
+CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionNoProtoType *FTNP) {
   return getFunctionInfo(FTNP->getResultType(), 
                          llvm::SmallVector<QualType, 16>());
 }
 
 const 
-CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionTypeProto *FTP) {
+CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionProtoType *FTP) {
   llvm::SmallVector<QualType, 16> ArgTys;
   // FIXME: Kill copy.
   for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
@@ -53,9 +53,9 @@ CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionTypeProto *FTP) {
 
 const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const FunctionDecl *FD) {
   const FunctionType *FTy = FD->getType()->getAsFunctionType();
-  if (const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(FTy))
+  if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FTy))
     return getFunctionInfo(FTP);
-  return getFunctionInfo(cast<FunctionTypeNoProto>(FTy));
+  return getFunctionInfo(cast<FunctionNoProtoType>(FTy));
 }
 
 const CGFunctionInfo &CodeGenTypes::getFunctionInfo(const ObjCMethodDecl *MD) {
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index 5e78c5817d7..6c67ba58142 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -179,7 +179,7 @@ llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty,
   
   // Set up remainder of arguments if there is a prototype.
   // FIXME: IF NOT, HOW IS THIS REPRESENTED?  llvm-gcc doesn't represent '...'!
-  if (const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(Ty)) {
+  if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) {
     for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
       EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit));
   } else {
@@ -481,6 +481,13 @@ llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty,
 
   // Work out details of type.
   switch (Ty->getTypeClass()) {
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base)
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+    assert(false && "Dependent types cannot show up in debug information");
+    
   case Type::Complex:
   case Type::Reference:
   case Type::Vector:
@@ -489,13 +496,16 @@ llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty,
   case Type::ObjCInterface:
   case Type::ObjCQualifiedInterface:
   case Type::ObjCQualifiedId:
-  default:
     return llvm::DIType();
 
   case Type::Builtin: Slot = CreateType(cast<BuiltinType>(Ty), Unit); break;
   case Type::Pointer: Slot = CreateType(cast<PointerType>(Ty), Unit); break;
-  case Type::TypeName: Slot = CreateType(cast<TypedefType>(Ty), Unit); break;
-  case Type::Tagged: Slot = CreateType(cast<TagType>(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;
   case Type::FunctionProto:
   case Type::FunctionNoProto:
     return Slot = CreateType(cast<FunctionType>(Ty), Unit);
@@ -504,10 +514,10 @@ llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty,
   case Type::VariableArray:
   case Type::IncompleteArray:
     return Slot = CreateType(cast<ArrayType>(Ty), Unit);
-  case Type::TypeOfExp:
-    return Slot = getOrCreateType(cast<TypeOfExpr>(Ty)->getUnderlyingExpr()
+  case Type::TypeOfExpr:
+    return Slot = getOrCreateType(cast<TypeOfExprType>(Ty)->getUnderlyingExpr()
                                   ->getType(), Unit);
-  case Type::TypeOfTyp:
+  case Type::TypeOf:
     return Slot = getOrCreateType(cast<TypeOfType>(Ty)->getUnderlyingType(),
                                   Unit);
   }
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index 81fd3871d61..d6e3394b8d8 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -209,7 +209,7 @@ void CodeGenFunction::GenerateCode(const FunctionDecl *FD,
   
   FunctionArgList Args;
   if (FD->getNumParams()) {
-    const FunctionTypeProto* FProto = FD->getType()->getAsFunctionTypeProto();
+    const FunctionProtoType* FProto = FD->getType()->getAsFunctionProtoType();
     assert(FProto && "Function def must have prototype!");
 
     for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i)
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index 918646f9559..057f554ac69 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -41,7 +41,7 @@ namespace clang {
   class Decl;
   class EnumConstantDecl;
   class FunctionDecl;
-  class FunctionTypeProto;
+  class FunctionProtoType;
   class LabelStmt;
   class ObjCContainerDecl;
   class ObjCInterfaceDecl;
diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index 1458ccd91be..09121830538 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -174,13 +174,14 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) {
   const clang::Type &Ty = *Context.getCanonicalType(T);
   
   switch (Ty.getTypeClass()) {
-  case Type::TypeName:        // typedef isn't canonical.
-  case Type::TemplateTypeParm:// template type parameters never generated
-  case Type::ClassTemplateSpecialization: // these types are always sugar
-  case Type::DependentSizedArray: // dependent types are never generated
-  case Type::TypeOfExp:       // typeof isn't canonical.
-  case Type::TypeOfTyp:       // typeof isn't canonical.
-    assert(0 && "Non-canonical type, shouldn't happen");
+#define TYPE(Class, Base)
+#define ABSTRACT_TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#include "clang/AST/TypeNodes.def"
+    assert(false && "Non-canonical or dependent types aren't possible.");
+    break;
+
   case Type::Builtin: {
     switch (cast<BuiltinType>(Ty).getKind()) {
     default: assert(0 && "Unknown builtin type!");
@@ -265,10 +266,10 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) {
                                  VT.getNumElements());
   }
   case Type::FunctionNoProto:
-    return GetFunctionType(getFunctionInfo(cast<FunctionTypeNoProto>(&Ty)), 
+    return GetFunctionType(getFunctionInfo(cast<FunctionNoProtoType>(&Ty)), 
                            true);
   case Type::FunctionProto: {
-    const FunctionTypeProto *FTP = cast<FunctionTypeProto>(&Ty);
+    const FunctionProtoType *FTP = cast<FunctionProtoType>(&Ty);
     return GetFunctionType(getFunctionInfo(FTP), FTP->isVariadic());
   }
   
@@ -300,7 +301,9 @@ const llvm::Type *CodeGenTypes::ConvertNewType(QualType T) {
     // Protocols don't influence the LLVM type.
     return ConvertTypeRecursive(Context.getObjCIdType());
 
-  case Type::Tagged: {
+  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/clang/lib/CodeGen/CodeGenTypes.h b/clang/lib/CodeGen/CodeGenTypes.h
index 228502d0cdd..e5dbd84f433 100644
--- a/clang/lib/CodeGen/CodeGenTypes.h
+++ b/clang/lib/CodeGen/CodeGenTypes.h
@@ -33,7 +33,7 @@ namespace clang {
   class ABIInfo;
   class ASTContext;
   class FieldDecl;
-  class FunctionTypeProto;
+  class FunctionProtoType;
   class ObjCInterfaceDecl;
   class ObjCIvarDecl;
   class PointerType;
@@ -166,8 +166,8 @@ public:
                                         const llvm::SmallVector<QualType,16> 
                                         &ArgTys);
 
-  const CGFunctionInfo &getFunctionInfo(const FunctionTypeNoProto *FTNP);
-  const CGFunctionInfo &getFunctionInfo(const FunctionTypeProto *FTP);
+  const CGFunctionInfo &getFunctionInfo(const FunctionNoProtoType *FTNP);
+  const CGFunctionInfo &getFunctionInfo(const FunctionProtoType *FTP);
   const CGFunctionInfo &getFunctionInfo(const FunctionDecl *FD);
   const CGFunctionInfo &getFunctionInfo(const ObjCMethodDecl *MD);
   const CGFunctionInfo &getFunctionInfo(QualType ResTy, 
diff --git a/clang/lib/CodeGen/Mangle.cpp b/clang/lib/CodeGen/Mangle.cpp
index c8029666865..525f0fe1d62 100644
--- a/clang/lib/CodeGen/Mangle.cpp
+++ b/clang/lib/CodeGen/Mangle.cpp
@@ -454,10 +454,10 @@ void CXXNameMangler::mangleBareFunctionType(const FunctionType *T,
   if (MangleReturnType)
     mangleType(T->getResultType());
 
-  const FunctionTypeProto *Proto = dyn_cast<FunctionTypeProto>(T);
+  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(T);
   assert(Proto && "Can't mangle K&R function prototypes");
 
-  for (FunctionTypeProto::arg_type_iterator Arg = Proto->arg_type_begin(),
+  for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(),
                                          ArgEnd = Proto->arg_type_end(); 
        Arg != ArgEnd; ++Arg)
     mangleType(*Arg);
diff --git a/clang/lib/Sema/Sema.h b/clang/lib/Sema/Sema.h
index 68e0ce8f7d9..22bfee47fa9 100644
--- a/clang/lib/Sema/Sema.h
+++ b/clang/lib/Sema/Sema.h
@@ -458,7 +458,7 @@ public:
                               Expr *From, QualType ToType,
                               OverloadCandidateSet& CandidateSet);
   void AddSurrogateCandidate(CXXConversionDecl *Conversion,
-                             const FunctionTypeProto *Proto,
+                             const FunctionProtoType *Proto,
                              Expr *Object, Expr **Args, unsigned NumArgs,
                              OverloadCandidateSet& CandidateSet);
   bool AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
@@ -1107,7 +1107,7 @@ public:
                                                     IdentifierInfo &Member);
   bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
                                FunctionDecl *FDecl,
-                               const FunctionTypeProto *Proto,
+                               const FunctionProtoType *Proto,
                                Expr **Args, unsigned NumArgs,
                                SourceLocation RParenLoc);
 
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index fdd22fa4bfb..3e6bd5a2efb 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -144,8 +144,8 @@ Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) {
   if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) {
     if (Format->getType() == "printf") {
       bool HasVAListArg = false;
-      if (const FunctionTypeProto *Proto 
-          = FDecl->getType()->getAsFunctionTypeProto())
+      if (const FunctionProtoType *Proto 
+          = FDecl->getType()->getAsFunctionProtoType())
         HasVAListArg = !Proto->isVariadic();
       CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1,
                            Format->getFirstArg() - 1);
@@ -210,8 +210,8 @@ bool Sema::SemaBuiltinVAStart(CallExpr *TheCall) {
   // Determine whether the current function is variadic or not.
   bool isVariadic;
   if (getCurFunctionDecl()) {
-    if (FunctionTypeProto* FTP =
-            dyn_cast<FunctionTypeProto>(getCurFunctionDecl()->getType()))
+    if (FunctionProtoType* FTP =
+            dyn_cast<FunctionProtoType>(getCurFunctionDecl()->getType()))
       isVariadic = FTP->isVariadic();
     else
       isVariadic = false;
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 0ad3839fde1..b3f25005392 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -340,7 +340,7 @@ NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
 
   // Create Decl objects for each parameter, adding them to the
   // FunctionDecl.
-  if (FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(R)) {
+  if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
     llvm::SmallVector<ParmVarDecl*, 16> Params;
     for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
       Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
@@ -609,9 +609,9 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
   if (!getLangOptions().CPlusPlus &&
       Context.typesAreCompatible(OldQType, NewQType)) {
     const FunctionType *NewFuncType = NewQType->getAsFunctionType();
-    const FunctionTypeProto *OldProto = 0;
-    if (isa<FunctionTypeNoProto>(NewFuncType) &&
-        (OldProto = OldQType->getAsFunctionTypeProto())) {
+    const FunctionProtoType *OldProto = 0;
+    if (isa<FunctionNoProtoType>(NewFuncType) &&
+        (OldProto = OldQType->getAsFunctionProtoType())) {
       // The old declaration provided a function prototype, but the
       // new declaration does not. Merge in the prototype.
       llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
@@ -625,7 +625,7 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
 
       // Synthesize a parameter for each argument type.
       llvm::SmallVector<ParmVarDecl*, 16> Params;
-      for (FunctionTypeProto::arg_type_iterator 
+      for (FunctionProtoType::arg_type_iterator 
              ParamType = OldProto->arg_type_begin(), 
              ParamEnd = OldProto->arg_type_end();
            ParamType != ParamEnd; ++ParamType) {
@@ -1834,7 +1834,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
     // typedef void fn(int);
     // fn f;
     // @endcode
-    const FunctionTypeProto *FT = R->getAsFunctionTypeProto();
+    const FunctionProtoType *FT = R->getAsFunctionProtoType();
     if (!FT) {
       // This is a typedef of a function with no prototype, so we
       // don't need to do anything.
@@ -1845,7 +1845,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
     } else {
       // Synthesize a parameter for each argument type.
       llvm::SmallVector<ParmVarDecl*, 16> Params;
-      for (FunctionTypeProto::arg_type_iterator ArgType = FT->arg_type_begin();
+      for (FunctionProtoType::arg_type_iterator ArgType = FT->arg_type_begin();
            ArgType != FT->arg_type_end(); ++ArgType) {
         ParmVarDecl *Param = ParmVarDecl::Create(Context, DC,
                                                  SourceLocation(), 0,
@@ -1900,7 +1900,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
 
       // Functions marked "overloadable" must have a prototype (that
       // we can't get through declaration merging).
-      if (!R->getAsFunctionTypeProto()) {
+      if (!R->getAsFunctionProtoType()) {
         Diag(NewFD->getLocation(), diag::err_attribute_overloadable_no_prototype)
           << NewFD;
         InvalidDecl = true;
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index fb8b795af22..8757005a478 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -56,7 +56,7 @@ static bool isFunctionOrMethod(Decl *d) {
 /// isFunctionOrMethod.
 static bool hasFunctionProto(Decl *d) {
   if (const FunctionType *FnTy = getFunctionType(d)) {
-    return isa<FunctionTypeProto>(FnTy);
+    return isa<FunctionProtoType>(FnTy);
   } else {
     assert(isa<ObjCMethodDecl>(d));
     return true;
@@ -68,20 +68,20 @@ static bool hasFunctionProto(Decl *d) {
 /// hasFunctionProto first).
 static unsigned getFunctionOrMethodNumArgs(Decl *d) {
   if (const FunctionType *FnTy = getFunctionType(d))
-    return cast<FunctionTypeProto>(FnTy)->getNumArgs();
+    return cast<FunctionProtoType>(FnTy)->getNumArgs();
   return cast<ObjCMethodDecl>(d)->param_size();
 }
 
 static QualType getFunctionOrMethodArgType(Decl *d, unsigned Idx) {
   if (const FunctionType *FnTy = getFunctionType(d))
-    return cast<FunctionTypeProto>(FnTy)->getArgType(Idx);
+    return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
   
   return cast<ObjCMethodDecl>(d)->param_begin()[Idx]->getType();
 }
 
 static bool isFunctionOrMethodVariadic(Decl *d) {
   if (const FunctionType *FnTy = getFunctionType(d)) {
-    const FunctionTypeProto *proto = cast<FunctionTypeProto>(FnTy);
+    const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
     return proto->isVariadic();
   } else {
     return cast<ObjCMethodDecl>(d)->isVariadic();
@@ -688,7 +688,7 @@ static void HandleSentinelAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 
   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) {
     QualType FT = FD->getType();
-    if (!FT->getAsFunctionTypeProto()->isVariadic()) {
+    if (!FT->getAsFunctionProtoType()->isVariadic()) {
       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic);
       return;
     }    
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 8dd409bd218..1c98529fa89 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -1077,7 +1077,7 @@ bool Sema::CheckConstructorDeclarator(Declarator &D, QualType &R,
       << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
       << SourceRange(D.getIdentifierLoc());
   } 
-  if (R->getAsFunctionTypeProto()->getTypeQuals() != 0) {
+  if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
     DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
     if (FTI.TypeQuals & QualType::Const)
       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
@@ -1095,7 +1095,7 @@ bool Sema::CheckConstructorDeclarator(Declarator &D, QualType &R,
   // return type, since constructors don't have return types. We
   // *always* have to do this, because GetTypeForDeclarator will
   // put in a result type of "int" when none was specified.
-  const FunctionTypeProto *Proto = R->getAsFunctionTypeProto();
+  const FunctionProtoType *Proto = R->getAsFunctionProtoType();
   R = Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
                               Proto->getNumArgs(),
                               Proto->isVariadic(),
@@ -1187,7 +1187,7 @@ bool Sema::CheckDestructorDeclarator(Declarator &D, QualType &R,
       << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
       << SourceRange(D.getIdentifierLoc());
   }
-  if (R->getAsFunctionTypeProto()->getTypeQuals() != 0) {
+  if (R->getAsFunctionProtoType()->getTypeQuals() != 0) {
     DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
     if (FTI.TypeQuals & QualType::Const)
       Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
@@ -1201,7 +1201,7 @@ bool Sema::CheckDestructorDeclarator(Declarator &D, QualType &R,
   }
 
   // Make sure we don't have any parameters.
-  if (R->getAsFunctionTypeProto()->getNumArgs() > 0) {
+  if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
     Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
 
     // Delete the parameters.
@@ -1209,7 +1209,7 @@ bool Sema::CheckDestructorDeclarator(Declarator &D, QualType &R,
   }
 
   // Make sure the destructor isn't variadic.  
-  if (R->getAsFunctionTypeProto()->isVariadic())
+  if (R->getAsFunctionProtoType()->isVariadic())
     Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
 
   // Rebuild the function type "R" without any type qualifiers or
@@ -1258,7 +1258,7 @@ bool Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
   }
 
   // Make sure we don't have any parameters.
-  if (R->getAsFunctionTypeProto()->getNumArgs() > 0) {
+  if (R->getAsFunctionProtoType()->getNumArgs() > 0) {
     Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
 
     // Delete the parameters.
@@ -1266,7 +1266,7 @@ bool Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
   }
 
   // Make sure the conversion function isn't variadic.  
-  if (R->getAsFunctionTypeProto()->isVariadic())
+  if (R->getAsFunctionProtoType()->isVariadic())
     Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
 
   // C++ [class.conv.fct]p4:
@@ -1285,7 +1285,7 @@ bool Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
   // of the errors above fired) and with the conversion type as the
   // return type. 
   R = Context.getFunctionType(ConvType, 0, 0, false, 
-                              R->getAsFunctionTypeProto()->getTypeQuals());
+                              R->getAsFunctionProtoType()->getTypeQuals());
 
   // C++0x explicit conversion operators.
   if (D.getDeclSpec().isExplicitSpecified() && !getLangOptions().CPlusPlus0x)
@@ -2122,7 +2122,7 @@ bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
 
   // Overloaded operators other than operator() cannot be variadic.
   if (Op != OO_Call &&
-      FnDecl->getType()->getAsFunctionTypeProto()->isVariadic()) {
+      FnDecl->getType()->getAsFunctionProtoType()->isVariadic()) {
     return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
       << FnDecl->getDeclName();
   }
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 01be6b2474c..29d5f59de91 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -887,8 +887,8 @@ Sema::ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
       // type.
       QualType T = Func->getType();
       QualType NoProtoType = T;
-      if (const FunctionTypeProto *Proto = T->getAsFunctionTypeProto())
-        NoProtoType = Context.getFunctionTypeNoProto(Proto->getResultType());
+      if (const FunctionProtoType *Proto = T->getAsFunctionProtoType())
+        NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType());
       return Owned(BuildDeclRefExpr(VD, NoProtoType, Loc, false, false, SS));
     }
   }
@@ -1949,7 +1949,7 @@ Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc,
 bool
 Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
                               FunctionDecl *FDecl,
-                              const FunctionTypeProto *Proto,
+                              const FunctionProtoType *Proto,
                               Expr **Args, unsigned NumArgs,
                               SourceLocation RParenLoc) {
   // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
@@ -2164,12 +2164,12 @@ Sema::ActOnCallExpr(Scope *S, ExprArg fn, SourceLocation LParenLoc,
   // We know the result type of the call, set it.
   TheCall->setType(FuncT->getResultType().getNonReferenceType());
 
-  if (const FunctionTypeProto *Proto = dyn_cast<FunctionTypeProto>(FuncT)) {
+  if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) {
     if (ConvertArgumentsForCall(&*TheCall, Fn, FDecl, Proto, Args, NumArgs,
                                 RParenLoc))
       return ExprError();
   } else {
-    assert(isa<FunctionTypeNoProto>(FuncT) && "Unknown FunctionType!");
+    assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
 
     // Promote the arguments (C99 6.5.2.2p6).
     for (unsigned i = 0; i != NumArgs; i++) {
@@ -4501,7 +4501,7 @@ Sema::ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, StmtTy *body,
 
   QualType BlockTy;
   if (!BSI->hasPrototype)
-    BlockTy = Context.getFunctionTypeNoProto(RetTy);
+    BlockTy = Context.getFunctionNoProtoType(RetTy);
   else
     BlockTy = Context.getFunctionType(RetTy, &ArgTypes[0], ArgTypes.size(),
                                       BSI->isVariadic, 0);
diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
index 7c5464a4a30..00849a68812 100644
--- a/clang/lib/Sema/SemaLookup.cpp
+++ b/clang/lib/Sema/SemaLookup.cpp
@@ -1269,12 +1269,12 @@ addAssociatedClassesAndNamespaces(QualType T,
                                       Context,
                                       AssociatedNamespaces, AssociatedClasses);
 
-    const FunctionTypeProto *Proto = dyn_cast<FunctionTypeProto>(FunctionType);
+    const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FunctionType);
     if (!Proto)
       return;
 
     // Argument types
-    for (FunctionTypeProto::arg_type_iterator Arg = Proto->arg_type_begin(),
+    for (FunctionProtoType::arg_type_iterator Arg = Proto->arg_type_begin(),
                                            ArgEnd = Proto->arg_type_end(); 
          Arg != ArgEnd; ++Arg)
       addAssociatedClassesAndNamespaces(*Arg, Context,
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 5392af4abf0..c33389eda4c 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -310,12 +310,12 @@ Sema::IsOverload(FunctionDecl *New, Decl* OldD,
 
     // If either of these functions is a K&R-style function (no
     // prototype), then we consider them to have matching signatures.
-    if (isa<FunctionTypeNoProto>(OldQType.getTypePtr()) ||
-        isa<FunctionTypeNoProto>(NewQType.getTypePtr()))
+    if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
+        isa<FunctionNoProtoType>(NewQType.getTypePtr()))
       return false;
 
-    FunctionTypeProto* OldType = cast<FunctionTypeProto>(OldQType.getTypePtr());
-    FunctionTypeProto* NewType = cast<FunctionTypeProto>(NewQType.getTypePtr());
+    FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType.getTypePtr());
+    FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType.getTypePtr());
 
     // The signature of a function includes the types of its
     // parameters (C++ 1.3.10), which includes the presence or absence
@@ -1052,10 +1052,10 @@ bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
   // differences in the argument and result types are in Objective-C
   // pointer conversions. If so, we permit the conversion (but
   // complain about it).
-  const FunctionTypeProto *FromFunctionType 
-    = FromPointeeType->getAsFunctionTypeProto();
-  const FunctionTypeProto *ToFunctionType
-    = ToPointeeType->getAsFunctionTypeProto();
+  const FunctionProtoType *FromFunctionType 
+    = FromPointeeType->getAsFunctionProtoType();
+  const FunctionProtoType *ToFunctionType
+    = ToPointeeType->getAsFunctionProtoType();
   if (FromFunctionType && ToFunctionType) {
     // If the function types are exactly the same, this isn't an
     // Objective-C pointer conversion.
@@ -1985,8 +1985,8 @@ Sema::AddOverloadCandidate(FunctionDecl *Function,
                            OverloadCandidateSet& CandidateSet,
                            bool SuppressUserConversions)
 {
-  const FunctionTypeProto* Proto 
-    = dyn_cast<FunctionTypeProto>(Function->getType()->getAsFunctionType());
+  const FunctionProtoType* Proto 
+    = dyn_cast<FunctionProtoType>(Function->getType()->getAsFunctionType());
   assert(Proto && "Functions without a prototype cannot be overloaded");
   assert(!isa<CXXConversionDecl>(Function) && 
          "Use AddConversionCandidate for conversion functions");
@@ -2075,8 +2075,8 @@ Sema::AddMethodCandidate(CXXMethodDecl *Method, Expr *Object,
                          OverloadCandidateSet& CandidateSet,
                          bool SuppressUserConversions)
 {
-  const FunctionTypeProto* Proto 
-    = dyn_cast<FunctionTypeProto>(Method->getType()->getAsFunctionType());
+  const FunctionProtoType* Proto 
+    = dyn_cast<FunctionProtoType>(Method->getType()->getAsFunctionType());
   assert(Proto && "Methods without a prototype cannot be overloaded");
   assert(!isa<CXXConversionDecl>(Method) && 
          "Use AddConversionCandidate for conversion functions");
@@ -2228,7 +2228,7 @@ Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
 /// the type of function that we'll eventually be calling.
 void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
-                                 const FunctionTypeProto *Proto,
+                                 const FunctionProtoType *Proto,
                                  Expr *Object, Expr **Args, unsigned NumArgs,
                                  OverloadCandidateSet& CandidateSet) {
   CandidateSet.push_back(OverloadCandidate());
@@ -2318,7 +2318,7 @@ IsAcceptableNonMemberOperatorCandidate(FunctionDecl *Fn,
   if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
     return true;
 
-  const FunctionTypeProto *Proto = Fn->getType()->getAsFunctionTypeProto();
+  const FunctionProtoType *Proto = Fn->getType()->getAsFunctionProtoType();
   if (Proto->getNumArgs() < 1)
     return false;
 
@@ -3773,7 +3773,7 @@ Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
   MemExpr->setBase(ObjectArg);
 
   // Convert the rest of the arguments
-  const FunctionTypeProto *Proto = cast<FunctionTypeProto>(Method->getType());
+  const FunctionProtoType *Proto = cast<FunctionProtoType>(Method->getType());
   if (ConvertArgumentsForCall(&*TheCall, MemExpr, Method, Proto, Args, NumArgs, 
                               RParenLoc))
     return true;
@@ -3842,7 +3842,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object,
     if (const PointerType *ConvPtrType = ConvType->getAsPointerType())
       ConvType = ConvPtrType->getPointeeType();
 
-    if (const FunctionTypeProto *Proto = ConvType->getAsFunctionTypeProto())
+    if (const FunctionProtoType *Proto = ConvType->getAsFunctionProtoType())
       AddSurrogateCandidate(Conv, Proto, Object, Args, NumArgs, CandidateSet);
   }
 
@@ -3909,7 +3909,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object,
   // that calls this method, using Object for the implicit object
   // parameter and passing along the remaining arguments.
   CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
-  const FunctionTypeProto *Proto = Method->getType()->getAsFunctionTypeProto();
+  const FunctionProtoType *Proto = Method->getType()->getAsFunctionProtoType();
 
   unsigned NumArgsInProto = Proto->getNumArgs();
   unsigned NumArgsToCheck = NumArgs;
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 47cf8e5611d..d1dcca6cf12 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -172,7 +172,7 @@ QualType Sema::ConvertDeclSpecToType(const DeclSpec &DS) {
     Expr *E = static_cast<Expr *>(DS.getTypeRep());
     assert(E && "Didn't get an expression for typeof?");
     // TypeQuals handled by caller.
-    Result = Context.getTypeOfExpr(E);
+    Result = Context.getTypeOfExprType(E);
     break;
   }
   case DeclSpec::TST_error:
@@ -505,7 +505,7 @@ QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip) {
           T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, 0);
         } else {
           // Simple void foo(), where the incoming T is the result type.
-          T = Context.getFunctionTypeNoProto(T);
+          T = Context.getFunctionNoProtoType(T);
         }
       } else if (FTI.ArgInfo[0].Param == 0) {
         // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function definition.
@@ -540,7 +540,7 @@ QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip) {
           
           // Look for 'void'.  void is allowed only as a single argument to a
           // function with no other parameters (C99 6.7.5.3p10).  We record
-          // int(void) as a FunctionTypeProto with an empty argument list.
+          // int(void) as a FunctionProtoType with an empty argument list.
           else if (ArgTy->isVoidType()) {
             // If this is something like 'float(int, void)', reject it.  'void'
             // is an incomplete type (C99 6.2.5p19) and function decls cannot
@@ -634,8 +634,8 @@ QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip) {
   }
 
   if (getLangOptions().CPlusPlus && T->isFunctionType()) {
-    const FunctionTypeProto *FnTy = T->getAsFunctionTypeProto();
-    assert(FnTy && "Why oh why is there not a FunctionTypeProto here ?");
+    const FunctionProtoType *FnTy = T->getAsFunctionProtoType();
+    assert(FnTy && "Why oh why is there not a FunctionProtoType here ?");
 
     // C++ 8.3.5p4: A cv-qualifier-seq shall only be part of the function type
     // for a nonstatic member function, the function type to which a pointer