[libcxx] [test] Avoid P0138R2, direct-list-init of fixed enums from integers.

[STL_MSFT]

Summary

[libcxx] [test] Avoid P0138R2, direct-list-init of fixed enums from integers.

This C++17 Core Language feature isn't necessary when testing std::byte.
It's a minor convenience, but it limits test coverage to very new compilers.

(I encountered this because C1XX currently has a bug in this feature, and our Clang/C2 is still 3.8 and missing this feature. But these tests had UNSUPPORTED comments knocking out several versions of Clang, so the impact isn't just limited to us.)

[EricWF]

Could you add a separate test that performs direct-list-init of fixed enums from integers, and XFAIL it accordingly? Testing it found a bug, so I don't want to complete eliminate that test coverage.

Other than that this LGTM.

test/std/language.support/support.types/byteops/and.assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // constexpr byte& operator &=(byte l, byte r) noexcept;
 
 
 constexpr std::byte test(std::byte b1, std::byte b2) {
   std::byte bret = b1;
   return bret &= b2;
   }
 
 
 int main () {
   std::byte b;  // not constexpr, just used in noexcept check
-  constexpr std::byte b1{1};
-  constexpr std::byte b8{8};
-  constexpr std::byte b9{9};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b8{static_cast<std::byte>(8)};
+  constexpr std::byte b9{static_cast<std::byte>(9)};
 
   static_assert(noexcept(b &= b), "" );
 
   static_assert(std::to_integer<int>(test(b1, b8)) == 0, "");
   static_assert(std::to_integer<int>(test(b1, b9)) == 1, "");
   static_assert(std::to_integer<int>(test(b8, b9)) == 8, "");
 
   static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
   static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
   static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
 }

test/std/language.support/support.types/byteops/and.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // constexpr byte operator&(byte l, byte r) noexcept;
 
 int main () {
-  constexpr std::byte b1{1};
-  constexpr std::byte b8{8};
-  constexpr std::byte b9{9};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b8{static_cast<std::byte>(8)};
+  constexpr std::byte b9{static_cast<std::byte>(9)};
 
   static_assert(noexcept(b1 & b8), "" );
 
   static_assert(std::to_integer<int>(b1 & b8) ==  0, "");
   static_assert(std::to_integer<int>(b1 & b9) ==  1, "");
   static_assert(std::to_integer<int>(b8 & b9) ==  8, "");
 
   static_assert(std::to_integer<int>(b8 & b1) ==  0, "");
   static_assert(std::to_integer<int>(b9 & b1) ==  1, "");
   static_assert(std::to_integer<int>(b9 & b8) ==  8, "");
 }

test/std/language.support/support.types/byteops/lshift.assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //   constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept;
 // This function shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 
 constexpr std::byte test(std::byte b) {
   return b <<= 2;
   }
 
 
 int main () {
   std::byte b;  // not constexpr, just used in noexcept check
-  constexpr std::byte b2{2};
-  constexpr std::byte b3{3};
+  constexpr std::byte b2{static_cast<std::byte>(2)};
+  constexpr std::byte b3{static_cast<std::byte>(3)};
 
   static_assert(noexcept(b <<= 2), "" );
   
   static_assert(std::to_integer<int>(test(b2)) ==  8, "" );
   static_assert(std::to_integer<int>(test(b3)) == 12, "" );
 
 }

test/std/language.support/support.types/byteops/lshift.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //    constexpr byte operator <<(byte b, IntegerType shift) noexcept;
 // These functions shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-  constexpr std::byte b1{1};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
   constexpr std::byte b2 = b1 << 2.0f;
 }

test/std/language.support/support.types/byteops/lshift.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //    constexpr byte operator <<(byte b, IntegerType shift) noexcept;
 // These functions shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-  constexpr std::byte b1{1};
