Clang doesn't recognise friendship in default parameters in C++20+

[cjdb]

This code doesn't compile on Compiler Explorer. Moving the defaulted parameter to the constructor body seems to be okay.

template<class T>
class single;

template<class T, class U>
class check_constructible {
    check_constructible() = default;

    static_assert(is_constructible_v<T, U>);

    template<class X>
    friend class single;
};

template<class T>
struct single {
    template<class U>
    single(U u, check_constructible<T, U> = {})
    : x(u)
    {}

    T x;
};

int main() {
    single<int> x(0);
}

Diagnostic:

<source>:25:45: error: calling a private constructor of class 'check_constructible<int, int>'
   25 |     single(U u, check_constructible<T, U> = {})
      |                                             ^
<source>:14:5: note: implicitly declared private here
   14 |     check_constructible() = default;
      |     ^

Compiler info:

clang version 19.0.0git (https://github.com/llvm/llvm-project.git 5b058709536dd883980722ee000bb7b8c7b2cd8b)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /opt/compiler-explorer/clang-trunk-20240301/bin
Compiler returned: 0

Both GCC and MSVC accept this code. If it's not conforming, should we accept it as an extension?

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Christopher Di Bella (cjdb)

This code doesn't compile on Compiler Explorer. Moving the defaulted parameter to the constructor body seems to be okay.

template<class T>
class single;

template<class T, class U>
class check_constructible {
    check_constructible() = default;

    static_assert(is_constructible_v<T, U>);

    template<class X>
    friend class single;
};

template<class T>
struct single {
    template<class U>
    single(U u, check_constructible<T, U> = {})
    : x(u)
    {}

    T x;
};

int main() {
    single<int> x(0);
}

Diagnostic:

<source>:25:45: error: calling a private constructor of class 'check_constructible<int, int>'
   25 |     single(U u, check_constructible<T, U> = {})
      |                                             ^
<source>:14:5: note: implicitly declared private here
   14 |     check_constructible() = default;
      |     ^

Compiler info:

clang version 19.0.0git (https://github.com/llvm/llvm-project.git 5b058709536dd883980722ee000bb7b8c7b2cd8b)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /opt/compiler-explorer/clang-trunk-20240301/bin
Compiler returned: 0

Both GCC and MSVC accept this code. If it's not conforming, should we accept it as an extension?

[llvmbot]

@llvm/issue-subscribers-c-1

Author: Christopher Di Bella (cjdb)

This code doesn't compile on Compiler Explorer. Moving the defaulted parameter to the constructor body seems to be okay.

template<class T>
class single;

template<class T, class U>
class check_constructible {
    check_constructible() = default;

    static_assert(is_constructible_v<T, U>);

    template<class X>
    friend class single;
};

template<class T>
struct single {
    template<class U>
    single(U u, check_constructible<T, U> = {})
    : x(u)
    {}

    T x;
};

int main() {
    single<int> x(0);
}

Diagnostic:

<source>:25:45: error: calling a private constructor of class 'check_constructible<int, int>'
   25 |     single(U u, check_constructible<T, U> = {})
      |                                             ^
<source>:14:5: note: implicitly declared private here
   14 |     check_constructible() = default;
      |     ^

Compiler info:

clang version 19.0.0git (https://github.com/llvm/llvm-project.git 5b058709536dd883980722ee000bb7b8c7b2cd8b)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /opt/compiler-explorer/clang-trunk-20240301/bin
Compiler returned: 0

Both GCC and MSVC accept this code. If it's not conforming, should we accept it as an extension?

[shafik]

If I am reading class.access.general p8:

Access is checked for a default argument ([dcl.fct.default]) at the point of declaration, rather than at any points of use of the default argument. Access checking for default arguments in function templates and in member functions of class templates is performed as described in [temp.inst].

and temp.inst p12:

If a templated function f is called in a way that requires a default argument to be used, the dependent names are looked up, the semantics constraints are checked, and the instantiation of any template used in the default argument is done as if the default argument had been an initializer used in a function template specialization with the same scope, the same template parameters and the same access as that of the function template f used at that point ...

correctly then clang is not correct.

CC @zygoloid @Endilll

[Endilll]

I agree with Shafik's analysis.

[jcsxky]

@cjdb I have checked the code with clang-trunk and it runs ok. Could you have a double check?

[cor3ntin]

@jcsxky it reproduces https://godbolt.org/z/dWf54MYq8

[jcsxky]

@jcsxky it reproduces https://godbolt.org/z/dWf54MYq8

Hmm, compliant with -std=c++17