This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
C++ PATCH: PR c++/11509
- From: Mark Mitchell <mark at codesourcery dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Mon, 14 Jul 2003 14:47:59 -0700
- Subject: C++ PATCH: PR c++/11509
- Reply-to: mark at codesourcery dot com
This patch fixes PR c++/11509, which is more fallout from the
non-dependent expressions patch.
Tested on i686-pc-linux-gnu, applied on the mainline.
--
Mark Mitchell
CodeSourcery, LLC
mark@codesourcery.com
2003-07-14 Mark Mitchell <mark@codesourcery.com>
PR c++/11509
* pt.c (dependent_scope_ref_p): New function.
(value_dependent_expression_p): Use it.
(type_dependent_expression_p): Likewise.
* pt.c (tsubst_friend_function): Use reregister_specialization.
2003-07-14 Mark Mitchell <mark@codesourcery.com>
PR c++/11509
* g++.dg/template/crash6.C: New test.
Index: cp/pt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/pt.c,v
retrieving revision 1.725
diff -c -5 -p -r1.725 pt.c
*** cp/pt.c 14 Jul 2003 19:05:02 -0000 1.725
--- cp/pt.c 14 Jul 2003 21:27:07 -0000
*************** tsubst_friend_function (tree decl, tree
*** 4910,4930 ****
any, with the new template information pertaining to
the declaration. */
DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
if (TREE_CODE (old_decl) != TEMPLATE_DECL)
! {
! tree t;
! tree spec;
!
! t = most_general_template (old_decl);
! for (spec = DECL_TEMPLATE_SPECIALIZATIONS (t);
! spec;
! spec = TREE_CHAIN (spec))
! if (TREE_VALUE (spec) == new_friend)
! TREE_VALUE (spec) = old_decl;
! }
else
{
tree t;
tree new_friend_args;
--- 4910,4922 ----
any, with the new template information pertaining to
the declaration. */
DECL_TEMPLATE_INFO (old_decl) = new_friend_template_info;
if (TREE_CODE (old_decl) != TEMPLATE_DECL)
! reregister_specialization (new_friend,
! most_general_template (old_decl),
! old_decl);
else
{
tree t;
tree new_friend_args;
*************** dependent_type_p (tree type)
*** 11453,11462 ****
--- 11445,11488 ----
}
return TYPE_DEPENDENT_P (type);
}
+ /* Returns TRUE if EXPRESSION is dependent, according to CRITERION. */
+
+ static bool
+ dependent_scope_ref_p (tree expression, bool criterion (tree))
+ {
+ tree scope;
+ tree name;
+
+ my_friendly_assert (TREE_CODE (expression) == SCOPE_REF, 20030714);
+
+ if (!TYPE_P (TREE_OPERAND (expression, 0)))
+ return true;
+
+ scope = TREE_OPERAND (expression, 0);
+ name = TREE_OPERAND (expression, 1);
+
+ /* [temp.dep.expr]
+
+ An id-expression is type-dependent if it contains a
+ nested-name-specifier that contains a class-name that names a
+ dependent type. */
+ /* The suggested resolution to Core Issue 2 implies that if the
+ qualifying type is the current class, then we must peek
+ inside it. */
+ if (DECL_P (name)
+ && currently_open_class (scope)
+ && !criterion (name))
+ return false;
+ if (dependent_type_p (scope))
+ return true;
+
+ return false;
+ }
+
/* Returns TRUE if the EXPRESSION is value-dependent, in the sense of
[temp.dep.constexpr] */
bool
value_dependent_expression_p (tree expression)
*************** value_dependent_expression_p (tree expre
*** 11516,11525 ****
--- 11542,11553 ----
expression = TREE_OPERAND (expression, 0);
if (TYPE_P (expression))
return dependent_type_p (expression);
return type_dependent_expression_p (expression);
}
+ if (TREE_CODE (expression) == SCOPE_REF)
+ return dependent_scope_ref_p (expression, value_dependent_expression_p);
/* A constant expression is value-dependent if any subexpression is
value-dependent. */
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (expression))))
{
switch (TREE_CODE_CLASS (TREE_CODE (expression)))
*************** type_dependent_expression_p (tree expres
*** 11602,11635 ****
(TREE_OPERAND (TREE_VALUE (type), 1));
else
return dependent_type_p (type);
}
- /* [temp.dep.expr]
-
- An id-expression is type-dependent if it contains a
- nested-name-specifier that contains a class-name that names a
- dependent type. */
if (TREE_CODE (expression) == SCOPE_REF
! && TYPE_P (TREE_OPERAND (expression, 0)))
! {
! tree scope;
! tree name;
!
! scope = TREE_OPERAND (expression, 0);
! name = TREE_OPERAND (expression, 1);
!
! /* The suggested resolution to Core Issue 2 implies that if the
! qualifying type is the current class, then we must peek
! inside it. */
! if (DECL_P (name)
! && currently_open_class (scope)
! && !type_dependent_expression_p (name))
! return false;
! if (dependent_type_p (scope))
! return true;
! }
if (TREE_CODE (expression) == FUNCTION_DECL
&& DECL_LANG_SPECIFIC (expression)
&& DECL_TEMPLATE_INFO (expression)
&& (dependent_template_id_p
--- 11630,11643 ----
(TREE_OPERAND (TREE_VALUE (type), 1));
else
return dependent_type_p (type);
}
if (TREE_CODE (expression) == SCOPE_REF
! && dependent_scope_ref_p (expression,
! type_dependent_expression_p))
! return true;
if (TREE_CODE (expression) == FUNCTION_DECL
&& DECL_LANG_SPECIFIC (expression)
&& DECL_TEMPLATE_INFO (expression)
&& (dependent_template_id_p
Index: testsuite/g++.dg/template/crash6.C
===================================================================
RCS file: testsuite/g++.dg/template/crash6.C
diff -N testsuite/g++.dg/template/crash6.C
*** /dev/null 1 Jan 1970 00:00:00 -0000
--- testsuite/g++.dg/template/crash6.C 14 Jul 2003 21:27:08 -0000
***************
*** 0 ****
--- 1,8 ----
+ template <class> struct A { static const int n = 1; } ;
+ template <int> struct B;
+
+ template <class S>
+ struct restype_order {
+ static const int s = A<S>::n;
+ typedef typename B<(s > 0)>::t t;
+ };