clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
   3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   4
   5 // We have to avoid ADL for this test.
   6
   7 template <unsigned N> class test {};
   8
   9 class foo {};   // expected-note {{candidate constructor (the implicit copy constructor) not viable}}
  10 #if __cplusplus >= 201103L // C++11 or later
  11 // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
  12 #endif
  13 test<0> foo(foo); // expected-note {{candidate}}
  14
  15 namespace Test0 {
  16   class foo { int x; };
  17   test<1> foo(class foo);
  18
  19   namespace A {
  20     test<2> foo(class ::foo); // expected-note {{candidate}} \
  21     // expected-note{{passing argument to parameter here}}
  22
  23     void test0() {
  24       using ::foo;
  25
  26       class foo a;
  27       test<0> _ = (foo)(a);
  28     }
  29
  30     void test1() {
  31       using Test0::foo;
  32
  33       class foo a;
  34       test<1> _ = (foo)(a);
  35     };
  36
  37     void test2() {
  38       class ::foo a;
  39
  40       // Argument-dependent lookup is ambiguous between B:: and ::.
  41       test<0> _0 = foo(a); // expected-error {{call to 'foo' is ambiguous}}
  42
  43       // But basic unqualified lookup is not.
  44       test<2> _1 = (foo)(a);
  45
  46       class Test0::foo b;
  47       test<2> _2 = (foo)(b); // expected-error {{no viable conversion from 'class Test0::foo' to 'class ::foo'}}
  48     }
  49   }
  50 }
  51
  52 namespace Test1 {
  53   namespace A {
  54     class a {};
  55   }
  56
  57   namespace B {
  58     typedef class {} b;
  59   }
  60
  61   namespace C {
  62     int c(); // expected-note {{target of using declaration}}
  63   }
  64
  65   namespace D {
  66     using typename A::a;
  67     using typename B::b;
  68     using typename C::c; // expected-error {{'typename' keyword used on a non-type}}
  69
  70     a _1 = A::a();
  71     b _2 = B::b();
  72   }
  73 }
  74
  75 namespace test2 {
  76   class A {
  77   protected:
  78     operator int();
  79     operator bool();
  80   };
  81
  82   class B : private A {
  83   protected:
  84     using A::operator int; // expected-note {{declared protected here}}
  85   public:
  86     using A::operator bool;
  87   };
  88
  89   int test() {
  90     bool b = B();
  91     return B(); // expected-error {{'operator int' is a protected member of 'test2::B'}}
  92   }
  93 }
  94
  95 namespace test3 {
  96   class A {
  97   public:
  98     ~A();
  99   };
 100
 101   class B {
 102     friend class C;
 103   private:
 104     operator A*();
 105   };
 106
 107   class C : public B {
 108   public:
 109     using B::operator A*;
 110   };
 111
 112   void test() {
 113     delete C();
 114   }
 115 }