Xcode16 build fix

.github/workflows/build.yaml

@@ -46,10 +46,11 @@ jobs:
     needs: setup
     strategy:
       matrix:
-        runner: [windows-large, macos-12-xl]
+        runner: [windows-large, macos-14-xlarge]
         configuration: ${{ fromJSON(needs.setup.outputs.configurations) }}
         include:
         - runner: linux-large
+          continue-on-error: true
           configuration: ReleaseOS
     runs-on: ${{ matrix.runner }}
     outputs:
@@ -71,7 +72,7 @@ jobs:
       # autobuild-package.xml.
       AUTOBUILD_VCS_INFO: "true"
       AUTOBUILD_VSVER: "170"
-      DEVELOPER_DIR: "/Applications/Xcode_14.0.1.app/Contents/Developer"
+      DEVELOPER_DIR: "/Applications/Xcode_16.0.app/Contents/Developer"
       # Ensure that Linden viewer builds engage Bugsplat.
       BUGSPLAT_DB: ${{ needs.setup.outputs.bugsplat_db }}
       build_coverity: false

indra/CMakeLists.txt

@@ -29,6 +29,9 @@ else()
   set( USE_AUTOBUILD_3P ON )
 endif()
 
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 include(Variables)
 include(BuildVersion)
 

indra/llcommon/fsyspath.h

@@ -12,7 +12,10 @@
 #if ! defined(LL_FSYSPATH_H)
 #define LL_FSYSPATH_H
 
+#include <boost/iterator/transform_iterator.hpp>
 #include <filesystem>
+#include <string>
+#include <string_view>
 
 // While std::filesystem::path can be directly constructed from std::string on
 // both Posix and Windows, that's not what we want on Windows. Per
@@ -33,42 +36,55 @@
 // char"), the "native narrow encoding" isn't UTF-8, so file paths containing
 // non-ASCII characters get mangled.
 //
-// Once we're building with C++20, we could pass a UTF-8 std::string through a
-// vector<char8_t> to engage std::filesystem::path's own UTF-8 conversion. But
-// sigh, as of 2024-04-03 we're not yet there.
-//
-// Anyway, encapsulating the important UTF-8 conversions in our own subclass
-// allows us to migrate forward to C++20 conventions without changing
-// referencing code.
+// Encapsulating the important UTF-8 conversions in our own subclass allows us
+// to migrate forward to C++20 conventions without changing referencing code.
 
 class fsyspath: public std::filesystem::path
 {
     using super = std::filesystem::path;
 
+    // In C++20 (__cpp_lib_char8_t), std::filesystem::u8path() is deprecated.
+    // std::filesystem::path(iter, iter) performs UTF-8 conversions when the
+    // value_type of the iterators is char8_t. While we could copy into a
+    // temporary std::u8string and from there into std::filesystem::path, to
+    // minimize string copying we'll define a transform_iterator that accepts
+    // a std::string_view::iterator and dereferences to char8_t.
+    struct u8ify
+    {
+        char8_t operator()(char c) const { return char8_t(c); }
+    };
+    using u8iter = boost::transform_iterator<u8ify, std::string_view::iterator>;
+
 public:
     // default
     fsyspath() {}
-    // construct from UTF-8 encoded std::string
-    fsyspath(const std::string& path): super(std::filesystem::u8path(path)) {}
-    // construct from UTF-8 encoded const char*
-    fsyspath(const char* path): super(std::filesystem::u8path(path)) {}
+    // construct from UTF-8 encoded string
+    fsyspath(const std::string& path): fsyspath(std::string_view(path)) {}
+    fsyspath(const char* path):        fsyspath(std::string_view(path)) {}
+    fsyspath(std::string_view path):
+        super(u8iter(path.begin(), u8ify()), u8iter(path.end(), u8ify()))
+    {}
     // construct from existing path
     fsyspath(const super& path): super(path) {}
 
-    fsyspath& operator=(const super& p) { super::operator=(p); return *this; }
-    fsyspath& operator=(const std::string& p)
-    {
-        super::operator=(std::filesystem::u8path(p));
-        return *this;
-    }
-    fsyspath& operator=(const char* p)
+    fsyspath& operator=(const super& p)       { super::operator=(p); return *this; }
+    fsyspath& operator=(const std::string& p) { return (*this) = std::string_view(p); }
+    fsyspath& operator=(const char* p)        { return (*this) = std::string_view(p); }
+    fsyspath& operator=(std::string_view p)
     {
-        super::operator=(std::filesystem::u8path(p));
+        assign(u8iter(p.begin(), u8ify()), u8iter(p.end(), u8ify()));
         return *this;
     }
 
     // shadow base-class string() method with UTF-8 aware method
-    std::string string() const { return super::u8string(); }
+    std::string string() const
+    {
+        // Short of forbidden type punning, I see no way to avoid copying this
+        // std::u8string to a std::string.
+        auto u8str{ super::u8string() };
+        // from https://github.com/tahonermann/char8_t-remediation/blob/master/char8_t-remediation.h#L180-L182
+        return { u8str.begin(), u8str.end() };
+    }
     // On Posix systems, where value_type is already char, this operator
     // std::string() method shadows the base class operator string_type()
     // method. But on Windows, where value_type is wchar_t, the base class

indra/llcommon/llkeybind.cpp

@@ -123,22 +123,18 @@ LLKeyData& LLKeyData::operator=(const LLKeyData& rhs)
     return *this;
 }
 
-bool LLKeyData::operator==(const LLKeyData& rhs)
+bool LLKeyData::operator==(const LLKeyData& rhs) const
 {
-    if (mMouse != rhs.mMouse) return false;
-    if (mKey != rhs.mKey) return false;
-    if (mMask != rhs.mMask) return false;
-    if (mIgnoreMasks != rhs.mIgnoreMasks) return false;
-    return true;
+    return
+        (mMouse       == rhs.mMouse) &&
+        (mKey         == rhs.mKey) &&
+        (mMask        == rhs.mMask) &&
+        (mIgnoreMasks == rhs.mIgnoreMasks);
 }
 
-bool LLKeyData::operator!=(const LLKeyData& rhs)
+bool LLKeyData::operator!=(const LLKeyData& rhs) const
 {
-    if (mMouse != rhs.mMouse) return true;
-    if (mKey != rhs.mKey) return true;
-    if (mMask != rhs.mMask) return true;
-    if (mIgnoreMasks != rhs.mIgnoreMasks) return true;
-    return false;
+    return ! (*this == rhs);
 }
 
 bool LLKeyData::canHandle(const LLKeyData& data) const

indra/llcommon/llkeybind.h

@@ -44,8 +44,8 @@ class LL_COMMON_API LLKeyData
     bool empty() const { return isEmpty(); };
     void reset();
     LLKeyData& operator=(const LLKeyData& rhs);
-    bool operator==(const LLKeyData& rhs);
-    bool operator!=(const LLKeyData& rhs);
+    bool operator==(const LLKeyData& rhs) const;
+    bool operator!=(const LLKeyData& rhs) const;
 
     bool canHandle(const LLKeyData& data) const;
     bool canHandle(EMouseClickType mouse, KEY key, MASK mask) const;