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 
test0()23     void test0() {
24       using ::foo;
25 
26       class foo a;
27       test<0> _ = (foo)(a);
28     }
29 
test1()30     void test1() {
31       using Test0::foo;
32 
33       class foo a;
34       test<1> _ = (foo)(a);
35     };
36 
test2()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 
test()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 
test()112   void test() {
113     delete C();
114   }
115 }
116