Revert r107374, which broke bootstrap.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@107378 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index 93e6a06ef89e19b24bcc3860f3118d91ec6176c0..5588db79e372fb2f7395bb760913386f4c58a882 100644 (file)
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -2672,7 +2672,7 @@ public:
   QualType CheckConstructorDeclarator(Declarator &D, QualType R,
                                       FunctionDecl::StorageClass& SC);
   void CheckConstructor(CXXConstructorDecl *Constructor);
-  QualType CheckDestructorDeclarator(Declarator &D, QualType R,
+  QualType CheckDestructorDeclarator(Declarator &D,
                                      FunctionDecl::StorageClass& SC);
   bool CheckDestructor(CXXDestructorDecl *Destructor);
   void CheckConversionDeclarator(Declarator &D, QualType &R,

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 500d73eb9b44ced67199b763f9456a6bf375976f..ba84f7c223350fc3ad2fa9031ba4f220744dbef1 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -3023,7 +3023,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
   } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
     // This is a C++ destructor declaration.
     if (DC->isRecord()) {
-      R = CheckDestructorDeclarator(D, R, SC);
+      R = CheckDestructorDeclarator(D, SC);
 
       NewFD = CXXDestructorDecl::Create(Context,
                                         cast<CXXRecordDecl>(DC),

diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index c59575f13b575993f18402c2be0974da43b29d56..1c0a72bf1183fc0069a6051ed07b5bf196061d5d 100644 (file)
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -2990,7 +2990,9 @@ QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
 
   // Rebuild the function type "R" without any type qualifiers (in
   // case any of the errors above fired) and with "void" as the
-  // return type, since constructors don't have return types.
+  // 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 FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
   return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
                                  Proto->getNumArgs(),
@@ -3085,7 +3087,7 @@ FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
 /// emit diagnostics and set the declarator to invalid.  Even if this happens,
 /// will be updated to reflect a well-formed type for the destructor and
 /// returned.
-QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
+QualType Sema::CheckDestructorDeclarator(Declarator &D,
                                          FunctionDecl::StorageClass& SC) {
   // C++ [class.dtor]p1:
   //   [...] A typedef-name that names a class is a class-name
@@ -3093,9 +3095,11 @@ QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
   //   be used as the identifier in the declarator for a destructor
   //   declaration.
   QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
-  if (isa<TypedefType>(DeclaratorType))
+  if (isa<TypedefType>(DeclaratorType)) {
     Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
       << DeclaratorType;
+    D.setInvalidType();
+  }
 
   // C++ [class.dtor]p2:
   //   A destructor is used to destroy objects of its class type. A
@@ -3109,10 +3113,9 @@ QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
     if (!D.isInvalidType())
       Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
         << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
-        << SourceRange(D.getIdentifierLoc())
-        << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
-    
+        << SourceRange(D.getIdentifierLoc());
     SC = FunctionDecl::None;
+    D.setInvalidType();
   }
   if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
     // Destructors don't have return types, but the parser will
@@ -3160,17 +3163,11 @@ QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
   // Rebuild the function type "R" without any type qualifiers or
   // parameters (in case any of the errors above fired) and with
   // "void" as the return type, since destructors don't have return
-  // types. 
-  const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
-  if (!Proto)
-    return QualType();
-  
+  // types. We *always* have to do this, because GetTypeForDeclarator
+  // will put in a result type of "int" when none was specified.
+  // FIXME: Exceptions!
   return Context.getFunctionType(Context.VoidTy, 0, 0, false, 0,
-                                 Proto->hasExceptionSpec(),
-                                 Proto->hasAnyExceptionSpec(),
-                                 Proto->getNumExceptions(),
-                                 Proto->exception_begin(),
-                                 Proto->getExtInfo());
+                                 false, false, 0, 0, FunctionType::ExtInfo());
 }
 
 /// CheckConversionDeclarator - Called by ActOnDeclarator to check the

diff --git a/test/CodeGenCXX/destructors.cpp b/test/CodeGenCXX/destructors.cpp
index 62621f6e9883c1e5693e4ea4a4bf88328aafdac3..1442e374039391a3618eeed04da11a86a83fb8bc 100644 (file)
--- a/test/CodeGenCXX/destructors.cpp
+++ b/test/CodeGenCXX/destructors.cpp
@@ -32,17 +32,6 @@ struct C {
 
 C::~C() { }
 
-namespace PR7526 {
-  extern void foo();
-  struct allocator {
-    ~allocator() throw();
-  };
-
-  // CHECK: define void @_ZN6PR75269allocatorD2Ev
-  // CHECK: call void @__cxa_call_unexpected
-  allocator::~allocator() throw() { foo(); }
-}
-
 // PR5084
 template<typename T>
 class A1 {

diff --git a/test/SemaCXX/destructor.cpp b/test/SemaCXX/destructor.cpp
index 1d36ceab236bcafd9775ce00a0dccdbd4f35fdb7..ae3dc86e97f507bc58b9e306fa96f343af5f1d7e 100644 (file)
--- a/test/SemaCXX/destructor.cpp
+++ b/test/SemaCXX/destructor.cpp
@@ -19,9 +19,7 @@ struct D {
     // expected-error{{type qualifier is not allowed on this function}} \
     // expected-error{{destructor cannot be declared 'static'}}  \
     // expected-error{{destructor cannot have any parameters}}   \
-    // expected-error{{destructor cannot be variadic}} \
-    // expected-error{{destructor cannot have a return type}} \
-    // expected-error{{'const' qualifier is not allowed on a destructor}}
+    // expected-error{{destructor cannot be variadic}}
 };
 
 struct D2 {

diff --git a/www/compatibility.html b/www/compatibility.html
index 0f8409b953a5ff216edffde94132bbfb6ee82440..85133fbca2f6ff2d539a35e7ec9328f1d0c87d6f 100644 (file)
--- a/www/compatibility.html
+++ b/www/compatibility.html
@@ -590,8 +590,9 @@ void g(Base *base) {
 downcast.mm:6:3: error: no matching function for call to 'f'
   f(base);
   ^
-downcast.mm:4:6: note: candidate function not viable: cannot convert from
-      superclass 'Base *' to subclass 'Derived *' for 1st argument
+downcast.mm:4:6: note: candidate function not viable: cannot convert from base
+      class pointer 'Base *' to derived class pointer 'Derived *' for 1st
+      argument
 void f(Derived *);
      ^
 </pre>