LineageOS/android_external_libcxx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert Add <optional>. Will recommit with better commit message

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@283978 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2016-10-12 06:48:31 +00:00
parent fbc80168bb
commit ead5d404cc
86 changed files with 55 additions and 8467 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
test/libcxx/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp
View File

@@ -1,81 +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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11, c++14
// XFAIL: libcpp-no-exceptions
// <optional>
// optional<T>& operator=(const optional<T>& rhs);
#include <optional>
#include <string>
#include <type_traits>
using std::optional;
struct X {};
struct Y
{
Y() = default;
Y& operator=(const Y&) { return *this; }
};
struct Z1
{
Z1() = default;
Z1(Z1&&) = default;
Z1(const Z1&) = default;
Z1& operator=(Z1&&) = default;
Z1& operator=(const Z1&) = delete;
};
struct Z2
{
Z2() = default;
Z2(Z2&&) = default;
Z2(const Z2&) = delete;
Z2& operator=(Z2&&) = default;
Z2& operator=(const Z2&) = default;
};
#if __cplusplus >= 201402
template <class T>
constexpr bool
test()
{
optional<T> opt;
optional<T> opt2;
opt = opt2;
return true;
}
#endif
int main()
{
{
using T = int;
static_assert((std::is_trivially_copy_assignable<optional<T>>::value), "");
#if __cplusplus >= 201402
static_assert(test<T>(), "");
#endif
}
{
using T = X;
static_assert((std::is_trivially_copy_assignable<optional<T>>::value), "");
#if __cplusplus >= 201402
static_assert(test<T>(), "");
#endif
}
static_assert(!(std::is_trivially_copy_assignable<optional<Y>>::value), "");
static_assert(!(std::is_trivially_copy_assignable<optional<std::string>>::value), "");
static_assert(!(std::is_copy_assignable<optional<Z1>>::value), "");
static_assert(!(std::is_copy_assignable<optional<Z2>>::value), "");
}

78
test/libcxx/utilities/optional/optional.object/optional.object.assign/move.pass.cpp
View File

@@ -1,78 +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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11, c++14
// XFAIL: libcpp-no-exceptions
// <optional>
// optional<T>& operator=(optional<T>&& rhs);
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
using std::optional;
struct X {};
struct Y
{
Y() = default;
Y& operator=(Y&&) { return *this; }
};
struct Z1
{
Z1() = default;
Z1(Z1&&) = default;
Z1& operator=(Z1&&) = delete;
};
struct Z2
{
Z2() = default;
Z2(Z2&&) = delete;
Z2& operator=(Z2&&) = default;
};
#if __cplusplus >= 201402
template <class T>
constexpr bool
test()
{
optional<T> opt;
optional<T> opt2;
opt = std::move(opt2);
return true;
}
#endif
int main()
{
{
using T = int;
static_assert((std::is_trivially_copy_constructible<optional<T>>::value), "");
#if __cplusplus >= 201402
static_assert(test<T>(), "");
#endif
}
{
using T = X;
static_assert((std::is_trivially_copy_constructible<optional<T>>::value), "");
#if __cplusplus >= 201402
static_assert(test<T>(), "");
#endif
}
static_assert(!(std::is_trivially_move_assignable<optional<Y>>::value), "");
static_assert(!(std::is_trivially_move_assignable<optional<std::string>>::value), "");
static_assert(!(std::is_move_assignable<optional<Z1>>::value), "");
static_assert(!(std::is_move_assignable<optional<Z2>>::value), "");
}

59
test/libcxx/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
View File

@@ -1,59 +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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11, c++14
// XFAIL: libcpp-no-exceptions
// <optional>
// optional(const optional<T>& rhs);
#include <optional>
#include <string>
#include <type_traits>
using std::optional;
struct X {};
struct Y
{
Y() = default;
Y(const Y&) {}
};
struct Z
{
Z() = default;
Z(Z&&) = delete;
Z(const Z&) = delete;
Z& operator=(Z&&) = delete;
Z& operator=(const Z&) = delete;
};
int main()
{
{
using T = int;
static_assert((std::is_trivially_copy_constructible<optional<T>>::value), "");
constexpr optional<T> opt;
constexpr optional<T> opt2 = opt;
(void)opt2;
}
{
using T = X;
static_assert((std::is_trivially_copy_constructible<optional<T>>::value), "");
constexpr optional<T> opt;
constexpr optional<T> opt2 = opt;
(void)opt2;
}
static_assert(!(std::is_trivially_copy_constructible<optional<Y>>::value), "");
static_assert(!(std::is_trivially_copy_constructible<optional<std::string>>::value), "");
static_assert(!(std::is_copy_constructible<optional<Z>>::value), "");
}

