[libc++][test] Silence allocator conversion warnings

[CaseyCarter]

Summary

... by accepting std::size_t instead of int in allocate and deallocate functions.

Drive-by: To conform to the allocator requirements, the Allocator types in these tests need to have (1) converting constructors and (2) cross-specialization == that returns true at least for copies of the same allocator.

[jloser]

Thanks for the fix! LGTM FWIW.

[ldionne]

CI issues seem unrelated. Just curious -- how did you catch that? Is there anything we can/should add to our implementation?

[CaseyCarter]

In D141334#4040566, @ldionne wrote:

CI issues seem unrelated. Just curious -- how did you catch that? Is there anything we can/should add to our implementation?

As you may be aware, MSVC doesn't have the "system header" notion that GCC/Clang do. Consequently we run testing with TONS of warnings enabled to ensure that our header code only emits warnings when the user has asked us to do something questionable. This is a pretty good example: Allocator's size type is size_t, so using this allocator with Standard Library containers results in lots of narrowing conversions from size_t to int. If the user asks for narrowing conversion warnings, they'll get them. The consequence is we have to police our tests pretty carefully to avoid warnings so we only see warnings from bad product code.

[ldionne]

In D141334#4040909, @CaseyCarter wrote:

In D141334#4040566, @ldionne wrote:

CI issues seem unrelated. Just curious -- how did you catch that? Is there anything we can/should add to our implementation?

As you may be aware, MSVC doesn't have the "system header" notion that GCC/Clang do. Consequently we run testing with TONS of warnings enabled to ensure that our header code only emits warnings when the user has asked us to do something questionable. This is a pretty good example: Allocator's size type is size_t, so using this allocator with Standard Library containers results in lots of narrowing conversions from size_t to int. If the user asks for narrowing conversion warnings, they'll get them. The consequence is we have to police our tests pretty carefully to avoid warnings so we only see warnings from bad product code.

Interesting! And I guess we don't enable this warning in our testing configuration. We have a block like this in params.py:

# These warnings should be enabled in order to support the MSVC
# team using the test suite; They enable the warnings below and
# expect the test suite to be clean.
'-Wsign-compare',
'-Wunused-variable',
'-Wunused-parameter',
'-Wunreachable-code',
'-Wno-unused-local-typedef',

Would it maybe make sense to add a new warning that would catch this?

libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <vector>
 
+#include <cstddef>
 #include <vector>
 
 #include "test_macros.h"
 
 struct Incomplete;
 template<class T> struct Holder { T t; };
 
 template<class T, class AdlTrap = Holder<Incomplete>>
 struct MyAlloc {
     using value_type = T;
     MyAlloc() = default;
     template<class U> MyAlloc(const MyAlloc<U>&) {}
-    T *allocate(int n) { return std::allocator<T>().allocate(n); }
-    void deallocate(T *p, int n) { return std::allocator<T>().deallocate(p, n); }
+    T *allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
+    void deallocate(T *p, std::size_t n) { return std::allocator<T>().deallocate(p, n); }
 };
 
 int main(int, char**)
 {
     std::vector<bool, MyAlloc<bool>> vb;
     std::vector<bool, MyAlloc<bool>> wb(100);
 
     std::vector<int, MyAlloc<int>> v;

libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
 // (bug report: https://llvm.org/PR58392)
 // Check that vector<bool> constructors don't leak memory when an operation inside the constructor throws an exception
 
+#include <cstddef>
 #include <type_traits>
 #include <vector>
 
 #include "count_new.h"
 #include "test_iterators.h"
 
 template <class T>
 struct Allocator {
   using value_type      = T;
   using is_always_equal = std::false_type;
 
   template <class U>
   Allocator(const Allocator<U>&) {}
 
   Allocator(bool should_throw = true) {
     if (should_throw)
       throw 0;
   }
 
-  T* allocate(int n) { return std::allocator<T>().allocate(n); }
-  void deallocate(T* ptr, int n) { std::allocator<T>().deallocate(ptr, n); }
+  T* allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
+  void deallocate(T* ptr, std::size_t n) { std::allocator<T>().deallocate(ptr, n); }
 
-  friend bool operator==(const Allocator&, const Allocator&) { return false; }
+  template <class U>
+  friend bool operator==(const Allocator&, const Allocator<U>&) { return true; }
 };
 
 template <class IterCat>
 struct Iterator {
   using iterator_category = IterCat;
   using difference_type   = std::ptrdiff_t;
   using value_type        = bool;
   using reference         = bool&;

libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-exceptions
 
 // (bug report: https://llvm.org/PR58392)
 // Check that vector constructors don't leak memory when an operation inside the constructor throws an exception
 
+#include <cstddef>
 #include <type_traits>
 #include <vector>
 
 #include "count_new.h"
 #include "test_iterators.h"
 
 template <class T>
 struct Allocator {
   using value_type      = T;
   using is_always_equal = std::false_type;
 
+  template <class U>
+  Allocator(const Allocator<U>&) {}
+
   Allocator(bool should_throw = true) {
     if (should_throw)
       throw 0;
   }
 
-  T* allocate(int n) { return std::allocator<T>().allocate(n); }
-  void deallocate(T* ptr, int n) { std::allocator<T>().deallocate(ptr, n); }
+  T* allocate(std::size_t n) { return std::allocator<T>().allocate(n); }
+  void deallocate(T* ptr, std::size_t n) { std::allocator<T>().deallocate(ptr, n); }
 
-  friend bool operator==(const Allocator&, const Allocator&) { return false; }
+  template <class U>
+  friend bool operator==(const Allocator&, const Allocator<U>&) { return true; }
 };
 
 struct ThrowingT {
   int* throw_after_n_ = nullptr;
   ThrowingT() { throw 0; }
 
   ThrowingT(int& throw_after_n) : throw_after_n_(&throw_after_n) {
     if (throw_after_n == 0)