-  constexpr std::byte b3{3};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b3{static_cast<std::byte>(3)};
   
   static_assert(noexcept(b3 << 2), "" );
 
   static_assert(std::to_integer<int>(b1 << 1) ==   2, "");
   static_assert(std::to_integer<int>(b1 << 2) ==   4, "");
   static_assert(std::to_integer<int>(b3 << 4) ==  48, "");
   static_assert(std::to_integer<int>(b3 << 6) == 192, "");  
 }

test/std/language.support/support.types/byteops/not.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // constexpr byte operator~(byte b) noexcept;
 
 int main () {
-  constexpr std::byte b1{1};
-  constexpr std::byte b2{2};
-  constexpr std::byte b8{8};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b2{static_cast<std::byte>(2)};
+  constexpr std::byte b8{static_cast<std::byte>(8)};
 
   static_assert(noexcept(~b1), "" );
 
   static_assert(std::to_integer<int>(~b1) == 254, "");
   static_assert(std::to_integer<int>(~b2) == 253, "");
   static_assert(std::to_integer<int>(~b8) == 247, "");
 }

test/std/language.support/support.types/byteops/or.assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // constexpr byte& operator |=(byte l, byte r) noexcept;
 
 
 constexpr std::byte test(std::byte b1, std::byte b2) {
   std::byte bret = b1;
   return bret |= b2;
   }
 
 
 int main () {
   std::byte b;  // not constexpr, just used in noexcept check
-  constexpr std::byte b1{1};
-  constexpr std::byte b2{2};
-  constexpr std::byte b8{8};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b2{static_cast<std::byte>(2)};
+  constexpr std::byte b8{static_cast<std::byte>(8)};
 
   static_assert(noexcept(b |= b), "" );
 
   static_assert(std::to_integer<int>(test(b1, b2)) ==  3, "");
   static_assert(std::to_integer<int>(test(b1, b8)) ==  9, "");
   static_assert(std::to_integer<int>(test(b2, b8)) == 10, "");
 
   static_assert(std::to_integer<int>(test(b2, b1)) ==  3, "");
   static_assert(std::to_integer<int>(test(b8, b1)) ==  9, "");
   static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
 
 }

test/std/language.support/support.types/byteops/or.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // constexpr byte operator|(byte l, byte r) noexcept;
 
 int main () {
-  constexpr std::byte b1{1};
-  constexpr std::byte b2{2};
-  constexpr std::byte b8{8};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b2{static_cast<std::byte>(2)};
+  constexpr std::byte b8{static_cast<std::byte>(8)};
 
   static_assert(noexcept(b1 | b2), "" );
 
   static_assert(std::to_integer<int>(b1 | b2) ==  3, "");
   static_assert(std::to_integer<int>(b1 | b8) ==  9, "");
   static_assert(std::to_integer<int>(b2 | b8) == 10, "");
 
   static_assert(std::to_integer<int>(b2 | b1) ==  3, "");
   static_assert(std::to_integer<int>(b8 | b1) ==  9, "");
   static_assert(std::to_integer<int>(b8 | b2) == 10, "");
 }

test/std/language.support/support.types/byteops/rshift.assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //   constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept;
 // This function shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 
 constexpr std::byte test(std::byte b) {
   return b >>= 2;
   }
 
 
 int main () {
   std::byte b;  // not constexpr, just used in noexcept check
-  constexpr std::byte b16{16};
-  constexpr std::byte b192{192};
+  constexpr std::byte b16{static_cast<std::byte>(16)};
+  constexpr std::byte b192{static_cast<std::byte>(192)};
 
   static_assert(noexcept(b >>= 2), "" );
 
   static_assert(std::to_integer<int>(test(b16))  ==  4, "" );
   static_assert(std::to_integer<int>(test(b192)) == 48, "" );
 }

test/std/language.support/support.types/byteops/rshift.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //    constexpr byte operator >>(byte b, IntegerType shift) noexcept;
 // These functions shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-  constexpr std::byte b1{1};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
   constexpr std::byte b2 = b1 >> 2.0f;
 }