60
test/libcxx/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
View File

@@ -1,60 +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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11, c++14
// XFAIL: libcpp-no-exceptions
// <optional>
// optional(optional<T>&& rhs);
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
using std::optional;
struct X {};
struct Y
{
Y() = default;
Y(Y&&) {}
};
struct Z
{
Z() = default;
Z(Z&&) = delete;
Z(const Z&) = delete;
Z& operator=(Z&&) = delete;
Z& operator=(const Z&) = delete;
};
int main()
{
{
using T = int;
static_assert((std::is_trivially_copy_constructible<optional<T>>::value), "");
constexpr optional<T> opt;
constexpr optional<T> opt2 = std::move(opt);
(void)opt2;
}
{
using T = X;
static_assert((std::is_trivially_copy_constructible<optional<T>>::value), "");
constexpr optional<T> opt;
constexpr optional<T> opt2 = std::move(opt);
(void)opt2;
}
static_assert(!(std::is_trivially_move_constructible<optional<Y>>::value), "");
static_assert(!(std::is_trivially_move_constructible<optional<std::string>>::value), "");
static_assert(!(std::is_move_constructible<optional<Z>>::value), "");
}

66
test/libcxx/utilities/optional/optional.object/special_member_gen.pass.cpp
View File

@@ -1,66 +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.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11, c++14
// <optional>
#include <optional>
#include <type_traits>
#include <cassert>
#include "archetypes.hpp"
template <class T>
struct SpecialMemberTest {
using O = std::optional<T>;
template <template <class> class TestMF>
static constexpr bool check_same() {
return TestMF<O>::value == TestMF<T>::value;
}
// Test that optional inherits the correct trivial/non-trivial members
static_assert(check_same<std::is_trivially_destructible>(), "");
static_assert(check_same<std::is_trivially_copyable>(), "");
};
template <class ...Args> static void sink(Args&&...) {}
template <class ...TestTypes>
struct DoTestsMetafunction {
DoTestsMetafunction() { sink(SpecialMemberTest<TestTypes>{}...); }
};
struct TrivialMoveNonTrivialCopy {
TrivialMoveNonTrivialCopy() = default;
TrivialMoveNonTrivialCopy(const TrivialMoveNonTrivialCopy&) {}
TrivialMoveNonTrivialCopy(TrivialMoveNonTrivialCopy&&) = default;
TrivialMoveNonTrivialCopy& operator=(const TrivialMoveNonTrivialCopy&) { return *this; }
TrivialMoveNonTrivialCopy& operator=(TrivialMoveNonTrivialCopy&&) = default;
};
struct TrivialCopyNonTrivialMove {
TrivialCopyNonTrivialMove() = default;
TrivialCopyNonTrivialMove(const TrivialCopyNonTrivialMove&) = default;
TrivialCopyNonTrivialMove(TrivialCopyNonTrivialMove&&) {}
TrivialCopyNonTrivialMove& operator=(const TrivialCopyNonTrivialMove&) = default;
TrivialCopyNonTrivialMove& operator=(TrivialCopyNonTrivialMove&&) { return *this; }
};
int main()
{
sink(
ImplicitTypes::ApplyTypes<DoTestsMetafunction>{},
ExplicitTypes::ApplyTypes<DoTestsMetafunction>{},
NonLiteralTypes::ApplyTypes<DoTestsMetafunction>{},
NonTrivialTypes::ApplyTypes<DoTestsMetafunction>{},
DoTestsMetafunction<TrivialMoveNonTrivialCopy, TrivialCopyNonTrivialMove>{}
);
}

20
test/libcxx/utilities/optional/version.pass.cpp
View File

@@ -1,20 +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.
//
//===----------------------------------------------------------------------===//
// <optional>
#include <optional>
#ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined
#endif
int main()
{
}