+2002-12-26 Nathan Sidwell <nathan@codesourcery.com>
+
+ PR c++/8503
+ 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.
+
2002-12-18 Kriang Lerdsuwanakij <lerdsuwa@users.sourceforge.net>
* parse.y (bad_parm): Add missing argument to error function call.
{
/* 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)
{
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;
|| 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);
}
/*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);
}
}
+2002-12-26 Nathan Sidwell <nathan@codesourcery.com>
+
+ * g++.dg/template/qualttp20.C: Adjust expected errors.
+ * g++.old-deja/g++.jason/report.C: Likewise.
+ * g++.old-deja/g++.other/qual1.C: Likewise.
+
2002-12-21 Eric Botcazou <ebotcazou@libertysurf.fr>
* gcc.dg/unroll-1.c: New test.
template <typename T> 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 <typename T> 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<AS> b1; // { dg-error "instantiated" "" }
-B2<AS> b2;
+B2<AS> b2; // { dg-error "instantiated" "" }
};
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
{
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)