10 files changed, 391 insertions, 0 deletions
diff --git a/clang/test/CXX/class.derived/class.abstract/p4.cpp b/clang/test/CXX/class.derived/class.abstract/p4.cpp
new file mode 100644
index 0000000..b04de21
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.abstract/p4.cpp
@@ -0,0 +1,80 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace PR6631 {
+  struct A { 
+    virtual void f() = 0;
+  };
+
+  struct B : virtual A { };
+
+  struct C : virtual A { 
+    virtual void f();
+  };
+
+  struct D : public B, public C { 
+    virtual void f();
+  };
+
+  void f() {
+    (void)new D; // okay
+  }
+}
+
+// Check cases where we have a virtual function that is pure in one
+// subobject but not pure in another subobject.
+namespace PartlyPure {
+  struct A { 
+    virtual void f() = 0; // expected-note{{unimplemented pure virtual method}}
+  };
+
+  struct B : A {
+    virtual void f();
+  };
+
+  struct C : virtual A { };
+
+  struct D : B, C { };
+
+  void f() {
+    (void) new D; // expected-error{{abstract class}}
+  }
+}
+
+namespace NonPureAlongOnePath {
+  struct A { 
+    virtual void f() = 0;
+  };
+
+  struct B : virtual A {
+    virtual void f();
+  };
+
+  struct C : virtual A { };
+
+  struct D : B, C { };
+
+  void f() {
+    (void) new D; // okay
+  }  
+}
+
+namespace NonPureAlongOnePath2 {
+  struct Aprime { 
+    virtual void f() = 0;
+  };
+
+  struct A : Aprime {
+  };
+
+  struct B : virtual A {
+    virtual void f();
+  };
+
+  struct C : virtual A { };
+
+  struct D : B, C { };
+
+  void f() {
+    (void) new D; // okay
+  }  
+}
diff --git a/clang/test/CXX/class.derived/class.abstract/p5.cpp b/clang/test/CXX/class.derived/class.abstract/p5.cpp
new file mode 100644
index 0000000..cdff931
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.abstract/p5.cpp
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct A {
+  virtual void f() = 0; // expected-note{{unimplemented pure virtual method}}
+};
+
+struct B : A {
+  virtual void f();
+};
+
+struct C : B {
+  virtual void f() = 0; // expected-note 2{{unimplemented pure virtual method}}
+};
+
+struct D : C {
+};
+
+void test() {
+  (void)new A; // expected-error{{abstract class}}
+  (void)new B;
+  (void)new C; // expected-error{{abstract class}}
+  (void)new D; // expected-error{{abstract class}}
+}
diff --git a/clang/test/CXX/class.derived/class.member.lookup/p6.cpp b/clang/test/CXX/class.derived/class.member.lookup/p6.cpp
new file mode 100644
index 0000000..7239881
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.member.lookup/p6.cpp
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+class V { 
+public: 
+  int f(); 
+  int x; 
+};
+
+class W { 
+public: 
+  int g(); // expected-note{{member found by ambiguous name lookup}}
+  int y; // expected-note{{member found by ambiguous name lookup}}
+};
+
+class B : public virtual V, public W
+{
+public:
+  int f(); 
+  int x;
+  int g();  // expected-note{{member found by ambiguous name lookup}}
+  int y; // expected-note{{member found by ambiguous name lookup}}
+};
+
+class C : public virtual V, public W { };
+
+class D : public B, public C { void glorp(); };
+
+void D::glorp() {
+  x++;
+  f();
+  y++; // expected-error{{member 'y' found in multiple base classes of different types}}
+  g(); // expected-error{{member 'g' found in multiple base classes of different types}}
+}
+
+// PR6462
+struct BaseIO { BaseIO* rdbuf() { return 0; } };
+struct Pcommon : virtual BaseIO { int rdbuf() { return 0; } };
+struct P : virtual BaseIO, Pcommon {};
+
+void f() { P p; p.rdbuf(); }
diff --git a/clang/test/CXX/class.derived/class.member.lookup/p8.cpp b/clang/test/CXX/class.derived/class.member.lookup/p8.cpp
new file mode 100644
index 0000000..4d4acc3
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.member.lookup/p8.cpp
@@ -0,0 +1,63 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// FIXME: Access control checks
+
+namespace PR5820 {
+  // also <rdar://problem/7535045>
+  struct Base {
+    void Foo();
+    int Member;
+  };
+
+  struct D1 : public Base {};
+  struct D2 : public Base {};
+
+  struct Derived : public D1, public D2 {
+    void Inner();
+  };
+
+  void Test() {
+    Derived d;
+    d.D1::Foo();
+    d.D1::Member = 17;
+  }
+
+  void Derived::Inner() {
+    D1::Foo();
+    D1::Member = 42;
+    this->D1::Foo();
+    this->D1::Member = 42;
+  }
+}
+
+template<typename T>
+struct BaseT {
+  void Foo(); // expected-note{{found by ambiguous name lookup}}
+  int Member;
+};
+
+template<typename T> struct Derived1T : BaseT<T> { };
+template<typename T> struct Derived2T : BaseT<T> { };
+
+template<typename T>
+struct DerivedT : public Derived1T<T>, public Derived2T<T> {
+  void Inner();
+};
+
+template<typename T>
+void DerivedT<T>::Inner() {
+  Derived1T<T>::Foo();
+  Derived2T<T>::Member = 42;
+  this->Derived1T<T>::Foo();
+  this->Derived2T<T>::Member = 42;
+  this->Foo(); // expected-error{{non-static member 'Foo' found in multiple base-class subobjects of type 'BaseT<int>'}}
+}
+
+template<typename T>
+void Test(DerivedT<T> d) {
+  d.template Derived1T<T>::Foo();
+  d.template Derived2T<T>::Member = 17;
+  d.Inner(); // expected-note{{in instantiation}}
+}
+
+template void Test(DerivedT<int>);
diff --git a/clang/test/CXX/class.derived/class.member.lookup/p9.cpp b/clang/test/CXX/class.derived/class.member.lookup/p9.cpp
new file mode 100644
index 0000000..ba7bd21
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.member.lookup/p9.cpp
@@ -0,0 +1,28 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace rdar8436162 {
+  class ClsA {
+  public:
+    static void f();
+    void g();
+  };
+
+  class ClsB : virtual private ClsA {
+  public:
+    using ClsA::f;
+    using ClsA::g; // expected-note{{member found by ambiguous name lookup}}
+  };
+
+  class ClsF : virtual private ClsA {
+  public:
+    using ClsA::f;
+    using ClsA::g; // expected-note{{member found by ambiguous name lookup}}
+  };
+
+  class ClsE : public ClsB, public ClsF {
+    void test() { 
+      f();
+      g(); // expected-error{{member 'g' found in multiple base classes of different types}}
+    }
+  };
+}
diff --git a/clang/test/CXX/class.derived/class.virtual/p12.cpp b/clang/test/CXX/class.derived/class.virtual/p12.cpp
new file mode 100644
index 0000000..208a0d1
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.virtual/p12.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -ast-print %s | FileCheck %s
+
+// CHECK: test12_A::foo()
+struct test12_A {
+  virtual void foo();
+  
+  void bar() {
+    test12_A::foo();
+  }
+};
+
+// CHECK: xp->test24_B::wibble()
+struct test24_B {
+  virtual void wibble();
+};
+
+void foo(test24_B *xp) {
+  xp->test24_B::wibble();
+}
diff --git a/clang/test/CXX/class.derived/class.virtual/p2.cpp b/clang/test/CXX/class.derived/class.virtual/p2.cpp
new file mode 100644
index 0000000..64d93c8
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.virtual/p2.cpp
@@ -0,0 +1,37 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+struct A {
+  virtual void f() = 0; // expected-note 2{{overridden virtual function}}
+};
+
+struct Aprime : virtual A {
+  virtual void f();
+};
+
+struct B : Aprime {
+  virtual void f(); // expected-note 3{{final overrider of 'A::f'}}
+};
+
+struct C : virtual A {
+  virtual void f(); // expected-note{{final overrider of 'A::f'}}
+};
+
+struct D : B, C { }; // expected-error{{virtual function 'A::f' has more than one final overrider in 'D'}}
+
+struct B2 : B { };
+
+struct E : B, B2 { }; //expected-error{{virtual function 'A::f' has more than one final overrider in 'E'}}
+
+struct F : B, B2 {
+  virtual void f(); // okay
+};
+
+struct G : F { }; // okay
+
+struct H : G, A { }; // okay
+
+namespace MultipleSubobjects {
+  struct A { virtual void f(); };
+  struct B : A { virtual void f(); };
+  struct C : A { virtual void f(); };
+  struct D : B, C { }; // okay
+}
diff --git a/clang/test/CXX/class.derived/class.virtual/p3-0x.cpp b/clang/test/CXX/class.derived/class.virtual/p3-0x.cpp
new file mode 100644
index 0000000..c4a401b
--- /dev/null
+++ b/clang/test/CXX/class.derived/class.virtual/p3-0x.cpp
@@ -0,0 +1,53 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s 
+
+namespace Test1 {
+
+struct B {
+  virtual void f(int);
+};
+
+struct D : B {
+  virtual void f(long) override; // expected-error {{'f' marked 'override' but does not override any member functions}}
+  void f(int) override;
+};
+}
+
+namespace Test2 {
+
+struct A {
+  virtual void f(int, char, int);
+};
+
+template<typename T>
+struct B : A {
+  virtual void f(T) override;
+};
+
+}
+
+namespace Test3 {
+
+struct A {
+  virtual void f(int, char, int);
+};
+
+template<typename... Args>
+struct B : A { 
+  virtual void f(Args...) override; // expected-error {{'f' marked 'override' but does not override any member functions}}
+};
+
+template struct B<int, char, int>;
+template struct B<int>; // expected-note {{in instantiation of template class 'Test3::B<int>' requested here}}
+
+}
+
+namespace Test4 {
+struct B {
+  virtual void f() const final; // expected-note {{overridden virtual function is here}}
+};
+
+struct D : B {
+  void f() const; // expected-error {{declaration of 'f' overrides a 'final' function}}
+};
+
+}
diff --git a/clang/test/CXX/class.derived/p1.cpp b/clang/test/CXX/class.derived/p1.cpp
new file mode 100644
index 0000000..dc5cb2b
--- /dev/null
+++ b/clang/test/CXX/class.derived/p1.cpp
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 %s -fsyntax-only -verify -std=c++11
+
+// base-clause:
+//         : base-specifier-list
+// base-specifier-list:
+//         base-specifier ...[opt]
+//         base-specifier-list , base-specifier ...[opt]
+// base-specifier:
+//         attribute-specifier-seq[opt] base-type-specifier
+//         attribute-specifier-seq[opt] virtual access-specifier[opt] base-type-specifier
+//         attribute-specifier-seq[opt] access-specifier virtual[opt] base-type-specifier
+// class-or-decltype:
+//         nested-name-specifier[opt] class-name
+//         decltype-specifier
+// base-type-specifier:
+//         class-or-decltype
+// access-specifier:
+//         private
+//         protected
+//         public
+
+namespace PR11216 {
+  struct Base { };
+  struct Derived : decltype(Base()) { };
+
+  int func();
+  struct Derived2 : decltype(func()) { }; // expected-error {{base specifier must name a class}}
+
+  template<typename T>
+  struct Derived3 : decltype(T().foo()) { };
+  struct Foo { Base foo(); };
+  Derived3<Foo> d;
+
+  struct Derived4 : :: decltype(Base()) { }; // expected-error {{unexpected namespace scope prior to decltype}}
+
+  struct Derived5 : PR11216:: decltype(Base()) { }; // expected-error {{unexpected namespace scope prior to decltype}}
+
+  template<typename T>
+  struct Derived6 : typename T::foo { }; // expected-error {{'typename' is redundant; base classes are implicitly types}}
+}
diff --git a/clang/test/CXX/class.derived/p2.cpp b/clang/test/CXX/class.derived/p2.cpp
new file mode 100644
index 0000000..7ef53d3
--- /dev/null
+++ b/clang/test/CXX/class.derived/p2.cpp
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 %s -fsyntax-only -verify
+
+// "During the lookup for a base class name, non-type names are ignored"
+namespace PR5840 {
+  struct Base {};
+  int Base = 10;
+  struct Derived : Base {};
+}