Merge branch 'master' of ssh://bitbucket.org/czan/honours

3 files changed, 134 insertions, 0 deletions

diff --git a/clang/test/CXX/special/class.inhctor/elsewhere.cpp b/clang/test/CXX/special/class.inhctor/elsewhere.cpp
new file mode 100644
index 0000000..09fd3d5
--- /dev/null
+++ b/clang/test/CXX/special/class.inhctor/elsewhere.cpp
@@ -0,0 +1,57 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+// Tests related to constructor inheriting, but not specified in [class.inhctor]
+
+// [namespace.udecl]p8:
+//   A using-declaration for a class member shall be a member-declaration.
+
+struct B1 {
+  B1(int);
+};
+
+using B1::B1; // expected-error {{using declaration can not refer to class member}} expected-error {{not supported}}
+
+// C++0x [namespace.udecl]p10:
+//   A using-declaration is a declaration and can therefore be used repeatedly
+//   where (and only where) multiple declarations are allowed.
+
+struct I1 : B1 {
+  using B1::B1; // expected-note {{previous using declaration}} expected-error {{not supported}}
+  using B1::B1; // expected-error {{redeclaration of using decl}} expected-error {{not supported}}
+};
+
+// C++0x [namespace.udecl]p3:
+//   In a using declaration used as a member-declaration, the nested-name-
+//   specifier shall name a base class of the class being defined.
+//   If such a using-declaration names a constructor, the nested-name-specifier
+//   shall name a direct base class of the class being defined.
+
+struct D1 : I1 {
+  using B1::B1; // expected-error {{'B1' is not a direct base of 'D1', can not inherit constructors}} expected-error {{not supported}}
+};
+
+template<typename T> struct A {};
+
+template<typename T> struct B : A<bool>, A<char> {
+  using A<T>::A; // expected-error {{'A<double>::', which is not a base class of 'B<double>'}} expected-error {{not supported}}
+};
+B<bool> bb;
+B<char> bc;
+B<double> bd; // expected-note {{here}}
+
+template<typename T> struct C : A<T> {
+  using A<bool>::A; // expected-error {{'A<bool>::', which is not a base class of 'C<char>'}} expected-error {{not supported}}
+};
+C<bool> cb;
+C<char> cc; // expected-note {{here}}
+
+template<typename T> struct D : A<T> {};
+template<typename T> struct E : D<T> {
+  using A<bool>::A; // expected-error {{'A<bool>' is not a direct base of 'E<bool>', can not inherit}} expected-error {{not supported}}
+};
+E<bool> eb; // expected-note {{here}}
+
+template<typename T> struct F : D<bool> {
+  using A<T>::A; // expected-error {{'A<bool>' is not a direct base of 'F<bool>'}} expected-error {{not supported}}
+};
+F<bool> fb; // expected-note {{here}}
diff --git a/clang/test/CXX/special/class.inhctor/p3.cpp b/clang/test/CXX/special/class.inhctor/p3.cpp
new file mode 100644
index 0000000..d7093fb
--- /dev/null
+++ b/clang/test/CXX/special/class.inhctor/p3.cpp
@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+struct B1 {
+  B1(int);
+  B1(int, int);
+};
+struct D1 : B1 {
+  using B1::B1; // expected-error {{not supported}}
+};
+D1 d1a(1), d1b(1, 1);
+
+D1 fd1() { return 1; }
+
+struct B2 {
+  explicit B2(int, int = 0, int = 0);
+};
+struct D2 : B2 { // expected-note 2 {{candidate constructor}}
+  using B2::B2; // expected-error {{not supported}}
+};
+D2 d2a(1), d2b(1, 1), d2c(1, 1, 1);
+
+D2 fd2() { return 1; } // expected-error {{no viable conversion}}
+
+struct B3 {
+  B3(void*); // expected-note {{inherited from here}}
+};
+struct D3 : B3 { // expected-note 2 {{candidate constructor}}
+  using B3::B3; // expected-note {{candidate constructor (inherited)}} expected-error {{not supported}}
+};
+D3 fd3() { return 1; } // expected-error {{no viable conversion}}
+
+template<typename T> struct T1 : B1 {
+  using B1::B1; // expected-error {{not supported}}
+};
+template<typename T> struct T2 : T1<T> {
+  using T1<int>::T1; // expected-error {{not supported}}
+};
+template<typename T> struct T3 : T1<int> {
+  using T1<T>::T1; // expected-error {{not supported}}
+};
+struct U {
+  friend T1<int>::T1(int);
+  friend T1<int>::T1(int, int);
+  friend T2<int>::T2(int);
+  friend T2<int>::T2(int, int);
+  friend T3<int>::T3(int);
+  friend T3<int>::T3(int, int);
+};
diff --git a/clang/test/CXX/special/class.inhctor/p7.cpp b/clang/test/CXX/special/class.inhctor/p7.cpp
new file mode 100644
index 0000000..bfaa3ac
--- /dev/null
+++ b/clang/test/CXX/special/class.inhctor/p7.cpp
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+// Straight from the standard
+struct B1 {
+  B1(int); // expected-note {{previous constructor}} expected-note {{conflicting constructor}}
+};
+struct B2 {
+  B2(int); // expected-note {{conflicting constructor}}
+};
+struct D1 : B1, B2 {
+  using B1::B1; // expected-note {{inherited here}} expected-error {{not supported}}
+  using B2::B2; // expected-error {{already inherited constructor with the same signature}} expected-error {{not supported}}
+};
+struct D2 : B1, B2 {
+  using B1::B1; // expected-error {{not supported}}
+  using B2::B2; // expected-error {{not supported}}
+  D2(int);
+};
+
+template<typename T> struct B3 {
+  B3(T); // expected-note {{previous constructor}}
+};
+template<typename T> struct B4 : B3<T>, B1 {
+  B4();
+  using B3<T>::B3; // expected-note {{inherited here}} expected-error {{not supported}}
+  using B1::B1; // expected-error {{already inherited}} expected-error {{not supported}}
+};
+B4<char> b4c;
+B4<int> b4i; // expected-note {{here}}