From e351c8549e22504e9bf3496a1bea197767efe4d0 Mon Sep 17 00:00:00 2001
From: mmitchel <mmitchel@138bc75d-0d04-0410-961f-82ee72b054a4>
Date: Wed, 9 Jul 2003 23:06:39 +0000
Subject: [PATCH] 	* parser.c (cp_parser_primary_expression): Preserve
 the form of 	qualified expressions in templates, even if they are not 
 dependent. 	* pt.c (convert_nontype_argument): Handle non-dependent
 SCOPE_REFs. 	(tsubst_qualified_id): Likewise. 	* search.c
 (accessible_p): Treat everything in the body of a

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@69160 138bc75d-0d04-0410-961f-82ee72b054a4
---
 gcc/cp/ChangeLog | 10 ++++++++++
 gcc/cp/parser.c  | 11 +++++++++++
 gcc/cp/pt.c      | 19 ++++++++++---------
 gcc/cp/search.c  |  7 +++++++
 4 files changed, 38 insertions(+), 9 deletions(-)

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 8d83247f636..4544e1b4f11 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,13 @@
+2003-07-09  Mark Mitchell  <mark@codesourcery.com>
+
+	* parser.c (cp_parser_primary_expression): Preserve the form of
+	qualified expressions in templates, even if they are not
+	dependent.
+	* pt.c (convert_nontype_argument): Handle non-dependent SCOPE_REFs.
+	(tsubst_qualified_id): Likewise.
+	* search.c (accessible_p): Treat everything in the body of a
+	template as accessible.
+
 2003-07-08  Mark Mitchell  <mark@codesourcery.com>
 
 	* cp-tree.def (NON_DEPENDENT_EXPR): New node.
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 19f55f40a8e..60ec0694755 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -2648,6 +2648,12 @@ cp_parser_primary_expression (cp_parser *parser,
 		      return build_nt (SCOPE_REF, 
 				       parser->scope, 
 				       id_expression);
+		    else if (TYPE_P (parser->scope)
+			     && DECL_P (decl))
+		      return build (SCOPE_REF,
+				    TREE_TYPE (decl),
+				    parser->scope,
+				    id_expression);
 		    else
 		      return decl;
 		  }
@@ -2705,6 +2711,11 @@ cp_parser_primary_expression (cp_parser *parser,
 		  *qualifying_class = parser->scope;
 		else if (!processing_template_decl)
 		  decl = convert_from_reference (decl);
+		else if (TYPE_P (parser->scope))
+		  decl = build (SCOPE_REF,
+				TREE_TYPE (decl),
+				parser->scope,
+				decl);
 	      }
 	    else
 	      /* Transform references to non-static data members into
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 4d650c5e23d..b4c9cedfad8 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -3054,7 +3054,6 @@ convert_nontype_argument (tree type, tree expr)
 	goto bad_argument;
     }
   else if (TYPE_PTR_P (expr_type)
-	   || TYPE_PTRMEM_P (expr_type)
 	   || TREE_CODE (expr_type) == ARRAY_TYPE
 	   || TREE_CODE (type) == REFERENCE_TYPE
 	   /* If expr is the address of an overloaded function, we
@@ -3100,6 +3099,9 @@ convert_nontype_argument (tree type, tree expr)
 	  return NULL_TREE;
 	}
 
+      if (TREE_CODE (referent) == SCOPE_REF)
+	referent = TREE_OPERAND (referent, 1);
+
       if (is_overloaded_fn (referent))
 	/* We'll check that it has external linkage later.  */
 	;
@@ -7160,14 +7162,13 @@ tsubst_qualified_id (tree qualified_id, tree args,
     }
 
   expr = tsubst_copy (name, args, complain, in_decl);
-  if (!BASELINK_P (name))
-    {
-      expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0);
-      if (DECL_P (expr))
-	check_accessibility_of_qualified_id (expr, 
-					     /*object_type=*/NULL_TREE,
-					     scope);
-    }
+  if (!BASELINK_P (name)
+      && !DECL_P (expr))
+    expr = lookup_qualified_name (scope, expr, /*is_type_p=*/0);
+  if (DECL_P (expr))
+    check_accessibility_of_qualified_id (expr, 
+					 /*object_type=*/NULL_TREE,
+					 scope);
 
   /* Remember that there was a reference to this entity.  */
   if (DECL_P (expr))
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 64e5707e1f0..c2c158a691c 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -903,6 +903,13 @@ accessible_p (tree type, tree decl)
   if (!TYPE_P (context_for_name_lookup (decl)))
     return 1;
 
+  /* In a template declaration, we cannot be sure whether the
+     particular specialization that is instantiated will be a friend
+     or not.  Therefore, all access checks are deferred until
+     instantiation.  */
+  if (processing_template_decl)
+    return 1;
+
   if (!TYPE_P (type))
     {
       binfo = type;
-- 
2.11.4.GIT