darlinghq/darling-libcxx
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-libcxx.git synced 2025-03-02 16:56:12 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[libc++] Extension: Make move and forward constexpr in C++11.

Browse Source 
Summary:
`std::move` and `std::forward` were not marked constexpr in C++11.  This can be very damaging because it makes otherwise constant expressions non-constant. For example:

```
#include <utility>
template <class T>
struct Foo {
  constexpr Foo(T&& tx) :  t(std::move(tx)) {}
  T t;
};
[[clang::require_constant_initialization]] Foo<int> f(42); // Foo should be constant initialized but C++11 move is not constexpr. As a result `f` is an unsafe global.
```

This patch applies `constexpr` to `move` and `forward` as an extension in C++11. Normally the library is not allowed to add `constexpr` because it may be observable to the user. In particular adding constexpr may cause valid code to stop compiling. However these problems only happen in more complex situations, like making `__invoke(...)` constexpr. `forward` and `move` are simply enough that applying `constexpr` is safe. 

Note that libstdc++ has offered this extension since at least 4.8.1.

Most of the changes in this patch are simply test cleanups or additions. The main changes in the tests are:

* Fold all `forward_N.fail.cpp` tests into a single `forward.fail.cpp` test using -verify.
* Delete most `move_only_N.fail.cpp` tests because they weren't actually testing anything.
* Fold `move_copy.pass.cpp` and `move_only.pass.cpp` into a single `move.pass.cpp` test.
* Add return type and noexcept tests for `forward` and `move`.




Reviewers: rsmith, mclow.lists, EricWF

Subscribers: K-ballo, loladiro

Differential Revision: https://reviews.llvm.org/D24637

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@282439 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier 2016-09-26 20:55:02 +00:00
parent 08fa01095a
commit 66bdfe223e
17 changed files with 300 additions and 476 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/type_traits
View File

