Improve diagnostics if friend function redefines file-level function.

[sepavloff]

Summary

Clang makes check for function redefinition after it merged the new
declaration with the existing one. As a result, it produces poor
diagnostics in the case of a friend function defined inline, as in
the code:

void func() {}
class C { friend void func() {} };

Error message in this case states that `inline declaration of 'func'
follows non-inline definition`, which is misleading, as func does
not have explicit inline specifier.

With this changes compiler reports function redefinition if the new
function is a friend defined inline and it does not have explicit
inline specifier.

[sepavloff]

Do not use getFriendObjectKind(), friend kind sometimes is set too late.

[sepavloff]

Ping.

[arphaman]

lib/Sema/SemaDeclCXX.cpp

646

This is somewhat confusing to me: are you using the !New->isOutOfLine() || !New->getLexicalDeclContext()->isRecord() check to ensure that this new declaration is not a friend?

[sepavloff]

lib/Sema/SemaDeclCXX.cpp

646

Indeed, this check is obscure. Replaced by call to getFriendObjectKind.

[sepavloff]

Rebased and enhance check

[arphaman]

LGTM.

lib/Sema/SemaDeclCXX.cpp

bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old,
   // template has a constexpr specifier then all its declarations shall
   // contain the constexpr specifier.
   if (New->isConstexpr() != Old->isConstexpr()) {
     Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
       << New << New->isConstexpr();
     Diag(Old->getLocation(), diag::note_previous_declaration);
     Invalid = true;
   } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
-             Old->isDefined(Def)) {
+             Old->isDefined(Def) &&
+             // If a friend function is inlined but does not have 'inline'
+             // specifier, it is a definition. Do not report attribute conflict
+             // in this case, redefinition will be diagnosed later.
+             (New->getFriendObjectKind() == Decl::FOK_None ||
+              New->isInlineSpecified())) {
     // C++11 [dcl.fcn.spec]p4:
     //   If the definition of a function appears in a translation unit before its
     //   first declaration as inline, the program is ill-formed.
     Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
     Diag(Def->getLocation(), diag::note_previous_definition);
     Invalid = true;
   }
 

test/CXX/dcl.dcl/dcl.spec/dcl.fct.spec/p4.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 void f0() { // expected-note {{previous definition is here}}
 }
 
 inline void f0(); // expected-error {{inline declaration of 'f0' follows non-inline definition}}
+
+void func_01() {} // expected-note{{previous definition is here}}
+struct C01 {
+  friend void func_01() {} // expected-error{{redefinition of 'func_01'}}
+};
+
+void func_02() {} // expected-note{{previous definition is here}}
+struct C02 {
+  friend inline void func_02(); // expected-error{{inline declaration of 'func_02' follows non-inline definition}}
+};
+
+void func_03() {} // expected-note{{previous definition is here}}
+struct C03 {
+  friend inline void func_03() {} // expected-error{{inline declaration of 'func_03' follows non-inline definition}}
+};
+
+void func_04() {} // expected-note{{previous definition is here}}
+inline void func_04() {} // expected-error{{inline declaration of 'func_04' follows non-inline definition}}
+
+void func_06() {} // expected-note{{previous definition is here}}
+template<typename T> struct C06 {
+  friend inline void func_06() {} // expected-error{{inline declaration of 'func_06' follows non-inline definition}}
+};
+
+void func_07() {} // expected-note{{previous definition is here}}
+template<typename T> struct C07 {
+  friend inline void func_07(); // expected-error{{inline declaration of 'func_07' follows non-inline definition}}
+};