Parse deleted member functions. Parsing member declarations goes through a different code path that I forgot previously.
Implement the rvalue reference overload dance for returning local objects. Returning a local object first tries to find a move constructor now.
The error message when no move constructor is defined (or is not applicable) and the copy constructor is deleted is quite ugly, though.
llvm-svn: 68902
diff --git a/clang/test/SemaCXX/deleted-function.cpp b/clang/test/SemaCXX/deleted-function.cpp
index 59a8260..0e36396 100644
--- a/clang/test/SemaCXX/deleted-function.cpp
+++ b/clang/test/SemaCXX/deleted-function.cpp
@@ -15,8 +15,20 @@
void ov(int) {} // expected-note {{candidate function}}
void ov(double) = delete; // expected-note {{candidate function has been explicitly deleted}}
+struct WithDel {
+ WithDel() = delete; // expected-note {{candidate function has been explicitly deleted}}
+ void fn() = delete; // expected-note {{function has been explicitly marked deleted here}}
+ operator int() = delete;
+ void operator +(int) = delete;
+};
+
void test() {
fn(); // expected-error {{call to deleted function 'fn'}}
ov(1);
ov(1.0); // expected-error {{call to deleted function 'ov'}}
+
+ WithDel dd; // expected-error {{call to deleted constructor of 'dd'}}
+ WithDel *d = 0;
+ d->fn(); // expected-error {{attempt to use a deleted function}}
+ int i = *d; // expected-error {{incompatible type initializing}}
}
diff --git a/clang/test/SemaCXX/rval-references.cpp b/clang/test/SemaCXX/rval-references.cpp
index 569693a..a7d26bb 100644
--- a/clang/test/SemaCXX/rval-references.cpp
+++ b/clang/test/SemaCXX/rval-references.cpp
@@ -52,3 +52,40 @@
} catch(int&&) { // expected-error {{cannot catch exceptions by rvalue reference}}
}
}
+
+int&& should_warn(int i) {
+ // FIXME: The stack address return test doesn't reason about casts.
+ return static_cast<int&&>(i); // xpected-warning {{returning reference to temporary}}
+}
+int&& should_not_warn(int&& i) { // But GCC 4.4 does
+ return static_cast<int&&>(i);
+}
+
+
+// Test the return dance. This also tests IsReturnCopyElidable.
+struct MoveOnly {
+ MoveOnly();
+ MoveOnly(const MoveOnly&) = delete;
+ MoveOnly(MoveOnly&&);
+ MoveOnly(int&&);
+};
+
+MoveOnly returning() {
+ MoveOnly mo;
+ return mo;
+}
+
+MoveOnly gmo;
+MoveOnly returningNonEligible() {
+ int i;
+ static MoveOnly mo;
+ MoveOnly &r = mo;
+ if (0) // Copy from global can't be elided
+ return gmo; // expected-error {{incompatible type returning}}
+ else if (0) // Copy from local static can't be elided
+ return mo; // expected-error {{incompatible type returning}}
+ else if (0) // Copy from reference can't be elided
+ return r; // expected-error {{incompatible type returning}}
+ else // Construction from different type can't be elided
+ return i; // expected-error {{incompatible type returning}}
+}