Update clang to r99115.

5 files changed, 156 insertions, 16 deletions

diff --git a/test/CXX/class.access/class.access.nest/p1.cpp b/test/CXX/class.access/class.access.nest/p1.cpp
new file mode 100644
index 0000000..d2644c6
--- /dev/null
+++ b/test/CXX/class.access/class.access.nest/p1.cpp
@@ -0,0 +1,33 @@
+// RUN: %clang_cc1 -fsyntax-only -faccess-control -verify %s
+
+// Derived from GNU's std::string
+namespace test0 {
+  class A {
+    struct B {
+      unsigned long length;
+    };
+    struct C : B {
+      static const unsigned long max_length;
+    };
+  };
+  
+  const unsigned long A::C::max_length = sizeof(B);
+}
+
+// Example from the standard.
+namespace test1 {
+  class E {
+    int x;
+    class B {};
+
+    class I {
+      B b;
+      int y; // expected-note {{declared private here}}
+      void f(E* p, int i) {
+        p->x = i;
+      }
+    };
+
+    int g(I* p) { return p->y; } // expected-error {{'y' is a private member of 'test1::E::I'}}
+  };
+}
diff --git a/test/CXX/class.access/class.friend/p1.cpp b/test/CXX/class.access/class.friend/p1.cpp
index 83b4227..851cd3d 100644
--- a/test/CXX/class.access/class.friend/p1.cpp
+++ b/test/CXX/class.access/class.friend/p1.cpp
@@ -115,3 +115,37 @@ namespace test0 {
     }
   };
 }
+
+// Make sure that friends have access to inherited protected members.
+namespace test2 {
+  struct X;
+
+  class ilist_half_node {
+    friend struct ilist_walker_bad;
+    X *Prev;
+  protected:
+    X *getPrev() { return Prev; }
+  };
+
+  class ilist_node : private ilist_half_node { // expected-note {{declared private here}} expected-note {{constrained by private inheritance here}}
+    friend struct ilist_walker;
+    X *Next;
+    X *getNext() { return Next; } // expected-note {{declared private here}}
+  };
+
+  struct X : ilist_node {};
+
+  struct ilist_walker {
+    static X *getPrev(X *N) { return N->getPrev(); }
+    static X *getNext(X *N) { return N->getNext(); }
+  };  
+
+  struct ilist_walker_bad {
+    static X *getPrev(X *N) { return N->getPrev(); } // \
+    // expected-error {{'getPrev' is a private member of 'test2::ilist_half_node'}} \
+    // expected-error {{cannot cast 'test2::X' to its private base class 'test2::ilist_half_node'}}
+
+    static X *getNext(X *N) { return N->getNext(); } // \
+    // expected-error {{'getNext' is a private member of 'test2::ilist_node'}}
+  };  
+}
diff --git a/test/CXX/class.access/p4.cpp b/test/CXX/class.access/p4.cpp
index 15b336a..bc69bee 100644
--- a/test/CXX/class.access/p4.cpp
+++ b/test/CXX/class.access/p4.cpp
@@ -112,9 +112,10 @@ namespace test3 {
     A local; // expected-error {{variable of type 'test3::A' has private destructor}}
   }
 
-  template <unsigned N> class Base { ~Base(); }; // expected-note 8 {{declared private here}}
-  class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 2 {{declared private here}}
-  class Base3 : virtual Base<3> { public: ~Base3(); };
+  template <unsigned N> class Base { ~Base(); }; // expected-note 14 {{declared private here}}
+  class Base2 : virtual Base<2> { ~Base2(); }; // expected-note 3 {{declared private here}} \
+                                               // expected-error {{base class 'Base<2>' has private destructor}}
+  class Base3 : virtual Base<3> { public: ~Base3(); }; // expected-error {{base class 'Base<3>' has private destructor}}
 
   // These don't cause diagnostics because we don't need the destructor.
   class Derived0 : Base<0> { ~Derived0(); };
@@ -130,11 +131,11 @@ namespace test3 {
     ~Derived2() {}
   };
 
-  class Derived3 : // expected-error {{inherited virtual base class 'Base<2>' has private destructor}} \
-                   // expected-error {{inherited virtual base class 'Base<3>' has private destructor}}
-    Base<0>,  // expected-error {{base class 'Base<0>' has private destructor}}
-    virtual Base<1>, // expected-error {{base class 'Base<1>' has private destructor}}
-    Base2, // expected-error {{base class 'test3::Base2' has private destructor}}
+  class Derived3 : // expected-error 2 {{inherited virtual base class 'Base<2>' has private destructor}} \
+                   // expected-error 2 {{inherited virtual base class 'Base<3>' has private destructor}}
+    Base<0>,  // expected-error 2 {{base class 'Base<0>' has private destructor}}
+    virtual Base<1>, // expected-error 2 {{base class 'Base<1>' has private destructor}}
+    Base2, // expected-error 2 {{base class 'test3::Base2' has private destructor}}
     virtual Base3
   {};
   Derived3 d3;
@@ -220,3 +221,44 @@ namespace test6 {
     Test2 a = t;
   }
 }
