Re: c++/9549: [3.4 regression] [New parser] ICE in regenerate_decl_from_template

[Martin Sebor <sebor@roguewave.com>]

The following reply was made to PR c++/9549; it has been noted by GNATS.

From: Martin Sebor <sebor@roguewave.com>
To: Wolfgang Bangerth <bangerth@ticam.utexas.edu>
Cc: bangerth@dealii.org, gcc-gnats@gcc.gnu.org
Subject: Re: c++/9549: [3.4 regression] [New parser] ICE in regenerate_decl_from_template
Date: Mon, 03 Feb 2003 12:37:26 -0700

 Wolfgang Bangerth wrote:
 >>>    This is not a bug. You need to write
 >>>      m.template do_it<T>();
 >>
 >>This is incorrect, as is your previous analysis in PR #9510:
 >>http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=9510
 >>
 >>This syntax is required only if the right hand side of the
                                        ^^^^^^^^^^^^^^^
 
 I meant left hand side here, not right hand side. Sorry.
 
 >>dot operator depends on a template parameter, otherwise it
 >>is optional. Please read 14.2, p4 for more.
 > 
 > 
 > Ehm, but in m.do_it<T>, the rhs of the dot operator _is_ template 
 > dependent, no? 14.2.4 has almost the same example and says that you need 
 > the template keyword -- what am I missing here?
 
 If the left hand side does not depend on a template parameter,
 there is no reason to use the template prefix since the name
 to the right of the dot is known to either be a template or
 not at the point of parsing the "surrounding" template and
 there is no possibility of an ambiguity with the less than
 operator. Otherwise it may or may not be a template, and the
 first "<" may or may not be a less than operator, depending
 on any specializations of the template to the left of the
 dot operator.
 
 For instance, in the example below, the declaration
 
          enum { e = A<I - 1>::B<J - 1>::e + 1 };
 
 is parsed as
 
          enum { e = (A<I - 1>::B) < (J - 1) > (::e + 1) };
                       ^^^^^^^     ^         ^
                       |           |         +- operator>()
                       |           +- operator<()
                       +-template argument list
 
 without the template keword because at the point of
 definition of the primary template A it's not known
 whether B is or is not a template. With the template
 keyword, A<I - 1>::template B<J - 1> would be parsed
 as the type name of the template B. The same logic
 applies to the dot operator as well as to operator->
 
 enum { e };
 
 template <int I>
 struct A {
      template <int J>
      struct B {
          enum { e = A<I - 1>::B<J - 1>::e + 1 };
      };
 };
 
 template<>
 struct A<0> {
      enum { B };
 };
 
 int main ()
 {
      return A<1>::B<1>::e;
 }
 
 Martin