Backporting to Xcode 13

Author: gershnik

include/objc-helpers/BoxUtil.h

@@ -25,6 +25,7 @@
 #include <ostream>
 #include <sstream>
 #include <filesystem>
+#include <compare>
 
 
 /**
@@ -120,7 +121,7 @@ namespace BoxMakerDetail __attribute__((visibility("hidden"))) {
 template<class T>
 class __attribute__((visibility("hidden"))) BoxMaker {
 private:
-    static consteval auto detectBoxedType() {
+    static constexpr auto detectBoxedType() {
         if constexpr (std::totally_ordered<T>) {
             if constexpr (std::is_copy_constructible_v<T>) {
                 return (NSObject<BoxedValue, BoxedComparable, NSCopying> *)nullptr;
@@ -284,8 +285,13 @@ class __attribute__((visibility("hidden"))) BoxMaker {
             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:@"comparison operand is of invalid type" userInfo:nullptr];
         auto * val = (T *)classData.addrOfValue(self);
         auto * otherVal = (T *)classData.addrOfValue(other);
+#if _LIBCPP_VERSION >= 14000
         const auto res = std::compare_strong_order_fallback(*val, *otherVal);
         return NSComparisonResult(-(res < 0) + (res > 0));
+#else
+        return NSComparisonResult(-(*val < *otherVal) + (*val > *otherVal));
+#endif
+        
     }
 public:
     template<class... Args>
@@ -334,7 +340,7 @@ class __attribute__((visibility("hidden"))) BoxMaker {
  */
 template<class T, class... Args>
 requires(std::is_constructible_v<T, Args...>)
-inline auto box(Args &&... args) -> BoxMaker<T>::BoxedType
+inline auto box(Args &&... args) -> typename BoxMaker<T>::BoxedType
     { return BoxMaker<T>::box(std::forward<Args>(args)...); }
 
 
@@ -358,7 +364,7 @@ inline auto box(Args &&... args) -> BoxMaker<T>::BoxedType
  */
 template<class T>
 requires(std::is_constructible_v<std::remove_cvref_t<T>, T &&>)
