re PR c++/38579 (Template: Wrong inherited copy-ctor visibility)

        PR c++/38579
        * search.c (protected_accessible_p): N doesn't vary.

From-SVN: r143439

gcc/cp/ChangeLog

+2009-01-16  Jason Merrill  <jason@redhat.com>
+
+	PR c++/38579
+	* search.c (protected_accessible_p): N doesn't vary.
+
 2009-01-15  Jason Merrill  <jason@redhat.com>
 
 	PR c++/38850

gcc/cp/search.c

@@ -721,20 +721,13 @@ protected_accessible_p (tree decl, tree derived, tree binfo)
 
        m as a member of N is protected, and the reference occurs in a
        member or friend of class N, or in a member or friend of a
-       class P derived from N, where m as a member of P is private or
-       protected.
-
-    Here DERIVED is a possible P and DECL is m.  accessible_p will
-    iterate over various values of N, but the access to m in DERIVED
-    does not change.
+       class P derived from N, where m as a member of P is public, private
+       or protected.
 
-    Note that I believe that the passage above is wrong, and should read
-    "...is private or protected or public"; otherwise you get bizarre results
-    whereby a public using-decl can prevent you from accessing a protected
-    member of a base.  (jason 2000/02/28)  */
+    Here DERIVED is a possible P, DECL is m and BINFO_TYPE (binfo) is N.  */
 
-  /* If DERIVED isn't derived from m's class, then it can't be a P.  */
-  if (!DERIVED_FROM_P (context_for_name_lookup (decl), derived))
+  /* If DERIVED isn't derived from N, then it can't be a P.  */
+  if (!DERIVED_FROM_P (BINFO_TYPE (binfo), derived))
     return 0;
 
   access = access_in_type (derived, decl);

gcc/testsuite/ChangeLog

+2009-01-16  Jason Merrill  <jason@redhat.com>
+
+	PR c++/38579
+	* g++.dg/conversion/access1.C: New test.
+
 2009-01-16  Jakub Jelinek  <jakub@redhat.com>
 
 	PR tree-optimization/38789

gcc/testsuite/g++.dg/conversion/access1.C

+// PR c++/38579
+
+struct P 
+{
+protected:
+  P() {}
+  P(const P&) {}
+};
+
+struct B : protected P
+{
+  B() {}
+};
+
+struct C : public P
+{
+  // C can access P's copy ctor, but can't convert b to const P&.
+  C(const B& b) : P(b) {}	// { dg-error "inaccessible base" }
+};
+
+void foo()
+{
+  B b;
+  C c(b);
+}