[libc++] static_assert preconditions in vector

[philnik]

Summary

This improves the diagnostics when instantiating member functions with types that don't meet the preconditions. For example, this error message now gets produced when instantiating resize() with a type that's not copy constructible:

In file included from erros.cpp:1:
/home/nikolas/llvm-projects/libcxx/build/include/c++/v1/vector:1886:5: error: static assertion failed due to requirement '__is_cpp17_copy_insertable<std::allocator<NotCopyInsertable>>::value': value_type has to be Cpp17CopyInsertable
    static_assert(__is_cpp17_copy_insertable<_Allocator>::value, "value_type has to be Cpp17CopyInsertable");
    ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
erros.cpp:10:5: note: in instantiation of member function 'std::vector<NotCopyInsertable>::resize' requested here
  v.resize(1, NotCopyInsertable(1));
    ^
In file included from erros.cpp:1:
In file included from /home/nikolas/llvm-projects/libcxx/build/include/c++/v1/vector:299:
In file included from /home/nikolas/llvm-projects/libcxx/build/include/c++/v1/__split_buffer:21:
/home/nikolas/llvm-projects/libcxx/build/include/c++/v1/__memory/allocator.h:165:28: error: call to implicitly-deleted copy constructor of 'NotCopyInsertable'
        ::new ((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
                           ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/nikolas/llvm-projects/libcxx/build/include/c++/v1/__memory/allocator_traits.h:292:13: note: in instantiation of function template specialization 'std::allocator<NotCopyInsertable>::construct<NotCopyInsertable, const NotCopyInsertable &>' requested here
        __a.construct(__p, _VSTD::forward<_Args>(__args)...);
            ^
/home/nikolas/llvm-projects/libcxx/build/include/c++/v1/vector:1000:25: note: in instantiation of function template specialization 'std::allocator_traits<std::allocator<NotCopyInsertable>>::construct<NotCopyInsertable, const NotCopyInsertable &, void>' requested here
        __alloc_traits::construct(this->__alloc(), std::__to_address(__pos), __x);
                        ^
/home/nikolas/llvm-projects/libcxx/build/include/c++/v1/vector:1043:15: note: in instantiation of member function 'std::vector<NotCopyInsertable>::__construct_at_end' requested here
        this->__construct_at_end(__n, __x);
              ^
/home/nikolas/llvm-projects/libcxx/build/include/c++/v1/vector:1889:15: note: in instantiation of member function 'std::vector<NotCopyInsertable>::__append' requested here
        this->__append(__sz - __cs, __x);
              ^
erros.cpp:10:5: note: in instantiation of member function 'std::vector<NotCopyInsertable>::resize' requested here
  v.resize(1, NotCopyInsertable(1));
    ^
erros.cpp:5:3: note: copy constructor is implicitly deleted because 'NotCopyInsertable' has a user-declared move constructor
  NotCopyInsertable(NotCopyInsertable&&);
  ^
2 errors generated.

Clangd emits the first error with this patch and the second error without.

[ldionne]

libcxx/include/__memory/allocator_traits.h

370–371

Let's add a comment like:

// Implement named requirements from http://eel.is/c++draft/container.alloc.reqmts

And then, while we're at it, we should also implement Cpp17EmplaceConstructible and other named requirements, and probably check them in the places where they are mandated.

371–392

Observation: our previous definition was wrong, since it looked for a Allocator.construct() method only, and the Cpp17FooInsertable requirements are based on allocator_traits<Alloc>::construct. Your implementation does it the right way. Can you please add a test that would fail if we did not do it correctly? This should be possible by creating an allocator A without a .construct() method, but defining allocator_traits<A>::construct (or, in C++<something>, allocator_traits::construct might even be defined for you automatically, although the test should work in older standards too so maybe don't rely on that).

423

For LLVM 15, I would be tempted to go and remove the static assert in __uninitialized_allocator_move_if_noexcept since it is wrong (due to checking Allocator.construct() instead of allocator_traits::construct:

static_assert(__is_cpp17_move_insertable<_Alloc>::value,
                "The specified type does not meet the requirements of Cpp17MoveInsertable");

We can also fix the trait, however I don't think this is a major issue and I would not spend a lot of time trying to backport a complicated fix. Can you ping me when you have a patch on top of LLVM 15? I can cherry-pick it.

libcxx/test/libcxx/containers/sequences/vector/preconditions.verify.cpp

10

This is kind of light on the details.

[rymiel]

libcxx/include/vector

391

Just happened to notice in passing: There seems to be 6 little typos in total which say "Inserable"

[philnik]

• Address comments

libcxx/include/__memory/allocator_traits.h

371–392

AFAICT construct was always optional, so I think it's OK to just use an allocator without construct.

libcxx/test/libcxx/containers/sequences/vector/preconditions.verify.cpp

10

A single section doesn't apply here, and I don't think it makes sense to list the subsections of [vector]. Saying it's in [vector] also seems quite obvious.

[ldionne]

libcxx/include/__memory/allocator_traits.h

383

[ldionne]

Actually, I'd like to see what the impact of this change is (given that our own tests seem to be violating some of these requirements). We should do it, but I still want to see the impact before we land it, because that will inform our communication about it. Can you ping me once CI is passing and I'll try this on our internal code base as a guinea pig.

[EricWF]

Please write out a more descriptive explanation of the benifit and rational for this change. It would be nice to have a lot more than a single line attached to the eventual commit.

Additionally, I assume the only thing this does is make the diagnostics for already ill-formed code slightly easier to grok? If so, we should consider whether that improvement is worth the additional compile time cost and maintenance cost.
Perhaps by providing concrete examples of where the existing diagnostics are grossly insufficient or need improving.

libcxx/test/libcxx/containers/sequences/vector/preconditions.verify.cpp

30

Can you add an annotation that actually shows that the line below is triggering any diagnostic at all? Something like // expected-note {{from here}}

[philnik]

Address comments

[philnik]

In D132061#3888778, @ldionne wrote:

Actually, I'd like to see what the impact of this change is (given that our own tests seem to be violating some of these requirements). We should do it, but I still want to see the impact before we land it, because that will inform our communication about it. Can you ping me once CI is passing and I'll try this on our internal code base as a guinea pig.

There was actually a bug in __is_cpp17_emplace_constructible. I've added a regression test.

[EricWF]

This change doesn't improve conformance, right? It just attempts to make the diagnostics nicer in a handful of cases where the error occurs in the immediate function call to the allocator?

libcxx/include/__memory/allocator_traits.h

374

Can't a user provided overload of operator, sneak in here?

403–414

Is _And still lazy? If so, do we really need the additional instantiations

libcxx/test/libcxx/containers/sequences/vector/preconditions.verify.cpp

58

expected-note

[EricWF]

I'm not convinced your average user knows what copy insertable means, and I think the static assert is more opaque than the templated messages, which while noiser, contain more information.

It would be interesting to actually do a user study to find out what non-expert users think.

[EricWF]

I would like other people to weigh in on this patch. I don't think these changes pull their weight. I'm not convinced they add clarity. And I'm certain they add complexity and cost -- also if we get the assert wrong (and I don't think we will), but we risk breaking totally valid code that would otherwise compile.

I feel like the conformance test is "does the function compile" and nothing more is needed.

Change my mind.

libcxx/include/__memory/allocator_traits.h

398

Why are these not template aliases? Wouldn't that have a smaller compile time effect?

[EricWF]

Sorry for the repeated comments. But if I understand the description correctly, the diagnostic below is no longer emitted?

error: call to implicitly-deleted copy constructor of 'NotCopyInsertable'
        ::new ((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);

Because that's what I would need to see to understand *how to fix* the issue.

If we're blocking the user from seeing that, this patch should not land.

libcxx/include/__memory/allocator_traits.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
 #define _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
 
 #include <__config>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
+#include <__type_traits/is_primary_template.h>
 #include <__utility/forward.h>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
struct _LIBCPP_TEMPLATE_VIS allocator_traits
     using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type;
     using difference_type = typename __alloc_traits_difference_type<allocator_type, pointer>::type;
     using size_type = typename __size_type<allocator_type, difference_type>::type;
     using propagate_on_container_copy_assignment = typename __propagate_on_container_copy_assignment<allocator_type>::type;
     using propagate_on_container_move_assignment = typename __propagate_on_container_move_assignment<allocator_type>::type;
     using propagate_on_container_swap = typename __propagate_on_container_swap<allocator_type>::type;
     using is_always_equal = typename __is_always_equal<allocator_type>::type;
 
+    using __primary_template = allocator_traits;
+
 #ifndef _LIBCPP_CXX03_LANG
     template <class _Tp>
     using rebind_alloc = __allocator_traits_rebind_t<allocator_type, _Tp>;
     template <class _Tp>
     using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
 #else  // _LIBCPP_CXX03_LANG
     template <class _Tp>
     struct rebind_alloc {

 // __is_default_allocator
 template <class _Tp>
 struct __is_default_allocator : false_type { };
 
 template <class> class allocator;
 
 template <class _Tp>
 struct __is_default_allocator<allocator<_Tp> > : true_type { };
 
-// __is_cpp17_move_insertable
-template <class _Alloc, class = void>
-struct __is_cpp17_move_insertable
-    : is_move_constructible<typename _Alloc::value_type>
-{ };
+// Implement named requirements from https://wg21.link/container.alloc.reqmts
+
+template <class _Alloc, class... _Args>
+decltype(allocator_traits<_Alloc>::construct(std::declval<_Alloc&>(),
+                                             std::declval<typename allocator_traits<_Alloc>::value_type*>(),
+                                             std::declval<_Args>()...),
+         true_type())
+__is_cpp17_emplace_constructible_impl(int);
+
+template <class _Alloc, class...>
+false_type __is_cpp17_emplace_constructible_impl(...);
+
+// If allocator_traits is the primary template and the allocator doesn't have a custom construt(),
+// we check instead that the type is constructible, since the default construct() isn't constrained.
+// This is also the case for std::allocator.
+template <class _Alloc, class... _Args>
+struct __is_cpp17_emplace_constructible
+    : _If<__is_primary_template<allocator_traits<_Alloc> >::value &&
+              (!__has_construct<_Alloc, typename allocator_traits<_Alloc>::value_type*, _Args...>::value ||
+               __is_default_allocator<_Alloc>::value),
+          is_constructible<typename allocator_traits<_Alloc>::value_type, _Args...>,
+          decltype(std::__is_cpp17_emplace_constructible_impl<_Alloc, _Args...>(0))> {};
 
 template <class _Alloc>
-struct __is_cpp17_move_insertable<_Alloc, __enable_if_t<
-    !__is_default_allocator<_Alloc>::value &&
-    __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value
-> > : true_type { };
+struct __is_cpp17_default_insertable : __is_cpp17_emplace_constructible<_Alloc> {};
 
-// __is_cpp17_copy_insertable
-template <class _Alloc, class = void>
+template <class _Alloc>
+struct __is_cpp17_move_insertable
+    : __is_cpp17_emplace_constructible<_Alloc, typename allocator_traits<_Alloc>::value_type&&> {};
+
+template <class _Alloc>
 struct __is_cpp17_copy_insertable
-    : integral_constant<bool,
-        is_copy_constructible<typename _Alloc::value_type>::value &&
-        __is_cpp17_move_insertable<_Alloc>::value
-    >
-{ };
+    : _And<__is_cpp17_move_insertable<_Alloc>,
+           __is_cpp17_emplace_constructible<_Alloc, typename allocator_traits<_Alloc>::value_type&>,
+           __is_cpp17_emplace_constructible<_Alloc, const typename allocator_traits<_Alloc>::value_type&> > {};
+
+template <class _Alloc>
+decltype(allocator_traits<_Alloc>::destroy(std::declval<_Alloc&>(),
+                                           std::declval<typename allocator_traits<_Alloc>::value_type*>()),
+         true_type())
+__is_cpp17_erasable_impl(int);
+
+template <class _Alloc>
+false_type __is_cpp17_erasable_impl(...);
 
 template <class _Alloc>
-struct __is_cpp17_copy_insertable<_Alloc, __enable_if_t<
-    !__is_default_allocator<_Alloc>::value &&
-    __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value
-> >
-    : __is_cpp17_move_insertable<_Alloc>
-{ };
+struct __is_cpp17_erasable : decltype(std::__is_cpp17_erasable_impl<_Alloc>(0)) {};
 
 #undef _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H

libcxx/include/vector

 #endif
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(size_type __n, const value_type& __x);
 
     template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
     vector(size_type __n, const value_type& __x, const allocator_type& __a)
         : __end_cap_(nullptr, __a)
     {
+      static_assert(__is_cpp17_copy_insertable<_Allocator>::value, "value_type has to be Cpp17CopyInsertable");
       std::__debug_db_insert_c(this);
       if (__n > 0)
       {
           __vallocate(__n);
           __construct_at_end(__n, __x);
       }
     }
 
else
         __swap_out_circular_buffer(__v);
     }
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(size_type __n)
 {
+    static_assert(__is_cpp17_default_insertable<_Allocator>::value, "value_type has to be Cpp17DefaultInsertable");
     std::__debug_db_insert_c(this);
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n);
     }
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
     : __end_cap_(nullptr, __a)
 {
+    static_assert(__is_cpp17_default_insertable<_Allocator>::value, "value_type has to be Cpp17DefaultInsertable");
     std::__debug_db_insert_c(this);
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n);
     }
 }
 #endif
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x)
 {
+    static_assert(__is_cpp17_copy_insertable<_Allocator>::value, "value_type has to be Cpp17CopyInsertable");
     std::__debug_db_insert_c(this);
     if (__n > 0)
     {
         __vallocate(__n);
         __construct_at_end(__n, __x);
     }
 }
 
