[Bug c++/109680] New: Regression where `int() const` is considered convertible to `int(*)()`.

[Bug c++/109680] New: Regression where `int() const` is considered convertible to `int(*)()`.

[dpsicilia at gmail dot com]

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

            Bug ID: 109680
           Summary: Regression where `int() const` is considered
                    convertible to `int(*)()`.
           Product: gcc
           Version: 13.1.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: dpsicilia at gmail dot com
  Target Milestone: ---

Demo of problem: https://godbolt.org/z/4z3zs8ocz

Minimal repro:

  static_assert( std::is_convertible_v<int() const, int(*)()> );

fails on all major compilers in C++20 mode, including GCC 12.2, but now passes
on GCC 13.1.0.

[Bug c++/109680] Regression where `int() const` is considered convertible to `int(*)()`.

[pinskia at gcc dot gnu.org]

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

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Created attachment 54957
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=54957&action=edit
Full testcase including the include

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[pinskia at gcc dot gnu.org]

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

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|---                         |13.2
     Ever confirmed|0                           |1
            Summary|Regression where `int()     |[13/14 Regression]
                   |const` is considered        |is_convertible<int() const,
                   |convertible to `int(*)()`.  |int(*)()> incorrectly true
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2023-04-29
           Keywords|accepts-invalid             |

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
The difference is how is_convertible is defined ...
In GCC 13 it is using the newly created builtin __is_convertible.
If we use the original preprocessed source from gcc 12 with GCC 13 (with one
minor change renaming __is_nothrow_convertible to __is_nothrow_convertible1),
GCC 13 works correctly.

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[jakub at gcc dot gnu.org]

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

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org,
                   |                            |mpolacek at gcc dot gnu.org

--- Comment #3 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
r13-2822-g8a7bcf95a82c3dd implemented __is_{,nothrow_}convertible for GCC 13,
CCing Marek.

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[mpolacek at gcc dot gnu.org]

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

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |ASSIGNED
           Assignee|unassigned at gcc dot gnu.org      |mpolacek at gcc dot gnu.org
           Priority|P3                          |P2

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[jakub at gcc dot gnu.org]

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

--- Comment #4 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
template <typename T, typename U = T&&>
U __declval (int);
template <typename T>
T __declval (long);
template <typename T>
auto declval () noexcept -> decltype (__declval <T> (0));
using To = int () const;
using From = int (*) ();
To foo () { return declval <From> (); }
From bar () { return declval <To> (); }
static_assert (!__is_convertible (To, From), "");
static_assert (!__is_convertible (From, To), "");
should show that both assertions should succeed.  Dunno if in this case the
reason why it isn't convertible is simply the fact that functions can't be
declared to return function/method/array types or some other reason as well.

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[mpolacek at gcc dot gnu.org]

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

