[Bug c++/102305] New: intrinsic __is_constrctible is wrong for templated abstract classes

[Bug c++/102305] New: intrinsic __is_constrctible is wrong for templated abstract classes

[andre.schackier at gmail dot com]

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

            Bug ID: 102305
           Summary: intrinsic __is_constrctible is wrong for templated
                    abstract classes
           Product: gcc
           Version: 12.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: andre.schackier at gmail dot com
  Target Milestone: ---

The compiler intrinsic function "__is_constructible" used to implement the
standard type traits falsy returns true for templated abstract classes. 

Minimal reproducable test case: (by Jonathan Wakely)

template <typename> struct AbstractTemplate {
  virtual ~AbstractTemplate() = 0;
};
static_assert(!__is_constructible(AbstractTemplate<int>), "");

Original godbolt link showcasing the problem with
std::is_default_constructible, which since version 9.2 uses __is_constructible 
https://godbolt.org/z/rq5GGd4rd

[Bug c++/102305] intrinsic __is_constrctible is wrong for templated abstract classes

[redi at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2021-09-13
             Status|UNCONFIRMED                 |NEW
     Ever confirmed|0                           |1

[Bug c++/102305] intrinsic __is_constrctible is wrong for templated abstract classes

[jakub at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |ASSIGNED
           Assignee|unassigned at gcc dot gnu.org      |jakub at gcc dot gnu.org

--- Comment #1 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Created attachment 51447
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=51447&action=edit
gcc12-pr102305.patch

Untested fix.
is_xible_helper checks ABSTRACT_CLASS_TYPE_P (to) and returns error_mark_node
if it is true, but when to is yet uninstantiated class template, it is false
and the template is instantiated only later on when trying to make the dummy
object.
With this patch we instantiate it before checking for abstract classes, but
will keep rejecting it or dealing with arrays of unknown bound till the spots
that were checking for that before.

[Bug c++/102305] intrinsic __is_constructible is wrong for templated abstract classes

[redi at gcc dot gnu.org]

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

--- Comment #2 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Thanks, Jakub!

Although this is a component=c++ bug, it also results in a libstdc++
regression, because we've been giving the wrong answer since starting to use
the intrinsic (e.g. std::is_default_constructible started to use it in GCC
9.2).

[Bug c++/102305] intrinsic __is_constructible is wrong for templated abstract classes

[cvs-commit at gcc dot gnu.org]

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

--- Comment #3 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Jakub Jelinek <jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:f008fd3a480e3718436156697ebe7eeb47841457

commit r12-3525-gf008fd3a480e3718436156697ebe7eeb47841457
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Tue Sep 14 16:55:04 2021 +0200

    c++: Fix __is_*constructible/assignable for templates [PR102305]

    is_xible_helper returns error_mark_node (i.e. false from the traits)
    for abstract classes by testing ABSTRACT_CLASS_TYPE_P (to) early.
    Unfortunately, as the testcase shows, that doesn't work on class templates
    that haven't been instantiated yet, ABSTRACT_CLASS_TYPE_P for them is false
    until it is instantiated, which is done when the routine later constructs
    a dummy object with that type.

    The following patch fixes this by calling complete_type first, so that
    ABSTRACT_CLASS_TYPE_P test will work properly, while keeping the handling
    of arrays with unknown bounds, or incomplete types where it is done
    currently.

    2021-09-14  Jakub Jelinek  <jakub@redhat.com>

            PR c++/102305
            * method.c (is_xible_helper): Call complete_type on to.

            * g++.dg/cpp0x/pr102305.C: New test.

[Bug c++/102305] intrinsic __is_constructible is wrong for templated abstract classes

[jakub at gcc dot gnu.org]

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

--- Comment #4 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Fixed for 12.0 so far.
Do we want to backport it?

[Bug c++/102305] intrinsic __is_constructible is wrong for templated abstract classes

[jakub at gcc dot gnu.org]

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

--- Comment #5 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
On one side, some code could be relying on bug compatibility and so it would be
undesirable to change it on release branches, on the other side the current
behavior there is just weird,
#include <type_traits>

template <typename> struct AbstractTemplate {
  virtual ~AbstractTemplate() = 0;
};

#ifdef D
struct S : AbstractTemplate<int> {};
#endif
bool a = std::is_default_constructible<AbstractTemplate<int> >::value;

a is true if D is not defined and false if D is defined.  And one can't really
construct those abstract template classes...

[Bug c++/102305] intrinsic __is_constructible is wrong for templated abstract classes

[redi at gcc dot gnu.org]

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

--- Comment #6 from Jonathan Wakely <redi at gcc dot gnu.org> ---
It should be backported IMHO.

I don't see how anybody can be relying on is_default_constructible being wrong,
that doesn't make much sense. You check that trait in SFINAE contexts to see if
you can construct the type, but because the answer is wrong any code that tries
to construct it will get a compiler error.

[Bug c++/102305] intrinsic __is_constructible is wrong for templated abstract classes

[cvs-commit at gcc dot gnu.org]

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

--- Comment #7 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-11 branch has been updated by Jakub Jelinek
<jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:6f61195e0433f907e5aa1a16f02d4106503d3351

commit r11-8997-g6f61195e0433f907e5aa1a16f02d4106503d3351
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Tue Sep 14 16:55:04 2021 +0200

    c++: Fix __is_*constructible/assignable for templates [PR102305]

    is_xible_helper returns error_mark_node (i.e. false from the traits)
    for abstract classes by testing ABSTRACT_CLASS_TYPE_P (to) early.
    Unfortunately, as the testcase shows, that doesn't work on class templates
    that haven't been instantiated yet, ABSTRACT_CLASS_TYPE_P for them is false
    until it is instantiated, which is done when the routine later constructs
    a dummy object with that type.

    The following patch fixes this by calling complete_type first, so that
    ABSTRACT_CLASS_TYPE_P test will work properly, while keeping the handling
    of arrays with unknown bounds, or incomplete types where it is done
    currently.

    2021-09-14  Jakub Jelinek  <jakub@redhat.com>

            PR c++/102305
            * method.c (is_xible_helper): Call complete_type on to.

            * g++.dg/cpp0x/pr102305.C: New test.

    (cherry picked from commit f008fd3a480e3718436156697ebe7eeb47841457)

[Bug c++/102305] intrinsic __is_constructible is wrong for templated abstract classes

[jakub at gcc dot gnu.org]

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

--- Comment #8 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Fixed for 11.3+ now too.

[Bug c++/102305] [9/10 regression] intrinsic __is_constructible is wrong for templated abstract classes

[cvs-commit at gcc dot gnu.org]

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

--- Comment #9 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-10 branch has been updated by Jakub Jelinek
<jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:269c6ed92a7dcfdacfa4a7ade2dc0616928b9b9b

commit r10-10642-g269c6ed92a7dcfdacfa4a7ade2dc0616928b9b9b
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Tue Sep 14 16:55:04 2021 +0200

    c++: Fix __is_*constructible/assignable for templates [PR102305]

    is_xible_helper returns error_mark_node (i.e. false from the traits)
    for abstract classes by testing ABSTRACT_CLASS_TYPE_P (to) early.
    Unfortunately, as the testcase shows, that doesn't work on class templates
    that haven't been instantiated yet, ABSTRACT_CLASS_TYPE_P for them is false
    until it is instantiated, which is done when the routine later constructs
    a dummy object with that type.

    The following patch fixes this by calling complete_type first, so that
    ABSTRACT_CLASS_TYPE_P test will work properly, while keeping the handling
    of arrays with unknown bounds, or incomplete types where it is done
    currently.

    2021-09-14  Jakub Jelinek  <jakub@redhat.com>

            PR c++/102305
            * method.c (is_xible_helper): Call complete_type on to.

            * g++.dg/cpp0x/pr102305.C: New test.

    (cherry picked from commit f008fd3a480e3718436156697ebe7eeb47841457)

[Bug c++/102305] [9/10 regression] intrinsic __is_constructible is wrong for templated abstract classes

[cvs-commit at gcc dot gnu.org]

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

--- Comment #10 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The releases/gcc-9 branch has been updated by Jakub Jelinek
<jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:edb57ecb1bcdcfef4ebc0ee78976d5718fcb00b2

commit r9-10099-gedb57ecb1bcdcfef4ebc0ee78976d5718fcb00b2
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Tue Sep 14 16:55:04 2021 +0200

    c++: Fix __is_*constructible/assignable for templates [PR102305]

    is_xible_helper returns error_mark_node (i.e. false from the traits)
    for abstract classes by testing ABSTRACT_CLASS_TYPE_P (to) early.
    Unfortunately, as the testcase shows, that doesn't work on class templates
    that haven't been instantiated yet, ABSTRACT_CLASS_TYPE_P for them is false
    until it is instantiated, which is done when the routine later constructs
    a dummy object with that type.

    The following patch fixes this by calling complete_type first, so that
    ABSTRACT_CLASS_TYPE_P test will work properly, while keeping the handling
    of arrays with unknown bounds, or incomplete types where it is done
    currently.

    2021-09-14  Jakub Jelinek  <jakub@redhat.com>

            PR c++/102305
            * method.c (is_xible_helper): Call complete_type on to.

            * g++.dg/cpp0x/pr102305.C: New test.

    (cherry picked from commit f008fd3a480e3718436156697ebe7eeb47841457)

[Bug c++/102305] [9/10 regression] intrinsic __is_constructible is wrong for templated abstract classes

[jakub at gcc dot gnu.org]

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

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

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

--- Comment #11 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Fixed.