If a function decl cannot be merged, mark it as invalid, phab edition.

[thakis]

Summary

Clang currently crashes on

class C {
  C() = default;
  C() = delete;
};

My cunning plan for fixing this was to change the if (!FnD) in Parser::ParseCXXInlineMethodDef() to if (!FnD || FnD->isInvalidDecl) – but alas, the second constructor decl wasn't marked as invalid. This patch lets Sema::MergeFunctionDecl() return true on function redeclarations, which leads to them being marked invalid. (There are two more diag::err_s later in the same function that also don't return true. These look fishy to me too – let me know if you think those should be changed too. Probably in a separate patch, though.)

This reduces the number of duplicate error messages in tests, which is probably a good thing for this kind of error – if you have two definitions of a function, things likely are pretty dire already.

[rsmith]

LGTM, all of these diagnostic changes look great.

[thakis]

r226365

lib/Sema/SemaDecl.cpp

if (OldMethod && NewMethod) {
             NewDiag = diag::err_member_redeclared;
 
           Diag(New->getLocation(), NewDiag);
         } else {
           Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
             << New << New->getType();
         }
         Diag(OldLocation, PrevDiag) << Old << Old->getType();
+        return true;
 
       // Complain if this is an explicit declaration of a special
       // member that was initially declared implicitly.
       //
       // As an exception, it's okay to befriend such methods in order
       // to permit the implicit constructor/destructor/operator calls.
       } else if (OldMethod->isImplicit()) {
         if (isFriend) {

test/Parser/DelayedTemplateParsing.cpp

 // RUN: %clang_cc1 -fms-extensions -fdelayed-template-parsing -fsyntax-only -verify -std=c++11 %s
 
 template <class T>
 class A {
    void foo() {
        undeclared();
    }
    void foo2();
 };
 
 template <class T>
 class B {
-   void foo4() { } // expected-note {{previous definition is here}}  expected-note {{previous definition is here}}
-   void foo4() { } // expected-error {{class member cannot be redeclared}} expected-error {{redefinition of 'foo4'}}
+   void foo4() { } // expected-note {{previous definition is here}}
+   void foo4() { } // expected-error {{class member cannot be redeclared}}
    void foo5() { } // expected-note {{previous definition is here}}
 
    friend void foo3() {
        undeclared();
    }
 };
 
 

test/Parser/cxx0x-ambig.cpp

namespace N {
     }
   }
 }
 
 namespace ellipsis {
   template<typename...T>
   struct S {
     void e(S::S());
-    void f(S(...args[sizeof(T)])); // expected-note {{here}}
-    void f(S(...args)[sizeof(T)]); // expected-error {{redeclared}} expected-note {{here}}
+    void f(S(...args[sizeof(T)])); // expected-note {{here}} expected-note {{here}}
+    void f(S(...args)[sizeof(T)]); // expected-error {{redeclared}}
     void f(S ...args[sizeof(T)]); // expected-error {{redeclared}}
     void g(S(...[sizeof(T)])); // expected-note {{here}} expected-warning {{ISO C++11 requires a parenthesized pack declaration to have a name}}
     void g(S(...)[sizeof(T)]); // expected-error {{function cannot return array type}}
     void g(S ...[sizeof(T)]); // expected-error {{redeclared}}
     void h(T(...)); // function type, expected-error {{unexpanded parameter pack}}
     void h(T...); // pack expansion, ok
     void i(int(T...)); // expected-note {{here}}
     void i(int(T...a)); // expected-error {{redeclared}}

test/SemaCXX/class.cpp

 struct C4 {
   void f(); // expected-note{{previous declaration is here}}
   int f; // expected-error{{duplicate member 'f'}}
 };
 
 // PR5415 - don't hang!
 struct S
 {
-  void f(); // expected-note 1 {{previous declaration}}
-  void S::f() {} // expected-error {{extra qualification on member}} expected-error {{class member cannot be redeclared}} expected-note {{previous declaration}} expected-note {{previous definition}}
-  void f() {} // expected-error {{class member cannot be redeclared}} expected-error {{redefinition}}
+  void f(); // expected-note 1 {{previous declaration}} expected-note {{previous declaration}}
+  void S::f() {} // expected-error {{extra qualification on member}} expected-error {{class member cannot be redeclared}}
+  void f() {} // expected-error {{class member cannot be redeclared}}
 };
 
 // Don't crash on this bogus code.
 namespace pr6629 {
   template<class T1, class T2> struct foo :
     bogus<foo<T1,T2> > // expected-error {{unknown template name 'bogus'}}
   { };
 

test/SemaCXX/cxx1y-constexpr-not-const.cpp

 // RUN: %clang_cc1 -std=c++11 %s -verify
 // RUN: %clang_cc1 -std=c++1y %s -verify -DCXX1Y
 
 struct X {
   constexpr int f(); // @5
   int f();           // @6
 };
 
 #ifdef CXX1Y
 // FIXME: Detect this situation and provide a better recovery.
 
 // expected-error@6 {{class member cannot be redeclared}}
 // expected-note@5 {{previous}}
-// expected-error@6 {{non-constexpr declaration of 'f' follows constexpr declaration}}
-// expected-note@5 {{previous}}
 #else
 // expected-warning@5 {{'constexpr' non-static member function will not be implicitly 'const' in C++14; add 'const' to avoid a change in behavior}}
 #endif

test/SemaCXX/cxx1y-deduced-return-type.cpp

 int conv1a = conv1; // expected-error {{function 'operator auto' with deduced return type cannot be used before it is defined}}
 // expected-error@-1 {{no viable conversion}}
 Conv1::operator auto() { return 123; }
 int conv1b = conv1;
 int conv1c = conv1.operator auto();
 int conv1d = conv1.operator int(); // expected-error {{no member named 'operator int'}}
 
 struct Conv2 {
-  operator auto() { return 0; }  // expected-note 2{{previous}}
-  operator auto() { return 0.; } // expected-error {{cannot be redeclared}} expected-error {{redefinition of 'operator auto'}}
+  operator auto() { return 0; }  // expected-note {{previous}}
+  operator auto() { return 0.; } // expected-error {{cannot be redeclared}}
 };
 
 struct Conv3 {
   operator auto() { int *p = nullptr; return p; }  // expected-note {{candidate}}
   operator auto*() { int *p = nullptr; return p; } // expected-note {{candidate}}
 } conv3;
 int *conv3a = conv3; // expected-error {{ambiguous}}
 int *conv3b = conv3.operator auto();

test/SemaCXX/overload-decl.cpp

class X {
   void g(int); // expected-note {{previous declaration is here}}
   void g(int, float); // expected-note {{previous declaration is here}}
   int g(int, Float); // expected-error {{functions that differ only in their return type cannot be overloaded}}
 
   static void g(float); // expected-note {{previous declaration is here}}
   static void g(int); // expected-error {{static and non-static member functions with the same parameter types cannot be overloaded}}
   static void g(float); // expected-error {{class member cannot be redeclared}}
 
-  void h(); // expected-note {{previous declaration is here}} \
-               expected-note {{previous declaration is here}}
-  void h() __restrict; // expected-error {{class member cannot be redeclared}} \
-                          expected-error {{conflicting types for 'h'}}
+  void h(); // expected-note {{previous declaration is here}}
+  void h() __restrict; // expected-error {{class member cannot be redeclared}}
 };
 
 int main() {} // expected-note {{previous definition is here}}
 int main(int,char**) {} // expected-error {{conflicting types for 'main'}}