test/std/language.support/support.types/byteops/rshift.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //    constexpr byte operator <<(byte b, IntegerType shift) noexcept;
 // These functions shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 
 constexpr std::byte test(std::byte b) {
   return b <<= 2;
   }
 
 
 int main () {
-  constexpr std::byte b100{100};
-  constexpr std::byte b115{115};
+  constexpr std::byte b100{static_cast<std::byte>(100)};
+  constexpr std::byte b115{static_cast<std::byte>(115)};
   
   static_assert(noexcept(b100 << 2), "" );
 
   static_assert(std::to_integer<int>(b100 >> 1) ==  50, "");
   static_assert(std::to_integer<int>(b100 >> 2) ==  25, "");
   static_assert(std::to_integer<int>(b115 >> 3) ==  14, "");
   static_assert(std::to_integer<int>(b115 >> 6) ==   1, "");  
 
 }

test/std/language.support/support.types/byteops/to_integer.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //    constexpr IntegerType to_integer(byte b) noexcept;
 // This function shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-  constexpr std::byte b1{1};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
   auto f = std::to_integer<float>(b1);
 }

test/std/language.support/support.types/byteops/to_integer.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // template <class IntegerType>
 //    constexpr IntegerType to_integer(byte b) noexcept;
 // This function shall not participate in overload resolution unless 
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-  constexpr std::byte b1{1};
-  constexpr std::byte b3{3};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b3{static_cast<std::byte>(3)};
   
   static_assert(noexcept(std::to_integer<int>(b1)), "" );
   static_assert(std::is_same<int, decltype(std::to_integer<int>(b1))>::value, "" );
   static_assert(std::is_same<long, decltype(std::to_integer<long>(b1))>::value, "" );
   static_assert(std::is_same<unsigned short, decltype(std::to_integer<unsigned short>(b1))>::value, "" );
 
   static_assert(std::to_integer<int>(b1) == 1, "");
   static_assert(std::to_integer<int>(b3) == 3, "");
 }

test/std/language.support/support.types/byteops/xor.assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // constexpr byte& operator ^=(byte l, byte r) noexcept;
 
 
 constexpr std::byte test(std::byte b1, std::byte b2) {
   std::byte bret = b1;
   return bret ^= b2;
   }
 
 
 int main () {
   std::byte b;  // not constexpr, just used in noexcept check
-  constexpr std::byte b1{1};
-  constexpr std::byte b8{8};
-  constexpr std::byte b9{9};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b8{static_cast<std::byte>(8)};
+  constexpr std::byte b9{static_cast<std::byte>(9)};
 
   static_assert(noexcept(b ^= b), "" );
 
   static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
   static_assert(std::to_integer<int>(test(b1, b9)) == 8, "");
   static_assert(std::to_integer<int>(test(b8, b9)) == 1, "");
 
   static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
   static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
   static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
 }

test/std/language.support/support.types/byteops/xor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstddef>
 #include <test_macros.h>
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
-// The following compilers don't like "std::byte b1{1}"
-// UNSUPPORTED: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// UNSUPPORTED: apple-clang-6, apple-clang-7, apple-clang-8.0
 
 // constexpr byte operator^(byte l, byte r) noexcept;
 
 int main () {
-  constexpr std::byte b1{1};
-  constexpr std::byte b8{8};
-  constexpr std::byte b9{9};
+  constexpr std::byte b1{static_cast<std::byte>(1)};
+  constexpr std::byte b8{static_cast<std::byte>(8)};
+  constexpr std::byte b9{static_cast<std::byte>(9)};
 
   static_assert(noexcept(b1 ^ b8), "" );
 
   static_assert(std::to_integer<int>(b1 ^ b8) == 9, "");
   static_assert(std::to_integer<int>(b1 ^ b9) == 8, "");
   static_assert(std::to_integer<int>(b8 ^ b9) == 1, "");
 
   static_assert(std::to_integer<int>(b8 ^ b1) == 9, "");
   static_assert(std::to_integer<int>(b9 ^ b1) == 8, "");
   static_assert(std::to_integer<int>(b9 ^ b8) == 1, "");
 }