Compiler Explorer

Source code

struct B {};

template<int N>
struct S : B {
#if 0
  // non-dependent constraint on non-dependent non-template non-definition.
  // gcc, clang, and MSVC REJECT.
  friend void ff1(B) requires true;
#endif

#if 0
  // non-dependent constraint on non-dependent non-template definition.
  // gcc, clang, and MSVC accept.
  // gcc, clang, and MSVC REJECT on multiple instantiation of S due to duplicate definitions.
  // FIXME?: Per [temp.friend]p9, this should be accepted.
  friend void ff2(B) requires true {}
#endif

#if 0
  // non-dependent constraint on dependent non-template non-definition.
  // gcc, clang, and MSVC REJECT.
  friend void ff3(S) requires true;
#endif

// non-dependent constraint on dependent non-template definition.
  // gcc, clang, and MSVC accept.
  friend void ff4(S) requires true {}

#if 0
  // dependent constraint on non-dependent non-template non-definition.
  // gcc REJECTS.
  // clang and MSVC accept.
  // clang and MSVC REJECT on instantiation of S.
  friend void ff5(B) requires (!!N);
#endif

#if !defined(_MSC_VER) && !(defined(__GNUC__) && !defined(__clang__))
  // dependent constraint on non-dependent non-template definition.
  // gcc, clang, and MSVC accept.
  // gcc and MSVC REJECT multiple instantiations of S due to duplicate definitions.
  // clang REJECTS calls to ff6() for multiple instantiations of S due to duplicate definitions.
  // FIXME?: Per [temp.friend]p9, this should be accepted.
  friend void ff6(B) requires (!!N) {}
#endif

#if 0
  // dependent constraint on dependent non-template non-definition.
  // gcc REJECTS.
  // clang and MSVC accept.
  // clang and MSVC REJECT on instantiation of S.
  friend void ff7(S) requires (!!N);
#endif

// dependent constraint on dependent non-template definition.
  // gcc, clang, and MSVC accept.
  friend void ff8(S) requires (!!N) {}

// non-dependent constraint on non-dependent function template non-definition.
  // gcc, clang, and MSVC accept.
  template<typename> friend void fft1(B) requires true;

#if 0
  // non-dependent constraint on non-dependent function template definition.
  // gcc, clang, and MSVC accept.
  // gcc, clang, and MSVC REJECT on multiple instantiation of S due to duplicate definitions.
  // FIXME?: [temp.friend]p9 does not apply here, but perhaps it should?
  template<typename> friend void fft2(B) requires true {}
#endif

// non-dependent constraint on dependent function template non-definition.
  // gcc, clang, and MSVC accept.
  // FIXME?: Is [temp.friend]p9 intended to apply here?
  template<typename> friend void fft3(S) requires true;

// non-dependent constraint on dependent function template definition.
  // gcc, clang, and MSVC accept.
  // FIXME?: Does [temp.friend]p9 apply here? If not, should it?
  template<typename> friend void fft4(S) requires true {}

// dependent constraint on non-dependent function template non-definition.
  // gcc, clang, and MSVC accept.
  // FIXME?: Per [temp.friend]p9, this should be rejected since a definition cannot be defined outside the class template.
  template<typename> friend void fft5(B) requires (!!N);

#if !defined(_MSC_VER)
  // dependent constraint on non-dependent function template definition.
  // gcc, clang, and MSVC accept.
  // FIXME?: MSVC REJECTs on multiple instantiation of S due to duplicate definitions.
  template<typename> friend void fft6(B) requires (!!N) {}
#endif

// dependent constraint on dependent function template non-definition.
  // gcc, clang, and MSVC accept.
  // FIXME?: Per [temp.friend]p9, this should be rejected since a definition cannot be defined outside the class template.
  template<typename> friend void fft7(S) requires (!!N);

// dependent constraint on dependent function template definition.
  // gcc, clang, and MSVC accept.
  template<typename> friend void fft8(S) requires (!!N) {}
};

// fft1() can be defined outside the class template.
template<typename> void fft1(B) requires true {}

void f() {
  S<1> s1; // clang and MSVC REJECT ff5() and ff7().
  S<2> s2; // gcc, clang, and MSVC REJECT duplicate definition of ff2() and fft2().
           // gcc and MSVC REJECT ff6().
           // MSVC REJECTS fft6().

ff4(s1);
  ff4(s2);

#if !defined(_MSC_VER) && !(defined(__GNUC__) && !defined(__clang__))
  ff6(s1);
#if !defined(__clang__)  
  ff6(s2); // clang REJECTS duplicate definition of ff6().
#endif
#endif

ff8(s1);
  ff8(s2);

fft1<int>(s1); // Ok, calls the out-of-class definition.
  fft1<int>(s2); // Ok, calls the out-of-class definition.

fft3<int>(s1);
  fft3<int>(s2);

fft4<int>(s1);
  fft4<int>(s2);

fft5<int>(s1);
  fft5<int>(s2); // FIXME?: This call resolves to the same mangled name as the previous line.

#if !defined(_MSC_VER)
  fft6<int>(s1);
#if !defined(__clang__)
  fft6<int>(s2); // Clang REJECTs duplicate definition of fft6().
                 // FIXME?: This call resolves to the same mangled name as the previous line for gcc.
#endif
#endif

fft7<int>(s1);
  fft7<int>(s2);

fft8<int>(s1);
  fft8<int>(s2);
}