[Bug c++/51312] New: Wrong interpretation of converted constant expressions (for template arguments and enumerator initializers)

[Bug c++/51312] New: Wrong interpretation of converted constant expressions (for template arguments and enumerator initializers)

[tsoae at mail dot ru]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51312

             Bug #: 51312
           Summary: Wrong interpretation of converted constant expressions
                    (for template arguments and enumerator initializers)
    Classification: Unclassified
           Product: gcc
           Version: 4.7.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: tsoae@mail.ru


GNU C++ 4.7.0 fails to compile the following well-defined code:

    struct X
    {
        constexpr operator int()
            { return true; }
    };

    template <int>
        struct A {};

    int main()
    {
        // error: expected a constant of type 'int', got 'X()'
        A<X()>();

        // error: enumerator value for 'e' is not an integer constant
        enum : int { e = X() };
    }

In both cases a converted constant expression of type int is required (see
14.3.2/1/1 and 7.2/5). According to 5.19/3, X() can be used in a context where
a converted constant expression of type int is required.

[Bug c++/51312] Wrong interpretation of converted constant expressions (for template arguments and enumerator initializers)

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51312

Marc Glisse <marc.glisse at normalesup dot org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |marc.glisse at normalesup
                   |                            |dot org

--- Comment #1 from Marc Glisse <marc.glisse at normalesup dot org> 2011-11-26 15:15:34 UTC ---
For the first one, you should write X{} instead of X() which looks too much
like a function type. The second one is more surprising.

[Bug c++/51312] Wrong interpretation of converted constant expressions (for template arguments and enumerator initializers)

[tsoae at mail dot ru]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51312

--- Comment #2 from Nikolka <tsoae at mail dot ru> 2011-11-26 15:33:36 UTC ---
> For the first one, you should write X{} instead of X() which looks too much
like a function type.

I agree, that was my mistake.

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[pinskia at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51312

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |rejects-valid
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2012-01-30
     Ever Confirmed|0                           |1

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> 2012-01-30 21:39:04 UTC ---
Interesting because:
        A<X{}>();

is accepted now on the trunk but:
        enum : int { e = X{} };
is rejected.
Also 
        A<X()>();
is still rejected.

So confirmed.

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[pinskia at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51312

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
         Depends on|                            |27403

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> 2012-02-08 20:19:45 UTC ---
I think this is related to PR 27403.

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51312

--- Comment #5 from Marc Glisse <marc.glisse at normalesup dot org> 2012-04-29 14:12:12 UTC ---
Created attachment 27261
  --> http://gcc.gnu.org/bugzilla/attachment.cgi?id=27261
build_enumerator patch

Changes the behavior on g++.dg/cpp0x/enum_base.C from an error to a warning in
the first 2 cases. And reusing the narrowing warning message may look a bit
strange.

enum E4 : char { 
  val = 500 // { dg-error "too large" }
};

enum_base.C:9:9: warning: narrowing conversion of '500' from 'int' to 'char'
inside { } [-Wnarrowing]
   val = 500 // { dg-error "too large" }
         ^
enum_base.C:9:9: warning: overflow in implicit constant conversion [-Woverflow]
   val = 500 // { dg-error "too large" }
         ^

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo.carlini at oracle dot com]

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

--- Comment #6 from Paolo Carlini <paolo.carlini at oracle dot com> ---
Marc, are you going to send your patch to the mailing list (CC Jason)? I note
that current clang too for enum_base.C issues the narrowing diagnostic: as-is
patch seems already pretty good to me.

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo.carlini at oracle dot com]

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

--- Comment #7 from Paolo Carlini <paolo.carlini at oracle dot com> ---
Uhm, it occurs to me that we may also play with moving up the code we already
have a few line below handling ENUM_UNDERLYING_TYPE (enumtype): if convert is
called first on the X() in e = X() we get a CALL_EXPR from a TARGET_EXPR, which
then cxx_constant_value is able to handle...

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo.carlini at oracle dot com]

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

--- Comment #8 from Paolo Carlini <paolo.carlini at oracle dot com> ---
... but then value isn't yet an INTEGER_CST and we can't use int_fits_type_p...
 Still, something seems redundant between an early conversion and the final
convert.

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[glisse at gcc dot gnu.org]

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

--- Comment #9 from Marc Glisse <glisse at gcc dot gnu.org> ---
(In reply to Paolo Carlini from comment #6)
> Marc, are you going to send your patch to the mailing list (CC Jason)?

Sorry, I don't remember this patch at all. I may try again to understand what
it does at some point, but you seem to have a much better understanding of what
is going on, so don't hesitate to take this bug.

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo.carlini at oracle dot com]

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

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |ASSIGNED
           Assignee|unassigned at gcc dot gnu.org      |paolo.carlini at oracle dot com

--- Comment #10 from Paolo Carlini <paolo.carlini at oracle dot com> ---
Ah Ok...

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo.carlini at oracle dot com]

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

--- Comment #11 from Paolo Carlini <paolo.carlini at oracle dot com> ---
I'm having a look at the issue and it seems rather different than I (we)
thought. Suffices to say that it does not affect constexpr non-operator member
functions, and that sort-of explains this (ugly) workaround:

  enum : int { e = X().operator int() };

Also, isn't just about C++11 enums, eg, this should be also accepted:

  enum { e = X() };

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo.carlini at oracle dot com]

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

--- Comment #12 from Paolo Carlini <paolo.carlini at oracle dot com> ---
build_expr_type_conversion is the answer

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo at gcc dot gnu.org]

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

--- Comment #13 from paolo at gcc dot gnu.org <paolo at gcc dot gnu.org> ---
Author: paolo
Date: Thu Aug  7 19:51:28 2014
New Revision: 213736

URL: https://gcc.gnu.org/viewcvs?rev=213736&root=gcc&view=rev
Log:
/cp
2014-08-07  Paolo Carlini  <paolo.carlini@oracle.com>

    PR c++/51312
    * decl.c (build_enumerator): Handle class types with conversion
    operators via perform_implicit_conversion_flags and
    build_expr_type_conversion.

    * cvt.c (build_expr_type_conversion): Replace pair of errors
    with error + inform.

/testsuite
2014-08-07  Paolo Carlini  <paolo.carlini@oracle.com>

    PR c++/51312
    * g++.dg/cpp0x/enum29.C: New.

Added:
    trunk/gcc/testsuite/g++.dg/cpp0x/enum29.C
Modified:
    trunk/gcc/cp/ChangeLog
    trunk/gcc/cp/cvt.c
    trunk/gcc/cp/decl.c
    trunk/gcc/testsuite/ChangeLog

[Bug c++/51312] [C++0x] Wrong interpretation of converted constant expressions (for enumerator initializers)

[paolo.carlini at oracle dot com]

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

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|---                         |FIXED
   Target Milestone|---                         |4.10.0

--- Comment #14 from Paolo Carlini <paolo.carlini at oracle dot com> ---
Fixed.