Apply some clang-tidy 18 fixes

CMakeLists.txt

@@ -1437,21 +1437,11 @@ include(${PROJECT_SOURCE_DIR}/vendor/polylabel.cmake)
 include(${PROJECT_SOURCE_DIR}/vendor/protozero.cmake)
 include(${PROJECT_SOURCE_DIR}/vendor/tracy.cmake)
 include(${PROJECT_SOURCE_DIR}/vendor/unique_resource.cmake)
+include(${PROJECT_SOURCE_DIR}/vendor/unordered_dense.cmake)
 include(${PROJECT_SOURCE_DIR}/vendor/vector-tile.cmake)
 include(${PROJECT_SOURCE_DIR}/vendor/wagyu.cmake)
 include(${PROJECT_SOURCE_DIR}/vendor/metal-cpp.cmake)
 
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/vendor/unordered_dense)
-set_target_properties(
-    unordered_dense
-    PROPERTIES
-        INTERFACE_MAPBOX_NAME "unordered_dense"
-        INTERFACE_MAPBOX_URL "https://github.com/martinus/unordered_dense"
-        INTERFACE_MAPBOX_AUTHOR "Martin Leitner-Ankerl"
-        INTERFACE_MAPBOX_LICENSE ${PROJECT_SOURCE_DIR}/vendor/unordered_dense/LICENSE
-)
-
 target_link_libraries(
     mbgl-core
     PRIVATE

include/mbgl/actor/established_actor.hpp

@@ -29,11 +29,9 @@ template <class Object>
 class EstablishedActor {
 public:
     // Construct the Object from a parameter pack `args` (i.e. `Object(args...)`)
-    template <typename U = Object,
-              class... Args,
-              typename std::enable_if_t<std::is_constructible_v<U, Args...> ||
-                                        std::is_constructible_v<U, ActorRef<U>, Args...>>* = nullptr>
+    template <typename U = Object, class... Args>
     EstablishedActor(Scheduler& scheduler, AspiringActor<Object>& parent_, Args&&... args)
+        requires(std::is_constructible_v<U, Args...> || std::is_constructible_v<U, ActorRef<U>, Args...>)
         : parent(parent_) {
         emplaceObject(std::forward<Args>(args)...);
         parent.mailbox->open(scheduler);

include/mbgl/gfx/context.hpp

@@ -148,9 +148,9 @@ class Context {
 
     /// `emplaceOrUpdateUniformBuffer` with type inference
     template <typename T>
-    std::enable_if_t<!std::is_pointer_v<T>, bool> emplaceOrUpdateUniformBuffer(gfx::UniformBufferPtr& ptr,
-                                                                               const T* data,
-                                                                               bool persistent = false) {
+    bool emplaceOrUpdateUniformBuffer(gfx::UniformBufferPtr& ptr, const T* data, bool persistent = false)
+        requires(!std::is_pointer_v<T>)
+    {
         return emplaceOrUpdateUniformBuffer(ptr, data, sizeof(T), persistent);
     }
 

include/mbgl/gfx/shader.hpp

@@ -33,8 +33,10 @@ class Shader {
     /// @brief Downcast to a type
     /// @tparam T Derived type
     /// @return Type or nullptr if type info was not a match
-    template <typename T, typename std::enable_if_t<is_shader_v<T>, bool>* = nullptr>
-    T* to() noexcept {
+    template <typename T>
+    T* to() noexcept
+        requires(is_shader_v<T>)
+    {
         if (typeName() != T::Name) {
             return nullptr;
         }

include/mbgl/gfx/shader_group.hpp

@@ -93,8 +93,10 @@ class ShaderGroup {
     /// This variant looks up shaders only by type name.
     /// @tparam T Derived type, inheriting `gfx::Shader`
     /// @return T or nullptr if not found in the group
-    template <typename T, typename std::enable_if_t<is_shader_v<T>, bool>* = nullptr>
-    std::shared_ptr<T> get() noexcept {
+    template <typename T>
+    std::shared_ptr<T> get() noexcept
+        requires(is_shader_v<T>)
+    {
         auto shader = getShader(std::string(T::Name));
         if (!shader || shader->typeName() != T::Name) {
             return nullptr;

include/mbgl/gfx/uniform_buffer.hpp

@@ -64,10 +64,9 @@ class UniformBufferArray {
     void createOrUpdate(const size_t id, const std::vector<uint8_t>& data, gfx::Context&, bool persistent = false);
     void createOrUpdate(const size_t id, const void* data, std::size_t size, gfx::Context&, bool persistent = false);
     template <typename T>
-    std::enable_if_t<!std::is_pointer_v<T>> createOrUpdate(const size_t id,
-                                                           const T* data,
-                                                           gfx::Context& context,
-                                                           bool persistent = false) {
+    void createOrUpdate(const size_t id, const T* data, gfx::Context& context, bool persistent = false)
+        requires(!std::is_pointer_v<T>)
+    {
         createOrUpdate(id, data, sizeof(T), context, persistent);
     }
 

include/mbgl/gfx/vertex_attribute.hpp

@@ -191,12 +191,12 @@ class VertexAttribute {
     }
 
     template <std::size_t I = 0, typename... Tp>
-    inline typename std::enable_if<I == sizeof...(Tp), void>::type set(std::size_t, std::tuple<Tp...>, std::size_t) {}
+    inline typename std::enable_if_t<I == sizeof...(Tp), void> set(std::size_t, std::tuple<Tp...>, std::size_t) {}
 
     /// Set item value
     template <std::size_t I = 0, typename... Tp>
-        inline typename std::enable_if <
-        I<sizeof...(Tp), void>::type set(std::size_t i, std::tuple<Tp...> tuple, std::size_t tupleIndex) {
+        inline typename std::enable_if_t <
+        I<sizeof...(Tp), void> set(std::size_t i, std::tuple<Tp...> tuple, std::size_t tupleIndex) {
         if (tupleIndex == 0) {
             set(i, std::get<I>(tuple).a1);
         } else {

include/mbgl/math/minmax.hpp

@@ -8,32 +8,44 @@ namespace mbgl {
 namespace util {
 
 template <typename T>
-typename std::enable_if_t<std::is_integral_v<T>, T> max(T a, T b) {
+T max(T a, T b)
+    requires(std::is_integral_v<T>)
+{
     return std::max(a, b);
 }
 
 template <typename T>
-typename std::enable_if_t<std::is_floating_point_v<T>, T> max(T a, T b) {
+T max(T a, T b)
+    requires(std::is_floating_point_v<T>)
+{
     return ::fmax(a, b);
 }
 
 template <typename T, typename... Ts>
-typename std::enable_if_t<std::is_arithmetic_v<T>, T> max(T a, T b, Ts... args) {
+T max(T a, T b, Ts... args)
+    requires(std::is_arithmetic_v<T>)
+{
     return max(a, max(b, args...));
 }
 
 template <typename T>
-typename std::enable_if_t<std::is_integral_v<T>, T> min(T a, T b) {
+T min(T a, T b)
+    requires(std::is_integral_v<T>)
+{
     return std::min(a, b);
 }
 
 template <typename T>
-typename std::enable_if_t<std::is_floating_point_v<T>, T> min(T a, T b) {
+T min(T a, T b)
+    requires(std::is_floating_point_v<T>)
+{
     return ::fmin(a, b);
 }
 
 template <typename T, typename... Ts>
-typename std::enable_if_t<std::is_arithmetic_v<T>, T> min(T a, T b, Ts... args) {
+T min(T a, T b, Ts... args)
+    requires(std::is_arithmetic_v<T>)
+{
     return min(a, min(b, args...));
 }
 

include/mbgl/style/expression/expression.hpp

@@ -282,9 +282,11 @@ class Expression {
         return *lhs == *rhs;
     }
 
-    template <typename T, typename = std::enable_if_t<std::is_scalar_v<T>>>
+    template <typename T>
     static bool childEqual(const std::pair<T, std::unique_ptr<Expression>>& lhs,
-                           const std::pair<T, std::unique_ptr<Expression>>& rhs) noexcept {
+                           const std::pair<T, std::unique_ptr<Expression>>& rhs) noexcept
+        requires(std::is_scalar_v<T>)
+    {
         return lhs.first == rhs.first && *(lhs.second) == *(rhs.second);
     }
 
@@ -294,9 +296,11 @@ class Expression {
         return lhs.first == rhs.first && *(lhs.second) == *(rhs.second);
     }
 
-    template <typename T, typename = std::enable_if_t<!std::is_scalar_v<T>>>
+    template <typename T>
     static bool childEqual(const std::pair<T, std::shared_ptr<Expression>>& lhs,
-                           const std::pair<T, std::shared_ptr<Expression>>& rhs) noexcept {
+                           const std::pair<T, std::shared_ptr<Expression>>& rhs) noexcept
+        requires(!std::is_scalar_v<T>)
+    {
 #if __clang_major__ > 16
         // On older compilers, this assignment doesn't do overload resolution
         // in the same way that `lhs==rhs` does and produces ambiguity errors.

include/mbgl/style/expression/format_section_override.hpp

@@ -35,7 +35,7 @@ class FormatSectionOverride final : public Expression {
         defaultValue.match([&fn](const style::PropertyExpression<T>& e) { fn(e.getExpression()); }, [](const T&) {});
     }
 
-    bool operator==(const Expression& e) const final override {
+    bool operator==(const Expression& e) const final {
         if (e.getKind() == Kind::FormatSectionOverride) {
             const auto* other = static_cast<const FormatSectionOverride*>(&e);
 

include/mbgl/style/property_expression.hpp

@@ -90,7 +90,9 @@ class PropertyExpression final : public PropertyExpressionBase {
         const expression::EvaluationResult result = expression->evaluate(context);
         if (result) {
             const std::optional<T> typed = expression::fromExpressionValue<T>(*result);
-            return typed ? *typed : defaultValue ? *defaultValue : finalDefaultValue;
+            if (typed) {
+                return *typed;
+            }
         }
         return defaultValue ? *defaultValue : finalDefaultValue;
     }

include/mbgl/util/bitmask_operations.hpp

@@ -7,25 +7,25 @@ namespace mbgl {
 
 template <typename Enum>
 constexpr Enum operator|(Enum a, Enum b) {
-    static_assert(std::is_enum<Enum>::value, "Enum must be an enum type");
+    static_assert(std::is_enum_v<Enum>, "Enum must be an enum type");
     return Enum(mbgl::underlying_type(a) | mbgl::underlying_type(b));
 }
 
 template <typename Enum>
 constexpr Enum& operator|=(Enum& a, Enum b) {
-    static_assert(std::is_enum<Enum>::value, "Enum must be an enum type");
+    static_assert(std::is_enum_v<Enum>, "Enum must be an enum type");
     return (a = a | b);
 }
 
 template <typename Enum>
 constexpr bool operator&(Enum a, Enum b) {
-    static_assert(std::is_enum<Enum>::value, "Enum must be an enum type");
+    static_assert(std::is_enum_v<Enum>, "Enum must be an enum type");
     return bool(mbgl::underlying_type(a) & mbgl::underlying_type(b));
 }
 
 template <typename Enum>
 constexpr Enum operator~(Enum value) {
-    static_assert(std::is_enum<Enum>::value, "Enum must be an enum type");
+    static_assert(std::is_enum_v<Enum>, "Enum must be an enum type");
     return Enum(~mbgl::underlying_type(value));
 }
 

include/mbgl/util/chrono.hpp

@@ -46,11 +46,10 @@ _NODISCARD constexpr std::chrono::duration<_Rep, _Period> abs(const std::chrono:
                                                                : _Dur;
 }
 #else
-template <
-    class Rep,
-    class Period,
-    class = std::enable_if_t<std::chrono::duration<Rep, Period>::min() < std::chrono::duration<Rep, Period>::zero()>>
-constexpr std::chrono::duration<Rep, Period> abs(std::chrono::duration<Rep, Period> d) {
+template <class Rep, class Period>
+constexpr std::chrono::duration<Rep, Period> abs(std::chrono::duration<Rep, Period> d)
+    requires(std::chrono::duration<Rep, Period>::min() < std::chrono::duration<Rep, Period>::zero())
+{
     return d >= d.zero() ? d : -d;
 }
 #endif

include/mbgl/util/convert.hpp

@@ -11,15 +11,19 @@
 namespace mbgl {
 namespace util {
 
-template <typename To, typename From, std::size_t Size, typename = std::enable_if_t<std::is_convertible_v<From, To>>>
-constexpr std::array<To, Size> convert(const std::array<From, Size>& from) {
+template <typename To, typename From, std::size_t Size>
+constexpr std::array<To, Size> convert(const std::array<From, Size>& from)
+    requires(std::is_convertible_v<From, To>)
+{
     std::array<To, Size> to{{}};
     std::copy(std::begin(from), std::end(from), std::begin(to));
     return to;
 }
 
-template <typename To, typename From, std::size_t Size, typename = std::enable_if_t<std::is_assignable_v<To&, From>>>
-constexpr std::array<To, Size> cast(const std::array<From, Size>& from) {
+template <typename To, typename From, std::size_t Size>
+constexpr std::array<To, Size> cast(const std::array<From, Size>& from)
+    requires(std::is_assignable_v<To&, From>)
+{
     std::array<To, Size> to{{}};
     std::transform(std::begin(from), std::end(from), std::begin(to), [](From x) { return static_cast<To>(x); });
     return to;

include/mbgl/util/size.hpp

@@ -22,11 +22,11 @@ class Size {
     uint32_t height = 0;
 };
 
-constexpr inline bool operator==(const Size& a, const Size& b) noexcept {
+constexpr bool operator==(const Size& a, const Size& b) noexcept {
     return a.width == b.width && a.height == b.height;
 }
 
-constexpr inline bool operator!=(const Size& a, const Size& b) noexcept {
+constexpr bool operator!=(const Size& a, const Size& b) noexcept {
     return !(a == b);
 }
 

include/mbgl/util/traits.hpp

@@ -25,13 +25,12 @@ struct is_utf16char_like<uint16_t> : std::true_type {};
 
 template <typename T>
 using is_utf16char_like_pointer =
-    std::integral_constant<bool,
-                           std::is_pointer_v<T> && is_utf16char_like<typename std::remove_pointer<T>::type>::value>;
+    std::integral_constant<bool, std::is_pointer_v<T> && is_utf16char_like<std::remove_pointer_t<T>>::value>;
 
 template <class OutPointer, class InChar>
-typename std::enable_if<is_utf16char_like<InChar>::value && is_utf16char_like_pointer<OutPointer>::value,
-                        OutPointer>::type
-utf16char_cast(InChar *in) {
+OutPointer utf16char_cast(InChar *in)
+    requires(is_utf16char_like<InChar>::value && is_utf16char_like_pointer<OutPointer>::value)
+{
     return reinterpret_cast<OutPointer>(in);
 }
 

src/mbgl/actor/mailbox.cpp

@@ -20,7 +20,7 @@ Mailbox::Mailbox(const TaggedScheduler& scheduler_)
 void Mailbox::open(const TaggedScheduler& scheduler_) {
     assert(!weakScheduler);
     schedulerTag = scheduler_.tag;
-    return open(*scheduler_.get());
+    open(*scheduler_.get());
 }
 
 void Mailbox::open(Scheduler& scheduler_) {

src/mbgl/actor/scheduler.cpp

@@ -13,10 +13,12 @@ std::function<void()> Scheduler::bindOnce(std::function<void()> fn) {
     };
 }
 
-static auto& current() {
+namespace {
+auto& current() {
     static util::ThreadLocal<Scheduler> scheduler;
     return scheduler;
 }
+} // namespace
 
 void Scheduler::SetCurrent(Scheduler* scheduler) {
     current().set(scheduler);

src/mbgl/annotation/annotation_manager.cpp

@@ -234,12 +234,16 @@ void AnnotationManager::removeTile(AnnotationTile& tile) {
     tiles.erase(&tile);
 }
 
+namespace {
+
 // To ensure that annotation images do not collide with images from the style,
 // we prefix input image IDs with "org.maplibre.annotations".
-static std::string prefixedImageID(const std::string& id) {
+std::string prefixedImageID(const std::string& id) {
     return AnnotationManager::SourceID + "." + id;
 }
 
+} // namespace
+
 void AnnotationManager::addImage(std::unique_ptr<style::Image> image) {
     CHECK_ANNOTATIONS_ENABLED_AND_RETURN_NOARG();
     std::lock_guard<std::mutex> lock(mutex);

src/mbgl/gfx/vertex_vector.hpp

@@ -70,7 +70,7 @@ class VertexVector final : public VertexVectorBase {
         : VertexVectorBase(other),
           v(other.v) {}
     VertexVector(VertexVector<V>&& other)
-        : VertexVectorBase(std::move(other)),
+        : VertexVectorBase(static_cast<VertexVectorBase&&>(other)),
           v(std::move(other.v)) {}
     ~VertexVector() override = default;
 

src/mbgl/layout/symbol_instance.cpp

@@ -193,15 +193,15 @@ const std::optional<SymbolQuads>& SymbolInstance::iconQuads() const {
 }
 
 bool SymbolInstance::hasText() const {
-    return static_cast<bool>(symbolContent & SymbolContent::Text);
+    return symbolContent & SymbolContent::Text;
 }
 
 bool SymbolInstance::hasIcon() const {
-    return static_cast<bool>(symbolContent & SymbolContent::IconRGBA) || hasSdfIcon();
+    return symbolContent & SymbolContent::IconRGBA || hasSdfIcon();
 }
 
 bool SymbolInstance::hasSdfIcon() const {
-    return static_cast<bool>(symbolContent & SymbolContent::IconSDF);
+    return symbolContent & SymbolContent::IconSDF;
 }
 
 const std::optional<SymbolQuads>& SymbolInstance::verticalIconQuads() const {

src/mbgl/layout/symbol_layout.cpp

@@ -266,8 +266,7 @@ std::array<float, 2> evaluateRadialOffset(style::SymbolAnchorType anchor, float
     std::array<float, 2> result{{0.0f, 0.0f}};
     if (radialOffset < 0.0f) radialOffset = 0.0f; // Ignore negative offset.
     // solve for r where r^2 + r^2 = radialOffset^2
-    const float sqrt2 = 1.41421356237f;
-    const float hypotenuse = radialOffset / sqrt2;
+    const float hypotenuse = radialOffset / std::numbers::sqrt2_v<float>;
 
     switch (anchor) {
         case SymbolAnchorType::TopRight: