[libcxx] [test] Fix recently introduced warnings emitted by MSVC.

[STL_MSFT]

Summary

[libcxx] [test] Fix recently introduced warnings emitted by MSVC.

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
These tests were using malloc()'s return value without checking for null,
which MSVC's /analyze rightly warns about. Asserting that the pointer is
non-null both expresses the test's intention and silences the warning.

test/support/controlled_allocators.hpp
Fix two unreferenced parameters by removing their names, and one unused variable by void-casting it.

test/support/uses_alloc_types.hpp
Fix an unreferenced function parameter pack by removing its name.

[EricWF]

Sorry about that. I'm working to turn on -Wunused-parameter and others to avoid these issues.

[EricWF]

Alright. The unused parameter parts of this patch are no longer needed. -Wunused-parameter and -Wunused-variable have been enabled within libc++.

Just working on -Wsign-compare now.

[EricWF]

-Wsign-compare has also landed :-) Now just -Wconversion to go (but that will likely take a while).

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp

AllocController P;
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int&, int const&&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         const PairIn in(x, std::move(y));
         A.construct(ptr, in);
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_AllocLast, CA));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&>&&,
P.reset();
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int, int const&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         const PairIn in(x, y);
         A.construct(ptr, in);
         assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int const&>&&,
AllocController PInner;
         int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         const PairIn in(x, std::move(y));
         A.construct(ptr, in);
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_AllocLast));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
POuter.reset();
         int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         const PairIn in(x, y);
         A.construct(ptr, in);
         assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp

AllocController P;
         using U = UsesAllocatorV2<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(x),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
P.reset();
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(std::move(x)),
                     std::forward_as_tuple(y));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
AllocController PInner;
         int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(x),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
POuter.reset();
         const int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(std::move(x)),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_None));

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp

AllocController P;
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int&, int const&&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         PairIn in(x, std::move(y));
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&>&&,
P.reset();
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int, int const&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         PairIn in(x, y);
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&&>&&,
AllocController PInner;
         int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         PairIn in(x, std::move(y));
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
POuter.reset();
         int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         PairIn in(x, y);
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp

AllocController P;
         using U = UsesAllocatorV2<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, x, std::move(y));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&>&&,
                                  std::tuple<int const&&, SA&>&&
               >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::move(x), y);
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
         assert((P.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SA&, int&&>&&,
                                  std::tuple<int const&>&&
AllocController PInner;
         int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, x, std::move(y));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
POuter.reset();
         const int y = 101;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
+        assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::move(x), std::move(y));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_None));
         assert((POuter.checkConstruct<std::piecewise_construct_t const&,
                                  std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,

test/support/controlled_allocators.hpp

void countDealloc(void* p, size_t s, size_t a) {
         alive_size -= s;
         deallocated_size += s;
         last_pointer = last_dealloc_pointer = p;
         last_size = last_dealloc_size = s;
         last_align = last_dealloc_align = a;
     }
 
     template <class ...Args, class Alloc, class Tp>
-    void countConstruct(Alloc const& a, Tp *p) {
+    void countConstruct(Alloc const&, Tp *p) {
       ++construct_called;
       last_construct_pointer = p;
       last_construct_alloc = &makeTypeID<Alloc>();
       last_construct_type = &makeTypeID<Tp>();
       last_construct_args = &makeArgumentID<Args...>();
     }
 
     template <class Alloc, class Tp>
-    void countDestroy(Alloc const& a, Tp *p) {
+    void countDestroy(Alloc const&, Tp *p) {
       ++destroy_called;
       last_destroy_alloc = &makeTypeID<Alloc>();
       last_destroy_type = &makeTypeID<Tp>();
       last_destroy_pointer = p;
     }
 
     void reset() { std::memset(this, 0, sizeof(*this)); }
     void resetConstructDestroy() {
void deallocate(T* p, std::size_t n)
         void* vp = static_cast<void*>(p);
         P->countDealloc(vp, n*sizeof(T), alignof(T));
         ::operator delete(vp);
     }
 
     template <class U, class ...Args>
     void construct(U *p, Args&&... args) {
       auto *c = ::new ((void*)p) U(std::forward<Args>(args)...);
+      ((void)c); // Prevent unused warning
       P->countConstruct<Args&&...>(*this, p);
     }
 
     template <class U>
     void destroy(U* p) {
       p->~U();
       P->countDestroy(*this, p);
     }

test/support/uses_alloc_types.hpp

public:
 
     NotUsesAllocator() : Base(&makeArgumentID<>()) {}
     NotUsesAllocator(NotUsesAllocator const&)
         : Base(&makeArgumentID<NotUsesAllocator const&>()) {}
     NotUsesAllocator(NotUsesAllocator &&)
         : Base(&makeArgumentID<NotUsesAllocator &&>()) {}
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
-    NotUsesAllocator(Args&&... args) : Base(&makeArgumentID<Args&&...>()) {}
+    NotUsesAllocator(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Arg Ctor
     template <class ...Args>
     NotUsesAllocator(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
         : Base(tag, alloc, std::forward<Args>(args)...)
     {}
 
     // Uses Allocator Last Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
     NotUsesAllocator(Args&&... args)
         : Base(AllocLastTag{}, std::forward<Args>(args)...)
     {}
 };
 
 #endif /* USES_ALLOC_TYPES_HPP */