-inline auto box(T && src) -> BoxMaker<T>::BoxedType
+inline auto box(T && src) -> typename BoxMaker<T>::BoxedType
     { return BoxMaker<std::remove_cvref_t<T>>::box(std::forward<T>(src)); }
 
 /**

include/objc-helpers/CoDispatch.h

@@ -26,6 +26,7 @@
 #include <cassert>
 #include <limits>
 #include <utility>
+#include <exception>
 
 #include <dispatch/dispatch.h>
 #ifndef __OBJC__
@@ -658,7 +659,7 @@ inline namespace CO_DISPATCH_NS {
 
             template<class... Args>
             requires(DelayedValue::template IsEmplaceableFrom<Args...>)
-            void success(Args && ...args) const noexcept(noexcept(m_sharedState->emplaceReturnValue(std::forward<Args>(args)...))) 
+            void success(Args && ...args) const noexcept(noexcept(m_sharedState->emplaceReturnValue(std::forward<Args>(args)...)))
                 { m_sharedState->emplaceReturnValue(std::forward<Args>(args)...); }
 
             template<class X=DelayedValue>
@@ -958,7 +959,7 @@ inline namespace CO_DISPATCH_NS {
                 return awaiter{*this};
             }
 
-            void return_void() noexcept 
+            void return_void() noexcept
             {}
 
             void destroy() const noexcept {
@@ -1141,7 +1142,7 @@ inline namespace CO_DISPATCH_NS {
     };
 
     /**
-     @function 
+     @function
      Coroutine version of `dispatch_io_read`
      
      Unlike `dispatch_io_read` the progressHandler parameter is optional and is only needed if you
@@ -1160,7 +1161,7 @@ inline namespace CO_DISPATCH_NS {
     }
 
     /**
-     @function 
+     @function
      Coroutine version of `dispatch_read`
      
      @return DispatchIOResult object with operation result
@@ -1174,7 +1175,7 @@ inline namespace CO_DISPATCH_NS {
     }
 
     /**
-     @function 
+     @function
      Coroutine version of `dispatch_io_write`
      
      Unlike `dispatch_io_write` the progressHandler parameter is optional and is only needed if you
@@ -1194,7 +1195,7 @@ inline namespace CO_DISPATCH_NS {
     }
 
     /**
-     @function 
+     @function
      Coroutine version of `dispatch_write`
      
      @return DispatchIOResult object with operation result

include/objc-helpers/NSStringUtil.h

@@ -15,10 +15,11 @@
 
 #include <version>
 
-#if __cpp_lib_ranges < 201911L
-    #error This header requires C++20 mode or above with ranges support
+#if !__cpp_concepts
+    #error This header requires C++20 mode or above with concepts support
 #endif
 
+
 #include "NSObjectUtil.h"
 
 #ifdef __OBJC__
@@ -30,6 +31,10 @@
 #include <ranges>
 #include <string_view>
 #include <ostream>
+#if __cpp_lib_ranges < 201911L
+    #include <vector>
+    #include <span>
+#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wnullability-extension"
@@ -446,6 +451,8 @@ inline auto makeStdString(NSStringCharAccess::const_iterator first, NSStringChar
     return makeStdString<Char>(first.getCFString(), first.index(), last.index() - first.index());
 }
 
+#if __cpp_lib_ranges >= 201911L
+    
 /**
  Converts NSStringCharAccess or a view derived from it to `std::basic_string<Char>`
  
@@ -489,6 +496,90 @@ inline auto makeCFString(const CharRange & range)  -> CFStringRef __nullable {
     }
 }
 
+#else
+
+/**
+ Converts `NSStringCharAccess`  to `std::basic_string<Char>`
+ 
+ @tparam Char character type of the resultant std::basic_string
+ 
+ Conversions to char16_t are exact and never fail. Conversions to other character types are transcodings and can fail if source string contains invalid UTF-16
+ sequences. In such cases an empty string is returned. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeStdString(const NSStringCharAccess & access) {
+    return makeStdString<Char>(access.begin(), access.end());
+}
+
+/**
+ Converts `std::basic_string_view` to `CFString`
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ @returns nullptr on failure
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeCFString(std::basic_string_view<Char> str)  -> CFStringRef __nullable {
+    if (str.empty())
+        return CFSTR("");
+    if constexpr (std::is_same_v<Char, char16_t>) {
+        return CFStringCreateWithCharacters(nullptr, (const UniChar *)str.data(), CFIndex(str.size()));
+    } else {
+        return CFStringCreateWithBytes(nullptr, (const UInt8 *)str.data(), CFIndex(str.size() * sizeof(Char)),
+                                       kCFStringEncodingFor<Char>, false);
+    }
+}
+
+/**
+ Converts `std::basic_string` to `CFString`
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ @returns nullptr on failure
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeCFString(std::basic_string<Char> str)  -> CFStringRef __nullable {
+    return makeCFString(std::basic_string_view<Char>(str));
+}
+
+/**
+ Converts `std::vector<Char>` to `CFString`
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ @returns nullptr on failure
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeCFString(std::vector<Char> str)  -> CFStringRef __nullable {
+    return makeCFString(std::basic_string_view<Char>(str.data(), str.size()));
+}
+
+/**
+ Converts `std::span<Char>` to `CFString`
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ @returns nullptr on failure
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeCFString(std::span<Char> str)  -> CFStringRef __nullable {
+    return makeCFString(std::basic_string_view<Char>(str.data(), str.size()));
+}
+
+#endif
+
 /**
  Converts a null terminated character string to CFString
  
@@ -524,6 +615,8 @@ inline auto makeCFString(const std::initializer_list<Char> & str) {
 
 #ifdef __OBJC__
 
+#if __cpp_lib_ranges >= 201911L
+
 /**
  Converts any contiguous range of characters to NSString
  
@@ -540,6 +633,70 @@ inline auto makeNSString(const CharRange & range) {
     return (__bridge_transfer NSString *)makeCFString(range);
 }
 
+#else
+
+/**
+ Converts `std::basic_string_view` to NSString
+ 
+ @returns nil on failure
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeNSString(std::basic_string_view<Char> str) {
+    return (__bridge_transfer NSString *)makeCFString(str);
+}
+
+/**
+ Converts `std::basic_string` to NSString
+ 
+ @returns nil on failure
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeNSString(std::basic_string<Char> str) {
+    return (__bridge_transfer NSString *)makeCFString(str);
+}
+
+/**
+ Converts `std::vector<Char>` to NSString
+ 
+ @returns nil on failure
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeNSString(std::vector<Char> str) {
+    return (__bridge_transfer NSString *)makeCFString(str);
+}
+
+/**
+ Converts `std::span<Char>` to NSString
+ 
+ @returns nil on failure
+ 
+ The type of range's characters can be any of: char, char16_t, char32_t, char8_t, wchar_t.
+ 
+ Conversions from char16_t are exact and can only fail if out of memory. Conversions from other character types are
+ transcodings and can fail if source string contains invalid UTF sequences. Encodings of char and wchar_t are UTF-8 and UTF-32 respectively.
+ */
+template<CharTypeConvertibleWithNSString Char>
+inline auto makeNSString(std::span<Char> str) {
+    return (__bridge_transfer NSString *)makeCFString(str);
+}
+
+#endif
+
 /**
  Converts a null terminated character string to NSString
  

include/objc-helpers/XCTestUtil.h

@@ -13,6 +13,10 @@
     #error This header requires C++20 mode or above with concepts support
 #endif
 
+#if !__has_feature(cxx_exceptions)
+    #error This header requires C++ exceptions to be enabled
+#endif
+
 #ifdef __OBJC__
 
 #import <XCTest/XCTest.h>
@@ -67,20 +71,49 @@ namespace TestUtil {
             return [NSString stringWithFormat:@"%s object", demangle(typeid(T).name()).c_str()];
         }
     }
+
+    inline NSString * getCurrentExceptionReason() {
+        std::exception_ptr ex = std::current_exception();
+        try {
+            std::rethrow_exception(ex);
+        } catch (NSException * nex) {
+            return nex.reason;
+        } catch (const std::exception & cex) {
+            return [NSString stringWithFormat:@"%s: %s", demangle(typeid(cex).name()).c_str(), cex.what()];
+        } catch(...) {
+            return @"unknown exception type";
+        }
+    }
 }
 
+#if defined(_XCT_TRY) && defined(_XCT_CATCH) && defined(_XCT_THROW)
+    #define OBJCH_XCT_TRY _XCT_TRY
+    #define OBJCH_CATCH(T) _XCT_CATCH(T)
+    #define OBJCH_XCT_THROW _XCT_THROW
+#else
+    #define OBJCH_XCT_TRY try
+    #define OBJCH_XCT_CATCH(T) catch(T)
+    #define OBJCH_XCT_THROW throw
+#endif
+
+#ifdef _XCTGetCurrentExceptionReason
+    #define objchGetCurrentExceptionReason _XCTGetCurrentExceptionReason
+#else
+    #define objchGetCurrentExceptionReason TestUtil::getCurrentExceptionReason
+#endif
+
 #define XCTPrimitiveAssertCpp(test, op, type, expression1, expressionStr1, expression2, expressionStr2, ...) \
 ({ \
-    _XCT_TRY { \
+    OBJCH_XCT_TRY { \
         __typeof__(expression1) expressionValue1 = (expression1); \
         __typeof__(expression2) expressionValue2 = (expression2); \
         if (expressionValue1 op expressionValue2) { \
             _XCTRegisterFailure(test, _XCTFailureDescription((type), 0, expressionStr1, expressionStr2, TestUtil::describeForTest(expressionValue1), TestUtil::describeForTest(expressionValue2)), __VA_ARGS__); \
         } \
     } \
-    _XCT_CATCH (_XCTestCaseInterruptionException *interruption) { [interruption raise]; } \
-    _XCT_CATCH (...) { \
-        NSString *_xct_reason = _XCTGetCurrentExceptionReason(); \
+    OBJCH_XCT_CATCH (_XCTestCaseInterruptionException *interruption) { [interruption raise]; } \
+    OBJCH_XCT_CATCH (...) { \
+        NSString *_xct_reason = objchGetCurrentExceptionReason(); \
         _XCTRegisterUnexpectedFailure(test, _XCTFailureDescription((type), 1, expressionStr1, expressionStr2, _xct_reason), __VA_ARGS__); \
     } \
 })