build(cmake): Lower minimum Clang version for Velox compatibility:

.github/workflows/unit-tests.yaml

@@ -43,21 +43,11 @@ jobs:
         run: "npm install -g @go-task/cli"
 
       - if: "'macos-14' == matrix.os"
-        name: "Install macOS 14 deps: coreutils (for md5sum) and Apple Clang 16 (for C++20)"
+        name: "Install macOS 14 deps: coreutils (for md5sum)"
         run: |-
           brew install coreutils
-          brew install llvm@16
 
       - name: "Run unit tests and examples"
-        env: >-
-          ${{
-          'macos-14' == matrix.os
-          && fromJson('{
-          "CC": "/opt/homebrew/opt/llvm@16/bin/clang",
-          "CXX": "/opt/homebrew/opt/llvm@16/bin/clang++"
-          }')
-          || fromJson('{}')
-          }}
         # Currently unit tests rely on cassert and fail to compile in release mode.
         run: |-
           task test:run-debug

CMakeLists.txt

@@ -1,7 +1,14 @@
 cmake_minimum_required(VERSION 3.23)
 
+# Toolchain setup must come before the first project() call in the entire CMake buildsystem.
+# If ystdlib is not the top-level project, the following setup has no effect.
+include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/Toolchains/utils.cmake")
+setup_toolchains()
+
 project(ystdlib VERSION "0.1.0" LANGUAGES CXX)
 
+validate_compiler_versions()
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
@@ -10,27 +17,6 @@ include(ystdlib-helpers)
 option(BUILD_SHARED_LIBS "Build using shared libraries." OFF)
 option(ystdlib_BUILD_TESTING "Build the testing tree for ystdlib." ON)
 