@ -2155,7 +2155,7 @@ template <class _Tp> _LIBCPP_CONSTEXPR bool is_destructible_v
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename remove_reference<_Tp>::type&&
move(_Tp&& __t) _NOEXCEPT
{
@ -2164,7 +2164,7 @@ move(_Tp&& __t) _NOEXCEPT
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
_Tp&&
forward(typename remove_reference<_Tp>::type& __t) _NOEXCEPT
{
@ -2172,12 +2172,12 @@ forward(typename remove_reference<_Tp>::type& __t) _NOEXCEPT
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
_Tp&&
forward(typename remove_reference<_Tp>::type&& __t) _NOEXCEPT
{
static_assert(!is_lvalue_reference<_Tp>::value,
"Can not forward an rvalue as an lvalue.");
"can not forward an rvalue as an lvalue");
return static_cast<_Tp&&>(__t);
}

53
test/std/utilities/utility/forward/forward.fail.cpp Normal file
View File

@ -0,0 +1,53 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
#include "test_macros.h"
struct A
{
};
A source() {return A();}
const A csource() {return A();}
int main()
{
#if TEST_STD_VER >= 11
{
std::forward<A&>(source()); // expected-note {{requested here}}
// expected-error@type_traits:* 1 {{static_assert failed "can not forward an rvalue as an lvalue"}}
}
#else
{
std::forward<A&>(source()); // expected-error {{no matching function for call to 'forward'}}
}
#endif
{
const A ca = A();
std::forward<A&>(ca); // expected-error {{no matching function for call to 'forward'}}
}
{
std::forward<A&>(csource()); // expected-error {{no matching function for call to 'forward'}}
}
{
const A ca = A();
std::forward<A>(ca); // expected-error {{no matching function for call to 'forward'}}
}
{
std::forward<A>(csource()); // expected-error {{no matching function for call to 'forward'}}
}
{
A a;
std::forward(a); // expected-error {{no matching function for call to 'forward'}}
}
}

104
test/std/utilities/utility/forward/forward.pass.cpp
View File

@ -7,32 +7,40 @@
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// test forward
#include <utility>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
struct A
{
};
A source() {return A();}
const A csource() {return A();}
A source() noexcept {return A();}
const A csource() noexcept {return A();}
typedef char one;
struct two {one _[2];};
struct four {one _[4];};
struct eight {one _[8];};
one test(A&);
two test(const A&);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
four test(A&&);
eight test(const A&&);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
constexpr bool test_constexpr_forward() {
#if TEST_STD_VER > 11
int x = 42;
const int cx = 101;
return std::forward<int&>(x) == 42
&& std::forward<int>(x) == 42
&& std::forward<const int&>(x) == 42
&& std::forward<const int>(x) == 42
&& std::forward<int&&>(x) == 42
&& std::forward<const int&&>(x) == 42
&& std::forward<const int&>(cx) == 101
&& std::forward<const int>(cx) == 101;
#else
return true;
#endif
}
int main()
{
@ -42,42 +50,42 @@ int main()
((void)a); // Prevent unused warning
((void)ca); // Prevent unused warning
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
static_assert(sizeof(test(std::forward<A&>(a))) == 1, "");
static_assert(sizeof(test(std::forward<A>(a))) == 4, "");
static_assert(sizeof(test(std::forward<A>(source()))) == 4, "");
static_assert(std::is_same<decltype(std::forward<A&>(a)), A&>::value, "");
static_assert(std::is_same<decltype(std::forward<A>(a)), A&&>::value, "");
static_assert(std::is_same<decltype(std::forward<A>(source())), A&&>::value, "");
static_assert(noexcept(std::forward<A&>(a)), "");
static_assert(noexcept(std::forward<A>(a)), "");
static_assert(noexcept(std::forward<A>(source())), "");
static_assert(sizeof(test(std::forward<const A&>(a))) == 2, "");
// static_assert(sizeof(test(std::forward<const A&>(source()))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(a))) == 8, "");
static_assert(sizeof(test(std::forward<const A>(source()))) == 8, "");
static_assert(std::is_same<decltype(std::forward<const A&>(a)), const A&>::value, "");
static_assert(std::is_same<decltype(std::forward<const A>(a)), const A&&>::value, "");
static_assert(std::is_same<decltype(std::forward<const A>(source())), const A&&>::value, "");
static_assert(noexcept(std::forward<const A&>(a)), "");
static_assert(noexcept(std::forward<const A>(a)), "");
static_assert(noexcept(std::forward<const A>(source())), "");
static_assert(sizeof(test(std::forward<const A&>(ca))) == 2, "");
// static_assert(sizeof(test(std::forward<const A&>(csource()))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(ca))) == 8, "");
static_assert(sizeof(test(std::forward<const A>(csource()))) == 8, "");
static_assert(std::is_same<decltype(std::forward<const A&>(ca)), const A&>::value, "");
static_assert(std::is_same<decltype(std::forward<const A>(ca)), const A&&>::value, "");
static_assert(std::is_same<decltype(std::forward<const A>(csource())), const A&&>::value, "");
static_assert(noexcept(std::forward<const A&>(ca)), "");
static_assert(noexcept(std::forward<const A>(ca)), "");
static_assert(noexcept(std::forward<const A>(csource())), "");
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
static_assert(sizeof(test(std::forward<A&>(a))) == 1, "");
static_assert(sizeof(test(std::forward<A>(a))) == 1, "");
// static_assert(sizeof(test(std::forward<A>(source()))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(a))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(source()))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(a))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(source()))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(ca))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(csource()))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(ca))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(csource()))) == 2, "");
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#if _LIBCPP_STD_VER > 11
constexpr int i1 = std::move(23);
static_assert(i1 == 23, "" );
#if TEST_STD_VER > 11
{
constexpr int i2 = std::forward<int>(42);
static_assert(i2 == 42, "" );
static_assert(std::forward<int>(42) == 42, "");
static_assert(std::forward<const int&>(i2) == 42, "");
static_assert(test_constexpr_forward(), "");
}
#endif
#if TEST_STD_VER == 11 && defined(_LIBCPP_VERSION)
// Test that std::forward is constexpr in C++11. This is an extension
// provided by both libc++ and libstdc++.
{
constexpr int i2 = std::forward<int>(42);
static_assert(std::forward<int>(42) == 42, "" );
static_assert(std::forward<const int&>(i2) == 42, "");
}
#endif
}

24
test/std/utilities/utility/forward/forward1.fail.cpp
View File

@ -1,24 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
struct A
{
};
A source() {return A();}
const A csource() {return A();}
int main()
{
std::forward<A&>(source()); // error
}

25
test/std/utilities/utility/forward/forward2.fail.cpp
View File

@ -1,25 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
struct A
{
};
A source() {return A();}
const A csource() {return A();}
int main()
{
const A ca = A();
std::forward<A&>(ca); // error
}

24
test/std/utilities/utility/forward/forward3.fail.cpp
View File

@ -1,24 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
struct A
{
};
A source() {return A();}
const A csource() {return A();}
int main()
{
std::forward<A&>(csource()); // error
}

25
test/std/utilities/utility/forward/forward4.fail.cpp
View File

@ -1,25 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
struct A
{
};
A source() {return A();}
const A csource() {return A();}
int main()
{
const A ca = A();
std::forward<A>(ca); // error
}

25
test/std/utilities/utility/forward/forward5.fail.cpp
View File

@ -1,25 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
struct A
{
};
A source() {return A();}
const A csource() {return A();}
int main()
{
const A ca = A();
std::forward<A>(csource()); // error
}

22
test/std/utilities/utility/forward/forward6.fail.cpp
View File

@ -1,22 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
struct A
{
};
int main()
{
A a;
std::forward(a); // error
}

58
test/std/utilities/utility/forward/forward_03.pass.cpp Normal file
View File

@ -0,0 +1,58 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test forward
#include <utility>
#include <cassert>
#include "test_macros.h"
struct A
{
};
A source() {return A();}
const A csource() {return A();}
typedef char one;
struct two {one _[2];};
struct four {one _[4];};
struct eight {one _[8];};
one test(A&);
two test(const A&);
int main()
{
A a;
const A ca = A();
((void)a); // Prevent unused warning
((void)ca); // Prevent unused warning
#if TEST_STD_VER < 11
static_assert(sizeof(test(std::forward<A&>(a))) == 1, "");
static_assert(sizeof(test(std::forward<A>(a))) == 1, "");
// Libc++'s C++03 implementation of 'forward' cannot accept true non-const
// rvalues.
// static_assert(sizeof(test(std::forward<A>(source()))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(a))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(source()))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(a))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(source()))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(ca))) == 2, "");
static_assert(sizeof(test(std::forward<const A&>(csource()))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(ca))) == 2, "");
static_assert(sizeof(test(std::forward<const A>(csource()))) == 2, "");
#endif
}

