[Bug c++/39970] gcc accepts the . dot operator in template arguments

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[jason at gcc dot gnu.org]

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

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |diagnostic
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2012-01-06
                 CC|                            |jason at gcc dot gnu.org
     Ever Confirmed|0                           |1

--- Comment #2 from Jason Merrill <jason at gcc dot gnu.org> 2012-01-06 15:15:25 UTC ---
We started rejecting this testcase in 3.4 due to the access violation.  If we
change 'class' to 'struct' we still don't (as of pre-4.7) diagnose the invalid
constant-expression because the default argument is never used.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[paolo.carlini at oracle dot com]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |ASSIGNED
                 CC|gcc-bugs at gcc dot gnu.org |
         AssignedTo|unassigned at gcc dot       |paolo.carlini at oracle dot
                   |gnu.org                     |com
   Target Milestone|---                         |4.8.0

--- Comment #3 from Paolo Carlini <paolo.carlini at oracle dot com> 2012-04-24 17:32:27 UTC ---
On it.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[paolo.carlini at oracle dot com]

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

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

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

--- Comment #4 from Paolo Carlini <paolo.carlini at oracle dot com> 2012-04-25 12:08:54 UTC ---
Not actively working on this.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[jakub at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.8.0                       |4.8.1

--- Comment #5 from Jakub Jelinek <jakub at gcc dot gnu.org> 2013-03-22 14:43:58 UTC ---
GCC 4.8.0 is being released, adjusting target milestone.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[jakub at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.8.1                       |4.8.2

--- Comment #6 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
GCC 4.8.1 has been released.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[jakub at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.8.2                       |4.8.3

--- Comment #7 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
GCC 4.8.2 has been released.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[rguenth at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|4.8.3                       |---

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[arthur.j.odwyer at gmail dot com]

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

Arthur O'Dwyer <arthur.j.odwyer at gmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |arthur.j.odwyer at gmail dot com

--- Comment #9 from Arthur O'Dwyer <arthur.j.odwyer at gmail dot com> ---
As of C++11, the original code is legitimate-ish:

struct blah { int member; };
constexpr blah global = {42};

template <int param=global.member>
class template_blah { };

template_blah<> x;  // OK, param is 42

But:
(1) GCC still incorrectly accepts the template even when `global` is non-const.
So does MSVC. Clang correctly(?) rejects it.
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96213 might be related.


(2) I don't understand Brandon's original concern around mangling operator dot.
The value of the default argument here is just "42"; we don't have to mangle
the dot at all.

An example of name-mangling the dot operator would be like

    template<class T>
    decltype(T().x) foo() { return 0; }
    struct S { int x; };
    template int foo<S>();

which GCC correctly mangles as `_Z3fooI1SEDtdtcvT__E1xEv`.

So I think the only remaining issue here is the incorrect acceptance of a
non-const default argument for `int param`, and that part MIGHT duplicate bug
#96213 which I just filed.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[bbnickell at gmail dot com]

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

--- Comment #10 from Brandon Nickell <bbnickell at gmail dot com> ---
Well I did open this bug 11 years ago (time flies!) and C++0x was still in mid
flight before it turned into C++11, so quite a bit has changed since this was
originally reported (for instance there was no constexpr or decltype which is
used in the previous comment). At the time there was nothing in the name
mangling scheme that clarified how you would even handle mangling the
global.member template parameter as it was unusual that it would even be
accepted. FWIW, I suspect this test case is correctly rejected in Edison Design
Group's front end but cannot immediately confirm. Thanks.

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|2018-09-13 00:00:00         |2021-8-3

--- Comment #11 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
For the original code, GCC does not reject the code unless the default value is
used.

MSVC also accepts the code.
ICC and clang both reject it.

[Bug c++/39970] New: gcc accepts the . dot operator in template arguments

[bbnickell at gmail dot com]

The following reproducer violates ISO/IEC 14882:2003 [14.3.2p1]

class blah { int member; };
blah global; // global
template <int param=global.member>
class template_blah { /* blah */ };

Thanks,
-=brandon=-


-- 
           Summary: gcc accepts the . dot operator in template arguments
           Product: gcc
           Version: 4.0.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: bbnickell at gmail dot com


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

[Bug c++/39970] gcc accepts the . dot operator in template arguments

[bbnickell at gmail dot com]

------- Comment #1 from bbnickell at gmail dot com  2009-07-31 18:18 -------
Additionally, there does not appear to be a way to represent the dot argument
in the current IA64 name-mangling scheme:

http://www.codesourcery.com/public/cxx-abi/abi.html#mangling-type

I would like some clarifying remarks as to whether or not this is an
undocumented gcc extension, otherwise this should perhaps be considered as a
potentially serious flaw in the gcc compiler.

Thanks!
Brandon Nickell
email: bbnickell@gmail.com


-- 


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