From 171d2f505b1b9e8d3fe2dd29d364e3933d3412ed Mon Sep 17 00:00:00 2001 From: Nathan Sidwell Date: Mon, 16 Sep 2002 19:09:05 +0000 Subject: [PATCH] Remove DR 295 implementation. cp: Remove DR 295 implementation. * pt.c (check_cv_quals_for_unify): Disable function & method cases. * tree.c (cp_build_qualified_type_real): Likewise. Don't warn about ignoring volatile qualifiers. * search.c (lookup_member): Correct documentation. testsuite: * g++.dg/template/qualttp20.C: Adjust expected errors. * g++.old-deja/g++.jason/report.C: Likewise. * g++.old-deja/g++.other/qual1.C: Likewise. From-SVN: r57209 --- gcc/cp/ChangeLog | 9 +++++++++ gcc/cp/pt.c | 4 +--- gcc/cp/search.c | 19 +++++++++--------- gcc/cp/tree.c | 15 +++++++++++--- gcc/testsuite/g++.dg/template/qualttp20.C | 20 ++++++++++--------- gcc/testsuite/g++.old-deja/g++.jason/report.C | 5 +++-- gcc/testsuite/g++.old-deja/g++.other/qual1.C | 5 +++-- 7 files changed, 49 insertions(+), 28 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 4a480412cf5..a405a9114eb 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,12 @@ +2002-09-16 Nathan Sidwell + + Remove DR 295 implementation. + * pt.c (check_cv_quals_for_unify): Disable function & method cases. + * tree.c (cp_build_qualified_type_real): Likewise. Don't warn + about ignoring volatile qualifiers. + + * search.c (lookup_member): Correct documentation. + 2002-09-16 Geoffrey Keating * cp-tree.h (union lang_tree_node): Add chain_next option. diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 12c420a18f5..86b3fc20d8e 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -8570,9 +8570,7 @@ check_cv_quals_for_unify (strict, arg, parm) { /* If the cvr quals of parm will not unify with ARG, they'll be ignored in instantiation, so we have to do the same here. */ - if (TREE_CODE (arg) == REFERENCE_TYPE - || TREE_CODE (arg) == FUNCTION_TYPE - || TREE_CODE (arg) == METHOD_TYPE) + if (TREE_CODE (arg) == REFERENCE_TYPE) parm_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); if (!POINTER_TYPE_P (arg) && TREE_CODE (arg) != TEMPLATE_TYPE_PARM) diff --git a/gcc/cp/search.c b/gcc/cp/search.c index 41bde712082..0c4935149d2 100644 --- a/gcc/cp/search.c +++ b/gcc/cp/search.c @@ -1400,15 +1400,16 @@ build_baselink (tree binfo, tree access_binfo, tree functions, tree optype) } /* Look for a member named NAME in an inheritance lattice dominated by - XBASETYPE. If PROTECT is 0 or two, we do not check access. If it is - 1, we enforce accessibility. If PROTECT is zero, then, for an - ambiguous lookup, we return NULL. If PROTECT is 1, we issue an - error message. If PROTECT is 2, we return a TREE_LIST whose - TREE_TYPE is error_mark_node and whose TREE_VALUEs are the list of - ambiguous candidates. - - WANT_TYPE is 1 when we should only return TYPE_DECLs, if no - TYPE_DECL can be found return NULL_TREE. */ + XBASETYPE. If PROTECT is 0 or two, we do not check access. If it + is 1, we enforce accessibility. If PROTECT is zero, then, for an + ambiguous lookup, we return NULL. If PROTECT is 1, we issue error + messages about inaccessible or ambiguous lookup. If PROTECT is 2, + we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose + TREE_VALUEs are the list of ambiguous candidates. + + WANT_TYPE is 1 when we should only return TYPE_DECLs. + + If nothing can be found return NULL_TREE and do not issue an error. */ tree lookup_member (xbasetype, name, protect, want_type) diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 44a013cfe77..ab7751b9253 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -577,6 +577,11 @@ cp_build_qualified_type_real (type, type_quals, complain) { tree result; int bad_quals = TYPE_UNQUALIFIED; + /* We keep bad function qualifiers separate, so that we can decide + whether to implement DR 295 or not. DR 295 break existing code, + unfortunately. Remove this variable to implement the defect + report. */ + int bad_func_quals = TYPE_UNQUALIFIED; if (type == error_mark_node) return type; @@ -592,6 +597,8 @@ cp_build_qualified_type_real (type, type_quals, complain) || TREE_CODE (type) == METHOD_TYPE)) { bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); + if (TREE_CODE (type) != REFERENCE_TYPE) + bad_func_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE); } @@ -610,21 +617,23 @@ cp_build_qualified_type_real (type, type_quals, complain) /*OK*/; else if (!(complain & (tf_error | tf_ignore_bad_quals))) return error_mark_node; + else if (bad_func_quals && !(complain & tf_error)) + return error_mark_node; else { if (complain & tf_ignore_bad_quals) /* We're not going to warn about constifying things that can't be constified. */ bad_quals &= ~TYPE_QUAL_CONST; + bad_quals |= bad_func_quals; if (bad_quals) { tree bad_type = build_qualified_type (ptr_type_node, bad_quals); - if (!(complain & tf_ignore_bad_quals)) + if (!(complain & tf_ignore_bad_quals) + || bad_func_quals) error ("`%V' qualifiers cannot be applied to `%T'", bad_type, type); - else if (complain & tf_warning) - warning ("ignoring `%V' qualifiers on `%T'", bad_type, type); } } diff --git a/gcc/testsuite/g++.dg/template/qualttp20.C b/gcc/testsuite/g++.dg/template/qualttp20.C index 2c6c71445c9..6c68a3a2a8a 100644 --- a/gcc/testsuite/g++.dg/template/qualttp20.C +++ b/gcc/testsuite/g++.dg/template/qualttp20.C @@ -16,18 +16,20 @@ struct AS template struct B1 : T { typedef typename T::L __restrict__ r;// { dg-error "`__restrict' qualifiers cannot" "" } - typedef typename T::myT __restrict__ p;// { dg-warning "ignoring `__restrict'" "" } - - typedef typename T::myT volatile *myvolatile; // { dg-warning "ignoring `volatile'" "" } - typename T::myT volatile *a; // { dg-warning "ignoring `volatile'" "" } - myvolatile b; // { dg-bogus "ignoring `volatile'" "" { xfail *-*-* } } + typedef typename T::myT __restrict__ p;// { dg-warning "ignoring `__restrict'" "" { xfail *-*-* } } + + // The following are DR 295 dependent + typedef typename T::myT volatile *myvolatile; // { dg-error "qualifiers" "" } + typename T::myT volatile *a; // { dg-error "qualifiers" "" } + myvolatile b; // { dg-error "qualifiers" "" } }; template struct B2 : T { - typedef typename T::myT const *myconst; - typename T::myT const *a; - myconst b; + // The following are DR 295 dependent + typedef typename T::myT const *myconst; // { dg-error "qualifiers" "" } + typename T::myT const *a; // { dg-error "qualifiers" "" } + myconst b; // { dg-error "qualifiers" "" } }; B1 b1; // { dg-error "instantiated" "" } -B2 b2; +B2 b2; // { dg-error "instantiated" "" } diff --git a/gcc/testsuite/g++.old-deja/g++.jason/report.C b/gcc/testsuite/g++.old-deja/g++.jason/report.C index bbc1adaf942..73adee87c9c 100644 --- a/gcc/testsuite/g++.old-deja/g++.jason/report.C +++ b/gcc/testsuite/g++.old-deja/g++.jason/report.C @@ -46,8 +46,9 @@ class X{ }; typedef int const * bart (); -typedef bart const * const * bar2; // ok - constifying qualifiers -typedef bart volatile * const * bar2v; // WARNING - qualifiers +//The following is DR295 dependant +typedef bart const * const * bar2; // ERROR - constifying qualifiers +typedef bart volatile * const * bar2v; // ERROR - qualifiers bar2 baz (X::Y y) { // ERROR - in this context diff --git a/gcc/testsuite/g++.old-deja/g++.other/qual1.C b/gcc/testsuite/g++.old-deja/g++.other/qual1.C index fa2d33f2ce8..13f9bbe497a 100644 --- a/gcc/testsuite/g++.old-deja/g++.other/qual1.C +++ b/gcc/testsuite/g++.old-deja/g++.other/qual1.C @@ -10,8 +10,9 @@ class { public: func_type *Function; - const func_type* function(void) { return Function; } // ok constifying - volatile func_type* functionv(void); // WARNING - qualifier + // The following is DR 295 dependent + const func_type* function(void) { return Function; } // ERROR - constifying + volatile func_type* functionv(void); // ERROR - qualifier } action; void work(const char *source) -- 2.30.2