21
test/std/utilities/utility/forward/move_only.pass.cpp → test/std/utilities/utility/forward/move.fail.cpp
View File

@ -7,22 +7,17 @@
//
//===----------------------------------------------------------------------===//
// test move
// UNSUPPORTED: c++98, c++03
// test move
#include <utility>
#include <cassert>
class move_only
{
move_only(const move_only&);
move_only& operator=(const move_only&);
public:
move_only(move_only&&) {}
move_only& operator=(move_only&&) {return *this;}
struct move_only {
move_only() {}
move_only(move_only&&) = default;
move_only& operator=(move_only&&) = default;
};
move_only source() {return move_only();}
@ -32,8 +27,8 @@ void test(move_only) {}
int main()
{
move_only mo;
move_only a;
const move_only ca = move_only();
test(std::move(mo));
test(source());
test(std::move(ca)); // c
}

121
test/std/utilities/utility/forward/move.pass.cpp Normal file
View File

@ -0,0 +1,121 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test move
// UNSUPPORTED: c++98, c++03
#include <utility>
#include <type_traits>
#include <cassert>
#include "test_macros.h"
class move_only
{
move_only(const move_only&);
move_only& operator=(const move_only&);
public:
move_only(move_only&&) {}
move_only& operator=(move_only&&) {return *this;}
move_only() {}
};
move_only source() {return move_only();}
const move_only csource() {return move_only();}
void test(move_only) {}
int x = 42;
const int& cx = x;
template <class QualInt>
QualInt get() noexcept { return static_cast<QualInt>(x); }
int copy_ctor = 0;
int move_ctor = 0;
struct A {
A() {}
A(const A&) {++copy_ctor;}
A(A&&) {++move_ctor;}
A& operator=(const A&) = delete;
};
constexpr bool test_constexpr_move() {
#if TEST_STD_VER > 11
int x = 42;
const int cx = x;
return std::move(x) == 42
&& std::move(cx) == 42
&& std::move(static_cast<int&&>(x)) == 42
&& std::move(static_cast<int const&&>(x)) == 42;
#else
return true;
#endif
}
int main()
{
{ // Test return type and noexcept.
static_assert(std::is_same<decltype(std::move(x)), int&&>::value, "");
static_assert(noexcept(std::move(x)), "");
static_assert(std::is_same<decltype(std::move(cx)), const int&&>::value, "");
static_assert(noexcept(std::move(cx)), "");
static_assert(std::is_same<decltype(std::move(42)), int&&>::value, "");
static_assert(noexcept(std::move(42)), "");
static_assert(std::is_same<decltype(std::move(get<const int&&>())), const int&&>::value, "");
static_assert(noexcept(std::move(get<int const&&>())), "");
}
{ // test copy and move semantics
A a;
const A ca = A();
assert(copy_ctor == 0);
assert(move_ctor == 0);
A a2 = a;
assert(copy_ctor == 1);
assert(move_ctor == 0);
A a3 = std::move(a);
assert(copy_ctor == 1);
assert(move_ctor == 1);
A a4 = ca;
assert(copy_ctor == 2);
assert(move_ctor == 1);
A a5 = std::move(ca);
assert(copy_ctor == 3);
assert(move_ctor == 1);
}
{ // test on a move only type
move_only mo;
test(std::move(mo));
test(source());
}
#if TEST_STD_VER > 11
{
constexpr int x = 42;
static_assert(std::move(x) == 42, "");
static_assert(test_constexpr_move(), "");
}
#endif
#if TEST_STD_VER == 11 && defined(_LIBCPP_VERSION)
// Test that std::forward is constexpr in C++11. This is an extension
// provided by both libc++ and libstdc++.
{
constexpr int x = 42;
static_assert(std::move(x) == 42, "");
}
#endif
}

61
test/std/utilities/utility/forward/move_copy.pass.cpp
View File

@ -1,61 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test move
// UNSUPPORTED: c++98, c++03
#include <utility>
#include <cassert>
int copy_ctor = 0;
int move_ctor = 0;
class A
{
public:
A(const A&) {++copy_ctor;}
A& operator=(const A&);
A(A&&) {++move_ctor;}
A& operator=(A&&);
A() {}
};
A source() {return A();}
const A csource() {return A();}
void test(A) {}
int main()
{
A a;
const A ca = A();
assert(copy_ctor == 0);
assert(move_ctor == 0);
A a2 = a;
assert(copy_ctor == 1);
assert(move_ctor == 0);
A a3 = std::move(a);
assert(copy_ctor == 1);
assert(move_ctor == 1);
A a4 = ca;
assert(copy_ctor == 2);
assert(move_ctor == 1);
A a5 = std::move(ca);
assert(copy_ctor == 3);
assert(move_ctor == 1);
}

52
test/std/utilities/utility/forward/move_only1.fail.cpp
View File

@ -1,52 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test move
#include <utility>
#include <cassert>
#include <typeinfo>
#include <stdio.h>
class move_only
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(const move_only&);
move_only& operator=(const move_only&);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&);
move_only& operator=(move_only&);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&&) {}
move_only& operator=(move_only&&) {}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
operator std::__rv<move_only> () {return std::__rv<move_only>(*this);}
move_only(std::__rv<move_only>) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only() {}
};
move_only source() {return move_only();}
const move_only csource() {return move_only();}
void test(move_only) {}
int main()
{
move_only a;
const move_only ca = move_only();
test(a);
}

