116 lines
2.3 KiB
C++
116 lines
2.3 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify %s
|
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
|
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
|
|
|
|
// We have to avoid ADL for this test.
|
|
|
|
template <unsigned N> class test {};
|
|
|
|
class foo {}; // expected-note {{candidate constructor (the implicit copy constructor) not viable}}
|
|
#if __cplusplus >= 201103L // C++11 or later
|
|
// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
|
|
#endif
|
|
test<0> foo(foo); // expected-note {{candidate}}
|
|
|
|
namespace Test0 {
|
|
class foo { int x; };
|
|
test<1> foo(class foo);
|
|
|
|
namespace A {
|
|
test<2> foo(class ::foo); // expected-note {{candidate}} \
|
|
// expected-note{{passing argument to parameter here}}
|
|
|
|
void test0() {
|
|
using ::foo;
|
|
|
|
class foo a;
|
|
test<0> _ = (foo)(a);
|
|
}
|
|
|
|
void test1() {
|
|
using Test0::foo;
|
|
|
|
class foo a;
|
|
test<1> _ = (foo)(a);
|
|
};
|
|
|
|
void test2() {
|
|
class ::foo a;
|
|
|
|
// Argument-dependent lookup is ambiguous between B:: and ::.
|
|
test<0> _0 = foo(a); // expected-error {{call to 'foo' is ambiguous}}
|
|
|
|
// But basic unqualified lookup is not.
|
|
test<2> _1 = (foo)(a);
|
|
|
|
class Test0::foo b;
|
|
test<2> _2 = (foo)(b); // expected-error {{no viable conversion from 'class Test0::foo' to 'class ::foo'}}
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace Test1 {
|
|
namespace A {
|
|
class a {};
|
|
}
|
|
|
|
namespace B {
|
|
typedef class {} b;
|
|
}
|
|
|
|
namespace C {
|
|
int c(); // expected-note {{target of using declaration}}
|
|
}
|
|
|
|
namespace D {
|
|
using typename A::a;
|
|
using typename B::b;
|
|
using typename C::c; // expected-error {{'typename' keyword used on a non-type}}
|
|
|
|
a _1 = A::a();
|
|
b _2 = B::b();
|
|
}
|
|
}
|
|
|
|
namespace test2 {
|
|
class A {
|
|
protected:
|
|
operator int();
|
|
operator bool();
|
|
};
|
|
|
|
class B : private A {
|
|
protected:
|
|
using A::operator int; // expected-note {{declared protected here}}
|
|
public:
|
|
using A::operator bool;
|
|
};
|
|
|
|
int test() {
|
|
bool b = B();
|
|
return B(); // expected-error {{'operator int' is a protected member of 'test2::B'}}
|
|
}
|
|
}
|
|
|
|
namespace test3 {
|
|
class A {
|
|
public:
|
|
~A();
|
|
};
|
|
|
|
class B {
|
|
friend class C;
|
|
private:
|
|
operator A*();
|
|
};
|
|
|
|
class C : public B {
|
|
public:
|
|
using B::operator A*;
|
|
};
|
|
|
|
void test() {
|
|
delete C();
|
|
}
|
|
}
|