[libcxx-commits] [libcxx] [libc++][hardening] Constrain construction for `__{bounded, wrap}_iter` (PR #115271)
A. Jiang via libcxx-commits
libcxx-commits at lists.llvm.org
Fri Nov 8 09:37:40 PST 2024
https://github.com/frederick-vs-ja updated https://github.com/llvm/llvm-project/pull/115271
>From 78dee26eb5a3bc074ea0269e2e33f1c12667df94 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Thu, 7 Nov 2024 16:09:59 +0800
Subject: [PATCH 1/3] [libc++][hardening] Constrain construction and use
`static_assert`
... for `__{bounded.wrap}_iter`.
This PR restricts construction to cases where reference types of
source/destination iterators are (`T&`, `T&`) or (`T&`, `const T&`) (
where T can be const).
We can't `static_assert` `__libcpp_is_contiguous_iterator` for
`__wrap_iter` currently because `__wrap_iter` is also used for wrapping
user-defined fancy pointers.
---
libcxx/include/__iterator/bounded_iter.h | 20 +++++--
libcxx/include/__iterator/wrap_iter.h | 17 ++++--
.../iterators/contiguous_iterators.verify.cpp | 22 ++++++++
.../wrap.bounded.iter.conv.compile.pass.cpp | 53 +++++++++++++++++++
4 files changed, 106 insertions(+), 6 deletions(-)
create mode 100644 libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp
create mode 100644 libcxx/test/libcxx/iterators/wrap.bounded.iter.conv.compile.pass.cpp
diff --git a/libcxx/include/__iterator/bounded_iter.h b/libcxx/include/__iterator/bounded_iter.h
index 5a86bd98e71940..7b14d765ce826a 100644
--- a/libcxx/include/__iterator/bounded_iter.h
+++ b/libcxx/include/__iterator/bounded_iter.h
@@ -16,9 +16,14 @@
#include <__config>
#include <__iterator/iterator_traits.h>
#include <__memory/pointer_traits.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/disjunction.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_constructible.h>
#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/make_const_lvalue_ref.h>
#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -47,8 +52,11 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// pointer, it is undefined at the language level (see [expr.add]). If
// bounded iterators exhibited this undefined behavior, we risk compiler
// optimizations deleting non-redundant bounds checks.
-template <class _Iterator, class = __enable_if_t< __libcpp_is_contiguous_iterator<_Iterator>::value > >
+template <class _Iterator>
struct __bounded_iter {
+ static_assert(__libcpp_is_contiguous_iterator<_Iterator>::value,
+ "Only contiguous iterators can be adapted by __bounded_iter.");
+
using value_type = typename iterator_traits<_Iterator>::value_type;
using difference_type = typename iterator_traits<_Iterator>::difference_type;
using pointer = typename iterator_traits<_Iterator>::pointer;
@@ -67,7 +75,13 @@ struct __bounded_iter {
_LIBCPP_HIDE_FROM_ABI __bounded_iter(__bounded_iter const&) = default;
_LIBCPP_HIDE_FROM_ABI __bounded_iter(__bounded_iter&&) = default;
- template <class _OtherIterator, __enable_if_t< is_convertible<_OtherIterator, _Iterator>::value, int> = 0>
+ template < class _OtherIterator,
+ __enable_if_t<
+ _And<is_constructible<_Iterator, const _OtherIterator&>,
+ is_convertible<const _OtherIterator&, _Iterator>,
+ _Or<is_same<reference, __iter_reference<_OtherIterator> >,
+ is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIterator> > > > >::value,
+ int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bounded_iter(__bounded_iter<_OtherIterator> const& __other) _NOEXCEPT
: __current_(__other.__current_),
__begin_(__other.__begin_),
@@ -247,7 +261,7 @@ struct __bounded_iter {
private:
template <class>
friend struct pointer_traits;
- template <class, class>
+ template <class>
friend struct __bounded_iter;
_Iterator __current_; // current iterator
_Iterator __begin_, __end_; // valid range represented as [begin, end]
diff --git a/libcxx/include/__iterator/wrap_iter.h b/libcxx/include/__iterator/wrap_iter.h
index 2856833e600798..352e94630d8551 100644
--- a/libcxx/include/__iterator/wrap_iter.h
+++ b/libcxx/include/__iterator/wrap_iter.h
@@ -17,9 +17,14 @@
#include <__iterator/iterator_traits.h>
#include <__memory/addressof.h>
#include <__memory/pointer_traits.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/disjunction.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_constructible.h>
#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/make_const_lvalue_ref.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
@@ -45,9 +50,15 @@ class __wrap_iter {
public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT : __i_() {}
- template <class _Up, __enable_if_t<is_convertible<_Up, iterator_type>::value, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter(const __wrap_iter<_Up>& __u) _NOEXCEPT
- : __i_(__u.base()) {}
+ template <
+ class _OtherIter,
+ __enable_if_t< _And<is_constructible<_Iter, const _OtherIter&>,
+ is_convertible<const _OtherIter&, _Iter>,
+ _Or<is_same<reference, __iter_reference<_OtherIter> >,
+ is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIter> > > > >::value,
+ int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter(const __wrap_iter<_OtherIter>& __u) _NOEXCEPT
+ : __i_(__u.__i_) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator*() const _NOEXCEPT { return *__i_; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pointer operator->() const _NOEXCEPT {
return std::__to_address(__i_);
diff --git a/libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp b/libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp
new file mode 100644
index 00000000000000..c211104bef7273
--- /dev/null
+++ b/libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp
@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+
+// <iterator>
+
+// __bounded_iter<_Iter>
+
+// Verify that __bounded_iter does not accept non-contiguous iterators as determined by __libcpp_is_contiguous_iterator.
+// static_assert should be used, see https://github.com/llvm/llvm-project/issues/115002.
+// __wrap_iter cannot be so handled because it may directly wrap user-defined fancy pointers in libc++'s vector.
+
+#include <deque>
+#include <vector>
+
+// expected-error-re@*:* {{static assertion failed due to requirement {{.*}}Only contiguous iterators can be adapted by __bounded_iter.}}
+std::__bounded_iter<std::deque<int>::iterator> bit;
diff --git a/libcxx/test/libcxx/iterators/wrap.bounded.iter.conv.compile.pass.cpp b/libcxx/test/libcxx/iterators/wrap.bounded.iter.conv.compile.pass.cpp
new file mode 100644
index 00000000000000..4fd08f03562041
--- /dev/null
+++ b/libcxx/test/libcxx/iterators/wrap.bounded.iter.conv.compile.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+
+// <iterator>
+
+// __bounded_iter<_Iter>
+// __wrap_iter<_Iter>
+
+// Verify that libc++-wrapped iterators do not permit slicing conversion or construction.
+
+#include <array>
+#include <vector>
+#include <span>
+#include <type_traits>
+
+#include "test_macros.h"
+
+struct Base {};
+struct Derived : Base {};
+
+#ifdef _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY
+static_assert(!std::is_convertible<std::array<Derived, 1>::iterator, std::array<Base, 1>::iterator>::value, "");
+static_assert(!std::is_convertible<std::array<Derived, 1>::iterator, std::array<Base, 1>::const_iterator>::value, "");
+static_assert(!std::is_convertible<std::array<Derived, 1>::const_iterator, std::array<Base, 1>::const_iterator>::value,
+ "");
+static_assert(!std::is_constructible<std::array<Base, 1>::iterator, std::array<Derived, 1>::iterator>::value, "");
+static_assert(!std::is_constructible<std::array<Base, 1>::const_iterator, std::array<Derived, 1>::iterator>::value, "");
+static_assert(
+ !std::is_constructible<std::array<Base, 1>::const_iterator, std::array<Derived, 1>::const_iterator>::value, "");
+#endif
+
+static_assert(!std::is_convertible<std::vector<Derived>::iterator, std::vector<Base>::iterator>::value, "");
+static_assert(!std::is_convertible<std::vector<Derived>::iterator, std::vector<Base>::const_iterator>::value, "");
+static_assert(!std::is_convertible<std::vector<Derived>::const_iterator, std::vector<Base>::const_iterator>::value, "");
+static_assert(!std::is_constructible<std::vector<Base>::iterator, std::vector<Derived>::iterator>::value, "");
+static_assert(!std::is_constructible<std::vector<Base>::const_iterator, std::vector<Derived>::iterator>::value, "");
+static_assert(!std::is_constructible<std::vector<Base>::const_iterator, std::vector<Derived>::const_iterator>::value,
+ "");
+
+#if TEST_STD_VER >= 20
+static_assert(!std::is_convertible_v<std::span<Derived>::iterator, std::span<Base>::iterator>);
+static_assert(!std::is_convertible_v<std::span<Derived>::iterator, std::span<const Base>::iterator>);
+static_assert(!std::is_convertible_v<std::span<const Derived>::iterator, std::span<Base>::iterator>);
+static_assert(!std::is_constructible_v<std::span<Base>::iterator, std::span<Derived>::iterator>);
+static_assert(!std::is_constructible_v<std::span<Base>::iterator, std::span<const Derived>::iterator>);
+static_assert(!std::is_constructible_v<std::span<const Base>::iterator, std::span<const Derived>::iterator>);
+#endif
>From a1b9e604b98ed99fe3a0c5f75bde20ca3494c74b Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Thu, 7 Nov 2024 19:44:22 +0800
Subject: [PATCH 2/3] Revert `static_assert`
---
libcxx/include/__iterator/bounded_iter.h | 7 ++----
.../iterators/contiguous_iterators.verify.cpp | 22 -------------------
2 files changed, 2 insertions(+), 27 deletions(-)
delete mode 100644 libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp
diff --git a/libcxx/include/__iterator/bounded_iter.h b/libcxx/include/__iterator/bounded_iter.h
index 7b14d765ce826a..788a1cd0a85e21 100644
--- a/libcxx/include/__iterator/bounded_iter.h
+++ b/libcxx/include/__iterator/bounded_iter.h
@@ -52,11 +52,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
// pointer, it is undefined at the language level (see [expr.add]). If
// bounded iterators exhibited this undefined behavior, we risk compiler
// optimizations deleting non-redundant bounds checks.
-template <class _Iterator>
+template <class _Iterator, class = __enable_if_t< __libcpp_is_contiguous_iterator<_Iterator>::value > >
struct __bounded_iter {
- static_assert(__libcpp_is_contiguous_iterator<_Iterator>::value,
- "Only contiguous iterators can be adapted by __bounded_iter.");
-
using value_type = typename iterator_traits<_Iterator>::value_type;
using difference_type = typename iterator_traits<_Iterator>::difference_type;
using pointer = typename iterator_traits<_Iterator>::pointer;
@@ -261,7 +258,7 @@ struct __bounded_iter {
private:
template <class>
friend struct pointer_traits;
- template <class>
+ template <class, class>
friend struct __bounded_iter;
_Iterator __current_; // current iterator
_Iterator __begin_, __end_; // valid range represented as [begin, end]
diff --git a/libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp b/libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp
deleted file mode 100644
index c211104bef7273..00000000000000
--- a/libcxx/test/libcxx/iterators/contiguous_iterators.verify.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-
-// <iterator>
-
-// __bounded_iter<_Iter>
-
-// Verify that __bounded_iter does not accept non-contiguous iterators as determined by __libcpp_is_contiguous_iterator.
-// static_assert should be used, see https://github.com/llvm/llvm-project/issues/115002.
-// __wrap_iter cannot be so handled because it may directly wrap user-defined fancy pointers in libc++'s vector.
-
-#include <deque>
-#include <vector>
-
-// expected-error-re@*:* {{static assertion failed due to requirement {{.*}}Only contiguous iterators can be adapted by __bounded_iter.}}
-std::__bounded_iter<std::deque<int>::iterator> bit;
>From a40207a497edcd8b91d28a5f6aa432e2c9afef81 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34 at live.cn>
Date: Sat, 9 Nov 2024 01:35:43 +0800
Subject: [PATCH 3/3] Address review comments
- Drop uses of `is_constructible`.
- Generalize to `__static_bounded_iter`.
- Improve conditional compilation in test.
---
libcxx/include/__iterator/bounded_iter.h | 8 ++---
.../include/__iterator/static_bounded_iter.h | 11 ++++++-
libcxx/include/__iterator/wrap_iter.h | 8 ++---
...ontiguous_iterators.conv.compile.pass.cpp} | 32 ++++++++++++-------
4 files changed, 37 insertions(+), 22 deletions(-)
rename libcxx/test/libcxx/iterators/{wrap.bounded.iter.conv.compile.pass.cpp => contiguous_iterators.conv.compile.pass.cpp} (65%)
diff --git a/libcxx/include/__iterator/bounded_iter.h b/libcxx/include/__iterator/bounded_iter.h
index 44b330ec84b3a8..d12750d1f81ac7 100644
--- a/libcxx/include/__iterator/bounded_iter.h
+++ b/libcxx/include/__iterator/bounded_iter.h
@@ -20,7 +20,6 @@
#include <__type_traits/disjunction.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_constructible.h>
#include <__type_traits/is_convertible.h>
#include <__type_traits/is_same.h>
#include <__type_traits/make_const_lvalue_ref.h>
@@ -77,10 +76,9 @@ struct __bounded_iter {
template < class _OtherIterator,
__enable_if_t<
- _And<is_constructible<_Iterator, const _OtherIterator&>,
- is_convertible<const _OtherIterator&, _Iterator>,
- _Or<is_same<reference, __iter_reference<_OtherIterator> >,
- is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIterator> > > > >::value,
+ _And< is_convertible<const _OtherIterator&, _Iterator>,
+ _Or<is_same<reference, __iter_reference<_OtherIterator> >,
+ is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIterator> > > > >::value,
int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bounded_iter(__bounded_iter<_OtherIterator> const& __other) _NOEXCEPT
: __current_(__other.__current_),
diff --git a/libcxx/include/__iterator/static_bounded_iter.h b/libcxx/include/__iterator/static_bounded_iter.h
index 9794c220384f55..a570c12c9e0894 100644
--- a/libcxx/include/__iterator/static_bounded_iter.h
+++ b/libcxx/include/__iterator/static_bounded_iter.h
@@ -17,9 +17,13 @@
#include <__cstddef/size_t.h>
#include <__iterator/iterator_traits.h>
#include <__memory/pointer_traits.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/disjunction.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/integral_constant.h>
#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/make_const_lvalue_ref.h>
#include <__utility/move.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -93,7 +97,12 @@ struct __static_bounded_iter {
_LIBCPP_HIDE_FROM_ABI __static_bounded_iter(__static_bounded_iter const&) = default;
_LIBCPP_HIDE_FROM_ABI __static_bounded_iter(__static_bounded_iter&&) = default;
- template <class _OtherIterator, __enable_if_t<is_convertible<_OtherIterator, _Iterator>::value, int> = 0>
+ template <class _OtherIterator,
+ __enable_if_t<
+ _And< is_convertible<const _OtherIterator&, _Iterator>,
+ _Or<is_same<reference, __iter_reference<_OtherIterator> >,
+ is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIterator> > > > >::value,
+ int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
__static_bounded_iter(__static_bounded_iter<_OtherIterator, _Size> const& __other) _NOEXCEPT
: __storage_(__other.__storage_.__current(), __other.__storage_.__begin()) {}
diff --git a/libcxx/include/__iterator/wrap_iter.h b/libcxx/include/__iterator/wrap_iter.h
index 352e94630d8551..966c4675b7049a 100644
--- a/libcxx/include/__iterator/wrap_iter.h
+++ b/libcxx/include/__iterator/wrap_iter.h
@@ -21,7 +21,6 @@
#include <__type_traits/disjunction.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_constructible.h>
#include <__type_traits/is_convertible.h>
#include <__type_traits/is_same.h>
#include <__type_traits/make_const_lvalue_ref.h>
@@ -52,10 +51,9 @@ class __wrap_iter {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT : __i_() {}
template <
class _OtherIter,
- __enable_if_t< _And<is_constructible<_Iter, const _OtherIter&>,
- is_convertible<const _OtherIter&, _Iter>,
- _Or<is_same<reference, __iter_reference<_OtherIter> >,
- is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIter> > > > >::value,
+ __enable_if_t< _And< is_convertible<const _OtherIter&, _Iter>,
+ _Or<is_same<reference, __iter_reference<_OtherIter> >,
+ is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIter> > > > >::value,
int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter(const __wrap_iter<_OtherIter>& __u) _NOEXCEPT
: __i_(__u.__i_) {}
diff --git a/libcxx/test/libcxx/iterators/wrap.bounded.iter.conv.compile.pass.cpp b/libcxx/test/libcxx/iterators/contiguous_iterators.conv.compile.pass.cpp
similarity index 65%
rename from libcxx/test/libcxx/iterators/wrap.bounded.iter.conv.compile.pass.cpp
rename to libcxx/test/libcxx/iterators/contiguous_iterators.conv.compile.pass.cpp
index 4fd08f03562041..372559594143ef 100644
--- a/libcxx/test/libcxx/iterators/wrap.bounded.iter.conv.compile.pass.cpp
+++ b/libcxx/test/libcxx/iterators/contiguous_iterators.conv.compile.pass.cpp
@@ -10,30 +10,40 @@
// <iterator>
// __bounded_iter<_Iter>
+// __static_bounded_iter<_Iter>
// __wrap_iter<_Iter>
// Verify that libc++-wrapped iterators do not permit slicing conversion or construction.
#include <array>
-#include <vector>
#include <span>
#include <type_traits>
+#include <vector>
#include "test_macros.h"
struct Base {};
struct Derived : Base {};
-#ifdef _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY
-static_assert(!std::is_convertible<std::array<Derived, 1>::iterator, std::array<Base, 1>::iterator>::value, "");
-static_assert(!std::is_convertible<std::array<Derived, 1>::iterator, std::array<Base, 1>::const_iterator>::value, "");
-static_assert(!std::is_convertible<std::array<Derived, 1>::const_iterator, std::array<Base, 1>::const_iterator>::value,
- "");
-static_assert(!std::is_constructible<std::array<Base, 1>::iterator, std::array<Derived, 1>::iterator>::value, "");
-static_assert(!std::is_constructible<std::array<Base, 1>::const_iterator, std::array<Derived, 1>::iterator>::value, "");
-static_assert(
- !std::is_constructible<std::array<Base, 1>::const_iterator, std::array<Derived, 1>::const_iterator>::value, "");
-#endif
+template <class B, class D, bool = std::is_pointer<typename std::array<B, 1>::iterator>::value>
+struct test_array_helper : std::true_type {
+ typedef typename std::array<B, 1>::iterator BaseIter;
+ typedef typename std::array<D, 1>::iterator DerivedIter;
+ typedef typename std::array<B, 1>::const_iterator BaseConstIter;
+ typedef typename std::array<D, 1>::const_iterator DerivedConstIter;
+
+ static_assert(!std::is_convertible<DerivedIter, BaseIter>::value, "");
+ static_assert(!std::is_convertible<DerivedIter, BaseConstIter>::value, "");
+ static_assert(!std::is_convertible<DerivedConstIter, BaseConstIter>::value, "");
+ static_assert(!std::is_constructible<BaseIter, DerivedIter>::value, "");
+ static_assert(!std::is_constructible<BaseConstIter, DerivedIter>::value, "");
+ static_assert(!std::is_constructible<BaseConstIter, DerivedConstIter>::value, "");
+};
+
+template <class B, class D>
+struct test_array_helper<B, D, true> : std::true_type {};
+
+static_assert(test_array_helper<Base, Derived>::value, "");
static_assert(!std::is_convertible<std::vector<Derived>::iterator, std::vector<Base>::iterator>::value, "");
static_assert(!std::is_convertible<std::vector<Derived>::iterator, std::vector<Base>::const_iterator>::value, "");
More information about the libcxx-commits
mailing list