7c2bcc9eb0
copy-initialization. We previously got this wrong in a couple of ways: - we only looked for copy / move constructors and constructor templates for this copy, and thus would fail to copy in cases where doing so should use some other constructor (but see core issue 670), - we mishandled the special case for disabling user-defined conversions that blocks infinite recursion through repeated application of a copy constructor (applying it in slightly too many cases) -- though as far as I can tell, this does not ever actually affect the result of overload resolution, and - we misapplied the special-case rules for constructors taking a parameter whose type is a (reference to) the same class type by incorrectly assuming that only happens for copy/move constructors (it also happens for constructors instantiated from templates and those inherited from base classes). These changes should only affect strange corner cases (for instance, where the copy constructor exists but has a non-const-qualified parameter type), so for the most part it only causes us to produce more 'candidate' notes, but see the test changes for other cases whose behavior is affected. llvm-svn: 280776
83 lines
1.9 KiB
C++
83 lines
1.9 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
|
|
|
|
class X {
|
|
public:
|
|
explicit X(const X&); // expected-note {{candidate constructor}}
|
|
X(int*); // expected-note 3{{candidate constructor}}
|
|
explicit X(float*); // expected-note {{candidate constructor}}
|
|
};
|
|
|
|
class Y : public X { };
|
|
|
|
void f(Y y, int *ip, float *fp) {
|
|
X x1 = y; // expected-error{{no matching constructor for initialization of 'X'}}
|
|
X x2 = 0;
|
|
X x3 = ip;
|
|
X x4 = fp; // expected-error{{no viable conversion}}
|
|
X x2a(0); // expected-error{{call to constructor of 'X' is ambiguous}}
|
|
X x3a(ip);
|
|
X x4a(fp);
|
|
}
|
|
|
|
struct foo {
|
|
void bar(); // expected-note{{declared here}}
|
|
};
|
|
|
|
// PR3600
|
|
void test(const foo *P) { P->bar(); } // expected-error{{'bar' not viable: 'this' argument has type 'const foo', but function is not marked const}}
|
|
|
|
namespace PR6757 {
|
|
struct Foo {
|
|
Foo(); // expected-note{{not viable}}
|
|
Foo(Foo&); // expected-note{{candidate constructor not viable}}
|
|
};
|
|
|
|
struct Bar {
|
|
operator const Foo&() const;
|
|
};
|
|
|
|
void f(Foo);
|
|
|
|
void g(Foo foo) {
|
|
f(Bar()); // expected-error{{no viable constructor copying parameter of type 'const PR6757::Foo'}}
|
|
f(foo);
|
|
}
|
|
}
|
|
|
|
namespace DR5 {
|
|
// Core issue 5: if a temporary is created in copy-initialization, it is of
|
|
// the cv-unqualified version of the destination type.
|
|
namespace Ex1 {
|
|
struct C { };
|
|
C c;
|
|
struct A {
|
|
A(const A&);
|
|
A(const C&);
|
|
};
|
|
const volatile A a = c; // ok
|
|
}
|
|
|
|
namespace Ex2 {
|
|
struct S {
|
|
S(S&&);
|
|
#if __cplusplus <= 199711L // C++03 or earlier modes
|
|
// expected-warning@-2 {{rvalue references are a C++11 extension}}
|
|
#endif
|
|
S(int);
|
|
};
|
|
const S a(0);
|
|
const S b = 0;
|
|
}
|
|
}
|
|
|
|
struct A {};
|
|
struct B : A {
|
|
B();
|
|
B(B&);
|
|
B(A);
|
|
B(int);
|
|
};
|
|
B b = 0; // ok, calls B(int) then A(const A&) then B(A).
|