Home | History | Annotate | Download | only in class.inhctor
      1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
      2 
      3 // Tests related to constructor inheriting, but not specified in [class.inhctor]
      4 
      5 // [namespace.udecl]p8:
      6 //   A using-declaration for a class member shall be a member-declaration.
      7 
      8 struct B1 {
      9   B1(int);
     10 };
     11 
     12 using B1::B1; // expected-error {{using declaration can not refer to class member}}
     13 
     14 // C++11 [namespace.udecl]p10:
     15 //   A using-declaration is a declaration and can therefore be used repeatedly
     16 //   where (and only where) multiple declarations are allowed.
     17 
     18 struct I1 : B1 {
     19   using B1::B1; // expected-note {{previous using declaration}}
     20   using B1::B1; // expected-error {{redeclaration of using decl}}
     21 };
     22 
     23 // C++11 [namespace.udecl]p3:
     24 //   In a using declaration used as a member-declaration, the nested-name-
     25 //   specifier shall name a base class of the class being defined.
     26 //   If such a using-declaration names a constructor, the nested-name-specifier
     27 //   shall name a direct base class of the class being defined.
     28 
     29 struct D1 : I1 {
     30   using B1::B1; // expected-error {{'B1' is not a direct base of 'D1', can not inherit constructors}}
     31 };
     32 
     33 template<typename T> struct A {};
     34 
     35 template<typename T> struct B : A<bool>, A<char> {
     36   using A<T>::A; // expected-error {{'A<double>::', which is not a base class of 'B<double>'}}
     37 };
     38 B<bool> bb;
     39 B<char> bc;
     40 B<double> bd; // expected-note {{here}}
     41 
     42 template<typename T> struct C : A<T> {
     43   using A<bool>::A; // expected-error {{'A<bool>::', which is not a base class of 'C<char>'}}
     44 };
     45 C<bool> cb;
     46 C<char> cc; // expected-note {{here}}
     47 
     48 template<typename T> struct D : A<T> {};
     49 template<typename T> struct E : D<T> {
     50   using A<bool>::A; // expected-error {{'A<bool>' is not a direct base of 'E<bool>', can not inherit}}
     51 };
     52 E<bool> eb; // expected-note {{here}}
     53 
     54 template<typename T> struct F : D<bool> {
     55   using A<T>::A; // expected-error {{'A<bool>' is not a direct base of 'F<bool>'}}
     56 };
     57 F<bool> fb; // expected-note {{here}}
     58 
     59 template<typename T>
     60 struct G : T {
     61   using T::T;
     62   G(int &) : G(0) {}
     63 };
     64 G<B1> g(123);
     65