[Bug c++/105766] New: requires std::is_constructible<> reports 'constraint depends on itself' error.

[Bug c++/105766] New: requires std::is_constructible<> reports 'constraint depends on itself' error.

[stream009 at gmail dot com]

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

            Bug ID: 105766
           Summary: requires std::is_constructible<> reports 'constraint
                    depends on itself' error.
           Product: gcc
           Version: 12.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: stream009 at gmail dot com
  Target Milestone: ---

GCC reports following error on following code.

|error: satisfaction of atomic constraint 'is_constructible_v<T, int> [with T =
T]' depends on itself

First of all, I can't decipher the error message. So I guessed, maybe root of
trouble is the fact, at the time of instantiation of template baz (4), although
parameter T = foo::bar is a complete type but its surrounding type foo is not.

- If I uncomment (1), the error goes away, so it seems to become a problem only
when the constraint is on a member function.
- Also the error goes away too if I uncomment (2).
- Most interestingly, error goes away if I comment out (3).
- The code compile without error on clang.

FYI, in real code, foo is thread pool, bar is worker, baz is container.

// code
// https://godbolt.org/z/M48ssEqvr
#include <type_traits>

template<typename T>
    //requires std::is_constructible_v<T, int> (1)
struct baz
{
    baz() = default;
    //template<typename = void> // (2)
    baz(int) requires std::is_constructible_v<T, int> {}
};

struct foo
{
    struct bar {
        bar() = default;
        bar(foo&);    // (3)
        bar(int);
    };
    baz<bar> m_bars; // (4)
};

int main()
{
    foo a; (void)a;
}

[Bug c++/105766] requires std::is_constructible<> reports 'constraint depends on itself' error.

[cvs-commit at gcc dot gnu.org]

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

--- Comment #1 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Patrick Palka <ppalka@gcc.gnu.org>:

https://gcc.gnu.org/g:68f37670eff0b872ce5dfd382c8d8f3206bdfc27

commit r13-1755-g68f37670eff0b872ce5dfd382c8d8f3206bdfc27
Author: Patrick Palka <ppalka@redhat.com>
Date:   Tue Jul 19 14:04:13 2022 -0400

    c++: shortcut bad reference binding [PR94894]

    In case of l/rvalue or cv-qual mismatch during reference binding, we
    try to give more helpful diagnostics by computing a bad conversion that
    allows the mismatch.  But in doing so, we may end up considering and
    instantiating a conversion function that could induce a hard error and
    in turn cause us to reject otherwise valid code.  We could just give up
    on producing a better diagnostic here, but ideally we'd preserve the
    better diagnostics for invalid code while avoiding unnecessary template
    instantiations for valid code.

    To that end, this patch adapts the bad conversion shortcutting mechanism
    from r12-3346-g47543e5f9d1fc5 to additionally handle this situation.
    The main observation from there is that during overload resolution, if we
    know we have a strictly viable candidate then we don't need to distinguish
    between an unviable and non-strictly viable candidate.  Thus we don't
    need to distinguish between an invalid and bad conversion either, which
    is what this patch exploits.  Of course, we don't know whether we have a
    strictly viable candidate until after the fact, so we still need to
    remember when we deferred distinguishing between an invalid and bad
    conversion.  This patch adds a special conversion kind ck_deferred_bad
    for this purpose.

            PR c++/94894
            PR c++/105766
            PR c++/106201

    gcc/cp/ChangeLog:

            * call.cc (enum conversion_kind): Add ck_deferred_bad enumerator.
            (has_next): Return false for it.
            (reference_binding): Return a ck_deferred_bad conversion instead
            of an actual bad conversion when LOOKUP_SHORTCUT_BAD_CONVS is set.
            Remove now obsolete early exit for the incomplete TO case.
            (implicit_conversion_1): Don't mask out LOOKUP_SHORTCUT_BAD_CONVS.
            (add_function_candidate): Set LOOKUP_SHORTCUT_BAD_CONVS iff
            shortcut_bad_convs.
            (missing_conversion_p): Also return true for a ck_deferred_bad
            conversion.
            * cp-tree.h (LOOKUP_SHORTCUT_BAD_CONVS): Define.

    gcc/testsuite/ChangeLog:

            * g++.dg/conversion/ref8.C: New test.
            * g++.dg/conversion/ref9.C: New test.

[Bug c++/105766] requires std::is_constructible<> reports 'constraint depends on itself' error.

[ppalka at gcc dot gnu.org]

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

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |ppalka at gcc dot gnu.org
         Resolution|---                         |FIXED
   Target Milestone|---                         |13.0
             Status|UNCONFIRMED                 |RESOLVED

--- Comment #2 from Patrick Palka <ppalka at gcc dot gnu.org> ---
Fixed for GCC 13, thanks for the bug report.

[Bug c++/105766] requires std::is_constructible<> reports 'constraint depends on itself' error.

[ppalka at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105766
Bug 105766 depends on bug 94894, which changed state.

Bug 94894 Summary: avoidable instantiation of conversion function template during overload resolution
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94894

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|---                         |FIXED