[libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible loss of data", part 3/7.

[STL_MSFT]

Summary

[libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible loss of data", part 3/7.

Add static_cast<short> when constructing pair<Whatever, short> from (Something, int).

[EricWF]

MSVC seriously emits a warning for void foo(short); foo(0); because the literal 0 is an int? If so you really should fix that in MSVC; That's a bogus warning. Does it emit a warning for short x = 3;?

[EricWF]

MSVC seriously emits a warning for void foo(short); foo(0); because the literal 0 is an int?

Oh my goodness it does... Your compiler is bad and it should feel bad. It's not like you can write foo(0s).

[STL_MSFT]

I can't possibly defend C1XX's behavior in your foo() scenario - but the pair scenarios being fixed here are different. pair<A, B>'s constructor from (X&&, Y&&) is perfect forwarding, so while the compiler can see that literals are being passed to (int&&, int&&), when it instantiates the constructor's definition, it just sees short being constructed from a perfectly-forwarded int, and warns about truncation there. C1XX doesn't attempt to "see through" the function call and notice that the arguments were literals. Its behavior is arguably desirable because the instantiation happens once per TU, and yet there may be other calls that are passing runtime-valued ints.

I chose static_cast<short> here because it was non-invasive, although ugly. There's a more invasive but prettier possibility - change the shorts to longs so that widening instead of truncation happens. I could do that if you want.

[STL_MSFT]

I checked, and Clang 3.8.0 behaves identically to C1XX in the pair scenario. Here's the test case:

#include <utility>

template <typename A, typename B> struct Pair {
    A a;
    B b;
    
    template <typename X, typename Y> Pair(X&& x, Y&& y) : a(std::forward<X>(x)), b(std::forward<Y>(y)) { }
};

int main() {
    Pair<short, short> p(11, 22);
    return p.a == 11 && p.b == 22 ? 0 : 1;
}

With -Wconversion, this emits:

prog.cc:7:62: warning: implicit conversion loses integer precision: 'int' to 'short' [-Wconversion]
    template <typename X, typename Y> Pair(X&& x, Y&& y) : a(std::forward<X>(x)), b(std::forward<Y>(y)) { }
                                                            ~^~~~~~~~~~~~~~~~~~
prog.cc:11:24: note: in instantiation of function template specialization 'Pair<short, short>::Pair<int, int>' requested here
    Pair<short, short> p(11, 22);
                       ^
prog.cc:7:85: warning: implicit conversion loses integer precision: 'int' to 'short' [-Wconversion]
    template <typename X, typename Y> Pair(X&& x, Y&& y) : a(std::forward<X>(x)), b(std::forward<Y>(y)) { }
                                                                                   ~^~~~~~~~~~~~~~~~~~

So, if you were compiling your tests with -Wconversion and not suppressing warnings in "system headers", you'd see this in libc++ too.

[EricWF]

Huh. Thanks for the analysis. LGTM.

test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp

 int main()
 {
     {
         typedef std::unordered_map<double, int> C;
         typedef C::iterator R;
         typedef std::pair<double, short> P;
         C c;
         C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
+        R r = c.insert(e, P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(3.5, 4));
+        r = c.insert(c.end(), P(3.5, static_cast<short>(4)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(4.5, 4));
+        r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 4.5);
         assert(r->second == 4);
 
-        r = c.insert(c.end(), P(5.5, 4));
+        r = c.insert(c.end(), P(5.5, static_cast<short>(4)));
         assert(c.size() == 3);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         typedef C::iterator R;
         typedef std::pair<MoveOnly, MoveOnly> P;
int main()
     }
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
         typedef C::iterator R;
         typedef std::pair<double, short> P;
         C c;
         C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
+        R r = c.insert(e, P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(3.5, 4));
+        r = c.insert(c.end(), P(3.5, static_cast<short>(4)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(4.5, 4));
+        r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 4.5);
         assert(r->second == 4);
 
-        r = c.insert(c.end(), P(5.5, 4));
+        r = c.insert(c.end(), P(5.5, static_cast<short>(4)));
         assert(c.size() == 3);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
     {
         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
         typedef C::iterator R;

test/std/containers/unord/unord.map/unord.map.modifiers/insert_rvalue.pass.cpp

 
 int main()
 {
     {
         typedef std::unordered_map<double, int> C;
         typedef std::pair<C::iterator, bool> R;
         typedef std::pair<double, short> P;
         C c;
-        R r = c.insert(P(3.5, 3));
+        R r = c.insert(P(3.5, static_cast<short>(3)));
         assert(r.second);
         assert(c.size() == 1);
         assert(r.first->first == 3.5);
         assert(r.first->second == 3);
 
-        r = c.insert(P(3.5, 4));
+        r = c.insert(P(3.5, static_cast<short>(4)));
         assert(!r.second);
         assert(c.size() == 1);
         assert(r.first->first == 3.5);
         assert(r.first->second == 3);
 
-        r = c.insert(P(4.5, 4));
+        r = c.insert(P(4.5, static_cast<short>(4)));
         assert(r.second);
         assert(c.size() == 2);
         assert(r.first->first == 4.5);
         assert(r.first->second == 4);
 
-        r = c.insert(P(5.5, 4));
+        r = c.insert(P(5.5, static_cast<short>(4)));
         assert(r.second);
         assert(c.size() == 3);
         assert(r.first->first == 5.5);
         assert(r.first->second == 4);
     }
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         typedef std::pair<C::iterator, bool> R;
int main()
         assert(r.first->second == 4);
     }
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
         typedef std::pair<C::iterator, bool> R;
         typedef std::pair<double, short> P;
         C c;
-        R r = c.insert(P(3.5, 3));
+        R r = c.insert(P(3.5, static_cast<short>(3)));
         assert(r.second);
         assert(c.size() == 1);
         assert(r.first->first == 3.5);
         assert(r.first->second == 3);
 
-        r = c.insert(P(3.5, 4));
+        r = c.insert(P(3.5, static_cast<short>(4)));
         assert(!r.second);
         assert(c.size() == 1);
         assert(r.first->first == 3.5);
         assert(r.first->second == 3);
 
-        r = c.insert(P(4.5, 4));
+        r = c.insert(P(4.5, static_cast<short>(4)));
         assert(r.second);
         assert(c.size() == 2);
         assert(r.first->first == 4.5);
         assert(r.first->second == 4);
 
-        r = c.insert(P(5.5, 4));
+        r = c.insert(P(5.5, static_cast<short>(4)));
         assert(r.second);
         assert(c.size() == 3);
         assert(r.first->first == 5.5);
         assert(r.first->second == 4);
     }
     {
         typedef std::unordered_map<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp

 int main()
 {
     {
         typedef std::unordered_multimap<double, int> C;
         typedef C::iterator R;
         typedef std::pair<double, short> P;
         C c;
         C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
+        R r = c.insert(e, P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(r, P(3.5, 4));
+        r = c.insert(r, P(3.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 3.5);
         assert(r->second == 4);
 
-        r = c.insert(c.end(), P(4.5, 4));
+        r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
         assert(c.size() == 3);
         assert(r->first == 4.5);
         assert(r->second == 4);
 
-        r = c.insert(c.end(), P(5.5, 4));
+        r = c.insert(c.end(), P(5.5, static_cast<short>(4)));
         assert(c.size() == 4);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
         typedef C::iterator R;
         typedef std::pair<MoveOnly, MoveOnly> P;
int main()
     }
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
         typedef C::iterator R;
         typedef std::pair<double, short> P;
         C c;
         C::const_iterator e = c.end();
-        R r = c.insert(e, P(3.5, 3));
+        R r = c.insert(e, P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(r, P(3.5, 4));
+        r = c.insert(r, P(3.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 3.5);
         assert(r->second == 4);
 
-        r = c.insert(c.end(), P(4.5, 4));
+        r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
         assert(c.size() == 3);
         assert(r->first == 4.5);
         assert(r->second == 4);
 
-        r = c.insert(c.end(), P(5.5, 4));
+        r = c.insert(c.end(), P(5.5, static_cast<short>(4)));
         assert(c.size() == 4);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
         typedef C::iterator R;

test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_rvalue.pass.cpp

 
 int main()
 {
     {
         typedef std::unordered_multimap<double, int> C;
         typedef C::iterator R;
         typedef std::pair<double, short> P;
         C c;
-        R r = c.insert(P(3.5, 3));
+        R r = c.insert(P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(P(3.5, 4));
+        r = c.insert(P(3.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 3.5);
         assert(r->second == 4);
 
-        r = c.insert(P(4.5, 4));
+        r = c.insert(P(4.5, static_cast<short>(4)));
         assert(c.size() == 3);
         assert(r->first == 4.5);
         assert(r->second == 4);
 
-        r = c.insert(P(5.5, 4));
+        r = c.insert(P(5.5, static_cast<short>(4)));
         assert(c.size() == 4);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly> C;
         typedef C::iterator R;
         typedef std::pair<MoveOnly, MoveOnly> P;
int main()
         assert(r->second == 4);
     }
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
         typedef C::iterator R;
         typedef std::pair<double, short> P;
         C c;
-        R r = c.insert(P(3.5, 3));
+        R r = c.insert(P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(P(3.5, 4));
+        r = c.insert(P(3.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 3.5);
         assert(r->second == 4);
 
-        r = c.insert(P(4.5, 4));
+        r = c.insert(P(4.5, static_cast<short>(4)));
         assert(c.size() == 3);
         assert(r->first == 4.5);
         assert(r->second == 4);
 
-        r = c.insert(P(5.5, 4));
+        r = c.insert(P(5.5, static_cast<short>(4)));
         assert(c.size() == 4);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
     {
         typedef std::unordered_multimap<MoveOnly, MoveOnly, std::hash<MoveOnly>, std::equal_to<MoveOnly>,
                             min_allocator<std::pair<const MoveOnly, MoveOnly>>> C;
         typedef C::iterator R;

test/std/utilities/utility/pairs/pair.astuple/get_const.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 int main()
 {
     {
         typedef std::pair<int, short> P;
-        const P p(3, 4);
+        const P p(3, static_cast<short>(4));
         assert(std::get<0>(p) == 3);
         assert(std::get<1>(p) == 4);
     }
 
 #if TEST_STD_VER > 11
     {
         typedef std::pair<int, short> P;
-        constexpr P p1(3, 4);
+        constexpr P p1(3, static_cast<short>(4));
         static_assert(std::get<0>(p1) == 3, "");
         static_assert(std::get<1>(p1) == 4, "");
     }
 #endif
 }

test/std/utilities/utility/pairs/pair.astuple/get_const_rv.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 int main()
 {
     {
     typedef std::pair<std::unique_ptr<int>, short> P;
-    const P p(std::unique_ptr<int>(new int(3)), 4);
+    const P p(std::unique_ptr<int>(new int(3)), static_cast<short>(4));
     static_assert(std::is_same<const std::unique_ptr<int>&&, decltype(std::get<0>(std::move(p)))>::value, "");
     static_assert(noexcept(std::get<0>(std::move(p))), "");
     const std::unique_ptr<int>&& ptr = std::get<0>(std::move(p));
     assert(*ptr == 3);
     }
 
     {
     int x = 42;
int main()
     static_assert(noexcept(std::get<0>(std::move(p))), "");
     static_assert(std::is_same<int const&&, decltype(std::get<1>(std::move(p)))>::value, "");
     static_assert(noexcept(std::get<1>(std::move(p))), "");
     }
 
 #if TEST_STD_VER > 11
     {
     typedef std::pair<int, short> P;
-    constexpr const P p1(3, 4);
+    constexpr const P p1(3, static_cast<short>(4));
     static_assert(std::get<0>(std::move(p1)) == 3, "");
     static_assert(std::get<1>(std::move(p1)) == 4, "");
     }
 #endif
 }

test/std/utilities/utility/pairs/pair.astuple/get_non_const.pass.cpp

 
 constexpr std::pair<int, int> getP () { return { 3, 4 }; }
 #endif
 
 int main()
 {
     {
         typedef std::pair<int, short> P;
-        P p(3, 4);
+        P p(3, static_cast<short>(4));
         assert(std::get<0>(p) == 3);
         assert(std::get<1>(p) == 4);
         std::get<0>(p) = 5;
         std::get<1>(p) = 6;
         assert(std::get<0>(p) == 5);
         assert(std::get<1>(p) == 6);
     }
 
 #if TEST_STD_VER > 11
     {
         static_assert(S().k == 1, "");
         static_assert(std::get<1>(getP()) == 4, "");
     }
 #endif
 
 }

test/std/utilities/utility/pairs/pair.astuple/get_rv.pass.cpp

 #include <utility>
 #include <memory>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::pair<std::unique_ptr<int>, short> P;
-        P p(std::unique_ptr<int>(new int(3)), 4);
+        P p(std::unique_ptr<int>(new int(3)), static_cast<short>(4));
         std::unique_ptr<int> ptr = std::get<0>(std::move(p));
         assert(*ptr == 3);
     }
 }

test/std/utilities/utility/pairs/pairs.pair/assign_const_pair_U_V.pass.cpp

 #include <utility>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::pair<int, short> P1;
         typedef std::pair<double, long> P2;
-        P1 p1(3, 4);
+        P1 p1(3, static_cast<short>(4));
         P2 p2;
         p2 = p1;
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
 }

test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair_U_V.pass.cpp

 {
 };
 
 int main()
 {
     {
         typedef std::pair<std::unique_ptr<Derived>, short> P1;
         typedef std::pair<std::unique_ptr<Base>, long> P2;
-        P1 p1(std::unique_ptr<Derived>(), 4);
+        P1 p1(std::unique_ptr<Derived>(), static_cast<short>(4));
         P2 p2;
         p2 = std::move(p1);
         assert(p2.first == nullptr);
         assert(p2.second == 4);
     }
 }

test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V_cxx03.pass.cpp

 #include <utility>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::pair<int, short> P1;
         typedef std::pair<double, long> P2;
-        const P1 p1(3, 4);
+        const P1 p1(3, static_cast<short>(4));
         const P2 p2 = p1;
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
 }

test/std/utilities/utility/pairs/pairs.pair/copy_ctor.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 int main()
 {
     {
         typedef std::pair<int, short> P1;
-        P1 p1(3, 4);
+        P1 p1(3, static_cast<short>(4));
         P1 p2 = p1;
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
 #if TEST_STD_VER > 11
     {
         typedef std::pair<int, short> P1;
-        constexpr P1 p1(3, 4);
+        constexpr P1 p1(3, static_cast<short>(4));
         constexpr P1 p2 = p1;
         static_assert(p2.first == 3, "");
         static_assert(p2.second == 4, "");
     }
 #endif
 }

test/std/utilities/utility/pairs/pairs.pair/move_ctor.pass.cpp

struct Dummy {
   Dummy(Dummy &&) = default;
 };
 
 int main()
 {
     {
         typedef std::pair<int, short> P1;
         static_assert(std::is_move_constructible<P1>::value, "");
-        P1 p1(3, 4);
+        P1 p1(3, static_cast<short>(4));
         P1 p2 = std::move(p1);
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
     {
         using P = std::pair<Dummy, int>;
         static_assert(!std::is_copy_constructible<P>::value, "");
         static_assert(std::is_move_constructible<P>::value, "");
     }
 }

test/std/utilities/utility/pairs/pairs.pair/swap.pass.cpp

struct S {
     S const * operator& () const { assert(false); return this; }
     bool operator==(int x) const { return i == x; }
     };
 
 int main()
 {
     {
         typedef std::pair<int, short> P1;
-        P1 p1(3, 4);
-        P1 p2(5, 6);
+        P1 p1(3, static_cast<short>(4));
+        P1 p2(5, static_cast<short>(6));
         p1.swap(p2);
         assert(p1.first == 5);
         assert(p1.second == 6);
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
     {
         typedef std::pair<int, S> P1;

test/std/utilities/utility/pairs/pairs.spec/comparison.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 int main()
 {
     {
         typedef std::pair<int, short> P;
-        P p1(3, 4);
-        P p2(3, 4);
+        P p1(3, static_cast<short>(4));
+        P p2(3, static_cast<short>(4));
         assert( (p1 == p2));
         assert(!(p1 != p2));
         assert(!(p1 <  p2));
         assert( (p1 <= p2));
         assert(!(p1 >  p2));
         assert( (p1 >= p2));
     }
     {
         typedef std::pair<int, short> P;
-        P p1(2, 4);
-        P p2(3, 4);
+        P p1(2, static_cast<short>(4));
+        P p2(3, static_cast<short>(4));
         assert(!(p1 == p2));
         assert( (p1 != p2));
         assert( (p1 <  p2));
         assert( (p1 <= p2));
         assert(!(p1 >  p2));
         assert(!(p1 >= p2));
     }
     {
         typedef std::pair<int, short> P;
-        P p1(3, 2);
-        P p2(3, 4);
+        P p1(3, static_cast<short>(2));
+        P p2(3, static_cast<short>(4));
         assert(!(p1 == p2));
         assert( (p1 != p2));
         assert( (p1 <  p2));
         assert( (p1 <= p2));
         assert(!(p1 >  p2));
         assert(!(p1 >= p2));
     }
     {
         typedef std::pair<int, short> P;
-        P p1(3, 4);
-        P p2(2, 4);
+        P p1(3, static_cast<short>(4));
+        P p2(2, static_cast<short>(4));
         assert(!(p1 == p2));
         assert( (p1 != p2));
         assert(!(p1 <  p2));
         assert(!(p1 <= p2));
         assert( (p1 >  p2));
         assert( (p1 >= p2));
     }
     {
         typedef std::pair<int, short> P;
-        P p1(3, 4);
-        P p2(3, 2);
+        P p1(3, static_cast<short>(4));
+        P p2(3, static_cast<short>(2));
         assert(!(p1 == p2));
         assert( (p1 != p2));
         assert(!(p1 <  p2));
         assert(!(p1 <= p2));
         assert( (p1 >  p2));
         assert( (p1 >= p2));
     }
 
 #if TEST_STD_VER > 11
     {
         typedef std::pair<int, short> P;
-        constexpr P p1(3, 4);
-        constexpr P p2(3, 2);
+        constexpr P p1(3, static_cast<short>(4));
+        constexpr P p2(3, static_cast<short>(2));
         static_assert(!(p1 == p2), "");
         static_assert( (p1 != p2), "");
         static_assert(!(p1 <  p2), "");
         static_assert(!(p1 <= p2), "");
         static_assert( (p1 >  p2), "");
         static_assert( (p1 >= p2), "");
     }
 #endif
 }

test/std/utilities/utility/pairs/pairs.spec/non_member_swap.pass.cpp

 
 #include <utility>
 #include <cassert>
 
 int main()
 {
     {
         typedef std::pair<int, short> P1;
-        P1 p1(3, 4);
-        P1 p2(5, 6);
+        P1 p1(3, static_cast<short>(4));
+        P1 p2(5, static_cast<short>(6));
         swap(p1, p2);
         assert(p1.first == 5);
         assert(p1.second == 6);
         assert(p2.first == 3);
         assert(p2.second == 4);
     }
 }