From a43754266a7e8d9e867edd10050f86246da22069 Mon Sep 17 00:00:00 2001
From: Nick Gerleman <ngerlem@meta.com>
Date: Tue, 12 Dec 2023 08:52:11 -0800
Subject: [PATCH] <bit> and <concepts> (#1497)

Summary:
Pull Request resolved: https://github.com/facebook/yoga/pull/1497

The lowest common denominator we have had for Yoga has been Clang 12 + MSVC 2017 stdlib. This has allowed Yoga to use C++ 20 language features, but not library features. React Native for mobile has not been bound to this restriction.

Builds using that toolchain are being updated to latest MSVC 2019 stdlib (which has good C++ 20 library support), along with Clang 17 (or maybe a stop at 15) pending projects using `-fcoroutines-ts` being migrated to C++ 20.

This tests out some C++ 20 standard library usages against the current Clang 12 + MSVC 2019 stdlib toolchain that didn't work before, and adds a couple concepts for better constraints/compiler error messages if misused.

This bumps min-tested XCode (and minimum required) version to 14.3, matching a similar change for React Native. This should probably be bumped to 15 sometime before Apple starts requiring 15+ to go out to the iOS app store.

We are approaching a practical support range of:
1. XCode >= 14.3
2. NDK >= 26
3. Clang/libc++ >= 14
4. GCC/libstdc++ >= 11
5. MSVC >= 16.11 (VS 2019)

Changelog: [Internal]

Reviewed By: cortinico

Differential Revision: D51604487

fbshipit-source-id: d394d0d86672b69781b8ae071d87adcf944ddc72
---
 .github/actions/setup-apple/action.yml |  4 ++++
 .github/workflows/validate-apple.yml   |  7 ++++--
 enums.py                               | 13 ++++-------
 yoga/YGMacros.h                        |  8 +++----
 yoga/bits/BitCast.h                    | 30 --------------------------
 yoga/enums/Align.h                     | 13 ++++-------
 yoga/enums/Dimension.h                 | 13 ++++-------
 yoga/enums/Direction.h                 | 13 ++++-------
 yoga/enums/Display.h                   | 13 ++++-------
 yoga/enums/Edge.h                      | 13 ++++-------
 yoga/enums/Errata.h                    |  4 ++--
 yoga/enums/ExperimentalFeature.h       | 13 ++++-------
 yoga/enums/FlexDirection.h             | 13 ++++-------
 yoga/enums/Gutter.h                    | 13 ++++-------
 yoga/enums/Justify.h                   | 13 ++++-------
 yoga/enums/LogLevel.h                  | 13 ++++-------
 yoga/enums/MeasureMode.h               | 13 ++++-------
 yoga/enums/NodeType.h                  | 13 ++++-------
 yoga/enums/Overflow.h                  | 13 ++++-------
 yoga/enums/PositionType.h              | 13 ++++-------
 yoga/enums/PrintOptions.h              |  4 ++--
 yoga/enums/Unit.h                      | 13 ++++-------
 yoga/enums/Wrap.h                      | 13 ++++-------
 yoga/enums/YogaEnums.h                 | 29 ++++++++++++++++++++-----
 yoga/numeric/Comparison.h              | 13 +++++++----
 yoga/style/CompactValue.h              | 10 ++++-----
 26 files changed, 123 insertions(+), 207 deletions(-)
 delete mode 100644 yoga/bits/BitCast.h

diff --git a/.github/actions/setup-apple/action.yml b/.github/actions/setup-apple/action.yml
index 6ef41f58..4087ecbb 100644
--- a/.github/actions/setup-apple/action.yml
+++ b/.github/actions/setup-apple/action.yml
@@ -7,3 +7,7 @@ runs:
     - name: Install Cocoapods
       shell: bash
       run: sudo gem install cocoapods
+
+    - uses: maxim-lobanov/setup-xcode@v1
+      with:
+        xcode-version: 14.3.1
diff --git a/.github/workflows/validate-apple.yml b/.github/workflows/validate-apple.yml
index 598ca2e8..3097cfe2 100644
--- a/.github/workflows/validate-apple.yml
+++ b/.github/workflows/validate-apple.yml
@@ -11,7 +11,7 @@ on:
 jobs:
   lint-pods:
     name: Build [CocoaPods]
-    runs-on: macos-latest
+    runs-on: macos-13
 
     steps:
       - uses: actions/checkout@v3
@@ -24,11 +24,14 @@ jobs:
 
   test:
     name: Build [SwiftPM]
-    runs-on: macos-latest
+    runs-on: macos-13
 
     steps:
       - uses: actions/checkout@v3
 
+      - name: Setup
+        uses: ./.github/actions/setup-apple
+
       - name: Build Debug
         run: swift build -c debug
 
diff --git a/enums.py b/enums.py
index 7e2a918e..7fe3732b 100755
--- a/enums.py
+++ b/enums.py
@@ -174,20 +174,15 @@ for name, values in sorted(ENUMS.items()):
             f.write(f"YG_DEFINE_ENUM_FLAG_OPERATORS({name})\n\n")
         else:
             f.write("template <>\n")
-            f.write(f"constexpr inline int32_t ordinalCount<{name}>() {{\n")
+            f.write(f"constexpr int32_t ordinalCount<{name}>() {{\n")
             f.write(f"  return {len(values)};\n")
-            f.write("} \n\n")
+            f.write("}\n\n")
 
-            f.write("template <>\n")
-            f.write(f"constexpr inline int32_t bitCount<{name}>() {{\n")
-            f.write(f"  return {math.ceil(math.log(len(values), 2))};\n")
-            f.write("} \n\n")
-
-        f.write(f"constexpr inline {name} scopedEnum(YG{name} unscoped) {{\n")
+        f.write(f"constexpr {name} scopedEnum(YG{name} unscoped) {{\n")
         f.write(f"  return static_cast<{name}>(unscoped);\n")
         f.write("}\n\n")
 
-        f.write(f"constexpr inline YG{name} unscopedEnum({name} scoped) {{\n")
+        f.write(f"constexpr YG{name} unscopedEnum({name} scoped) {{\n")
         f.write(f"  return static_cast<YG{name}>(scoped);\n")
         f.write("}\n\n")
 
diff --git a/yoga/YGMacros.h b/yoga/YGMacros.h
index 6460297a..6d1becce 100644
--- a/yoga/YGMacros.h
+++ b/yoga/YGMacros.h
@@ -49,21 +49,21 @@
 #ifdef __cplusplus
 #define YG_DEFINE_ENUM_FLAG_OPERATORS(name)                       \
   extern "C++" {                                                  \
-  constexpr inline name operator~(name a) {                       \
+  constexpr name operator~(name a) {                              \
     return static_cast<name>(                                     \
         ~static_cast<std::underlying_type<name>::type>(a));       \
   }                                                               \
-  constexpr inline name operator|(name a, name b) {               \
+  constexpr name operator|(name a, name b) {                      \
     return static_cast<name>(                                     \
         static_cast<std::underlying_type<name>::type>(a) |        \
         static_cast<std::underlying_type<name>::type>(b));        \
   }                                                               \
-  constexpr inline name operator&(name a, name b) {               \
+  constexpr name operator&(name a, name b) {                      \
     return static_cast<name>(                                     \
         static_cast<std::underlying_type<name>::type>(a) &        \
         static_cast<std::underlying_type<name>::type>(b));        \
   }                                                               \
-  constexpr inline name operator^(name a, name b) {               \
+  constexpr name operator^(name a, name b) {                      \
     return static_cast<name>(                                     \
         static_cast<std::underlying_type<name>::type>(a) ^        \
         static_cast<std::underlying_type<name>::type>(b));        \
diff --git a/yoga/bits/BitCast.h b/yoga/bits/BitCast.h
deleted file mode 100644
index 13fb0e41..00000000
--- a/yoga/bits/BitCast.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-#pragma once
-
-#include <cstring>
-#include <type_traits>
-
-namespace facebook::yoga {
-
-// Polyfill for std::bit_cast() from C++20, to allow safe type punning
-// https://en.cppreference.com/w/cpp/numeric/bit_cast
-// TODO: Remove when we upgrade to NDK 26+
-template <class To, class From>
-std::enable_if_t<
-    sizeof(To) == sizeof(From) && std::is_trivially_copyable_v<From> &&
-        std::is_trivially_copyable_v<To> &&
-        std::is_trivially_constructible_v<To>,
-    To>
-bit_cast(const From& src) noexcept {
-  To dst;
-  std::memcpy(&dst, &src, sizeof(To));
-  return dst;
-}
-
-} // namespace facebook::yoga
diff --git a/yoga/enums/Align.h b/yoga/enums/Align.h
index 67777fc3..3896fe2b 100644
--- a/yoga/enums/Align.h
+++ b/yoga/enums/Align.h
@@ -28,20 +28,15 @@ enum class Align : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Align>() {
+constexpr int32_t ordinalCount<Align>() {
   return 9;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Align>() {
-  return 4;
-} 
-
-constexpr inline Align scopedEnum(YGAlign unscoped) {
+constexpr Align scopedEnum(YGAlign unscoped) {
   return static_cast<Align>(unscoped);
 }
 
-constexpr inline YGAlign unscopedEnum(Align scoped) {
+constexpr YGAlign unscopedEnum(Align scoped) {
   return static_cast<YGAlign>(scoped);
 }
 
diff --git a/yoga/enums/Dimension.h b/yoga/enums/Dimension.h
index 2274a980..96590152 100644
--- a/yoga/enums/Dimension.h
+++ b/yoga/enums/Dimension.h
@@ -21,20 +21,15 @@ enum class Dimension : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Dimension>() {
+constexpr int32_t ordinalCount<Dimension>() {
   return 2;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Dimension>() {
-  return 1;
-} 
-
-constexpr inline Dimension scopedEnum(YGDimension unscoped) {
+constexpr Dimension scopedEnum(YGDimension unscoped) {
   return static_cast<Dimension>(unscoped);
 }
 
-constexpr inline YGDimension unscopedEnum(Dimension scoped) {
+constexpr YGDimension unscopedEnum(Dimension scoped) {
   return static_cast<YGDimension>(scoped);
 }
 
diff --git a/yoga/enums/Direction.h b/yoga/enums/Direction.h
index 1b5e19c9..5bbabaec 100644
--- a/yoga/enums/Direction.h
+++ b/yoga/enums/Direction.h
@@ -22,20 +22,15 @@ enum class Direction : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Direction>() {
+constexpr int32_t ordinalCount<Direction>() {
   return 3;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Direction>() {
-  return 2;
-} 
-
-constexpr inline Direction scopedEnum(YGDirection unscoped) {
+constexpr Direction scopedEnum(YGDirection unscoped) {
   return static_cast<Direction>(unscoped);
 }
 
-constexpr inline YGDirection unscopedEnum(Direction scoped) {
+constexpr YGDirection unscopedEnum(Direction scoped) {
   return static_cast<YGDirection>(scoped);
 }
 
diff --git a/yoga/enums/Display.h b/yoga/enums/Display.h
index c1d8c7a8..418ebc1d 100644
--- a/yoga/enums/Display.h
+++ b/yoga/enums/Display.h
@@ -21,20 +21,15 @@ enum class Display : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Display>() {
+constexpr int32_t ordinalCount<Display>() {
   return 2;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Display>() {
-  return 1;
-} 
-
-constexpr inline Display scopedEnum(YGDisplay unscoped) {
+constexpr Display scopedEnum(YGDisplay unscoped) {
   return static_cast<Display>(unscoped);
 }
 
-constexpr inline YGDisplay unscopedEnum(Display scoped) {
+constexpr YGDisplay unscopedEnum(Display scoped) {
   return static_cast<YGDisplay>(scoped);
 }
 
diff --git a/yoga/enums/Edge.h b/yoga/enums/Edge.h
index d6d2b0ee..3ab6a33f 100644
--- a/yoga/enums/Edge.h
+++ b/yoga/enums/Edge.h
@@ -28,20 +28,15 @@ enum class Edge : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Edge>() {
+constexpr int32_t ordinalCount<Edge>() {
   return 9;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Edge>() {
-  return 4;
-} 
-
-constexpr inline Edge scopedEnum(YGEdge unscoped) {
+constexpr Edge scopedEnum(YGEdge unscoped) {
   return static_cast<Edge>(unscoped);
 }
 
-constexpr inline YGEdge unscopedEnum(Edge scoped) {
+constexpr YGEdge unscopedEnum(Edge scoped) {
   return static_cast<YGEdge>(scoped);
 }
 
diff --git a/yoga/enums/Errata.h b/yoga/enums/Errata.h
index 5bda0c0b..e97b66c3 100644
--- a/yoga/enums/Errata.h
+++ b/yoga/enums/Errata.h
@@ -27,11 +27,11 @@ enum class Errata : uint32_t {
 
 YG_DEFINE_ENUM_FLAG_OPERATORS(Errata)
 
-constexpr inline Errata scopedEnum(YGErrata unscoped) {
+constexpr Errata scopedEnum(YGErrata unscoped) {
   return static_cast<Errata>(unscoped);
 }
 
-constexpr inline YGErrata unscopedEnum(Errata scoped) {
+constexpr YGErrata unscopedEnum(Errata scoped) {
   return static_cast<YGErrata>(scoped);
 }
 
diff --git a/yoga/enums/ExperimentalFeature.h b/yoga/enums/ExperimentalFeature.h
index 6ed35815..4c366fb4 100644
--- a/yoga/enums/ExperimentalFeature.h
+++ b/yoga/enums/ExperimentalFeature.h
@@ -21,20 +21,15 @@ enum class ExperimentalFeature : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<ExperimentalFeature>() {
+constexpr int32_t ordinalCount<ExperimentalFeature>() {
   return 2;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<ExperimentalFeature>() {
-  return 1;
-} 
-
-constexpr inline ExperimentalFeature scopedEnum(YGExperimentalFeature unscoped) {
+constexpr ExperimentalFeature scopedEnum(YGExperimentalFeature unscoped) {
   return static_cast<ExperimentalFeature>(unscoped);
 }
 
-constexpr inline YGExperimentalFeature unscopedEnum(ExperimentalFeature scoped) {
+constexpr YGExperimentalFeature unscopedEnum(ExperimentalFeature scoped) {
   return static_cast<YGExperimentalFeature>(scoped);
 }
 
diff --git a/yoga/enums/FlexDirection.h b/yoga/enums/FlexDirection.h
index 45f6497c..d2d3f610 100644
--- a/yoga/enums/FlexDirection.h
+++ b/yoga/enums/FlexDirection.h
@@ -23,20 +23,15 @@ enum class FlexDirection : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<FlexDirection>() {
+constexpr int32_t ordinalCount<FlexDirection>() {
   return 4;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<FlexDirection>() {
-  return 2;
-} 
-
-constexpr inline FlexDirection scopedEnum(YGFlexDirection unscoped) {
+constexpr FlexDirection scopedEnum(YGFlexDirection unscoped) {
   return static_cast<FlexDirection>(unscoped);
 }
 
-constexpr inline YGFlexDirection unscopedEnum(FlexDirection scoped) {
+constexpr YGFlexDirection unscopedEnum(FlexDirection scoped) {
   return static_cast<YGFlexDirection>(scoped);
 }
 
diff --git a/yoga/enums/Gutter.h b/yoga/enums/Gutter.h
index 5c0f4a25..f16bbbcd 100644
--- a/yoga/enums/Gutter.h
+++ b/yoga/enums/Gutter.h
@@ -22,20 +22,15 @@ enum class Gutter : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Gutter>() {
+constexpr int32_t ordinalCount<Gutter>() {
   return 3;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Gutter>() {
-  return 2;
-} 
-
-constexpr inline Gutter scopedEnum(YGGutter unscoped) {
+constexpr Gutter scopedEnum(YGGutter unscoped) {
   return static_cast<Gutter>(unscoped);
 }
 
-constexpr inline YGGutter unscopedEnum(Gutter scoped) {
+constexpr YGGutter unscopedEnum(Gutter scoped) {
   return static_cast<YGGutter>(scoped);
 }
 
diff --git a/yoga/enums/Justify.h b/yoga/enums/Justify.h
index 870a3cb2..255baa6e 100644
--- a/yoga/enums/Justify.h
+++ b/yoga/enums/Justify.h
@@ -25,20 +25,15 @@ enum class Justify : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Justify>() {
+constexpr int32_t ordinalCount<Justify>() {
   return 6;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Justify>() {
-  return 3;
-} 
-
-constexpr inline Justify scopedEnum(YGJustify unscoped) {
+constexpr Justify scopedEnum(YGJustify unscoped) {
   return static_cast<Justify>(unscoped);
 }
 
-constexpr inline YGJustify unscopedEnum(Justify scoped) {
+constexpr YGJustify unscopedEnum(Justify scoped) {
   return static_cast<YGJustify>(scoped);
 }
 
diff --git a/yoga/enums/LogLevel.h b/yoga/enums/LogLevel.h
index 45cac9fe..d4b2c360 100644
--- a/yoga/enums/LogLevel.h
+++ b/yoga/enums/LogLevel.h
@@ -25,20 +25,15 @@ enum class LogLevel : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<LogLevel>() {
+constexpr int32_t ordinalCount<LogLevel>() {
   return 6;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<LogLevel>() {
-  return 3;
-} 
-
-constexpr inline LogLevel scopedEnum(YGLogLevel unscoped) {
+constexpr LogLevel scopedEnum(YGLogLevel unscoped) {
   return static_cast<LogLevel>(unscoped);
 }
 
-constexpr inline YGLogLevel unscopedEnum(LogLevel scoped) {
+constexpr YGLogLevel unscopedEnum(LogLevel scoped) {
   return static_cast<YGLogLevel>(scoped);
 }
 
diff --git a/yoga/enums/MeasureMode.h b/yoga/enums/MeasureMode.h
index 80fbcc59..39e2102f 100644
--- a/yoga/enums/MeasureMode.h
+++ b/yoga/enums/MeasureMode.h
@@ -22,20 +22,15 @@ enum class MeasureMode : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<MeasureMode>() {
+constexpr int32_t ordinalCount<MeasureMode>() {
   return 3;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<MeasureMode>() {
-  return 2;
-} 
-
-constexpr inline MeasureMode scopedEnum(YGMeasureMode unscoped) {
+constexpr MeasureMode scopedEnum(YGMeasureMode unscoped) {
   return static_cast<MeasureMode>(unscoped);
 }
 
-constexpr inline YGMeasureMode unscopedEnum(MeasureMode scoped) {
+constexpr YGMeasureMode unscopedEnum(MeasureMode scoped) {
   return static_cast<YGMeasureMode>(scoped);
 }
 
diff --git a/yoga/enums/NodeType.h b/yoga/enums/NodeType.h
index 782b163c..dc881be8 100644
--- a/yoga/enums/NodeType.h
+++ b/yoga/enums/NodeType.h
@@ -21,20 +21,15 @@ enum class NodeType : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<NodeType>() {
+constexpr int32_t ordinalCount<NodeType>() {
   return 2;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<NodeType>() {
-  return 1;
-} 
-
-constexpr inline NodeType scopedEnum(YGNodeType unscoped) {
+constexpr NodeType scopedEnum(YGNodeType unscoped) {
   return static_cast<NodeType>(unscoped);
 }
 
-constexpr inline YGNodeType unscopedEnum(NodeType scoped) {
+constexpr YGNodeType unscopedEnum(NodeType scoped) {
   return static_cast<YGNodeType>(scoped);
 }
 
diff --git a/yoga/enums/Overflow.h b/yoga/enums/Overflow.h
index 1d29103e..20901b02 100644
--- a/yoga/enums/Overflow.h
+++ b/yoga/enums/Overflow.h
@@ -22,20 +22,15 @@ enum class Overflow : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Overflow>() {
+constexpr int32_t ordinalCount<Overflow>() {
   return 3;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Overflow>() {
-  return 2;
-} 
-
-constexpr inline Overflow scopedEnum(YGOverflow unscoped) {
+constexpr Overflow scopedEnum(YGOverflow unscoped) {
   return static_cast<Overflow>(unscoped);
 }
 
-constexpr inline YGOverflow unscopedEnum(Overflow scoped) {
+constexpr YGOverflow unscopedEnum(Overflow scoped) {
   return static_cast<YGOverflow>(scoped);
 }
 
diff --git a/yoga/enums/PositionType.h b/yoga/enums/PositionType.h
index bde2b189..8a552aac 100644
--- a/yoga/enums/PositionType.h
+++ b/yoga/enums/PositionType.h
@@ -22,20 +22,15 @@ enum class PositionType : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<PositionType>() {
+constexpr int32_t ordinalCount<PositionType>() {
   return 3;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<PositionType>() {
-  return 2;
-} 
-
-constexpr inline PositionType scopedEnum(YGPositionType unscoped) {
+constexpr PositionType scopedEnum(YGPositionType unscoped) {
   return static_cast<PositionType>(unscoped);
 }
 
-constexpr inline YGPositionType unscopedEnum(PositionType scoped) {
+constexpr YGPositionType unscopedEnum(PositionType scoped) {
   return static_cast<YGPositionType>(scoped);
 }
 
diff --git a/yoga/enums/PrintOptions.h b/yoga/enums/PrintOptions.h
index 90d0043c..5970bafb 100644
--- a/yoga/enums/PrintOptions.h
+++ b/yoga/enums/PrintOptions.h
@@ -23,11 +23,11 @@ enum class PrintOptions : uint32_t {
 
 YG_DEFINE_ENUM_FLAG_OPERATORS(PrintOptions)
 
-constexpr inline PrintOptions scopedEnum(YGPrintOptions unscoped) {
+constexpr PrintOptions scopedEnum(YGPrintOptions unscoped) {
   return static_cast<PrintOptions>(unscoped);
 }
 
-constexpr inline YGPrintOptions unscopedEnum(PrintOptions scoped) {
+constexpr YGPrintOptions unscopedEnum(PrintOptions scoped) {
   return static_cast<YGPrintOptions>(scoped);
 }
 
diff --git a/yoga/enums/Unit.h b/yoga/enums/Unit.h
index 36efe95a..57bd1969 100644
--- a/yoga/enums/Unit.h
+++ b/yoga/enums/Unit.h
@@ -23,20 +23,15 @@ enum class Unit : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Unit>() {
+constexpr int32_t ordinalCount<Unit>() {
   return 4;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Unit>() {
-  return 2;
-} 
-
-constexpr inline Unit scopedEnum(YGUnit unscoped) {
+constexpr Unit scopedEnum(YGUnit unscoped) {
   return static_cast<Unit>(unscoped);
 }
 
-constexpr inline YGUnit unscopedEnum(Unit scoped) {
+constexpr YGUnit unscopedEnum(Unit scoped) {
   return static_cast<YGUnit>(scoped);
 }
 
diff --git a/yoga/enums/Wrap.h b/yoga/enums/Wrap.h
index ae380a44..96552b7b 100644
--- a/yoga/enums/Wrap.h
+++ b/yoga/enums/Wrap.h
@@ -22,20 +22,15 @@ enum class Wrap : uint8_t {
 };
 
 template <>
-constexpr inline int32_t ordinalCount<Wrap>() {
+constexpr int32_t ordinalCount<Wrap>() {
   return 3;
-} 
+}
 
-template <>
-constexpr inline int32_t bitCount<Wrap>() {
-  return 2;
-} 
-
-constexpr inline Wrap scopedEnum(YGWrap unscoped) {
+constexpr Wrap scopedEnum(YGWrap unscoped) {
   return static_cast<Wrap>(unscoped);
 }
 
-constexpr inline YGWrap unscopedEnum(Wrap scoped) {
+constexpr YGWrap unscopedEnum(Wrap scoped) {
   return static_cast<YGWrap>(scoped);
 }
 
diff --git a/yoga/enums/YogaEnums.h b/yoga/enums/YogaEnums.h
index a3e1191d..de446621 100644
--- a/yoga/enums/YogaEnums.h
+++ b/yoga/enums/YogaEnums.h
@@ -7,25 +7,44 @@
 
 #pragma once
 
+#include <bit>
 #include <iterator>
 #include <type_traits>
 
 namespace facebook::yoga {
 
+/**
+ * Concept for any enum/enum class
+ */
 template <typename EnumT>
-constexpr inline int32_t ordinalCount();
+concept Enumeration = std::is_enum_v<EnumT>;
+
+/**
+ * Count of ordinals in a Yoga enum which is sequential
+ */
+template <Enumeration EnumT>
+constexpr int32_t ordinalCount();
+
+/**
+ * Concept for a yoga enum which is sequential
+ */
+template <typename EnumT>
+concept HasOrdinality = (ordinalCount<EnumT>() > 0);
 
 /**
  * Count of bits needed to represent every ordinal
  */
-template <typename EnumT>
-constexpr inline int32_t bitCount();
+template <HasOrdinality EnumT>
+constexpr int32_t bitCount() {
+  return std::bit_width(
+      static_cast<std::underlying_type_t<EnumT>>(ordinalCount<EnumT>() - 1));
+}
 
 /**
  * Polyfill of C++ 23 to_underlying()
  * https://en.cppreference.com/w/cpp/utility/to_underlying
  */
-constexpr auto to_underlying(auto e) noexcept {
+constexpr auto to_underlying(Enumeration auto e) noexcept {
   return static_cast<std::underlying_type_t<decltype(e)>>(e);
 }
 
@@ -33,7 +52,7 @@ constexpr auto to_underlying(auto e) noexcept {
  * Convenience function to iterate through every value in a Yoga enum as part of
  * a range-based for loop.
  */
-template <typename EnumT>
+template <HasOrdinality EnumT>
 auto ordinals() {
   struct Iterator {
     EnumT e{};
diff --git a/yoga/numeric/Comparison.h b/yoga/numeric/Comparison.h
index 3bf1037b..729589b9 100644
--- a/yoga/numeric/Comparison.h
+++ b/yoga/numeric/Comparison.h
@@ -10,27 +10,32 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <concepts>
 
 #include <yoga/Yoga.h>
 
 namespace facebook::yoga {
 
-constexpr bool isUndefined(auto value) {
+constexpr bool isUndefined(std::floating_point auto value) {
   return value != value;
 }
 
-constexpr bool isDefined(auto value) {
+constexpr bool isDefined(std::floating_point auto value) {
   return !isUndefined(value);
 }
 
-constexpr auto maxOrDefined(auto a, auto b) {
+constexpr auto maxOrDefined(
+    std::floating_point auto a,
+    std::floating_point auto b) {
   if (yoga::isDefined(a) && yoga::isDefined(b)) {
     return std::max(a, b);
   }
   return yoga::isUndefined(a) ? b : a;
 }
 
-constexpr auto minOrDefined(auto a, auto b) {
+constexpr auto minOrDefined(
+    std::floating_point auto a,
+    std::floating_point auto b) {
   if (yoga::isDefined(a) && yoga::isDefined(b)) {
     return std::min(a, b);
   }
diff --git a/yoga/style/CompactValue.h b/yoga/style/CompactValue.h
index c32dd927..d7884e1d 100644
--- a/yoga/style/CompactValue.h
+++ b/yoga/style/CompactValue.h
@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <bit>
 #include <cmath>
 #include <cstdint>
 #include <limits>
@@ -14,7 +15,6 @@
 #include <yoga/YGMacros.h>
 #include <yoga/YGValue.h>
 
-#include <yoga/bits/BitCast.h>
 #include <yoga/numeric/Comparison.h>
 
 static_assert(
@@ -69,7 +69,7 @@ class YG_EXPORT CompactValue {
     }
 
     uint32_t unitBit = Unit == YGUnitPercent ? PERCENT_BIT : 0;
-    auto data = yoga::bit_cast<uint32_t>(value);
+    auto data = std::bit_cast<uint32_t>(value);
     data -= BIAS;
     data |= unitBit;
     return {data};
@@ -112,7 +112,7 @@ class YG_EXPORT CompactValue {
         return YGValue{0.0f, YGUnitPercent};
     }
 
-    if (std::isnan(yoga::bit_cast<float>(repr_))) {
+    if (std::isnan(std::bit_cast<float>(repr_))) {
       return YGValueUndefined;
     }
 
@@ -121,14 +121,14 @@ class YG_EXPORT CompactValue {
     data += BIAS;
 
     return YGValue{
-        yoga::bit_cast<float>(data),
+        std::bit_cast<float>(data),
         repr_ & 0x40000000 ? YGUnitPercent : YGUnitPoint};
   }
 
   bool isUndefined() const noexcept {
     return (
         repr_ != AUTO_BITS && repr_ != ZERO_BITS_POINT &&
-        repr_ != ZERO_BITS_PERCENT && std::isnan(yoga::bit_cast<float>(repr_)));
+        repr_ != ZERO_BITS_PERCENT && std::isnan(std::bit_cast<float>(repr_)));
   }
 
   bool isDefined() const noexcept {