[libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 4/4.

[STL_MSFT]

Summary

[libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 4/4.

Change a few allocators' size_type/difference_type from unsigned/int to std::size_t/std::ptrdiff_t.

This avoids truncation warnings on x64 when unsigned/int are 32-bit but std::size_t/std::ptrdiff_t are 64-bit.

[EricWF]

This change looks OK to me. As mentioned above I think the reason the test allocators used int/unsigned is so they could detect if the container actually propagated their typedefs.
However there are other ways to test this.

test/std/utilities/allocator.adaptor/types.pass.cpp

78

This part of the change loses test coverage. Specifically it no longer tests that scoped_allocator_adaptor propagates the OuterAlloc's typedefs.

I would scribble out a minimal custom allocator at the top of this file, and rewrite these static asserts using that.

[EricWF]

Actually I've changed my mind on this patch. While attempting to clean up -Wconversion errors in libc++ I found many of them were caused by these custom allocators providing a custom 32 bit size type. Since users are free to do this AFAIK it seems like we should keep these tests for it.

@STL_MSFT Does that make sense?

[STL_MSFT]

Yeah, users are free to do this, which also triggers conversion warnings for us. I think I'll need to investigate actually fixing/suppressing them in our sources and abandoning this patch; leaving it open for now as a todo.

[STL_MSFT]

Abandoning; I have changes in our STL to fix the bulk of these warnings, plus a small number of test changes that I'm about to send out.

test/std/utilities/allocator.adaptor/types.pass.cpp

 //     typedef typename OuterTraits::pointer pointer;
 //     typedef typename OuterTraits::const_pointer const_pointer;
 //     typedef typename OuterTraits::void_pointer void_pointer;
 //     typedef typename OuterTraits::const_void_pointer const_void_pointer;
 // };
 
 #include <scoped_allocator>
 #include <type_traits>
+#include <cstddef>
 
 #include "allocators.h"
 
 int main()
 {
     static_assert((std::is_base_of<
         A1<int>,
         std::scoped_allocator_adaptor<A1<int>>
static_assert((std::is_base_of<
         A2<int>,
         std::scoped_allocator_adaptor<A2<int>, A1<int>>
         >::value), "");
 
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::outer_allocator_type,
         A2<int>>::value), "");
 
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::size_type,
-        unsigned>::value), "");
+        std::size_t>::value), "");
 
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::difference_type,
-        int>::value), "");
+        std::ptrdiff_t>::value), "");
 
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::pointer,
         int*>::value), "");
 
     static_assert((std::is_same<
         std::scoped_allocator_adaptor<A2<int>, A1<int>>::const_pointer,
         const int*>::value), "");

test/support/allocators.h

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ALLOCATORS_H
 #define ALLOCATORS_H
 
 #include <type_traits>
 #include <utility>
+#include <cstddef>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class T>
 class A1
 {

 class A2
 {
     int id_;
 public:
     explicit A2(int id = 0) TEST_NOEXCEPT : id_(id) {}
 
     typedef T value_type;
 
-    typedef unsigned size_type;
-    typedef int difference_type;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
 
     typedef std::true_type propagate_on_container_move_assignment;
 
     int id() const {return id_;}
 
     static bool copy_called;
     static bool move_called;
     static bool allocate_called;

test/support/test_allocator.h

 class test_allocator
     : public test_alloc_base
 {
     int data_;
 
     template <class U> friend class test_allocator;
 public:
 
-    typedef unsigned                                                   size_type;
-    typedef int                                                        difference_type;
+    typedef std::size_t                                                size_type;
+    typedef std::ptrdiff_t                                             difference_type;
     typedef T                                                          value_type;
     typedef value_type*                                                pointer;
     typedef const value_type*                                          const_pointer;
     typedef typename std::add_lvalue_reference<value_type>::type       reference;
     typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
 
     template <class U> struct rebind {typedef test_allocator<U> other;};
 

 class non_default_test_allocator
     : public test_alloc_base
 {
     int data_;
 
     template <class U> friend class non_default_test_allocator;
 public:
 
-    typedef unsigned                                                   size_type;
-    typedef int                                                        difference_type;
+    typedef std::size_t                                                size_type;
+    typedef std::ptrdiff_t                                             difference_type;
     typedef T                                                          value_type;
     typedef value_type*                                                pointer;
     typedef const value_type*                                          const_pointer;
     typedef typename std::add_lvalue_reference<value_type>::type       reference;
     typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
 
     template <class U> struct rebind {typedef non_default_test_allocator<U> other;};
 

 class test_allocator<void>
     : public test_alloc_base
 {
     int data_;
 
     template <class U> friend class test_allocator;
 public:
 
-    typedef unsigned                                                   size_type;
-    typedef int                                                        difference_type;
+    typedef std::size_t                                                size_type;
+    typedef std::ptrdiff_t                                             difference_type;
     typedef void                                                       value_type;
     typedef value_type*                                                pointer;
     typedef const value_type*                                          const_pointer;
 
     template <class U> struct rebind {typedef test_allocator<U> other;};
 
     test_allocator() throw() : data_(0) {}
     explicit test_allocator(int i) throw() : data_(i) {}