52
test/std/utilities/utility/forward/move_only2.fail.cpp
View File

@ -1,52 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test move
#include <utility>
#include <cassert>
#include <typeinfo>
#include <stdio.h>
class move_only
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(const move_only&);
move_only& operator=(const move_only&);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&);
move_only& operator=(move_only&);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&&) {}
move_only& operator=(move_only&&) {}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
operator std::__rv<move_only> () {return std::__rv<move_only>(*this);}
move_only(std::__rv<move_only>) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only() {}
};
move_only source() {return move_only();}
const move_only csource() {return move_only();}
void test(move_only) {}
int main()
{
move_only a;
const move_only ca = move_only();
test(ca);
}

49
test/std/utilities/utility/forward/move_only3.fail.cpp
View File

@ -1,49 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test move
#include <utility>
#include <cassert>
class move_only
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(const move_only&);
move_only& operator=(const move_only&);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&);
move_only& operator=(move_only&);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&&) {}
move_only& operator=(move_only&&) {}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
operator std::__rv<move_only> () {return std::__rv<move_only>(*this);}
move_only(std::__rv<move_only>) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only() {}
};
move_only source() {return move_only();}
const move_only csource() {return move_only();}
void test(move_only) {}
int main()
{
move_only a;
const move_only ca = move_only();
test(std::move(ca));
}

52
test/std/utilities/utility/forward/move_only4.fail.cpp
View File

@ -1,52 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// test move
#include <utility>
#include <cassert>
#include <typeinfo>
#include <stdio.h>
class move_only
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(const move_only&);
move_only& operator=(const move_only&);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&);
move_only& operator=(move_only&);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only(move_only&&) {}
move_only& operator=(move_only&&) {}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
operator std::__rv<move_only> () {return std::__rv<move_only>(*this);}
move_only(std::__rv<move_only>) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
move_only() {}
};
move_only source() {return move_only();}
const move_only csource() {return move_only();}
void test(move_only) {}
int main()
{
move_only a;
const move_only ca = move_only();
test(csource());
}