--- Comment #5 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
(In reply to Jakub Jelinek from comment #4)
> template <typename T, typename U = T&&>
> U __declval (int);
> template <typename T>
> T __declval (long);
> template <typename T>
> auto declval () noexcept -> decltype (__declval <T> (0));
> using To = int () const;
> using From = int (*) ();
> To foo () { return declval <From> (); }
> From bar () { return declval <To> (); }
> static_assert (!__is_convertible (To, From), "");
> static_assert (!__is_convertible (From, To), "");
> should show that both assertions should succeed.  

Thanks.

> Dunno if in this case the
> reason why it isn't convertible is simply the fact that functions can't be
> declared to return function/method/array types or some other reason as well.

Yeah, I'm also not sure, so I think this should fix it:

--- a/gcc/cp/method.cc
+++ b/gcc/cp/method.cc
@@ -2245,6 +2245,8 @@ is_convertible_helper (tree from, tree to)
 {
   if (VOID_TYPE_P (from) && VOID_TYPE_P (to))
     return integer_one_node;
+  if (FUNC_OR_METHOD_TYPE_P (from) || FUNC_OR_METHOD_TYPE_P (to))
+    return error_mark_node;
   cp_unevaluated u;
   tree expr = build_stub_object (from);
   deferring_access_check_sentinel acs (dk_no_deferred);


Since
static_assert (!__is_convertible (int[3], int[3]), "");
already passes, arrays are handled correctly I think.

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[jakub at gcc dot gnu.org]

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

--- Comment #6 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Not sure about the from case, but what do I know about C++?
While To type is directly returned from a function, std::declval doesn't return
From but
From &&.
#include <type_traits>

using F1 = int (int);
using T1 = int (*) (int);
static_assert (std::is_convertible_v<F1, T1>);
using F2 = int (int) const;
using T2 = int (*) (int);
static_assert (!std::is_convertible_v<F2, T2>);
using F3 = int (*) (int);
using T3 = int (int);
static_assert (!std::is_convertible_v<F3, T3>);
using F4 = int (*) (int);
using T4 = int (int) const;
static_assert (!std::is_convertible_v<F4, T4>);

passes in both g++ 12 and clang++.
And, on

using F1 = int (int);
using T1 = int (*) (int);
static_assert (__is_convertible(F1, T1));
using F2 = int (int) const;
using T2 = int (*) (int);
static_assert (!__is_convertible(F2, T2));
using F3 = int (*) (int);
using T3 = int (int);
static_assert (!__is_convertible(F3, T3));
using F4 = int (*) (int);
using T4 = int (int) const;
static_assert (!__is_convertible(F4, T4));

clang++ emits:
/tmp/2a.C:6:34: error: non-member function of type 'F2' (aka 'int (int) const')
cannot have 'const' qualifier
static_assert (!__is_convertible(F2, T2));
                                 ^
/tmp/2a.C:6:1: error: static_assert failed due to requirement
'!__is_convertible(int (int), int (*)(int))'
static_assert (!__is_convertible(F2, T2));
^              ~~~~~~~~~~~~~~~~~~~~~~~~~
/tmp/2a.C:12:38: error: non-member function of type 'T4' (aka 'int (int)
const') cannot have 'const' qualifier
static_assert (!__is_convertible(F4, T4));
                                     ^
while g++ trunk
/tmp/2a.C:6:16: error: static assertion failed
    6 | static_assert (!__is_convertible(F2, T2));
      |                ^~~~~~~~~~~~~~~~~~~~~~~~~

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[mpolacek at gcc dot gnu.org]

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

--- Comment #7 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
Ah, I think I see what's going on here.  Once again, the problem is that this
assert no longer passes:

#include <utility>
static_assert (!std::is_convertible_v <int () const, int (*) ()>, "");

std::is_convertible does
To test() { return std::declval<From>(); }
here, From is 'int () const'.

std::declval is defined as:

template<class T>
typename std::add_rvalue_reference<T>::type declval() noexcept;

Now, std::add_rvalue_reference is defined as "If T is a function type that has
no cv- or ref- qualifier or an object type, provides a member typedef type
which is T&&, otherwise type is T."

In our case, T is cv-qualified, so the result is T, so we end up with

int () const declval() noexcept;

which is invalid.  In other words:

using T = int () const;
T fn1(); // bad, fn returning a fn
T& fn2(); // bad, cannot declare reference to qualified function type
T* fn3(); // bad, cannot declare pointer to qualified function type

using U = int ();
U fn4(); // bad, fn returning a fn
U& fn5(); // OK
U* fn6(); // OK

So the check we're looking for is probably

if (TREE_CODE (type) == FUNCTION_TYPE
    && (type_memfn_quals (type) != TYPE_UNQUALIFIED
        || type_memfn_rqual (type) != REF_QUAL_NONE))

but I think it should be put wherever we simulate declval().

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[mpolacek at gcc dot gnu.org]

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

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |patch

--- Comment #8 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
Patch: <https://gcc.gnu.org/pipermail/gcc-patches/2023-May/617311.html>

[Bug c++/109680] [13/14 Regression] is_convertible<int() const, int(*)()> incorrectly true

[cvs-commit at gcc dot gnu.org]

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

--- Comment #9 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The trunk branch has been updated by Marek Polacek <mpolacek@gcc.gnu.org>:

https://gcc.gnu.org/g:4c2ffb02fd4104d77c5d907662f04434dc4c3fe8

commit r14-669-g4c2ffb02fd4104d77c5d907662f04434dc4c3fe8
Author: Marek Polacek <polacek@redhat.com>
Date:   Tue May 2 17:36:00 2023 -0400

    c++: wrong std::is_convertible with cv-qual fn [PR109680]

    This PR points out that std::is_convertible has given the wrong answer
    in

      static_assert (!std::is_convertible_v <int () const, int (*) ()>, "");

    since r13-2822 implemented __is_{,nothrow_}convertible.

    std::is_convertible uses the imaginary

      To test() { return std::declval<From>(); }

    to do its job.  Here, From is 'int () const'.  std::declval is defined as:

      template<class T>
      typename std::add_rvalue_reference<T>::type declval() noexcept;

    std::add_rvalue_reference is defined as "If T is a function type that
    has no cv- or ref- qualifier or an object type, provides a member typedef
    type which is T&&, otherwise type is T."

    In our case, T is cv-qualified, so the result is T, so we end up with

      int () const declval() noexcept;

    which is invalid.  In other words, this is pretty much like:

      using T = int () const;
      T fn1(); // bad, fn returning a fn
      T& fn2(); // bad, cannot declare reference to qualified function type
      T* fn3(); // bad, cannot declare pointer to qualified function type

      using U = int ();
      U fn4(); // bad, fn returning a fn
      U& fn5(); // OK
      U* fn6(); // OK

    I think is_convertible_helper needs to simulate std::declval better.
    To that end, I'm introducing build_trait_object, to be used where
    a declval is needed.

            PR c++/109680

    gcc/cp/ChangeLog:

            * method.cc (build_trait_object): New.
            (assignable_expr): Use it.
            (ref_xes_from_temporary): Likewise.
            (is_convertible_helper): Likewise.  Check FUNC_OR_METHOD_TYPE_P.

    gcc/testsuite/ChangeLog:

            * g++.dg/ext/is_convertible6.C: New test.

[Bug c++/109680] [13 Regression] is_convertible<int() const, int(*)()> incorrectly true

[mpolacek at gcc dot gnu.org]

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

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|[13/14 Regression]          |[13 Regression]
                   |is_convertible<int() const, |is_convertible<int() const,
                   |int(*)()> incorrectly true  |int(*)()> incorrectly true

--- Comment #10 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
Fixed on trunk so far.

[Bug c++/109680] [13 Regression] is_convertible<int() const, int(*)()> incorrectly true

[dpsicilia at gmail dot com]

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

--- Comment #11 from David Sicilia <dpsicilia at gmail dot com> ---
Does anyone know which version of gcc this fix will be available in?  Will it
be merged into 13.1 or does it have to wait until 13.2?

[Bug c++/109680] [13 Regression] is_convertible<int() const, int(*)()> incorrectly true

[redi at gcc dot gnu.org]

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

--- Comment #12 from Jonathan Wakely <redi at gcc dot gnu.org> ---
13.1 has already been released, it can't be changed now.

As comment 10 says, the fix is only on trunk so far and has not been backported
to the gcc-13 branch. It will be in the next 13.x release after it's backported
to that branch.

[Bug c++/109680] [13 Regression] is_convertible<int() const, int(*)()> incorrectly true

[rguenth at gcc dot gnu.org]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|13.2                        |13.3

--- Comment #13 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 13.2 is being released, retargeting bugs to GCC 13.3.

[Bug c++/109680] [13 Regression] is_convertible<int() const, int(*)()> incorrectly true

[pinskia at gcc dot gnu.org]

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

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |nikolasklauser at berlin dot de

--- Comment #14 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
*** Bug 110904 has been marked as a duplicate of this bug. ***

[Bug c++/109680] [13 Regression] is_convertible<int() const, int(*)()> incorrectly true

[jakub at gcc dot gnu.org]

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

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|13.3                        |13.4

--- Comment #15 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
GCC 13.3 is being released, retargeting bugs to GCC 13.4.