[Bug c++/101113] New: g++ thinks constructor suppressed by a requires clause is actually a bad copy constructor

[Bug c++/101113] New: g++ thinks constructor suppressed by a requires clause is actually a bad copy constructor

[gcc at nospam dot scs.stanford.edu]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101113

            Bug ID: 101113
           Summary: g++ thinks constructor suppressed by a requires clause
                    is actually a bad copy constructor
           Product: gcc
           Version: 11.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: gcc at nospam dot scs.stanford.edu
  Target Milestone: ---

g++ 11.1.0 is rejecting the following correct code when compiling with
`-std=c++20` (test case public domain):

template<bool B> struct S {
  S() {}
  S(S<false>) requires B {}
};
S<false> sf;

Here is the error message:

$ g++ -std=c++20 -c test.cc
y.cc: In instantiation of 'struct S<false>':
y.cc:3:26:   required from here
y.cc:3:3: error: invalid constructor; you probably meant 'S<false> (const
S<false>&)'
    3 |   S(S<false>) requires B {}
      |   ^

[Bug c++/101113] g++ thinks constructor suppressed by a requires clause is actually a bad copy constructor

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101113

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2021-06-17
           Keywords|                            |rejects-valid
     Ever confirmed|0                           |1
             Status|UNCONFIRMED                 |NEW

--- Comment #1 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Confirmed. Fails with older versions too and doesn't seem to be a regression.

[Bug c++/101113] g++ thinks constructor suppressed by a requires clause is actually a bad copy constructor

[rs2740 at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101113

TC <rs2740 at gmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |rs2740 at gmail dot com

--- Comment #2 from TC <rs2740 at gmail dot com> ---
https://eel.is/c++draft/class.copy.ctor#5

I don't think this code is valid. The constraint (which isn't checked until
overload resolution time anyway) can't suppress the outright ill-formedness of
the declaration.

[Bug c++/101113] g++ thinks constructor suppressed by a requires clause is actually a bad copy constructor

[gcc at nospam dot scs.stanford.edu]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101113

--- Comment #3 from David Mazieres <gcc at nospam dot scs.stanford.edu> ---
(In reply to TC from comment #2)
> https://eel.is/c++draft/class.copy.ctor#5
> 
> I don't think this code is valid. The constraint (which isn't checked until
> overload resolution time anyway) can't suppress the outright ill-formedness
> of the declaration.

Admittedly, 11.4.5.3/5 makes no mention of constraints:

A declaration of a constructor for a class X is ill-formed if its first
parameter is of type cv X and either there are no other parameters or else all
other parameters have default arguments.
A member function template is never instantiated to produce such a constructor
signature.
- https://timsong-cpp.github.io/cppwp/n4868/class.copy.ctor#5

On the other hand, suppressed functions should not participate in overload
resolution.  Here's some normative language to the same effect 12.4.3/3:

Second, for a function to be viable, if it has associated constraints
([temp.constr.decl]), those constraints shall be satisfied
([temp.constr.constr]).
- https://timsong-cpp.github.io/cppwp/n4868/over.match.viable#3

So here's another example that doesn't involve 11.4.5.3/5:

#include <type_traits>

template<typename T> struct S2 {
  static T *fn() requires (!std::is_reference_v<T>) { return nullptr; }
  static std::nullptr_t fn() requires std::is_reference_v<T> { return {}; }
};

void
f()
{
  auto p = S2<int&>::fn();
}

$ g++ -std=c++20    -c -o constructor.o constructor.cc
constructor.cc: In instantiation of 'struct S2<int&>':
constructor.cc:11:20:   required from here
constructor.cc:4:13: error: forming pointer to reference type 'int&'
    4 |   static T *fn() requires (!std::is_reference_v<T>) { return nullptr; }
      |             ^~
make: *** [<builtin>: constructor.o] Error 1

So I guess your argument is that there's a certain level of well-formedness
required even before the constraints can be evaluated, and an X::X(X) method is
as non-sensical as a type like "int&*".  That seems like a reasonable position,
though I wish the standard were more explicit.

I apologize for wasting your time if this was a bogus bug report.

For the record, in case the closed bug report comes up in anyone's web search,
an easy fix is to rely on the fact that templates won't be instantiated to bad
copy constructors:

template<bool B> struct S {
  S() {}
  template<bool B2> S(S<B2>) requires B2 {}
};
S<false> sf;
S<true> st;

[Bug c++/101113] g++ thinks constructor suppressed by a requires clause is actually a bad copy constructor

[gcc at nospam dot scs.stanford.edu]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101113

David Mazières <gcc at nospam dot scs.stanford.edu> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
         Resolution|---                         |INVALID

--- Comment #4 from David Mazières <gcc at nospam dot scs.stanford.edu> ---
Sorry I should have closed this bug report a while ago when I said it wasn't a
bug.