+
+// Redeclaration lookups are not accesses.
+namespace test7 {
+  class A {
+    int private_member;
+  };
+  class B : A {
+    int foo(int private_member) {
+      return 0;
+    }
+  };
+}
+
+// Ignored operator new and delete overloads are not 
+namespace test8 {
+  typedef __typeof__(sizeof(int)) size_t;
+
+  class A {
+    void *operator new(size_t s);
+    void operator delete(void *p);
+  public:
+    void *operator new(size_t s, int n);
+    void operator delete(void *p, int n);
+  };
+
+  void test() {
+    new (2) A();
+  }
+}
+
+// Don't silently upgrade forbidden-access paths to private.
+namespace test9 {
+  class A {
+    public: static int x;
+  };
+  class B : private A { // expected-note {{constrained by private inheritance here}}
+  };
+  class C : public B {
+    static int getX() { return x; } // expected-error {{'x' is a private member of 'test9::A'}}
+  };
+}
diff --git a/test/CXX/class/class.union/p1.cpp b/test/CXX/class/class.union/p1.cpp
index f53783e..e974d82 100644
--- a/test/CXX/class/class.union/p1.cpp
+++ b/test/CXX/class/class.union/p1.cpp
@@ -46,25 +46,25 @@ union U1 {
 
 union U2 {
   struct {
-    Virtual v; // expected-note {{because type 'U2::<anonymous>' has a member with a non-trivial copy constructor}}
+    Virtual v; // expected-note {{because type 'U2::<anonymous struct}}
   } m1; // expected-error {{union member 'm1' has a non-trivial copy constructor}}
   struct {
-    VirtualBase vbase; // expected-note {{because type 'U2::<anonymous>' has a member with a non-trivial copy constructor}}
+    VirtualBase vbase; // expected-note {{because type 'U2::<anonymous struct}}
   } m2; // expected-error {{union member 'm2' has a non-trivial copy constructor}}
   struct {
-    Ctor ctor; // expected-note {{because type 'U2::<anonymous>' has a member with a non-trivial constructor}}
+    Ctor ctor; // expected-note {{because type 'U2::<anonymous struct}}
   } m3; // expected-error {{union member 'm3' has a non-trivial constructor}}
   struct {
-    Ctor2 ctor2; // expected-note {{because type 'U2::<anonymous>' has a member with a non-trivial constructor}}
+    Ctor2 ctor2; // expected-note {{because type 'U2::<anonymous struct}}
   } m3a; // expected-error {{union member 'm3a' has a non-trivial constructor}}
   struct {
-    CopyCtor copyctor; // expected-note {{because type 'U2::<anonymous>' has a member with a non-trivial copy constructor}}
+    CopyCtor copyctor; // expected-note {{because type 'U2::<anonymous struct}}
   } m4; // expected-error {{union member 'm4' has a non-trivial copy constructor}}
   struct {
-    CopyAssign copyassign; // expected-note {{because type 'U2::<anonymous>' has a member with a non-trivial copy assignment operator}}
+    CopyAssign copyassign; // expected-note {{because type 'U2::<anonymous struct}}
   } m5; // expected-error {{union member 'm5' has a non-trivial copy assignment operator}}
   struct {
-    Dtor dtor; // expected-note {{because type 'U2::<anonymous>' has a member with a non-trivial destructor}}
+    Dtor dtor; // expected-note {{because type 'U2::<anonymous struct}}
   } m6; // expected-error {{union member 'm6' has a non-trivial destructor}}
   struct {
     Okay okay;
diff --git a/test/CXX/temp/temp.decls/temp.friend/p1.cpp b/test/CXX/temp/temp.decls/temp.friend/p1.cpp
index 7a28e70..f1b3c81 100644
--- a/test/CXX/temp/temp.decls/temp.friend/p1.cpp
+++ b/test/CXX/temp/temp.decls/temp.friend/p1.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -emit-llvm-only %s
+// RUN: %clang_cc1 -faccess-control -verify -emit-llvm-only %s
 
 template <typename T> struct Num {
   T value_;
@@ -54,3 +54,34 @@ int calc2() {
   Num<int> result = x * n;
   return result.get();
 }
+
+// Reduced from GNU <locale>
+namespace test1 {
+  class A {
+    bool b; // expected-note {{declared private here}}
+    template <typename T> friend bool has(const A&);
+  };
+  template <typename T> bool has(const A &x) {
+    return x.b;
+  }
+  template <typename T> bool hasnot(const A &x) {
+    return x.b; // expected-error {{'b' is a private member of 'test1::A'}}
+  }
+}
+
+namespace test2 {
+  class A {
+    bool b; // expected-note {{declared private here}}
+    template <typename T> friend class HasChecker;
+  };
+  template <typename T> class HasChecker {
+    bool check(A *a) {
+      return a->b;
+    }
+  };
+  template <typename T> class HasNotChecker {
+    bool check(A *a) {
+      return a->b; // expected-error {{'b' is a private member of 'test2::A'}}
+    }
+  };
+}