1 files changed, 18 insertions, 19 deletions

diff --git a/lib/Sema/SemaExceptionSpec.cpp b/lib/Sema/SemaExceptionSpec.cpp
index c902e77..5d7993b 100644
--- a/lib/Sema/SemaExceptionSpec.cpp
+++ b/lib/Sema/SemaExceptionSpec.cpp
@@ -113,6 +113,9 @@ bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
   if (!MissingExceptionSpecification && !MissingEmptyExceptionSpecification)
     return true;
 
+  const FunctionProtoType *NewProto 
+    = New->getType()->getAs<FunctionProtoType>();
+
   // The new function declaration is only missing an empty exception
   // specification "throw()". If the throw() specification came from a
   // function in a system header that has C linkage, just add an empty
@@ -121,42 +124,38 @@ bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
   // to many libc functions as an optimization. Unfortunately, that
   // optimization isn't permitted by the C++ standard, so we're forced
   // to work around it here.
-  if (MissingEmptyExceptionSpecification &&
-      isa<FunctionProtoType>(New->getType()) &&
+  if (MissingEmptyExceptionSpecification && NewProto &&
       (Old->getLocation().isInvalid() ||
        Context.getSourceManager().isInSystemHeader(Old->getLocation())) &&
       Old->isExternC()) {
-    const FunctionProtoType *NewProto 
-      = cast<FunctionProtoType>(New->getType());
+    FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo();
+    EPI.HasExceptionSpec = true;
+    EPI.HasAnyExceptionSpec = false;
+    EPI.NumExceptions = 0;
     QualType NewType = Context.getFunctionType(NewProto->getResultType(),
                                                NewProto->arg_type_begin(),
                                                NewProto->getNumArgs(),
-                                               NewProto->isVariadic(),
-                                               NewProto->getTypeQuals(),
-                                               true, false, 0, 0,
-                                               NewProto->getExtInfo());
+                                               EPI);
     New->setType(NewType);
     return false;
   }
 
-  if (MissingExceptionSpecification && isa<FunctionProtoType>(New->getType())) {
-    const FunctionProtoType *NewProto 
-      = cast<FunctionProtoType>(New->getType());
+  if (MissingExceptionSpecification && NewProto) {
     const FunctionProtoType *OldProto
       = Old->getType()->getAs<FunctionProtoType>();
 
+    FunctionProtoType::ExtProtoInfo EPI = NewProto->getExtProtoInfo();
+    EPI.HasExceptionSpec = OldProto->hasExceptionSpec();
+    EPI.HasAnyExceptionSpec = OldProto->hasAnyExceptionSpec();
+    EPI.NumExceptions = OldProto->getNumExceptions();
+    EPI.Exceptions = OldProto->exception_begin();
+
     // Update the type of the function with the appropriate exception
     // specification.
     QualType NewType = Context.getFunctionType(NewProto->getResultType(),
                                                NewProto->arg_type_begin(),
                                                NewProto->getNumArgs(),
-                                               NewProto->isVariadic(),
-                                               NewProto->getTypeQuals(),
-                                               OldProto->hasExceptionSpec(),
-                                               OldProto->hasAnyExceptionSpec(),
-                                               OldProto->getNumExceptions(),
-                                               OldProto->exception_begin(),
-                                               NewProto->getExtInfo());
+                                               EPI);
     New->setType(NewType);
 
     // If exceptions are disabled, suppress the warning about missing
@@ -197,7 +196,7 @@ bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {
 
     SourceLocation AfterParenLoc;
     if (TypeSourceInfo *TSInfo = New->getTypeSourceInfo()) {
-      TypeLoc TL = TSInfo->getTypeLoc();
+      TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
       if (const FunctionTypeLoc *FTLoc = dyn_cast<FunctionTypeLoc>(&TL))
         AfterParenLoc = PP.getLocForEndOfToken(FTLoc->getRParenLoc());
     }