-# Require compiler versions that support the C++20 features necessary for compiling ystdlib
-if("AppleClang" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    set(ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION "16")
-elseif("Clang" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    set(ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION "16")
-elseif("GNU" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    set(ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION "11")
-else()
-    message(
-        FATAL_ERROR
-        "Unsupported compiler: ${CMAKE_CXX_COMPILER_ID}. Please use AppleClang, Clang, or GNU."
-    )
-endif()
-if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "${ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION}")
-    message(
-        FATAL_ERROR
-        "${CMAKE_CXX_COMPILER_ID} version ${CMAKE_CXX_COMPILER_VERSION} is too low. Must be at \
-        least ${ystdlib_CMAKE_CXX_COMPILER_MIN_VERSION}."
-    )
-endif()
-
 set(CMAKE_EXPORT_COMPILE_COMMANDS
     ON
     CACHE BOOL

cmake/Toolchains/llvm-clang-15-toolchain.cmake

@@ -0,0 +1,33 @@
+# Used for CMake toolchain setup. Sets `VAR_NAME` to `BINARY_PATH` after verifying the toolchain
+# binary exists. Stops configuration if the required binary is missing.
+#
+# @param {string} VAR_NAME Variable name to set.
+# @param {string} BINARY_PATH Path to the CMake toolchain binary.
+function(set_toolchain_binary_var VAR_NAME BINARY_PATH)
+    if(NOT EXISTS "${BINARY_PATH}")
+        message(FATAL_ERROR "Required CMake toolchain binary not found: ${BINARY_PATH}")
+    endif()
+    set(${VAR_NAME} "${BINARY_PATH}" PARENT_SCOPE)
+endfunction()
+
+message(STATUS "Setting up LLVM v15 toolchain...")
+
+execute_process(
+    COMMAND
+        "brew" "--prefix" "llvm@15"
+    RESULT_VARIABLE BREW_RESULT
+    OUTPUT_VARIABLE LLVM_TOOLCHAIN_PREFIX
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+if(NOT 0 EQUAL BREW_RESULT)
+    message(
+        FATAL_ERROR
+        "Failed to locate LLVM v15 using Homebrew. Please ensure llvm@15 is installed: 'brew"
+        " install llvm@15'"
+    )
+endif()
+
+set_toolchain_binary_var(CMAKE_C_COMPILER "${LLVM_TOOLCHAIN_PREFIX}/bin/clang")
+set_toolchain_binary_var(CMAKE_CXX_COMPILER "${LLVM_TOOLCHAIN_PREFIX}/bin/clang++")
+set_toolchain_binary_var(CMAKE_AR "${LLVM_TOOLCHAIN_PREFIX}/bin/llvm-ar")
+set_toolchain_binary_var(CMAKE_RANLIB "${LLVM_TOOLCHAIN_PREFIX}/bin/llvm-ranlib")

cmake/Toolchains/utils.cmake

@@ -0,0 +1,49 @@
+# This file contains utility functions for setting up toolchains and validating toolchain versions
+# to ensure compatibility with the C++20 features required by the project.
+
+# Sets up the appropriate toolchain file based on the host system.
+function(setup_toolchains)
+    # For macOS versions below 15, use the LLVM 15 Clang toolchain.
+    if("Darwin" STREQUAL "${CMAKE_HOST_SYSTEM_NAME}")
+        execute_process(
+            COMMAND
+                "sw_vers" "--productVersion"
+            OUTPUT_VARIABLE MACOS_VERSION
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+        if("${MACOS_VERSION}" VERSION_LESS "14")
+            set(CMAKE_TOOLCHAIN_FILE
+                "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Toolchains/llvm-clang-15-toolchain.cmake"
+                CACHE FILEPATH
+                "Toolchain file"
+            )
+        endif()
+    endif()
+endfunction()
+
+# Checks if the compiler ID and version meet the minimum requirements to support C++20 features
+# required by the project:
+# - AppleClang: version 15+
+# - Clang: version 15+
+# - GNU: version 11+
+function(validate_compiler_versions)
+    if("AppleClang" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
+        set(CXX_COMPILER_MIN_VERSION "15")
+    elseif("Clang" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
+        set(CXX_COMPILER_MIN_VERSION "15")
+    elseif("GNU" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
+        set(CXX_COMPILER_MIN_VERSION "11")
+    else()
+        message(
+            FATAL_ERROR
+            "Unsupported compiler: ${CMAKE_CXX_COMPILER_ID}. Please use AppleClang, Clang, or GNU."
+        )
+    endif()
+    if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "${CXX_COMPILER_MIN_VERSION}")
+        message(
+            FATAL_ERROR
+            "${CMAKE_CXX_COMPILER_ID} version ${CMAKE_CXX_COMPILER_VERSION} is too low. Must be at"
+            " least ${CXX_COMPILER_MIN_VERSION}."
+        )
+    endif()
+endfunction()

cmake/ystdlib-helpers.cmake

@@ -114,7 +114,7 @@ function(add_cpp_library)
     )
 endfunction()
 
-# Adds a C++ 20 test executable named `unit-test-NAME` that will be built with `SOURCES` and linked
+# Adds a C++20 test executable named `unit-test-NAME` that will be built with `SOURCES` and linked
 # with `LINK_LIBRARIES`, in addition to Catch2.
 #
 # @param {string} NAME

src/ystdlib/containers/Array.hpp

@@ -37,7 +37,7 @@ class Array {
             // NOLINTNEXTLINE(*-avoid-c-arrays)
             : m_data{std::make_unique<T[]>(list.size())},
               m_size{list.size()} {
-        std::ranges::copy(list, m_data.get());
+        std::copy(list.begin(), list.end(), m_data.get());
     }
 
     // Disable copy constructor and assignment operator

src/ystdlib/containers/test/test_Array.cpp

@@ -1,7 +1,6 @@
 #include <algorithm>
 #include <concepts>
 #include <cstddef>
-#include <ranges>
 #include <stdexcept>
 #include <string>
 #include <string_view>
@@ -66,9 +65,12 @@ void test_list_initialization_in_function_call(
         ystdlib::containers::Array<PolymorphicConstructors> const& arr,
         std::vector<size_t> const& data
 ) {
-    REQUIRE(std::ranges::equal(
-            arr | std::views::transform([](auto const& obj) { return obj.get_value(); }),
-            data
+    REQUIRE(std::equal(
+            arr.begin(),
+            arr.end(),
+            data.begin(),
+            data.end(),
+            [](auto const& obj, size_t v) { return obj.get_value() == v; }
     ));
 }
 }  // namespace
@@ -88,7 +90,7 @@ TEST_CASE("test_array_reference", "[containers][Array]") {
         arr.at(idx) = idx;
     }
     auto const& arr_const_ref = arr;
-    REQUIRE(std::ranges::equal(arr, arr_const_ref));
+    REQUIRE(std::equal(arr.begin(), arr.end(), arr_const_ref.begin(), arr_const_ref.end()));
 }
 
 TEST_CASE("test_array_ranged_copy", "[containers][Array]") {
@@ -97,8 +99,8 @@ TEST_CASE("test_array_ranged_copy", "[containers][Array]") {
         vec.push_back(idx);
     }
     Array<size_t> arr(cBufferSize);
-    std::ranges::copy(vec, arr.begin());
-    REQUIRE(std::ranges::equal(vec, arr));
+    std::copy(vec.begin(), vec.end(), arr.begin());
+    REQUIRE(std::equal(vec.cbegin(), vec.cend(), arr.begin(), arr.end()));
 }
 
 TEST_CASE("test_array_movable", "[containers][Array]") {
@@ -109,7 +111,12 @@ TEST_CASE("test_array_movable", "[containers][Array]") {
         reference_array.at(idx) = idx;
     }
     auto const arr_moved{std::move(arr)};
-    REQUIRE(std::ranges::equal(reference_array, arr_moved));
+    REQUIRE(std::equal(
+            reference_array.begin(),
+            reference_array.end(),
+            arr_moved.begin(),
+            arr_moved.end()
+    ));
 }
 
 TEST_CASE("test_array_illegal_access", "[containers][Array]") {
@@ -143,8 +150,8 @@ TEMPLATE_TEST_CASE(
 ) {
     REQUIRE(std::is_fundamental_v<TestType>);
     Array<TestType> arr(cBufferSize);
-    std::ranges::for_each(arr, [](auto const& p) -> void {
-        REQUIRE((static_cast<TestType>(0) == p));
+    std::for_each(arr.begin(), arr.end(), [](auto const& p) {
+        REQUIRE(static_cast<TestType>(0) == p);
     });
 }
 
@@ -158,7 +165,7 @@ TEST_CASE("test_array_list_initialization", "[containers][Array]") {
             vec{"yscope", "clp", "ystdlib", "ystdlib::containers::Array", "default_initializable"};
     Array<std::string> const
             arr{"yscope", "clp", "ystdlib", "ystdlib::containers::Array", "default_initializable"};
-    REQUIRE(std::ranges::equal(vec, arr));
+    REQUIRE(std::equal(vec.cbegin(), vec.cend(), arr.begin(), arr.end()));
 
     // Test polymorphic list initialization
     REQUIRE(std::is_copy_constructible_v<PolymorphicConstructors>);
@@ -174,10 +181,12 @@ TEST_CASE("test_array_list_initialization", "[containers][Array]") {
                    cTestNum0,
                    std::string{cTestStr},
                    ExplicitConstructor{cTestNum1}};
-        REQUIRE(std::ranges::equal(
-                list_init_arr
-                        | std::views::transform([](auto const& obj) { return obj.get_value(); }),
-                data
+        REQUIRE(std::equal(
+                list_init_arr.begin(),
+                list_init_arr.end(),
+                data.cbegin(),
+                data.cend(),
+                [](auto const& obj, auto const& v) { return obj.get_value() == v; }
         ));
     }
 

src/ystdlib/error_handling/CMakeLists.txt

@@ -16,7 +16,6 @@ add_cpp_library(
     NAMESPACE ystdlib
     PUBLIC_HEADERS
         ErrorCode.hpp
-        TraceableException.hpp
         Result.hpp
         utils.hpp
     PUBLIC_LINK_LIBRARIES
@@ -30,7 +29,6 @@ if(ystdlib_ENABLE_TESTS)
         SOURCES
             test/test_ErrorCode.cpp
             test/test_Result.cpp
-            test/test_TraceableException.cpp
             test/types.cpp
         UNIFIED_TEST_TARGET "${UNIFIED_UNIT_TEST_TARGET}"
     )

src/ystdlib/error_handling/test/test_ErrorCode.cpp

@@ -49,11 +49,11 @@ TEST_CASE("test_error_code", "[error_handling][ErrorCode]") {
 
 TEST_CASE("test_error_code_failure_condition", "[error_handling][ErrorCode]") {
     std::error_code const failure_error_code{BinaryErrorCode{BinaryErrorCodeEnum::Failure}};
-    std::ranges::for_each(cFailureConditions, [&](auto const& failure_condition) {
-        REQUIRE((failure_error_code == failure_condition));
-    });
-    std::ranges::for_each(cNoneFailureConditions, [&](auto const& none_failure_condition) {
-        REQUIRE((failure_error_code != none_failure_condition));
-    });
+    for (auto const& failure_condition : cFailureConditions) {
+        REQUIRE(failure_error_code == failure_condition);
+    }
+    for (auto const& none_failure_condition : cNoneFailureConditions) {
+        REQUIRE(failure_error_code != none_failure_condition);
+    }
 }
 }  // namespace ystdlib::error_handling::test