From a13b5832fca9fb734c2a397595741f774e48fd2a Mon Sep 17 00:00:00 2001
From: _Redstone_c_ <myredstone1024@gmail.com>
Date: Tue, 11 Jan 2022 23:21:05 +0800
Subject: [PATCH] feat(typetraits): add TCommonReference and the corresponding
 testing

---
 .../Private/Testing/TypeTraitsTesting.cpp     |  4 ++++
 .../Source/Public/TypeTraits/Miscellaneous.h  | 19 ++++++++++---------
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/Redcraft.Utility/Source/Private/Testing/TypeTraitsTesting.cpp b/Redcraft.Utility/Source/Private/Testing/TypeTraitsTesting.cpp
index afbbab1..c608dc0 100644
--- a/Redcraft.Utility/Source/Private/Testing/TypeTraitsTesting.cpp
+++ b/Redcraft.Utility/Source/Private/Testing/TypeTraitsTesting.cpp
@@ -413,6 +413,10 @@ void TestTypeTraits()
 	always_check((TIsSame<int64, TCommonType<int8, int32, int64>::Type>::Value));
 	always_check((TIsSame<double, TCommonType<float, double>::Type>::Value));
 
+	always_check((TIsSame<int32, TCommonReference<int8, int32>::Type>::Value));
+	always_check((TIsSame<int64, TCommonReference<int8, int32, int64>::Type>::Value));
+	always_check((TIsSame<double, TCommonReference<float, double>::Type>::Value));
+
 	always_check((TIsSame<int, TUnderlyingType<ETestEnumClass>::Type>::Value));
 	always_check((TIsSame<uint8, TUnderlyingType<ETestEnumClass8>::Type>::Value));
 	always_check((TIsSame<uint32, TUnderlyingType<ETestEnumClass32>::Type>::Value));
diff --git a/Redcraft.Utility/Source/Public/TypeTraits/Miscellaneous.h b/Redcraft.Utility/Source/Public/TypeTraits/Miscellaneous.h
index c4c9b32..a51a471 100644
--- a/Redcraft.Utility/Source/Public/TypeTraits/Miscellaneous.h
+++ b/Redcraft.Utility/Source/Public/TypeTraits/Miscellaneous.h
@@ -45,15 +45,16 @@ template <typename T> struct TRemoveAllExtents { using Type = NAMESPACE_STD::rem
 template <typename T> struct TMakeSigned   { using Type = NAMESPACE_STD::make_signed_t<T>;   };
 template <typename T> struct TMakeUnsigned { using Type = NAMESPACE_STD::make_unsigned_t<T>; };
 
-template <size_t Size, size_t Align>      struct TAlignedStorage { class Type { struct alignas(Align) { uint8 Pad[Size]; } Padding; }; };
-template <size_t Size, typename... Types> struct TAlignedUnion   { using Type = TAlignedStorage<NAMESPACE_PRIVATE::TMaximum<Size, sizeof(Types)...>::Value, NAMESPACE_PRIVATE::TMaximum<alignof(Types)...>::Value>::Type; };
-template <typename T>                     struct TDecay          { using Type = NAMESPACE_STD::decay_t<T>;                      };
-template <bool B, typename T = void>      struct TEnableIf       { using Type = NAMESPACE_STD::enable_if_t<B, T>;               };
-template <bool B, typename T, typename F> struct TConditional    { using Type = NAMESPACE_STD::conditional_t<B, T, F>;          };
-template <typename... Types>              struct TCommonType     { using Type = NAMESPACE_STD::common_type_t<Types...>;         };
-template <typename T>                     struct TUnderlyingType { using Type = NAMESPACE_STD::underlying_type_t<T>;            };
-template <typename F, typename... Args>   struct TInvokeResult   { using Type = NAMESPACE_STD::invoke_result_t<F, Args...>;     }; // FIXME: The result for char(&())[2] is wrong on MSVC
-template <typename... Types>              struct TVoid           { using Type = void;                                           };
+template <size_t Size, size_t Align>      struct TAlignedStorage  { class Type { struct alignas(Align) { uint8 Pad[Size]; } Padding; }; };
+template <size_t Size, typename... Types> struct TAlignedUnion    { using Type = TAlignedStorage<NAMESPACE_PRIVATE::TMaximum<Size, sizeof(Types)...>::Value, NAMESPACE_PRIVATE::TMaximum<alignof(Types)...>::Value>::Type; };
+template <typename T>                     struct TDecay           { using Type = NAMESPACE_STD::decay_t<T>;                      };
+template <bool B, typename T = void>      struct TEnableIf        { using Type = NAMESPACE_STD::enable_if_t<B, T>;               };
+template <bool B, typename T, typename F> struct TConditional     { using Type = NAMESPACE_STD::conditional_t<B, T, F>;          };
+template <typename... Types>              struct TCommonType      { using Type = NAMESPACE_STD::common_type_t<Types...>;         };
+template <typename... Types>              struct TCommonReference { using Type = NAMESPACE_STD::common_reference_t<Types...>;    };
+template <typename T>                     struct TUnderlyingType  { using Type = NAMESPACE_STD::underlying_type_t<T>;            };
+template <typename F, typename... Args>   struct TInvokeResult    { using Type = NAMESPACE_STD::invoke_result_t<F, Args...>;     }; // FIXME: The result for char(&())[2] is wrong on MSVC
+template <typename... Types>              struct TVoid            { using Type = void;                                           };
 
 NAMESPACE_MODULE_END(Utility)
 NAMESPACE_MODULE_END(Redcraft)