vector<_Tp, _Allocator>::at(size_type __n) const
     return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 vector<_Tp, _Allocator>::reserve(size_type __n)
 {
+    static_assert(__is_cpp17_move_insertable<_Allocator>::value, "value_type has to be Cpp17MoveInserable");
     if (__n > capacity())
     {
         if (__n > max_size())
             this->__throw_length_error();
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__n, size(), __a);
         __swap_out_circular_buffer(__v);
     }
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
 {
+    static_assert(__is_cpp17_move_insertable<_Allocator>::value, "value_type has to be Cpp17MoveInserable");
     if (capacity() > size())
     {
 #ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif // _LIBCPP_NO_EXCEPTIONS
             allocator_type& __a = this->__alloc();
             __split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
     return iterator(this, __p);
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 vector<_Tp, _Allocator>::resize(size_type __sz)
 {
+    static_assert(__is_cpp17_move_insertable<_Allocator>::value, "value_type has to be Cpp17MoveInserable");
+    static_assert(__is_cpp17_default_insertable<_Allocator>::value, "value_type has to be Cpp17DefaultInsertable");
     size_type __cs = size();
     if (__cs < __sz)
         this->__append(__sz - __cs);
     else if (__cs > __sz)
         this->__destruct_at_end(this->__begin_ + __sz);
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 void
 vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x)
 {
+    static_assert(__is_cpp17_copy_insertable<_Allocator>::value, "value_type has to be Cpp17CopyInsertable");
     size_type __cs = size();
     if (__cs < __sz)
         this->__append(__sz - __cs, __x);
     else if (__cs > __sz)
         this->__destruct_at_end(this->__begin_ + __sz);
 }
 
 template <class _Tp, class _Allocator>

libcxx/test/libcxx/containers/containers.requirements/container.gen.reqmts/allocator_requirements.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Check that allocator requirements are implemented correctly
+
+#include <memory>
+
+class S {};
+class T {
+  T() = delete;
+  T(const T&) = delete;
+  T(T&&) = delete;
+
+};
+
+struct Allocator {
+  using value_type = S;
+};
+
+struct CustomConstructAllocator {
+  using value_type = T;
+
+  template <class... Args>
+  void construct(T*, Args&&...);
+};
+
+template <int>
+struct SpecializedAllocator {
+  using value_type = S;
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<0>> {
+  using value_type = S;
+
+  static void construct(SpecializedAllocator<0>&, S*);
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<1>> {
+  using value_type = S;
+
+  static void construct(SpecializedAllocator<1>&, S*, S&&);
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<2>> {
+  using value_type = S;
+
+  static void construct(SpecializedAllocator<2>&, S*, int, long);
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<3>> {
+  using value_type = S;
+
+  static void construct(SpecializedAllocator<3>&, S*, S&&);
+  static void construct(SpecializedAllocator<3>&, S*, const S&);
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<4>> {
+  using value_type = S;
+
+  static void construct(SpecializedAllocator<4>&, S*, S&&) = delete;
+  static void construct(SpecializedAllocator<4>&, S*, const S&);
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<5>> {
+  using value_type = S;
+
+  static void destroy(SpecializedAllocator<5>&, S*);
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<6>> {
+  using value_type = S;
+
+  static void destroy(SpecializedAllocator<6>&, S*, int);
+};
+
+template <>
+struct std::allocator_traits<SpecializedAllocator<7>> {
+  using value_type = S;
+
+  static void destroy(SpecializedAllocator<7>&, S*, int);
+};
+
+static_assert(!std::__is_cpp17_emplace_constructible<SpecializedAllocator<7>, int, long>::value, "");
+
+static_assert(std::__is_cpp17_emplace_constructible<CustomConstructAllocator, int>::value, "");
+static_assert(!std::__is_cpp17_emplace_constructible<Allocator, int, long>::value, "");
+static_assert(!std::__is_cpp17_emplace_constructible<SpecializedAllocator<7>, int, long>::value, "");
+static_assert(std::__is_cpp17_emplace_constructible<SpecializedAllocator<2>, int, long>::value, "");
+
+static_assert(std::__is_cpp17_default_insertable<CustomConstructAllocator>::value, "");
+static_assert(std::__is_cpp17_default_insertable<Allocator>::value, "");
+static_assert(!std::__is_cpp17_default_insertable<SpecializedAllocator<7>>::value, "");
+static_assert(std::__is_cpp17_default_insertable<SpecializedAllocator<0>>::value, "");
+
+static_assert(std::__is_cpp17_move_insertable<CustomConstructAllocator>::value, "");
+static_assert(std::__is_cpp17_move_insertable<Allocator>::value, "");
+static_assert(!std::__is_cpp17_move_insertable<SpecializedAllocator<7>>::value, "");
+static_assert(std::__is_cpp17_move_insertable<SpecializedAllocator<1>>::value, "");
+
+static_assert(std::__is_cpp17_copy_insertable<CustomConstructAllocator>::value, "");
+static_assert(std::__is_cpp17_copy_insertable<Allocator>::value, "");
+static_assert(!std::__is_cpp17_copy_insertable<SpecializedAllocator<7>>::value, "");
+static_assert(std::__is_cpp17_copy_insertable<SpecializedAllocator<3>>::value, "");
+static_assert(!std::__is_cpp17_copy_insertable<SpecializedAllocator<4>>::value, "");
+
+static_assert(std::__is_cpp17_erasable<CustomConstructAllocator>::value, "");
+static_assert(std::__is_cpp17_erasable<Allocator>::value, "");
+static_assert(!std::__is_cpp17_erasable<SpecializedAllocator<7>>::value, "");
+static_assert(std::__is_cpp17_erasable<SpecializedAllocator<5>>::value, "");
+static_assert(!std::__is_cpp17_erasable<SpecializedAllocator<6>>::value, "");

libcxx/test/libcxx/containers/sequences/vector/preconditions.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// Ensure that libc++ statically checks preconditions when using std::vector, as a matter of QOI.
+
+#include <vector>
+
+struct NotDefaultInsertable {
+  NotDefaultInsertable(int);
+};
+
+struct NotMoveInsertable {
+  NotMoveInsertable(NotMoveInsertable&&) = delete;
+};
+
+struct NotCopyInsertable {
+  NotCopyInsertable(int);
+  NotCopyInsertable(NotCopyInsertable&&);
+};
+
+void func() {
+  // expected-error@* {{failed due to requirement}}
+  // expected-error@* {{no matching function for call to}}
+  std::vector<NotDefaultInsertable> v1(10); // expected-node {{from here}}
+
+  // expected-error@* {{failed due to requirement}}
+  std::vector<NotDefaultInsertable> v2(10, std::allocator<NotDefaultInsertable>()); // expected-node {{from here}}
+
+  // expected-error@* {{failed due to requirement}}
+  // expected-error@* {{no matching function for call to}}
+  std::vector<NotCopyInsertable> v3( // expected-node {{from here}}
+      10, NotCopyInsertable(1), std::allocator<NotCopyInsertable>());
+
+  std::vector<NotMoveInsertable> v4;
+
+  // expected-error@* {{failed due to requirement}}
+  // expected-error@* {{failed due to requirement}}
+  // expected-error@* {{no matching function for call to}}
+  v4.reserve(1); // expected-node {{from here}}
+  // expected-error@* {{failed due to requirement}}
+  v4.shrink_to_fit();
+  // expected-error@* {{failed due to requirement}}
+  // expected-error@* {{failed due to requirement}}
+  // expected-error@* {{no matching function for call to}}
+  v4.resize(1); // expected-node {{from here}}
+
+  std::vector<NotDefaultInsertable> v5;
+  // expected-error@* {{failed due to requirement}}
+  v5.resize(1); // expected-node {{from here}}
+
+  std::vector<NotCopyInsertable> v6;
+  // expected-error@* {{failed due to requirement}}
+  v6.resize(1, NotCopyInsertable(1)); // expected-node {{from here}}
+}