3 files changed, 14 insertions, 41 deletions
diff --git a/clang/test/CXX/class.access/p4.cpp b/clang/test/CXX/class.access/p4.cpp
index a2d0da1a832..6d452d8199e 100644
--- a/clang/test/CXX/class.access/p4.cpp
+++ b/clang/test/CXX/class.access/p4.cpp
@@ -514,12 +514,16 @@ namespace test17 {
 }
 
 namespace test18 {
-  template <class T> class A {}; // expected-note {{member is declared here}}
-  class B : A<int> { // expected-note {{constrained by implicitly private inheritance here}}
+  template <class T> class A {};
+  class B : A<int> {
     A<int> member;
   };
+
+  // FIXME: this access to A should be forbidden (because C++ is dumb),
+  // but LookupResult can't express the necessary information to do
+  // the check, so we aggressively suppress access control.
   class C : B {
-    A<int> member; // expected-error {{'A' is a private member of 'test18::A<int>'}}
+    A<int> member;
   };
 }
 
diff --git a/clang/test/CXX/temp/temp.decls/temp.friend/p1.cpp b/clang/test/CXX/temp/temp.decls/temp.friend/p1.cpp
index ab1b9f7a73e..849728a448b 100644
--- a/clang/test/CXX/temp/temp.decls/temp.friend/p1.cpp
+++ b/clang/test/CXX/temp/temp.decls/temp.friend/p1.cpp
@@ -380,10 +380,10 @@ template <class T> struct A {
 namespace test18 {
 namespace ns1 { template <class T> struct foo {}; } // expected-note{{candidate ignored: not a function template}}
 namespace ns2 { void foo() {} } // expected-note{{candidate ignored: not a function template}}
-using ns1::foo; // expected-note {{found by name lookup}}
-using ns2::foo; // expected-note {{found by name lookup}}
+using ns1::foo;
+using ns2::foo;
 
 template <class T> class A {
-  friend void foo<T>() {} // expected-error {{ambiguous}} expected-error{{no candidate function template was found for dependent friend function template specialization}}
+  friend void foo<T>() {} // expected-error{{no candidate function template was found for dependent friend function template specialization}}
 };
 }
diff --git a/clang/test/SemaTemplate/temp.cpp b/clang/test/SemaTemplate/temp.cpp
index a8a2daeac31..e037f0f0713 100644
--- a/clang/test/SemaTemplate/temp.cpp
+++ b/clang/test/SemaTemplate/temp.cpp
@@ -8,43 +8,12 @@ namespace test0 {
 
 // PR7252
 namespace test1 {
-  namespace A { template<typename T> struct Base { typedef T t; }; } // expected-note 3{{member}}
+  namespace A { template<typename T> struct Base { typedef T t; }; } // expected-note {{member found}}
   namespace B { template<typename T> struct Base { typedef T t; }; } // expected-note {{member found}}
 
   template<typename T> struct Derived : A::Base<char>, B::Base<int> {
-    typename Derived::Base<float>::t x; // expected-error {{found in multiple base classes of different types}}
+    // FIXME: the syntax error here is unfortunate
+    typename Derived::Base<float>::t x; // expected-error {{found in multiple base classes of different types}} \
+                                        // expected-error {{expected member name or ';'}}
   };
-
-  class X : A::Base<int> {}; // expected-note 2{{private}}
-  class Y : A::Base<float> {};
-  struct Z : A::Base<double> {};
-  struct Use1 : X, Y {
-    Base<double> b1; // expected-error {{private}}
-    Use1::Base<double> b2; // expected-error {{private}}
-  };
-  struct Use2 : Z, Y {
-    Base<double> b1;
-    Use2::Base<double> b2;
-  };
-  struct Use3 : X, Z {
-    Base<double> b1;
-    Use3::Base<double> b2;
-  };
-}
-
-namespace test2 {
-  struct A { static int x; }; // expected-note 4{{member}}
-  struct B { template<typename T> static T x(); }; // expected-note 4{{member}}
-  struct C { template<typename T> struct x {}; }; // expected-note 3{{member}}
-  struct D { template<typename T> static T x(); }; // expected-note {{member}}
-
-  template<typename ...T> struct X : T... {};
-
-  void f() {
-    X<A, B>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<A, C>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<B, C>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<A, B, C>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<A, B, D>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-  }
 }