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

+2002-09-16  Nathan Sidwell  <nathan@codesourcery.com>
+
+	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  <geoffk@apple.com>
 
 	* cp-tree.h (union lang_tree_node): Add chain_next option.

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)

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)

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);
  	}
     }
   

gcc/testsuite/g++.dg/template/qualttp20.C

@@ -16,18 +16,20 @@ struct AS
 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" "" }	

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

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)