From 6ec9162bb52265ead31e1ff16bcf1aa417032753 Mon Sep 17 00:00:00 2001
From: Eric Niebler <eniebler@boost.org>
Date: Thu, 26 Jan 2017 14:17:16 -0800
Subject: [PATCH] Rework a bunch of the *tructible concepts, Movable requires
 object types (#66)

---
 include/stl2/detail/concepts/core.hpp         |   2 +-
 .../detail/concepts/object/assignable.hpp     |  11 +-
 .../stl2/detail/concepts/object/movable.hpp   |   5 +-
 .../concepts/object/move_constructible.hpp    | 131 ++++--------------
 .../detail/concepts/object/semiregular.hpp    |  14 +-
 include/stl2/detail/ebo_box.hpp               |   3 +-
 include/stl2/detail/semiregular_box.hpp       |   3 +-
 include/stl2/detail/temporary_vector.hpp      |   4 +-
 include/stl2/optional.hpp                     |   4 +-
 test/concepts/object.cpp                      |  92 ++++++------
 test/optional.cpp                             |   6 +-
 11 files changed, 99 insertions(+), 176 deletions(-)

diff --git a/include/stl2/detail/concepts/core.hpp b/include/stl2/detail/concepts/core.hpp
index 9e7467822..e7750da9f 100644
--- a/include/stl2/detail/concepts/core.hpp
+++ b/include/stl2/detail/concepts/core.hpp
@@ -27,7 +27,7 @@ STL2_OPEN_NAMESPACE {
 	concept bool _Is = _Valid<T, U, V...> && T<U, V...>::value;
 
 	template <class U, template <class...> class T, class...V>
-	concept bool _IsNot = !_Is<U, T, V...>;
+	concept bool _IsNot = _Valid<T, U, V...> && !T<U, V...>::value;
 
 	// U is a cv/ref-qualified specialization of class template T.
 	template <class U, template <class...> class T>
diff --git a/include/stl2/detail/concepts/object/assignable.hpp b/include/stl2/detail/concepts/object/assignable.hpp
index 2ed829b5c..254a223b9 100644
--- a/include/stl2/detail/concepts/object/assignable.hpp
+++ b/include/stl2/detail/concepts/object/assignable.hpp
@@ -22,18 +22,21 @@ STL2_OPEN_NAMESPACE {
 	///////////////////////////////////////////////////////////////////////////
 	// Assignable [concepts.lib.corelang.assignable]
 	//
+	// Not to spec
+	// See https://github.com/ericniebler/stl2/issues/229
 	template <class, class>
 	constexpr bool __assignable = false;
 	template <class T, class U>
 	requires
-		requires(T&& t, U&& u) {
-			STL2_EXACT_TYPE_CONSTRAINT((T&&)t = (U&&)u, T&);
+		requires(T& t, U&& u) {
+			STL2_EXACT_TYPE_CONSTRAINT(t = (U&&)u, T&);
 		}
-	constexpr bool __assignable<T, U> = true;
+	constexpr bool __assignable<T&, U> = true;
 
 	template <class T, class U>
 	concept bool Assignable() {
-		return CommonReference<const T&, const U&>() &&
+		return Same<T, decay_t<T>&>() &&
+		    CommonReference<T, const U&>() &&
 			__assignable<T, U>;
 	}
 
diff --git a/include/stl2/detail/concepts/object/movable.hpp b/include/stl2/detail/concepts/object/movable.hpp
index 469ed59bc..695c9a890 100644
--- a/include/stl2/detail/concepts/object/movable.hpp
+++ b/include/stl2/detail/concepts/object/movable.hpp
@@ -22,9 +22,12 @@ STL2_OPEN_NAMESPACE {
 	///////////////////////////////////////////////////////////////////////////
 	// Movable [concepts.lib.object.movable]
 	//
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/310
 	template <class T>
 	concept bool Movable() {
-		return MoveConstructible<T>() &&
+		return _Is<T, is_object> &&
+			MoveConstructible<T>() &&
 			Assignable<T&, T&&>() &&
 			Swappable<T&>();
 	}
diff --git a/include/stl2/detail/concepts/object/move_constructible.hpp b/include/stl2/detail/concepts/object/move_constructible.hpp
index c13a393a5..72e42667f 100644
--- a/include/stl2/detail/concepts/object/move_constructible.hpp
+++ b/include/stl2/detail/concepts/object/move_constructible.hpp
@@ -26,8 +26,8 @@ STL2_OPEN_NAMESPACE {
 	constexpr bool __addressable = false;
 	template <class T>
 		requires requires(T& t, const T& ct) {
-			STL2_EXACT_TYPE_CONSTRAINT(&t, T*);
-			STL2_EXACT_TYPE_CONSTRAINT(&ct, const T*);
+			STL2_EXACT_TYPE_CONSTRAINT(&t, add_pointer_t<T>);
+			STL2_EXACT_TYPE_CONSTRAINT(&ct, add_pointer_t<const T>);
 			// Axiom: &ct == addressof(ct)
 		}
 	constexpr bool __addressable<T> = true;
@@ -35,7 +35,7 @@ STL2_OPEN_NAMESPACE {
 	namespace ext {
 		template <class T>
 		concept bool Addressable() {
-			return __addressable<T>;
+			return _Is<T, is_object> && __addressable<T>;
 		}
 	}
 
@@ -46,122 +46,44 @@ STL2_OPEN_NAMESPACE {
 		constexpr bool Addressable<T> = true;
 	}
 
-	namespace detail {
-		template <class>
-		constexpr bool is_complete_object = false;
-
-		template <_Is<is_object> T>
-		requires
-			sizeof(T) > 0
-		constexpr bool is_complete_object<T> = true;
-
-		template <class T>
-		constexpr bool MustBeComplete() {
-			static_assert(is_complete_object<T>, "Concept check for incomplete type T.");
-			return true;
-		}
-	}
-
 	///////////////////////////////////////////////////////////////////////////
 	// Destructible [concepts.lib.object.destructible]
-	// Not to spec: is_object and accepting the parameters by reference are
-	//              necessary to prevent hard errors in the requires clause
-	//              with odd types.
-	//
-	template <class>
-	constexpr bool __destructible = false;
-	template <class T>
-		requires _Is<T, is_object> &&
-			_IsNot<T, is_array> &&
-			detail::MustBeComplete<T>() &&
-			requires(T& t, T* const p) {
-				{ t.~T() } noexcept;
-				delete p;
-				delete[] p;
-			}
-	constexpr bool __destructible<T> = true;
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/301
+	namespace models {
+		template <class T>
+		constexpr bool Destructible =
+			is_nothrow_destructible<T>::value && __addressable<T>;
+	}
 
 	template <class T>
 	concept bool Destructible() {
-		return ext::Addressable<T>() && __destructible<T>;
-	}
-
-	namespace models {
-		template <class>
-		constexpr bool Destructible = false;
-		__stl2::Destructible{T}
-		constexpr bool Destructible<T> = true;
+		return models::Destructible<T>;
 	}
 
 	///////////////////////////////////////////////////////////////////////////
 	// Constructible [concepts.lib.object.constructible]
-	// Extension: ConstructibleObject and BindableReference are user-visible.
-	//
-	namespace ext {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Waddress"
-		template <class T, class...Args>
-		constexpr bool __constructible_object = false;
-		template <class T, class...Args>
-			requires requires(Args&&...args) {
-				T{ (Args&&)args... };
-				new T{ (Args&&)args... };
-			}
-		constexpr bool __constructible_object<T, Args...> = true;
-
-		template <class T, class...Args>
-		concept bool ConstructibleObject =
-			Destructible<T>() && __constructible_object<T, Args...>;
-#pragma GCC diagnostic pop
-
-		// 20150718: Not to spec: spec is broken.
-		// FIXME: Correct wording.
-		template <class T, class...Args>
-		concept bool BindableReference =
-			_Is<T, is_reference> &&
-			// requires(Args&&...args) { T{ (Args&&)args... }; };
-			// requires(Args&&...args) { T( (Args&&)args... ); };
-			_Is<T, is_constructible, Args...>;
+	// Not to spec
+	// See https://github.com/ericniebler/stl2/issues/301
+	template <class T, class... Args>
+	concept bool Constructible() {
+		return Destructible<T>() && _Is<T, is_constructible, Args...>;
 	}
 
 	namespace models {
-		template <class T, class...Args>
-		constexpr bool ConstructibleObject = false;
-		__stl2::ext::ConstructibleObject{T, ...Args}
-		constexpr bool ConstructibleObject<T, Args...> = true;
-
-		template <class T, class...Args>
-		constexpr bool BindableReference = false;
-		__stl2::ext::BindableReference{T, ...Args}
-		constexpr bool BindableReference<T, Args...> = true;
-
-		template <class T, class...Args>
-		constexpr bool Constructible =
-			ConstructibleObject<T, Args...> ||
-			BindableReference<T, Args...>;
-	}
-
-	template <class T, class...Args>
-	concept bool Constructible() {
-		return models::Constructible<T, Args...>;
+		template <class, class...>
+		constexpr bool Constructible = false;
+		__stl2::Constructible{T, ...Args}
+		constexpr bool Constructible<T, Args...> = true;
 	}
 
 	///////////////////////////////////////////////////////////////////////////
 	// DefaultConstructible [concepts.lib.object.defaultconstructible]
-	// Note: Due to implementation variance around DR1518, may not correctly
-	// enforce the requirement that the default constructor be non-explicit.
-	//
-	template <class T>
-	constexpr bool __default_constructible = false;
-	template <class T>
-		requires requires(const std::size_t n) {
-			new T[n]{}; // not required to be equality preserving
-		}
-	constexpr bool __default_constructible<T> = true;
-
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/301
 	template <class T>
 	concept bool DefaultConstructible() {
-		return Constructible<T>() && __default_constructible<T>;
+		return Constructible<T>();
 	}
 
 	namespace models {
@@ -173,11 +95,12 @@ STL2_OPEN_NAMESPACE {
 
 	///////////////////////////////////////////////////////////////////////////
 	// MoveConstructible [concepts.lib.object.moveconstructible]
-	//
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/313
 	template <class T>
 	concept bool MoveConstructible() {
-		return Constructible<T, remove_cv_t<T>&&>() &&
-			ConvertibleTo<remove_cv_t<T>&&, T>();
+		return Constructible<T, T>() &&
+			ConvertibleTo<T, T>();
 	}
 
 	namespace models {
diff --git a/include/stl2/detail/concepts/object/semiregular.hpp b/include/stl2/detail/concepts/object/semiregular.hpp
index ba10b7542..32a2095f1 100644
--- a/include/stl2/detail/concepts/object/semiregular.hpp
+++ b/include/stl2/detail/concepts/object/semiregular.hpp
@@ -23,14 +23,18 @@
 STL2_OPEN_NAMESPACE {
 	///////////////////////////////////////////////////////////////////////////
 	// CopyConstructible [concepts.lib.object.copyconstructible]
-	//
+	// Not to spec
+	// https://github.com/ericniebler/stl2/issues/301
+	// https://github.com/ericniebler/stl2/issues/313
 	template <class T>
 	concept bool CopyConstructible() {
 		return MoveConstructible<T>() &&
-			Constructible<T, const remove_cv_t<T>&>() &&
-			ConvertibleTo<remove_cv_t<T>&, T>() &&
-			ConvertibleTo<const remove_cv_t<T>&, T>() &&
-			ConvertibleTo<const remove_cv_t<T>&&, T>();
+			Constructible<T, T&>() &&
+			Constructible<T, const T&>() &&
+			Constructible<T, const T&&>() &&
+			ConvertibleTo<T&, T>() &&
+			ConvertibleTo<const T&, T>() &&
+			ConvertibleTo<const T&&, T>();
 	}
 
 	namespace models {
diff --git a/include/stl2/detail/ebo_box.hpp b/include/stl2/detail/ebo_box.hpp
index 6959b24d7..ee5902643 100644
--- a/include/stl2/detail/ebo_box.hpp
+++ b/include/stl2/detail/ebo_box.hpp
@@ -24,6 +24,7 @@ STL2_OPEN_NAMESPACE {
 			std::is_class<T>::value && !std::is_final<T>::value;
 
 		template <Destructible T, class Tag = void>
+		requires _Is<T, is_object>
 		class ebo_box {
 		public:
 			ebo_box() = default;
@@ -62,7 +63,7 @@ STL2_OPEN_NAMESPACE {
 		};
 
 		template <Destructible T, class Tag>
-		requires __non_final_class<T>
+		requires _Is<T, is_object> && __non_final_class<T>
 		class ebo_box<T, Tag> : private T {
 		public:
 			ebo_box() = default;
diff --git a/include/stl2/detail/semiregular_box.hpp b/include/stl2/detail/semiregular_box.hpp
index 3631961cc..8244e6fa2 100644
--- a/include/stl2/detail/semiregular_box.hpp
+++ b/include/stl2/detail/semiregular_box.hpp
@@ -20,7 +20,8 @@
 
 STL2_OPEN_NAMESPACE {
 	namespace detail {
-		Destructible{T}
+		template <Destructible T>
+		requires _Is<T, is_object>
 		class semiregular_box {
 		public:
 			semiregular_box() = default;
diff --git a/include/stl2/detail/temporary_vector.hpp b/include/stl2/detail/temporary_vector.hpp
index af25bc558..95c23d5f4 100644
--- a/include/stl2/detail/temporary_vector.hpp
+++ b/include/stl2/detail/temporary_vector.hpp
@@ -90,6 +90,7 @@ STL2_OPEN_NAMESPACE {
 		};
 
 		template <Destructible T>
+		requires _Is<T, is_object>
 		class temporary_vector {
 			T* begin_ = nullptr;
 			T* end_ = nullptr;
@@ -159,7 +160,8 @@ STL2_OPEN_NAMESPACE {
 			{ emplace_back(__stl2::move(t)); }
 		};
 
-		Destructible{T}
+		template <Destructible T>
+		requires _Is<T, is_object>
 		temporary_vector<T> make_temporary_vector(temporary_buffer<T>& buf) {
 			return {buf};
 		}
diff --git a/include/stl2/optional.hpp b/include/stl2/optional.hpp
index 3e60d5380..92e3d9a6d 100644
--- a/include/stl2/optional.hpp
+++ b/include/stl2/optional.hpp
@@ -46,7 +46,7 @@ STL2_OPEN_NAMESPACE {
 	};
 
 	template <class T>
-	requires models::Destructible<T>
+	requires models::Destructible<T> && _Is<T, is_object>
 	class optional;
 
 	namespace __optional {
@@ -264,7 +264,7 @@ STL2_OPEN_NAMESPACE {
 	} // namespace ext
 
 	template <class T>
-	requires models::Destructible<T>
+	requires models::Destructible<T> && _Is<T, is_object>
 	class optional
 	: public meta::_t<ext::optional_storage<T>>
 	, detail::smf_control::copy<models::CopyConstructible<T>>
diff --git a/test/concepts/object.cpp b/test/concepts/object.cpp
index a49346e58..87f0942c1 100644
--- a/test/concepts/object.cpp
+++ b/test/concepts/object.cpp
@@ -16,14 +16,6 @@ namespace models {
 template <class T>
 constexpr bool Destructible = ranges::Destructible<T>();
 
-template <class T, class...Args>
-constexpr bool ConstructibleObject =
-	ranges::concepts::models<ranges::concepts::ConstructibleObject, T, Args...>();
-
-template <class T, class...Args>
-constexpr bool BindableReference =
-	ranges::concepts::models<ranges::concepts::BindableReference, T, Args...>();
-
 template <class T, class...Args>
 constexpr bool Constructible = ranges::Constructible<T, Args...>();
 
@@ -82,10 +74,18 @@ struct indestructible {
 	~indestructible() = delete;
 };
 
+struct throwing_destructor {
+	~throwing_destructor() noexcept(false);
+};
+
 struct explicit_default {
 	explicit explicit_default() {}
 };
 
+struct deleted_default {
+	deleted_default() = delete;
+};
+
 struct explicit_move {
 	explicit_move() = default;
 	explicit explicit_move(explicit_move&&) = default;
@@ -133,17 +133,19 @@ struct XXX
 CONCEPT_ASSERT(models::Destructible<int>);
 CONCEPT_ASSERT(models::Destructible<const int>);
 CONCEPT_ASSERT(!models::Destructible<void>);
-CONCEPT_ASSERT(!models::Destructible<int&>);
+CONCEPT_ASSERT(models::Destructible<int&>);
 CONCEPT_ASSERT(!models::Destructible<void()>);
 CONCEPT_ASSERT(models::Destructible<void(*)()>);
-CONCEPT_ASSERT(!models::Destructible<void(&)()>);
+CONCEPT_ASSERT(models::Destructible<void(&)()>);
 CONCEPT_ASSERT(!models::Destructible<int[]>);
-CONCEPT_ASSERT(!models::Destructible<int[2]>);
+CONCEPT_ASSERT(models::Destructible<int[2]>);
 CONCEPT_ASSERT(models::Destructible<int(*)[2]>);
-CONCEPT_ASSERT(!models::Destructible<int(&)[2]>);
+CONCEPT_ASSERT(!models::Addressable<int(&)[2]>);
+CONCEPT_ASSERT(models::Destructible<int(&)[2]>);
 CONCEPT_ASSERT(models::Destructible<moveonly>);
 CONCEPT_ASSERT(models::Destructible<nonmovable>);
 CONCEPT_ASSERT(!models::Destructible<indestructible>);
+CONCEPT_ASSERT(!models::Destructible<throwing_destructor>);
 
 #if 0
 // ill-formed (hard error)
@@ -162,17 +164,11 @@ CONCEPT_ASSERT(!models::Constructible<int const&>);
 CONCEPT_ASSERT(!models::Constructible<int()>);
 CONCEPT_ASSERT(!models::Constructible<int(&)()>);
 CONCEPT_ASSERT(!models::Constructible<int[]>);
-CONCEPT_ASSERT(!models::Constructible<int[5]>);
+CONCEPT_ASSERT(models::Constructible<int[5]>);
 CONCEPT_ASSERT(!models::Constructible<nondefaultconstructible>);
 CONCEPT_ASSERT(models::Constructible<int const(&)[5], int(&)[5]>);
 CONCEPT_ASSERT(!models::Constructible<int, int(&)[3]>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<int, int>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, int&>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, int&&>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, const int>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, const int&>);
-CONCEPT_ASSERT(models::ConstructibleObject<int, const int&&>);
 CONCEPT_ASSERT(models::Constructible<int, int>);
 CONCEPT_ASSERT(models::Constructible<int, int&>);
 CONCEPT_ASSERT(models::Constructible<int, int&&>);
@@ -180,12 +176,6 @@ CONCEPT_ASSERT(models::Constructible<int, const int>);
 CONCEPT_ASSERT(models::Constructible<int, const int&>);
 CONCEPT_ASSERT(models::Constructible<int, const int&&>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, copyable>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, copyable&>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, copyable&&>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, const copyable>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, const copyable&>);
-CONCEPT_ASSERT(models::ConstructibleObject<copyable, const copyable&&>);
 CONCEPT_ASSERT(models::Constructible<copyable, copyable>);
 CONCEPT_ASSERT(models::Constructible<copyable, copyable&>);
 CONCEPT_ASSERT(models::Constructible<copyable, copyable&&>);
@@ -193,12 +183,6 @@ CONCEPT_ASSERT(models::Constructible<copyable, const copyable>);
 CONCEPT_ASSERT(models::Constructible<copyable, const copyable&>);
 CONCEPT_ASSERT(models::Constructible<copyable, const copyable&&>);
 
-CONCEPT_ASSERT(!models::BindableReference<int&, int>);
-CONCEPT_ASSERT(models::BindableReference<int&, int&>);
-CONCEPT_ASSERT(!models::BindableReference<int&, int&&>);
-CONCEPT_ASSERT(!models::BindableReference<int&, const int>);
-CONCEPT_ASSERT(!models::BindableReference<int&, const int&>);
-CONCEPT_ASSERT(!models::BindableReference<int&, const int&&>);
 CONCEPT_ASSERT(!models::Constructible<int&, int>);
 CONCEPT_ASSERT(models::Constructible<int&, int&>);
 CONCEPT_ASSERT(!models::Constructible<int&, int&&>);
@@ -206,12 +190,6 @@ CONCEPT_ASSERT(!models::Constructible<int&, const int>);
 CONCEPT_ASSERT(!models::Constructible<int&, const int&>);
 CONCEPT_ASSERT(!models::Constructible<int&, const int&&>);
 
-CONCEPT_ASSERT(models::BindableReference<const int&, int>);
-CONCEPT_ASSERT(models::BindableReference<const int&, int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&, int&&>);
-CONCEPT_ASSERT(models::BindableReference<const int&, const int>);
-CONCEPT_ASSERT(models::BindableReference<const int&, const int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&, const int&&>);
 CONCEPT_ASSERT(models::Constructible<const int&, int>);
 CONCEPT_ASSERT(models::Constructible<const int&, int&>);
 CONCEPT_ASSERT(models::Constructible<const int&, int&&>);
@@ -219,12 +197,6 @@ CONCEPT_ASSERT(models::Constructible<const int&, const int>);
 CONCEPT_ASSERT(models::Constructible<const int&, const int&>);
 CONCEPT_ASSERT(models::Constructible<const int&, const int&&>);
 
-CONCEPT_ASSERT(models::BindableReference<int&&, int>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, int&>);
-CONCEPT_ASSERT(models::BindableReference<int&&, int&&>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, const int>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, const int&>);
-CONCEPT_ASSERT(!models::BindableReference<int&&, const int&&>);
 CONCEPT_ASSERT(models::Constructible<int&&, int>);
 CONCEPT_ASSERT(!models::Constructible<int&&, int&>);
 CONCEPT_ASSERT(models::Constructible<int&&, int&&>);
@@ -232,12 +204,6 @@ CONCEPT_ASSERT(!models::Constructible<int&&, const int>);
 CONCEPT_ASSERT(!models::Constructible<int&&, const int&>);
 CONCEPT_ASSERT(!models::Constructible<int&&, const int&&>);
 
-CONCEPT_ASSERT(models::BindableReference<const int&&, int>);
-CONCEPT_ASSERT(!models::BindableReference<const int&&, int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&&, int&&>);
-CONCEPT_ASSERT(models::BindableReference<const int&&, const int>);
-CONCEPT_ASSERT(!models::BindableReference<const int&&, const int&>);
-CONCEPT_ASSERT(models::BindableReference<const int&&, const int&&>);
 CONCEPT_ASSERT(models::Constructible<const int&&, int>);
 CONCEPT_ASSERT(!models::Constructible<const int&&, int&>);
 CONCEPT_ASSERT(models::Constructible<const int&&, int&&>);
@@ -256,7 +222,7 @@ CONCEPT_ASSERT(!models::DefaultConstructible<int(&)()>);
 CONCEPT_ASSERT(models::DefaultConstructible<double>);
 CONCEPT_ASSERT(!models::DefaultConstructible<void>);
 CONCEPT_ASSERT(!models::DefaultConstructible<int[]>);
-CONCEPT_ASSERT(!models::DefaultConstructible<int[2]>);
+CONCEPT_ASSERT(models::DefaultConstructible<int[2]>);
 CONCEPT_ASSERT(!models::DefaultConstructible<nondefaultconstructible>);
 
 // It's hard to catch explicit default constructors, see
@@ -264,6 +230,7 @@ CONCEPT_ASSERT(!models::DefaultConstructible<nondefaultconstructible>);
 // CONCEPT_ASSERT(!models::DefaultConstructible<explicit_default>);
 CONCEPT_ASSERT(models::DefaultConstructible<explicit_move>);
 CONCEPT_ASSERT(models::DefaultConstructible<explicit_copy>);
+CONCEPT_ASSERT(!models::DefaultConstructible<deleted_default>);
 
 CONCEPT_ASSERT(!models::MoveConstructible<void>);
 CONCEPT_ASSERT(models::MoveConstructible<int>);
@@ -275,7 +242,6 @@ CONCEPT_ASSERT(models::MoveConstructible<int &&>);
 CONCEPT_ASSERT(models::MoveConstructible<const int &>);
 CONCEPT_ASSERT(models::MoveConstructible<const int &&>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<moveonly, moveonly>);
 CONCEPT_ASSERT(models::Constructible<moveonly, moveonly>);
 CONCEPT_ASSERT(models::MoveConstructible<copyable>);
 CONCEPT_ASSERT(models::MoveConstructible<moveonly>);
@@ -310,6 +276,22 @@ CONCEPT_ASSERT(!models::CopyConstructible<nonmovable &&>);
 CONCEPT_ASSERT(models::CopyConstructible<const nonmovable &>);
 CONCEPT_ASSERT(!models::CopyConstructible<const nonmovable &&>);
 
+// https://github.com/ericniebler/stl2/issues/301
+struct not_mutable_ref {
+	not_mutable_ref() = default;
+	not_mutable_ref(const not_mutable_ref&) = default;
+	not_mutable_ref(not_mutable_ref&&) = default;
+	not_mutable_ref(not_mutable_ref&) = delete;
+};
+struct not_const_ref_ref {
+	not_const_ref_ref() = default;
+	not_const_ref_ref(const not_const_ref_ref&) = default;
+	not_const_ref_ref(not_const_ref_ref&&) = default;
+	not_const_ref_ref(const not_const_ref_ref&&) = delete;
+};
+CONCEPT_ASSERT(!models::CopyConstructible<not_mutable_ref>);
+CONCEPT_ASSERT(!models::CopyConstructible<not_const_ref_ref>);
+
 CONCEPT_ASSERT(models::Movable<int>);
 CONCEPT_ASSERT(!models::Movable<const int>);
 CONCEPT_ASSERT(models::Movable<double>);
@@ -354,12 +336,16 @@ CONCEPT_ASSERT(!models::Regular<copyonly>);
 CONCEPT_ASSERT(!models::Regular<explicit_move>);
 CONCEPT_ASSERT(!models::Regular<explicit_copy>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<std::initializer_list<int>>);
 CONCEPT_ASSERT(models::Constructible<std::initializer_list<int>>);
 CONCEPT_ASSERT(models::DefaultConstructible<std::initializer_list<int>>);
 
-CONCEPT_ASSERT(models::ConstructibleObject<int*>);
 CONCEPT_ASSERT(models::Constructible<int*>);
 CONCEPT_ASSERT(models::DefaultConstructible<int*>);
 
+// https://github.com/ericniebler/stl2/issues/301
+CONCEPT_ASSERT(!models::Constructible<int&, long&>);
+
+// https://github.com/ericniebler/stl2/issues/310
+CONCEPT_ASSERT(!models::Movable<int&&>);
+
 int main() {}
diff --git a/test/optional.cpp b/test/optional.cpp
index 147518360..fb81fa8f0 100644
--- a/test/optional.cpp
+++ b/test/optional.cpp
@@ -226,11 +226,11 @@ int main() {
 		static_assert(models::Constructible<OL, OI>);
 		static_assert(models::ConvertibleTo<OI, OL>);
 
-		static_assert(!models::ConvertibleTo<OL, OI>);
-		static_assert(!models::Constructible<OI, OL>);
+		static_assert(models::ConvertibleTo<OL, OI>);
+		static_assert(models::Constructible<OI, OL>);
 
 		static_assert(models::ConvertibleTo<long, int>);
-		static_assert(!models::Constructible<int, long>); // narrowing
+		static_assert(models::Constructible<int, long>);
 
 		static_assert(!models::Swappable<OI&, OL&>);
 	}