From c424ec3a0d9c4a531b84fca63853ae94b57937e0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 31 Oct 2020 18:45:41 -0700
Subject: [PATCH 1/5] Use is_empty_v.

---
 stl/inc/xmemory | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index eef57cdbbf8..0d9926f45d4 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -397,7 +397,7 @@ struct _Get_propagate_on_container_swap<_Ty, void_t<typename _Ty::propagate_on_c
 // STRUCT TEMPLATE _Get_is_always_equal
 template <class _Ty, class = void>
 struct _Get_is_always_equal {
-    using type = typename is_empty<_Ty>::type;
+    using type = bool_constant<is_empty_v<_Ty>>;
 };
 
 template <class _Ty>

From 0d33af2fa10fa7408e05e248425bc4cf3921e309 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 31 Oct 2020 18:52:39 -0700
Subject: [PATCH 2/5] Use is_same_v.

---
 stl/inc/xtree | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/xtree b/stl/inc/xtree
index fc0276ba0fc..1b22fb347dc 100644
--- a/stl/inc/xtree
+++ b/stl/inc/xtree
@@ -1759,7 +1759,7 @@ protected:
         _Nodeptr _Newroot = _Scary->_Myhead; // point at nil node
 
         if (!_Rootnode->_Isnil) { // copy or move a node, then any subtrees
-            typename is_same<key_type, value_type>::type _Is_set;
+            bool_constant<is_same_v<key_type, value_type>> _Is_set;
             _Nodeptr _Pnode = _Copy_or_move(_Rootnode->_Myval, _Movefl, _Is_set);
             _Pnode->_Parent = _Wherenode;
             _Pnode->_Color  = _Rootnode->_Color;

From f84b293edbf1cb498a206058189e41fcfc1fa138 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 31 Oct 2020 18:54:54 -0700
Subject: [PATCH 3/5] Use static_cast<_Uty>.

---
 stl/inc/random | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stl/inc/random b/stl/inc/random
index 1854b1f234d..d18a00e7f7d 100644
--- a/stl/inc/random
+++ b/stl/inc/random
@@ -1824,12 +1824,12 @@ private:
     result_type _Eval(_Engine& _Eng, _Ty _Min, _Ty _Max) const { // compute next value in range [_Min, _Max]
         _Rng_from_urng<_Uty, _Engine> _Generator(_Eng);
 
-        const _Uty _Umin = _Adjust(_Uty(_Min));
-        const _Uty _Umax = _Adjust(_Uty(_Max));
+        const _Uty _Umin = _Adjust(static_cast<_Uty>(_Min));
+        const _Uty _Umax = _Adjust(static_cast<_Uty>(_Max));
 
         _Uty _Uret;
 
-        if (_Umax - _Umin == _Uty(-1)) {
+        if (_Umax - _Umin == static_cast<_Uty>(-1)) {
             _Uret = static_cast<_Uty>(_Generator._Get_all_bits());
         } else {
             _Uret = static_cast<_Uty>(_Generator(static_cast<_Uty>(_Umax - _Umin + 1)));
@@ -1843,7 +1843,7 @@ private:
     }
 
     static _Uty _Adjust(_Uty _Uval, true_type) { // convert signed ranges to unsigned ranges and vice versa
-        const _Uty _Adjuster = (_Uty(-1) >> 1) + 1; // 2^(N-1)
+        const _Uty _Adjuster = (static_cast<_Uty>(-1) >> 1) + 1; // 2^(N-1)
 
         if (_Uval < _Adjuster) {
             return static_cast<_Uty>(_Uval + _Adjuster);

From 795b3b848e60f86a5d6918953116fec4911ea7c6 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 31 Oct 2020 19:07:21 -0700
Subject: [PATCH 4/5] Use `if constexpr` with is_signed_v.

Both sides compile even when `if constexpr` is unavailable.
---
 stl/inc/random | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/stl/inc/random b/stl/inc/random
index d18a00e7f7d..2b7dd90f05c 100644
--- a/stl/inc/random
+++ b/stl/inc/random
@@ -1839,23 +1839,19 @@ private:
     }
 
     static _Uty _Adjust(_Uty _Uval) { // convert signed ranges to unsigned ranges and vice versa
-        return _Adjust(_Uval, is_signed<_Ty>{});
-    }
-
-    static _Uty _Adjust(_Uty _Uval, true_type) { // convert signed ranges to unsigned ranges and vice versa
-        const _Uty _Adjuster = (static_cast<_Uty>(-1) >> 1) + 1; // 2^(N-1)
+        if _CONSTEXPR_IF (is_signed_v<_Ty>) {
+            const _Uty _Adjuster = (static_cast<_Uty>(-1) >> 1) + 1; // 2^(N-1)
 
-        if (_Uval < _Adjuster) {
-            return static_cast<_Uty>(_Uval + _Adjuster);
-        } else {
-            return static_cast<_Uty>(_Uval - _Adjuster);
+            if (_Uval < _Adjuster) {
+                return static_cast<_Uty>(_Uval + _Adjuster);
+            } else {
+                return static_cast<_Uty>(_Uval - _Adjuster);
+            }
+        } else { // _Ty is already unsigned, do nothing
+            return _Uval;
         }
     }
 
-    static _Uty _Adjust(_Uty _Uval, false_type) { // _Ty is already unsigned, do nothing
-        return _Uval;
-    }
-
     param_type _Par;
 };
 

From 39b77a9ef3368b97c746089b9b07b71bda75f6e0 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Sat, 31 Oct 2020 19:16:41 -0700
Subject: [PATCH 5/5] Use is_signed_v.

---
 stl/inc/xutility | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stl/inc/xutility b/stl/inc/xutility
index bf788238d23..c75e08c6660 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -5466,7 +5466,8 @@ _NODISCARD constexpr bool _Within_limits(const _Ty& _Val, false_type, false_type
 template <class _InIt, class _Ty>
 _NODISCARD constexpr bool _Within_limits(_InIt, const _Ty& _Val) { // check whether _Val is within the limits of _Elem
     using _Elem = remove_pointer_t<_InIt>;
-    return _Within_limits(_Val, is_signed<_Elem>{}, is_signed<_Ty>{}, bool_constant<-1 == static_cast<_Ty>(-1)>{});
+    return _Within_limits(_Val, bool_constant<is_signed_v<_Elem>>{}, bool_constant<is_signed_v<_Ty>>{},
+        bool_constant<-1 == static_cast<_Ty>(-1)>{});
 }
 
 template <class _InIt>