When we see something that looks like a constructor with a return type, only issue one error, not two.

llvm-svn: 241424

clang/lib/Sema/SemaDecl.cpp

@@ -4742,15 +4742,16 @@ NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
     }
   }
 
-  if (DiagnoseClassNameShadow(DC, NameInfo))
-    // If this is a typedef, we'll end up spewing multiple diagnostics.
-    // Just return early; it's safer.
-    if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
-      return nullptr;
-
   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
   QualType R = TInfo->getType();
 
+  if (!R->isFunctionType() && DiagnoseClassNameShadow(DC, NameInfo))
+    // If this is a typedef, we'll end up spewing multiple diagnostics.
+    // Just return early; it's safer. If this is a function, let the
+    // "constructor cannot have a return type" diagnostic handle it.
+    if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
+      return nullptr;
+
   if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
                                       UPPC_DeclarationType))
     D.setInvalidType();

clang/test/CXX/class/class.mem/p2.cpp

@@ -76,13 +76,10 @@ namespace PR12629 {
 
 namespace PR12688 {
   struct S {
-    // FIXME: Producing one error saying this can't have the same name
+    // FIXME: Maybe suppress the "constructor cannot have a return type" error
-    //        as the class because it's not a constructor, then producing
+    // if the return type is invalid.
-    //        another error saying this can't have a return type because
-    //        it is a constructor, is redundant and inconsistent.
     nonsense S() throw (more_nonsense); // \
     // expected-error {{'nonsense'}} \
-    // expected-error {{has the same name as its class}} \
     // expected-error {{constructor cannot have a return type}}
   };
 }

clang/test/CXX/drs/dr1xx.cpp

@@ -943,10 +943,10 @@ namespace dr188 { // dr188: yes
 namespace dr194 { // dr194: yes
   struct A {
     A();
-    void A(); // expected-error {{has the same name as its class}} expected-error {{constructor cannot have a return type}}
+    void A(); // expected-error {{constructor cannot have a return type}}
   };
   struct B {
-    void B(); // expected-error {{has the same name as its class}} expected-error {{constructor cannot have a return type}}
+    void B(); // expected-error {{constructor cannot have a return type}}
     B();
   };
   struct C {

clang/test/Parser/cxx-default-delete.cpp

@@ -19,5 +19,5 @@ struct foo {
 void baz() = delete;
 
 struct quux {
-  int quux() = default; // expected-error{{constructor cannot have a return type}} expected-error {{member 'quux' has the same name as its class}}
+  int quux() = default; // expected-error{{constructor cannot have a return type}}
 };

clang/test/SemaCXX/constructor.cpp

@@ -15,8 +15,7 @@ class Foo {
   virtual Foo(double); // expected-error{{constructor cannot be declared 'virtual'}}
   Foo(long) const; // expected-error{{'const' qualifier is not allowed on a constructor}}
   
-  int Foo(int, int); // expected-error{{constructor cannot have a return type}} \
+  int Foo(int, int); // expected-error{{constructor cannot have a return type}}
-  // expected-error{{member 'Foo' has the same name as its class}}
 
   volatile Foo(float); // expected-error{{constructor cannot have a return type}}
 };