[libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 2/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 2/4.

Use static_cast<int> when storing size_t in int (or passing size_t to int).

Also, remove a spurious semicolon in test/support/archetypes.hpp.

[EricWF]

LGTM nix inline comments. Please fix MemCounter to use size_t instead.

test/support/count_new.hpp

62

These should be changed to size_t instead.

[STL_MSFT]

Changed data members to size_t as requested (also changed parameters for consistency).

[STL_MSFT]

Thanks, r288752.

test/std/utilities/optional/optional.specalg/make_optional_explicit_initializer_list.pass.cpp

 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct TestT {
   int x;
   int size;
-  constexpr TestT(std::initializer_list<int> il) : x(*il.begin()), size(il.size()) {}
+  constexpr TestT(std::initializer_list<int> il) : x(*il.begin()), size(static_cast<int>(il.size())) {}
   constexpr TestT(std::initializer_list<int> il, const int*)
-      : x(*il.begin()), size(il.size()) {}
+      : x(*il.begin()), size(static_cast<int>(il.size())) {}
 };
 
 int main()
 {
     using std::make_optional;
     {
         constexpr auto opt = make_optional<TestT>({42, 2, 3});
         ASSERT_SAME_TYPE(decltype(opt), const std::optional<TestT>);

test/support/archetypes.hpp

explicit TestBase(int, int y) noexcept : value(y) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     TestBase(int, int y) noexcept : value(y) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
-      : value(il.size()) {
+      : value(static_cast<int>(il.size())) {
         ++alive; ++constructed; ++value_constructed;
     }
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(il.size()) {
+    explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
         ++alive; ++constructed; ++value_constructed;
     }
     TestBase& operator=(int xvalue) noexcept {
       value = xvalue;
       ++assigned; ++value_assigned;
       return *this;
     }
 protected:
struct ValueBase {
     explicit constexpr ValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr ValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit constexpr ValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr ValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(il.size()) {}
+    explicit constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(il.size()) {}
+    constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
     TEST_CONSTEXPR_CXX14 ValueBase& operator=(int xvalue) noexcept {
         value = xvalue;
         return *this;
     }
     //~ValueBase() { assert(value != -999); value = -999; }
     int value;
 protected:
     constexpr static int check_value(int const& val) {
struct TrivialValueBase {
     explicit constexpr TrivialValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr TrivialValueBase(int x) : value(x) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
     explicit constexpr TrivialValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
     constexpr TrivialValueBase(int, int y) : value(y) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
-    explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(il.size()) {}
+    explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
-    constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(il.size()) {};
+    constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
     int value;
 protected:
     constexpr TrivialValueBase() noexcept : value(0) {}
 };
 
 }
 
 //============================================================================//

test/support/count_new.hpp

public:
     // number of allocations to throw after. Default (unsigned)-1. If
     // throw_after has the default value it will never be decremented.
     static const unsigned never_throw_value = static_cast<unsigned>(-1);
     unsigned throw_after;
 
     int outstanding_new;
     int new_called;
     int delete_called;
-    int last_new_size;
+    std::size_t last_new_size;
 
     int outstanding_array_new;
     int new_array_called;
     int delete_array_called;
-    int last_new_array_size;
+    std::size_t last_new_array_size;
 
 public:
     void newCalled(std::size_t s)
     {
         assert(disable_allocations == false);
         assert(s);
         if (throw_after == 0) {
             throw_after = never_throw_value;
bool checkDeleteCalledEq(int n) const
         return disable_checking || n == delete_called;
     }
 
     bool checkDeleteCalledNotEq(int n) const
     {
         return disable_checking || n != delete_called;
     }
 
-    bool checkLastNewSizeEq(int n) const
+    bool checkLastNewSizeEq(std::size_t n) const
     {
         return disable_checking || n == last_new_size;
     }
 
-    bool checkLastNewSizeNotEq(int n) const
+    bool checkLastNewSizeNotEq(std::size_t n) const
     {
         return disable_checking || n != last_new_size;
     }
 
     bool checkOutstandingArrayNewEq(int n) const
     {
         return disable_checking || n == outstanding_array_new;
     }
bool checkDeleteArrayCalledEq(int n) const
         return disable_checking || n == delete_array_called;
     }
 
     bool checkDeleteArrayCalledNotEq(int n) const
     {
         return disable_checking || n != delete_array_called;
     }
 
-    bool checkLastNewArraySizeEq(int n) const
+    bool checkLastNewArraySizeEq(std::size_t n) const
     {
         return disable_checking || n == last_new_array_size;
     }
 
-    bool checkLastNewArraySizeNotEq(int n) const
+    bool checkLastNewArraySizeNotEq(std::size_t n) const
     {
         return disable_checking || n != last_new_array_size;
     }
 };
 
 #ifdef DISABLE_NEW_COUNT
   const bool MemCounter::disable_checking = true;
 #else
explicit RequireAllocationGuard(std::size_t RequireAtLeast = 1)
               m_exactly(false)
     {
     }
 
     void requireAtLeast(std::size_t N) { m_req_alloc = N; m_exactly = false; }
     void requireExactly(std::size_t N) { m_req_alloc = N; m_exactly = true; }
 
     ~RequireAllocationGuard() {
-        assert(globalMemCounter.checkOutstandingNewEq(m_outstanding_new_on_init));
+        assert(globalMemCounter.checkOutstandingNewEq(static_cast<int>(m_outstanding_new_on_init)));
         std::size_t Expect = m_new_count_on_init + m_req_alloc;
-        assert(globalMemCounter.checkNewCalledEq(Expect) ||
-               (!m_exactly && globalMemCounter.checkNewCalledGreaterThan(Expect)));
+        assert(globalMemCounter.checkNewCalledEq(static_cast<int>(Expect)) ||
+               (!m_exactly && globalMemCounter.checkNewCalledGreaterThan(static_cast<int>(Expect))));
     }
 
 private:
     std::size_t m_req_alloc;
     const std::size_t m_new_count_on_init;
     const std::size_t m_outstanding_new_on_init;
     bool m_exactly;
     RequireAllocationGuard(RequireAllocationGuard const&);
     RequireAllocationGuard& operator=(RequireAllocationGuard const&);
 };
 
 #endif /* COUNT_NEW_HPP */