[Bug c++/67033] New: [c++11] template argument invalid for integral constant expression beginning with address-of expression

[Bug c++/67033] New: [c++11] template argument invalid for integral constant expression beginning with address-of expression

[ed at catmur dot co.uk]

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

            Bug ID: 67033
           Summary: [c++11] template argument invalid for integral
                    constant expression beginning with address-of
                    expression
           Product: gcc
           Version: 6.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: ed at catmur dot co.uk
  Target Milestone: ---

template<bool B> struct S { };
int x;
S<&x == &x> s;
// error: template argument 1 is invalid
//        ^

&x == &x is a valid converted constant expression of type bool.

The problem is that cp_parser_template_argument sees the initial '&' and
decides that the non-type template argument must be the address-of operator
applied to an id-expression; when it fails to reach the end of the template
argument it aborts.

This behavior is valid for <= C++03, where '&' cannot appear in a constant
expression, but C++11 is more relaxed.

[Bug c++/67033] [c++11] template argument invalid for integral constant expression beginning with address-of expression

[ed at catmur dot co.uk]

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

--- Comment #1 from Ed Catmur <ed at catmur dot co.uk> ---
Created attachment 36075
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=36075&action=edit
pr67033.patch

This is kinda ugly.

The problem is that before C++1z, a non-type template argument that evaluates
to the address of or a reference to an object [...] must be expressed as "&
id-expression" [...]; this means that the parser isn't really the place for
this, as the validity of the expression depends on its value:

template<int* p> class X {};
int i;
X<&i> x1;      // OK
X<(&(i))> x2;  // OK since C++11
template<bool b> class Y : X<b ? &i : nullptr> {};  // OK since C++11 if !b
X<true ? &i : nullptr> x3; // OK since C++1z

The attached patch lets through quite a lot of constructs that are actually
invalid pre-C++1z. A rigorous check would be to annotate the constant
expression to say whether it matches the form allowed in [temp.arg.nontype] and
then on evaluation check whether it is a null pointer constant.

[Bug c++/67033] [c++11] template argument invalid for integral constant expression beginning with address-of expression

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
   Target Milestone|---                         |6.0
         Resolution|---                         |FIXED

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Marek Polacek from comment #2)
> Confirmed.
> 
> Testcase from PR56428:

This is a different issue overall related to PMF rather than to addresses, I
filed PR 101681 for that.

(In reply to Ed Catmur from comment #1)
> template<int* p> class X {};
> int i;
> X<&i> x1;      // OK
> X<(&(i))> x2;  // OK since C++11
> template<bool b> class Y : X<b ? &i : nullptr> {};  // OK since C++11 if !b
> X<true ? &i : nullptr> x3; // OK since C++1z

GCC 6+ does the correct thing for the testcase in comment #1 so closing.