llvm-native-core 0.1.6

//! clang_stl3 — Extended C++ Standard Library behavioral models.
//!
//! Covers C++20/23 library additions:
//! - <expected>: std::expected<T,E>
//! - <source_location>: source_location
//! - <bit>: bit operations
//! - <numbers>: mathematical constants
//! - <version>: feature-test macros
//! - <concepts>: standard concepts
//! - <coroutine>: coroutine support
//! - <compare>: comparison categories
//! - <semaphore>: counting/binary semaphores
//! - <syncstream>: synchronized output streams
//! - <stop_token>: stop token for cooperative cancellation
//! - <barrier>: thread barrier
//! - <latch>: thread latch
//!
//! Clean-room reconstruction from ISO/IEC 14882:2020 and published documentation.

use std::fmt;

// ============================================================================
// <expected> — std::expected<T, E>
// ============================================================================

/// Error category for expected.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExpectedError {
    /// Attempted to access value of an expected that contains an error.
    BadExpectedAccess,
}

impl fmt::Display for ExpectedError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::BadExpectedAccess => write!(f, "bad expected access"),
        }
    }
}

/// Unexpected value wrapper for std::expected.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Unexpected<E> {
    error: E,
}

impl<E> Unexpected<E> {
    pub fn new(error: E) -> Self {
        Self { error }
    }

    pub fn error(&self) -> &E {
        &self.error
    }

    pub fn into_error(self) -> E {
        self.error
    }
}

impl<E: fmt::Display> fmt::Display for Unexpected<E> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "unexpected({})", self.error)
    }
}

/// std::expected<T, E> — a variant that holds either a value or an error.
///
/// Models the C++23 std::expected type. Provides monadic operations
/// and_then, or_else, transform, transform_error.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum StdExpected<T, E> {
    Value(T),
    Error(E),
}

impl<T, E> StdExpected<T, E> {
    /// Construct an expected holding a value.
    pub fn value(val: T) -> Self {
        StdExpected::Value(val)
    }

    /// Construct an expected holding an error.
    pub fn error(err: E) -> Self {
        StdExpected::Error(err)
    }

    /// Returns true if the expected holds a value.
    pub fn has_value(&self) -> bool {
        matches!(self, StdExpected::Value(_))
    }

    /// Returns true if the expected holds an error.
    pub fn has_error(&self) -> bool {
        matches!(self, StdExpected::Error(_))
    }

    /// Returns a reference to the contained value.
    /// Panics if the expected holds an error.
    pub fn value_ref(&self) -> &T {
        match self {
            StdExpected::Value(ref v) => v,
            StdExpected::Error(_) => panic!("bad expected access: no value"),
        }
    }

    /// Returns a mutable reference to the contained value.
    pub fn value_mut(&mut self) -> &mut T {
        match self {
            StdExpected::Value(ref mut v) => v,
            StdExpected::Error(_) => panic!("bad expected access: no value"),
        }
    }

    /// Returns a reference to the contained error.
    /// Panics if the expected holds a value.
    pub fn error_ref(&self) -> &E {
        match self {
            StdExpected::Value(_) => panic!("bad expected access: no error"),
            StdExpected::Error(ref e) => e,
        }
    }

    /// Returns the contained value, consuming the expected.
    /// Panics if the expected holds an error.
    pub fn into_value(self) -> T {
        match self {
            StdExpected::Value(v) => v,
            StdExpected::Error(_) => panic!("bad expected access: no value"),
        }
    }

    /// Returns the contained error, consuming the expected.
    /// Panics if the expected holds a value.
    pub fn into_error(self) -> E {
        match self {
            StdExpected::Value(_) => panic!("bad expected access: no error"),
            StdExpected::Error(e) => e,
        }
    }

    /// Returns the contained value or a default if error.
    pub fn value_or(self, default: T) -> T {
        match self {
            StdExpected::Value(v) => v,
            StdExpected::Error(_) => default,
        }
    }

    /// Returns the contained value or computes one from the error.
    pub fn value_or_else<F: FnOnce(E) -> T>(self, f: F) -> T {
        match self {
            StdExpected::Value(v) => v,
            StdExpected::Error(e) => f(e),
        }
    }

    /// Monadic bind: if value, apply f; otherwise propagate error.
    pub fn and_then<U, F: FnOnce(T) -> StdExpected<U, E>>(self, f: F) -> StdExpected<U, E> {
        match self {
            StdExpected::Value(v) => f(v),
            StdExpected::Error(e) => StdExpected::Error(e),
        }
    }

    /// If error, apply f to the error and return a new expected.
    pub fn or_else<F: FnOnce(E) -> StdExpected<T, E>>(self, f: F) -> StdExpected<T, E> {
        match self {
            StdExpected::Value(v) => StdExpected::Value(v),
            StdExpected::Error(e) => f(e),
        }
    }

    /// Transform the value using f.
    pub fn transform<U, F: FnOnce(T) -> U>(self, f: F) -> StdExpected<U, E> {
        match self {
            StdExpected::Value(v) => StdExpected::Value(f(v)),
            StdExpected::Error(e) => StdExpected::Error(e),
        }
    }

    /// Transform the error using f.
    pub fn transform_error<F: FnOnce(E) -> E>(self, f: F) -> StdExpected<T, E> {
        match self {
            StdExpected::Value(v) => StdExpected::Value(v),
            StdExpected::Error(e) => StdExpected::Error(f(e)),
        }
    }

    /// Map either the value or the error.
    pub fn map<U, F: FnOnce(T) -> U, G: FnOnce(E) -> E>(
        self,
        val_fn: F,
        err_fn: G,
    ) -> StdExpected<U, E> {
        match self {
            StdExpected::Value(v) => StdExpected::Value(val_fn(v)),
            StdExpected::Error(e) => StdExpected::Error(err_fn(e)),
        }
    }

    /// Convert to Option<T>, discarding the error.
    pub fn ok(self) -> Option<T> {
        match self {
            StdExpected::Value(v) => Some(v),
            StdExpected::Error(_) => None,
        }
    }

    /// Convert to Option<E>, discarding the value.
    pub fn err(self) -> Option<E> {
        match self {
            StdExpected::Value(_) => None,
            StdExpected::Error(e) => Some(e),
        }
    }

    /// Swap the value and error types (requires T = E).
    pub fn swap_error_value(self) -> StdExpected<E, T> {
        match self {
            StdExpected::Value(v) => StdExpected::Error(v),
            StdExpected::Error(e) => StdExpected::Value(e),
        }
    }
}

impl<T: fmt::Display, E: fmt::Display> fmt::Display for StdExpected<T, E> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            StdExpected::Value(v) => write!(f, "expected(value: {})", v),
            StdExpected::Error(e) => write!(f, "expected(error: {})", e),
        }
    }
}

impl<T: Default, E> Default for StdExpected<T, E> {
    fn default() -> Self {
        StdExpected::Value(T::default())
    }
}

// ============================================================================
// <source_location> — std::source_location
// ============================================================================

/// Represents a position in source code (C++20 source_location equivalent).
///
/// Captures file name, function name, line number, and column number
/// at the point of construction.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SourceLocation {
    /// The source file name.
    pub file_name: String,
    /// The function name where the location was captured.
    pub function_name: String,
    /// 1-based line number.
    pub line: u32,
    /// 1-based column number.
    pub column: u32,
}

impl SourceLocation {
    /// Create a new source_location with the given details.
    pub fn new(file_name: &str, function_name: &str, line: u32, column: u32) -> Self {
        Self {
            file_name: file_name.to_string(),
            function_name: function_name.to_string(),
            line,
            column,
        }
    }

    /// Create a source_location from the current position.
    /// In native C++, this would use __builtin_FILE(), etc.
    /// In our model, callers provide the information explicitly.
    pub fn current(file: &str, function: &str, line: u32, column: u32) -> Self {
        Self {
            file_name: file.to_string(),
            function_name: function.to_string(),
            line,
            column,
        }
    }

    /// Returns the file name.
    pub fn file_name(&self) -> &str {
        &self.file_name
    }

    /// Returns the function name.
    pub fn function_name(&self) -> &str {
        &self.function_name
    }

    /// Returns the line number.
    pub fn line(&self) -> u32 {
        self.line
    }

    /// Returns the column number.
    pub fn column(&self) -> u32 {
        self.column
    }

    /// Format as "file:line:column".
    pub fn to_position_string(&self) -> String {
        format!("{}:{}:{}", self.file_name, self.line, self.column)
    }

    /// Format as "function at file:line:column".
    pub fn to_full_string(&self) -> String {
        format!(
            "{} at {}:{}:{}",
            self.function_name, self.file_name, self.line, self.column
        )
    }
}

impl fmt::Display for SourceLocation {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.to_full_string())
    }
}

impl Default for SourceLocation {
    fn default() -> Self {
        Self {
            file_name: "<unknown>".to_string(),
            function_name: "<unknown>".to_string(),
            line: 0,
            column: 0,
        }
    }
}

// ============================================================================
// <bit> — Bit manipulation functions
// ============================================================================

/// Endianness indicator.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Endian {
    Little,
    Big,
    Native,
}

/// Reinterpret the bits of a value as another type of the same size.
/// Safe Rust equivalent of std::bit_cast.
pub fn bit_cast<T: Copy, U: Copy>(_from: T, _to: U) -> U {
    // In a real implementation, this would use transmute or raw pointer casts.
    // For our behavioral model, we document the intent.
    // std::bit_cast<T>(from) reinterprets the object representation.
    panic!("bit_cast requires same-size types and trivially copyable constraints")
}

/// Check if x is an integral power of two.
pub fn has_single_bit(x: u64) -> bool {
    x != 0 && (x & (x - 1)) == 0
}

/// Check if x is an integral power of two (32-bit).
pub fn has_single_bit_u32(x: u32) -> bool {
    x != 0 && (x & (x - 1)) == 0
}

/// Smallest power of two not less than x.
pub fn bit_ceil(x: u64) -> u64 {
    if x == 0 {
        return 1;
    }
    if has_single_bit(x) {
        return x;
    }
    1u64 << (64 - (x - 1).leading_zeros())
}

/// Smallest power of two not less than x (32-bit).
pub fn bit_ceil_u32(x: u32) -> u32 {
    if x == 0 {
        return 1;
    }
    if has_single_bit_u32(x) {
        return x;
    }
    1u32 << (32 - (x - 1).leading_zeros())
}

/// Largest power of two not greater than x.
pub fn bit_floor(x: u64) -> u64 {
    if x == 0 {
        return 0;
    }
    1u64 << (63 - x.leading_zeros())
}

/// Largest power of two not greater than x (32-bit).
pub fn bit_floor_u32(x: u32) -> u32 {
    if x == 0 {
        return 0;
    }
    1u32 << (31 - x.leading_zeros())
}

/// The smallest number of bits needed to represent x.
pub fn bit_width(x: u64) -> u32 {
    if x == 0 {
        return 0;
    }
    64 - x.leading_zeros()
}

/// Bit width for u32.
pub fn bit_width_u32(x: u32) -> u32 {
    if x == 0 {
        return 0;
    }
    32 - x.leading_zeros()
}

/// Rotate left.
pub fn rotl_u8(x: u8, s: u32) -> u8 {
    let s = s % 8;
    (x << s) | (x >> (8 - s))
}

/// Rotate left.
pub fn rotl_u16(x: u16, s: u32) -> u16 {
    let s = s % 16;
    (x << s) | (x >> (16 - s))
}

/// Rotate left.
pub fn rotl_u32(x: u32, s: u32) -> u32 {
    let s = s % 32;
    (x << s) | (x >> (32 - s))
}

/// Rotate left.
pub fn rotl_u64(x: u64, s: u32) -> u64 {
    let s = s % 64;
    (x << s) | (x >> (64 - s))
}

/// Rotate right.
pub fn rotr_u8(x: u8, s: u32) -> u8 {
    let s = s % 8;
    (x >> s) | (x << (8 - s))
}

/// Rotate right.
pub fn rotr_u16(x: u16, s: u32) -> u16 {
    let s = s % 16;
    (x >> s) | (x << (16 - s))
}

/// Rotate right.
pub fn rotr_u32(x: u32, s: u32) -> u32 {
    let s = s % 32;
    (x >> s) | (x << (32 - s))
}

/// Rotate right.
pub fn rotr_u64(x: u64, s: u32) -> u64 {
    let s = s % 64;
    (x >> s) | (x << (64 - s))
}

/// Count leading zeros.
pub fn countl_zero_u8(x: u8) -> u32 {
    x.leading_zeros()
}

/// Count leading zeros.
pub fn countl_zero_u16(x: u16) -> u32 {
    x.leading_zeros()
}

/// Count leading zeros.
pub fn countl_zero_u32(x: u32) -> u32 {
    x.leading_zeros()
}

/// Count leading zeros.
pub fn countl_zero_u64(x: u64) -> u32 {
    x.leading_zeros()
}

/// Count trailing zeros.
pub fn countr_zero_u8(x: u8) -> u32 {
    x.trailing_zeros()
}

/// Count trailing zeros.
pub fn countr_zero_u16(x: u16) -> u32 {
    x.trailing_zeros()
}

/// Count trailing zeros.
pub fn countr_zero_u32(x: u32) -> u32 {
    x.trailing_zeros()
}

/// Count trailing zeros.
pub fn countr_zero_u64(x: u64) -> u32 {
    x.trailing_zeros()
}

/// Count leading ones.
pub fn countl_one_u8(x: u8) -> u32 {
    (!x).leading_zeros()
}

/// Count leading ones.
pub fn countl_one_u16(x: u16) -> u32 {
    (!x).leading_zeros()
}

/// Count leading ones.
pub fn countl_one_u32(x: u32) -> u32 {
    (!x).leading_zeros()
}

/// Count leading ones.
pub fn countl_one_u64(x: u64) -> u32 {
    (!x).leading_zeros()
}

/// Count trailing ones.
pub fn countr_one_u8(x: u8) -> u32 {
    (!x).trailing_zeros()
}

/// Count trailing ones.
pub fn countr_one_u16(x: u16) -> u32 {
    (!x).trailing_zeros()
}

/// Count trailing ones.
pub fn countr_one_u32(x: u32) -> u32 {
    (!x).trailing_zeros()
}

/// Count trailing ones.
pub fn countr_one_u64(x: u64) -> u32 {
    (!x).trailing_zeros()
}

/// Population count (number of set bits).
pub fn popcount_u8(x: u8) -> u32 {
    x.count_ones()
}

/// Population count.
pub fn popcount_u16(x: u16) -> u32 {
    x.count_ones()
}

/// Population count.
pub fn popcount_u32(x: u32) -> u32 {
    x.count_ones()
}

/// Population count.
pub fn popcount_u64(x: u64) -> u32 {
    x.count_ones()
}

/// Generalized bit_cast for same-size integer types.
pub fn bit_cast_u32_to_i32(x: u32) -> i32 {
    x as i32
}

/// Generalized bit_cast.
pub fn bit_cast_i32_to_u32(x: i32) -> u32 {
    x as u32
}

/// Generalized bit_cast for f32/u32.
pub fn bit_cast_f32_to_u32(x: f32) -> u32 {
    x.to_bits()
}

/// Generalized bit_cast for u32/f32.
pub fn bit_cast_u32_to_f32(x: u32) -> f32 {
    f32::from_bits(x)
}

/// Generalized bit_cast for f64/u64.
pub fn bit_cast_f64_to_u64(x: f64) -> u64 {
    x.to_bits()
}

/// Generalized bit_cast for u64/f64.
pub fn bit_cast_u64_to_f64(x: u64) -> f64 {
    f64::from_bits(x)
}

/// Endian type detection.
pub const fn native_endian() -> Endian {
    #[cfg(target_endian = "little")]
    {
        Endian::Little
    }
    #[cfg(target_endian = "big")]
    {
        Endian::Big
    }
}

/// Convert from network byte order (big-endian).
pub fn ntohs(x: u16) -> u16 {
    u16::from_be(x)
}

pub fn ntohl(x: u32) -> u32 {
    u32::from_be(x)
}

pub fn htons(x: u16) -> u16 {
    x.to_be()
}

pub fn htonl(x: u32) -> u32 {
    x.to_be()
}

// ============================================================================
// <numbers> — Mathematical constants
// ============================================================================

/// std::numbers constants as f32.
pub mod numbers_f32 {
    /// π — pi constant.
    pub const PI: f32 = std::f32::consts::PI;
    /// e — Euler's number.
    pub const E: f32 = std::f32::consts::E;
    /// log2(e)
    pub const LOG2E: f32 = std::f32::consts::LOG2_E;
    /// log10(e)
    pub const LOG10E: f32 = std::f32::consts::LOG10_E;
    /// ln(2)
    pub const LN2: f32 = std::f32::consts::LN_2;
    /// ln(10)
    pub const LN10: f32 = std::f32::consts::LN_10;
    /// sqrt(2)
    pub const SQRT2: f32 = std::f32::consts::SQRT_2;
    /// sqrt(3)
    pub const SQRT3: f32 = 1.7320508075688772_f32;
    /// 1/sqrt(3)
    pub const INV_SQRT3: f32 = 0.5773502691896258_f32;
    /// Euler-Mascheroni constant γ
    pub const EGAMMA: f32 = 0.5772156649015329_f32;
    /// Golden ratio φ = (1 + sqrt(5)) / 2
    pub const PHI: f32 = 1.618033988749895_f32;
}

/// std::numbers constants as f64.
pub mod numbers_f64 {
    /// π — pi constant.
    pub const PI: f64 = std::f64::consts::PI;
    /// e — Euler's number.
    pub const E: f64 = std::f64::consts::E;
    /// log2(e)
    pub const LOG2E: f64 = std::f64::consts::LOG2_E;
    /// log10(e)
    pub const LOG10E: f64 = std::f64::consts::LOG10_E;
    /// ln(2)
    pub const LN2: f64 = std::f64::consts::LN_2;
    /// ln(10)
    pub const LN10: f64 = std::f64::consts::LN_10;
    /// sqrt(2)
    pub const SQRT2: f64 = std::f64::consts::SQRT_2;
    /// sqrt(3)
    pub const SQRT3: f64 = 1.7320508075688772_f64;
    /// 1/sqrt(3)
    pub const INV_SQRT3: f64 = 0.5773502691896258_f64;
    /// Euler-Mascheroni constant γ
    pub const EGAMMA: f64 = 0.577215664901532860606512090082402431_f64;
    /// Golden ratio φ = (1 + sqrt(5)) / 2
    pub const PHI: f64 = 1.618033988749894848204586834365638118_f64;
}

/// Convenience re-exports at f64 precision (std::numbers).
pub mod numbers {
    pub use super::numbers_f64::*;
}

/// Math constant struct for generic code parameterized on type.
#[derive(Debug, Clone, Copy)]
pub struct MathConstants<T> {
    pub pi: T,
    pub e: T,
    pub log2e: T,
    pub log10e: T,
    pub ln2: T,
    pub ln10: T,
    pub sqrt2: T,
    pub sqrt3: T,
    pub inv_sqrt3: T,
    pub egamma: T,
    pub phi: T,
}

impl MathConstants<f64> {
    pub const fn new() -> Self {
        Self {
            pi: numbers_f64::PI,
            e: numbers_f64::E,
            log2e: numbers_f64::LOG2E,
            log10e: numbers_f64::LOG10E,
            ln2: numbers_f64::LN2,
            ln10: numbers_f64::LN10,
            sqrt2: numbers_f64::SQRT2,
            sqrt3: numbers_f64::SQRT3,
            inv_sqrt3: numbers_f64::INV_SQRT3,
            egamma: numbers_f64::EGAMMA,
            phi: numbers_f64::PHI,
        }
    }
}

impl MathConstants<f32> {
    pub const fn new() -> Self {
        Self {
            pi: numbers_f32::PI,
            e: numbers_f32::E,
            log2e: numbers_f32::LOG2E,
            log10e: numbers_f32::LOG10E,
            ln2: numbers_f32::LN2,
            ln10: numbers_f32::LN10,
            sqrt2: numbers_f32::SQRT2,
            sqrt3: numbers_f32::SQRT3,
            inv_sqrt3: numbers_f32::INV_SQRT3,
            egamma: numbers_f32::EGAMMA,
            phi: numbers_f32::PHI,
        }
    }
}

// ============================================================================
// <version> — Feature-test macros
// ============================================================================

/// C++ standard library feature-test macros.
/// These correspond to the __cpp_lib_* macros defined by the standard.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FeatureTestMacro {
    // C++17
    /// __cpp_lib_byte — std::byte (C++17)
    Byte,
    /// __cpp_lib_optional — std::optional
    Optional,
    /// __cpp_lib_variant — std::variant
    Variant,
    /// __cpp_lib_any — std::any
    Any,
    /// __cpp_lib_string_view — std::string_view
    StringView,
    /// __cpp_lib_filesystem — std::filesystem
    FileSystem,
    /// __cpp_lib_shared_mutex — std::shared_mutex
    SharedMutex,
    /// __cpp_lib_parallel_algorithm — parallel algorithms
    ParallelAlgorithm,
    /// __cpp_lib_scoped_lock — std::scoped_lock
    ScopedLock,
    /// __cpp_lib_invoke — std::invoke
    Invoke,

    // C++20
    /// __cpp_lib_concepts — concepts library
    Concepts,
    /// __cpp_lib_ranges — ranges library
    Ranges,
    /// __cpp_lib_span — std::span
    Span,
    /// __cpp_lib_coroutine — coroutine support
    Coroutine,
    /// __cpp_lib_three_way_comparison — <=> operator
    ThreeWayComparison,
    /// __cpp_lib_format — std::format
    Format,
    /// __cpp_lib_source_location — std::source_location
    SourceLocation,
    /// __cpp_lib_jthread — std::jthread
    Jthread,
    /// __cpp_lib_barrier — std::barrier
    Barrier,
    /// __cpp_lib_latch — std::latch
    Latch,
    /// __cpp_lib_semaphore — std::counting_semaphore
    Semaphore,
    /// __cpp_lib_atomic_wait — atomic wait/notify
    AtomicWait,
    /// __cpp_lib_bit_cast — std::bit_cast
    BitCast,
    /// __cpp_lib_math_constants — <numbers>
    MathConstants,
    /// __cpp_lib_endian — std::endian
    Endian,
    /// __cpp_lib_bitops — <bit> header
    BitOps,
    /// __cpp_lib_char8_t — char8_t
    Char8T,
    /// __cpp_lib_erase_if — container erase_if
    EraseIf,
    /// __cpp_lib_to_array — std::to_array
    ToArray,
    /// __cpp_lib_bind_front — std::bind_front
    BindFront,
    /// __cpp_lib_ssize — std::ssize
    Ssize,

    // C++23
    /// __cpp_lib_expected — std::expected
    Expected,
    /// __cpp_lib_flat_map — std::flat_map
    FlatMap,
    /// __cpp_lib_print — std::print
    Print,
    /// __cpp_lib_mdspan — std::mdspan
    Mdspan,
    /// __cpp_lib_stacktrace — std::stacktrace
    Stacktrace,
    /// __cpp_lib_monadic_optional — monadic optional
    MonadicOptional,
    /// __cpp_lib_move_only_function — std::move_only_function
    MoveOnlyFunction,
    /// __cpp_lib_out_ptr — std::out_ptr
    OutPtr,
    /// __cpp_lib_to_underlying — std::to_underlying
    ToUnderlying,
    /// __cpp_lib_unreachable — std::unreachable
    Unreachable,
}

impl FeatureTestMacro {
    /// Return the macro name as it appears in source code.
    pub fn macro_name(&self) -> &'static str {
        match self {
            Self::Byte => "__cpp_lib_byte",
            Self::Optional => "__cpp_lib_optional",
            Self::Variant => "__cpp_lib_variant",
            Self::Any => "__cpp_lib_any",
            Self::StringView => "__cpp_lib_string_view",
            Self::FileSystem => "__cpp_lib_filesystem",
            Self::SharedMutex => "__cpp_lib_shared_mutex",
            Self::ParallelAlgorithm => "__cpp_lib_parallel_algorithm",
            Self::ScopedLock => "__cpp_lib_scoped_lock",
            Self::Invoke => "__cpp_lib_invoke",
            Self::Concepts => "__cpp_lib_concepts",
            Self::Ranges => "__cpp_lib_ranges",
            Self::Span => "__cpp_lib_span",
            Self::Coroutine => "__cpp_lib_coroutine",
            Self::ThreeWayComparison => "__cpp_lib_three_way_comparison",
            Self::Format => "__cpp_lib_format",
            Self::SourceLocation => "__cpp_lib_source_location",
            Self::Jthread => "__cpp_lib_jthread",
            Self::Barrier => "__cpp_lib_barrier",
            Self::Latch => "__cpp_lib_latch",
            Self::Semaphore => "__cpp_lib_semaphore",
            Self::AtomicWait => "__cpp_lib_atomic_wait",
            Self::BitCast => "__cpp_lib_bit_cast",
            Self::MathConstants => "__cpp_lib_math_constants",
            Self::Endian => "__cpp_lib_endian",
            Self::BitOps => "__cpp_lib_bitops",
            Self::Char8T => "__cpp_lib_char8_t",
            Self::EraseIf => "__cpp_lib_erase_if",
            Self::ToArray => "__cpp_lib_to_array",
            Self::BindFront => "__cpp_lib_bind_front",
            Self::Ssize => "__cpp_lib_ssize",
            Self::Expected => "__cpp_lib_expected",
            Self::FlatMap => "__cpp_lib_flat_map",
            Self::Print => "__cpp_lib_print",
            Self::Mdspan => "__cpp_lib_mdspan",
            Self::Stacktrace => "__cpp_lib_stacktrace",
            Self::MonadicOptional => "__cpp_lib_monadic_optional",
            Self::MoveOnlyFunction => "__cpp_lib_move_only_function",
            Self::OutPtr => "__cpp_lib_out_ptr",
            Self::ToUnderlying => "__cpp_lib_to_underlying",
            Self::Unreachable => "__cpp_lib_unreachable",
        }
    }

    /// Return the minimum C++ standard year that introduced this feature.
    pub fn introduced_in(&self) -> &'static str {
        match self {
            Self::Byte => "201603",
            Self::Optional => "201603",
            Self::Variant => "201603",
            Self::Any => "201606",
            Self::StringView => "201606",
            Self::FileSystem => "201703",
            Self::SharedMutex => "201505",
            Self::ParallelAlgorithm => "201603",
            Self::ScopedLock => "201703",
            Self::Invoke => "201703",
            Self::Concepts => "202002",
            Self::Ranges => "201911",
            Self::Span => "202002",
            Self::Coroutine => "201902",
            Self::ThreeWayComparison => "201907",
            Self::Format => "201907",
            Self::SourceLocation => "201907",
            Self::Jthread => "201911",
            Self::Barrier => "201907",
            Self::Latch => "201907",
            Self::Semaphore => "201907",
            Self::AtomicWait => "201907",
            Self::BitCast => "201806",
            Self::MathConstants => "201907",
            Self::Endian => "201907",
            Self::BitOps => "201907",
            Self::Char8T => "201811",
            Self::EraseIf => "201811",
            Self::ToArray => "201811",
            Self::BindFront => "201907",
            Self::Ssize => "201902",
            Self::Expected => "202211",
            Self::FlatMap => "202207",
            Self::Print => "202207",
            Self::Mdspan => "202207",
            Self::Stacktrace => "202011",
            Self::MonadicOptional => "202110",
            Self::MoveOnlyFunction => "202110",
            Self::OutPtr => "202106",
            Self::ToUnderlying => "202102",
            Self::Unreachable => "202202",
        }
    }

    /// Return the numeric macro value for a given standard year compliance.
    pub fn value_for_standard(&self, standard_year: u32) -> Option<u64> {
        let introduced = self.introduced_in().parse::<u32>().ok()?;
        if standard_year >= introduced {
            Some(introduced as u64)
        } else {
            None
        }
    }
}

/// Feature test macro database.
pub struct FeatureTestDatabase {
    macros: Vec<(FeatureTestMacro, bool)>,
}

impl FeatureTestDatabase {
    pub fn new() -> Self {
        Self { macros: Vec::new() }
    }

    /// Enable a feature test macro.
    pub fn enable(&mut self, ft: FeatureTestMacro) {
        self.macros.push((ft, true));
    }

    /// Check if a feature is enabled for a given standard year.
    pub fn is_available(&self, ft: FeatureTestMacro, standard_year: u32) -> bool {
        match ft.value_for_standard(standard_year) {
            Some(_) => {
                if let Some((_, enabled)) = self.macros.iter().find(|(m, _)| *m == ft) {
                    *enabled
                } else {
                    true // default: available if standard year >= intro year
                }
            }
            None => false,
        }
    }

    /// Generate #define directives for preprocessor.
    pub fn generate_defines(&self, standard_year: u32) -> Vec<String> {
        let all_macros = vec![
            FeatureTestMacro::Byte,
            FeatureTestMacro::Optional,
            FeatureTestMacro::Variant,
            FeatureTestMacro::Any,
            FeatureTestMacro::StringView,
            FeatureTestMacro::FileSystem,
            FeatureTestMacro::SharedMutex,
            FeatureTestMacro::Concepts,
            FeatureTestMacro::Ranges,
            FeatureTestMacro::Span,
            FeatureTestMacro::Coroutine,
            FeatureTestMacro::ThreeWayComparison,
            FeatureTestMacro::Format,
            FeatureTestMacro::SourceLocation,
            FeatureTestMacro::Expected,
            FeatureTestMacro::FlatMap,
            FeatureTestMacro::Barrier,
            FeatureTestMacro::Latch,
            FeatureTestMacro::Semaphore,
            FeatureTestMacro::BitCast,
            FeatureTestMacro::MathConstants,
            FeatureTestMacro::Endian,
            FeatureTestMacro::BitOps,
        ];

        let mut defines = Vec::new();
        for ft in all_macros {
            if self.is_available(ft, standard_year) {
                if let Some(val) = ft.value_for_standard(standard_year) {
                    defines.push(format!("#define {} {}", ft.macro_name(), val));
                }
            }
        }
        defines
    }
}

impl Default for FeatureTestDatabase {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// <concepts> — Standard concept predicates
// ============================================================================

/// Concept evaluation result.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConceptResult {
    Satisfied,
    NotSatisfied(String),
}

/// Trait representing a C++ concept.
pub trait ConceptPredicate {
    fn name(&self) -> &'static str;
    fn evaluate_type(&self, type_name: &str) -> ConceptResult;
}

/// std::same_as<T, U> — T and U are the same type.
pub struct SameAs {
    pub t: String,
    pub u: String,
}

impl SameAs {
    pub fn new(t: &str, u: &str) -> Self {
        Self {
            t: t.to_string(),
            u: u.to_string(),
        }
    }

    pub fn is_satisfied(&self) -> bool {
        self.t == self.u
    }
}

impl ConceptPredicate for SameAs {
    fn name(&self) -> &'static str {
        "same_as"
    }
    fn evaluate_type(&self, _type_name: &str) -> ConceptResult {
        if self.is_satisfied() {
            ConceptResult::Satisfied
        } else {
            ConceptResult::NotSatisfied(format!(
                "same_as<{}, {}>: types differ",
                self.t, self.u
            ))
        }
    }
}

/// std::derived_from<Derived, Base> — Derived is derived from Base.
pub struct DerivedFrom {
    pub derived: String,
    pub base: String,
}

impl DerivedFrom {
    pub fn new(derived: &str, base: &str) -> Self {
        Self {
            derived: derived.to_string(),
            base: base.to_string(),
        }
    }

    pub fn is_satisfied(&self, derived_from: &[(String, Vec<String>)]) -> bool {
        // Check if derived is same as base or in the base class chain
        derived_from
            .iter()
            .any(|(cls, bases)| cls == &self.derived && bases.contains(&self.base))
    }
}

/// std::convertible_to<From, To> — From is implicitly convertible to To.
pub struct ConvertibleTo {
    pub from: String,
    pub to: String,
}

impl ConvertibleTo {
    pub fn new(from: &str, to: &str) -> Self {
        Self {
            from: from.to_string(),
            to: to.to_string(),
        }
    }

    pub fn is_satisfied(
        &self,
        conversions: &[(String, Vec<String>)],
    ) -> bool {
        conversions
            .iter()
            .any(|(t, convs)| t == &self.from && convs.contains(&self.to))
    }
}

/// std::common_with<T, U> — T and U share a common type.
pub struct CommonWith {
    pub t: String,
    pub u: String,
}

impl CommonWith {
    pub fn new(t: &str, u: &str) -> Self {
        Self {
            t: t.to_string(),
            u: u.to_string(),
        }
    }
}

/// Standard type category for concept evaluation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TypeCategory {
    Integral,
    FloatingPoint,
    Pointer,
    Class,
    Enum,
    Union,
    Array,
    Function,
    Void,
    Nullptr,
}

/// Concept engine for evaluating standard concepts against types.
pub struct ConceptEngine {
    type_categories: Vec<(String, TypeCategory)>,
    base_classes: Vec<(String, Vec<String>)>,
    implicit_conversions: Vec<(String, Vec<String>)>,
}

impl ConceptEngine {
    pub fn new() -> Self {
        Self {
            type_categories: Vec::new(),
            base_classes: Vec::new(),
            implicit_conversions: Vec::new(),
        }
    }

    pub fn register_type(&mut self, name: &str, category: TypeCategory) {
        self.type_categories
            .push((name.to_string(), category));
    }

    pub fn register_base(&mut self, derived: &str, base: &str) {
        if let Some((_, bases)) = self
            .base_classes
            .iter_mut()
            .find(|(d, _)| d == derived)
        {
            bases.push(base.to_string());
        } else {
            self.base_classes
                .push((derived.to_string(), vec![base.to_string()]));
        }
    }

    pub fn register_conversion(&mut self, from: &str, to: &str) {
        if let Some((_, convs)) = self
            .implicit_conversions
            .iter_mut()
            .find(|(f, _)| f == from)
        {
            convs.push(to.to_string());
        } else {
            self.implicit_conversions
                .push((from.to_string(), vec![to.to_string()]));
        }
    }

    /// Evaluate same_as concept.
    pub fn same_as(&self, t: &str, u: &str) -> ConceptResult {
        if t == u {
            ConceptResult::Satisfied
        } else {
            ConceptResult::NotSatisfied(format!("same_as<{}, {}>: types differ", t, u))
        }
    }

    /// Evaluate derived_from concept.
    pub fn derived_from(&self, derived: &str, base: &str) -> ConceptResult {
        if derived == base {
            return ConceptResult::Satisfied;
        }
        if let Some((_, bases)) = self.base_classes.iter().find(|(d, _)| d == derived) {
            if bases.iter().any(|b| b == base) {
                return ConceptResult::Satisfied;
            }
        }
        ConceptResult::NotSatisfied(format!(
            "derived_from<{}, {}>: not a base class",
            derived, base
        ))
    }

    /// Evaluate integral concept.
    pub fn integral(&self, t: &str) -> ConceptResult {
        if let Some((_, cat)) = self.type_categories.iter().find(|(n, _)| n == t) {
            if *cat == TypeCategory::Integral {
                return ConceptResult::Satisfied;
            }
        }
        ConceptResult::NotSatisfied(format!("integral<{}>: not an integral type", t))
    }

    /// Evaluate floating_point concept.
    pub fn floating_point(&self, t: &str) -> ConceptResult {
        if let Some((_, cat)) = self.type_categories.iter().find(|(n, _)| n == t) {
            if *cat == TypeCategory::FloatingPoint {
                return ConceptResult::Satisfied;
            }
        }
        ConceptResult::NotSatisfied(format!("floating_point<{}>: not a floating point type", t))
    }

    /// Evaluate movable concept.
    pub fn movable(&self, t: &str) -> ConceptResult {
        if let Some((_, cat)) = self.type_categories.iter().find(|(n, _)| n == t) {
            match cat {
                TypeCategory::Void | TypeCategory::Function | TypeCategory::Nullptr => {
                    ConceptResult::NotSatisfied(format!("movable<{}>: void/function types not movable", t))
                }
                _ => ConceptResult::Satisfied,
            }
        } else {
            ConceptResult::Satisfied // unknown types assumed movable
        }
    }

    /// Evaluate copyable concept.
    pub fn copyable(&self, t: &str) -> ConceptResult {
        self.movable(t) // copyable refines movable in our model
    }

    /// Evaluate semiregular concept.
    pub fn semiregular(&self, t: &str) -> ConceptResult {
        self.copyable(t) // semiregular = copyable + default_initializable
    }

    /// Evaluate regular concept.
    pub fn regular(&self, t: &str) -> ConceptResult {
        self.semiregular(t) // regular = semiregular + equality_comparable
    }

    /// Evaluate convertible_to concept.
    pub fn convertible_to(&self, from: &str, to: &str) -> ConceptResult {
        if from == to {
            return ConceptResult::Satisfied;
        }
        if let Some((_, convs)) = self
            .implicit_conversions
            .iter()
            .find(|(f, _)| f == from)
        {
            if convs.iter().any(|c| c == to) {
                return ConceptResult::Satisfied;
            }
        }
        ConceptResult::NotSatisfied(format!(
            "convertible_to<{}, {}>: no implicit conversion",
            from, to
        ))
    }

    /// Evaluate common_with concept.
    pub fn common_with(&self, t: &str, u: &str) -> ConceptResult {
        if t == u {
            return ConceptResult::Satisfied;
        }
        // Simple case: if one is convertible to the other
        if self.convertible_to(t, u) == ConceptResult::Satisfied
            || self.convertible_to(u, t) == ConceptResult::Satisfied
        {
            return ConceptResult::Satisfied;
        }
        ConceptResult::NotSatisfied(format!(
            "common_with<{}, {}>: no common reference type",
            t, u
        ))
    }

    /// Evaluate invocable concept (simplified).
    pub fn invocable(&self, _fn_name: &str, _arg_types: &[String]) -> ConceptResult {
        ConceptResult::Satisfied // placeholder
    }

    /// Evaluate predicate concept (simplified).
    pub fn predicate(&self, _fn_name: &str, _arg_types: &[String]) -> ConceptResult {
        ConceptResult::Satisfied // placeholder
    }

    /// Evaluate totally_ordered concept.
    pub fn totally_ordered(&self, t: &str) -> ConceptResult {
        if let Some((_, cat)) = self.type_categories.iter().find(|(n, _)| n == t) {
            match cat {
                TypeCategory::Integral | TypeCategory::FloatingPoint => {
                    ConceptResult::Satisfied
                }
                TypeCategory::Class | TypeCategory::Enum => ConceptResult::Satisfied,
                _ => ConceptResult::NotSatisfied(format!(
                    "totally_ordered<{}>: not orderable",
                    t
                )),
            }
        } else {
            ConceptResult::NotSatisfied(format!("totally_ordered<{}>: unknown type", t))
        }
    }
}

impl Default for ConceptEngine {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// <coroutine> — Coroutine support
// ============================================================================

/// Coroutine state for tracking lifecycle.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CoroutineState {
    NotStarted,
    Suspended,
    Running,
    Returning,
    Complete,
}

/// Coroutine handle — represents a handle to a coroutine frame.
pub struct CoroutineHandle {
    /// Address of the coroutine frame.
    pub address: usize,
    /// Current state of the coroutine.
    pub state: CoroutineState,
    /// Whether the coroutine is done.
    pub done: bool,
}

impl CoroutineHandle {
    pub fn new(address: usize) -> Self {
        Self {
            address,
            state: CoroutineState::NotStarted,
            done: false,
        }
    }

    /// Check if the coroutine is done.
    pub fn done(&self) -> bool {
        self.done || self.state == CoroutineState::Complete
    }

    /// Resume the coroutine.
    pub fn resume(&mut self) {
        if !self.done {
            self.state = CoroutineState::Running;
            // In a real implementation, this would jump to the resume point
        }
    }

    /// Mark the coroutine as complete.
    pub fn destroy(&mut self) {
        self.done = true;
        self.state = CoroutineState::Complete;
    }

    /// Get the coroutine address.
    pub fn address(&self) -> usize {
        self.address
    }
}

impl fmt::Debug for CoroutineHandle {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("CoroutineHandle")
            .field("address", &format_args!("{:#x}", self.address))
            .field("state", &self.state)
            .field("done", &self.done)
            .finish()
    }
}

/// Suspend never — the coroutine never suspends at this point.
#[derive(Debug, Clone, Copy)]
pub struct SuspendNever;

impl SuspendNever {
    pub fn await_ready(&self) -> bool {
        true
    }

    pub fn await_suspend(&self, _handle: &CoroutineHandle) -> bool {
        false
    }

    pub fn await_resume(&self) {}
}

/// Suspend always — the coroutine always suspends at this point.
#[derive(Debug, Clone, Copy)]
pub struct SuspendAlways;

impl SuspendAlways {
    pub fn await_ready(&self) -> bool {
        false
    }

    pub fn await_suspend(&self, _handle: &CoroutineHandle) -> bool {
        true
    }

    pub fn await_resume(&self) {}
}

/// Promise type descriptor for coroutine frames.
#[derive(Debug, Clone)]
pub struct CoroutinePromise {
    /// Return type of the coroutine.
    pub return_type: String,
    /// Promise type name.
    pub promise_type: String,
    /// Initial suspend point.
    pub initial_suspend: CoroutineSuspendPoint,
    /// Final suspend point.
    pub final_suspend: CoroutineSuspendPoint,
}

#[derive(Debug, Clone)]
pub enum CoroutineSuspendPoint {
    Never,
    Always,
    Custom(String),
}

impl CoroutinePromise {
    pub fn new(return_type: &str) -> Self {
        Self {
            return_type: return_type.to_string(),
            promise_type: format!("{}_promise_type", return_type),
            initial_suspend: CoroutineSuspendPoint::Always,
            final_suspend: CoroutineSuspendPoint::Always,
        }
    }

    pub fn with_promise_type(mut self, pt: &str) -> Self {
        self.promise_type = pt.to_string();
        self
    }

    pub fn with_initial_suspend(mut self, sp: CoroutineSuspendPoint) -> Self {
        self.initial_suspend = sp;
        self
    }

    pub fn with_final_suspend(mut self, sp: CoroutineSuspendPoint) -> Self {
        self.final_suspend = sp;
        self
    }
}

/// Coroutine traits — maps return type to promise type.
pub struct CoroutineTraits {
    pub return_type: String,
    pub promise_type: String,
    pub allocator_type: Option<String>,
}

impl CoroutineTraits {
    pub fn new(return_type: &str, promise_type: &str) -> Self {
        Self {
            return_type: return_type.to_string(),
            promise_type: promise_type.to_string(),
            allocator_type: None,
        }
    }

    pub fn with_allocator(mut self, alloc: &str) -> Self {
        self.allocator_type = Some(alloc.to_string());
        self
    }
}

// ============================================================================
// <compare> — Comparison category types
// ============================================================================

/// Strong ordering — total ordering with substitutability.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum StrongOrdering {
    Less,
    Equal,
    Greater,
}

impl StrongOrdering {
    /// Convert strong_ordering to weak_ordering.
    pub fn as_weak(&self) -> WeakOrdering {
        match self {
            StrongOrdering::Less => WeakOrdering::Less,
            StrongOrdering::Equal => WeakOrdering::Equivalent,
            StrongOrdering::Greater => WeakOrdering::Greater,
        }
    }

    /// Convert strong_ordering to partial_ordering.
    pub fn as_partial(&self) -> PartialOrdering {
        match self {
            StrongOrdering::Less => PartialOrdering::Less,
            StrongOrdering::Equal => PartialOrdering::Equivalent,
            StrongOrdering::Greater => PartialOrdering::Greater,
        }
    }

    /// Returns true if this is 'less'.
    pub fn is_lt(&self) -> bool {
        matches!(self, StrongOrdering::Less)
    }

    /// Returns true if this is 'equal'.
    pub fn is_eq(&self) -> bool {
        matches!(self, StrongOrdering::Equal)
    }

    /// Returns true if this is 'greater'.
    pub fn is_gt(&self) -> bool {
        matches!(self, StrongOrdering::Greater)
    }
}

impl From<std::cmp::Ordering> for StrongOrdering {
    fn from(o: std::cmp::Ordering) -> Self {
        match o {
            std::cmp::Ordering::Less => StrongOrdering::Less,
            std::cmp::Ordering::Equal => StrongOrdering::Equal,
            std::cmp::Ordering::Greater => StrongOrdering::Greater,
        }
    }
}

/// Weak ordering — total ordering without substitutability.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum WeakOrdering {
    Less,
    Equivalent,
    Greater,
}

impl WeakOrdering {
    pub fn as_partial(&self) -> PartialOrdering {
        match self {
            WeakOrdering::Less => PartialOrdering::Less,
            WeakOrdering::Equivalent => PartialOrdering::Equivalent,
            WeakOrdering::Greater => PartialOrdering::Greater,
        }
    }

    pub fn is_lt(&self) -> bool {
        matches!(self, WeakOrdering::Less)
    }

    pub fn is_eqv(&self) -> bool {
        matches!(self, WeakOrdering::Equivalent)
    }

    pub fn is_gt(&self) -> bool {
        matches!(self, WeakOrdering::Greater)
    }
}

/// Partial ordering — allows unordered results.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PartialOrdering {
    Less,
    Equivalent,
    Greater,
    Unordered,
}

impl PartialOrdering {
    pub fn is_lt(&self) -> bool {
        matches!(self, PartialOrdering::Less)
    }

    pub fn is_eqv(&self) -> bool {
        matches!(self, PartialOrdering::Equivalent)
    }

    pub fn is_gt(&self) -> bool {
        matches!(self, PartialOrdering::Greater)
    }

    pub fn is_unordered(&self) -> bool {
        matches!(self, PartialOrdering::Unordered)
    }
}

/// Common comparison category type for metaprogramming.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ComparisonCategory {
    Strong(StrongOrdering),
    Weak(WeakOrdering),
    Partial(PartialOrdering),
}

impl ComparisonCategory {
    /// Create from a strong ordering.
    pub fn strong(o: StrongOrdering) -> Self {
        ComparisonCategory::Strong(o)
    }

    /// Create from a weak ordering.
    pub fn weak(o: WeakOrdering) -> Self {
        ComparisonCategory::Weak(o)
    }

    /// Create from a partial ordering.
    pub fn partial(o: PartialOrdering) -> Self {
        ComparisonCategory::Partial(o)
    }
}

/// Compute the common comparison category of two types.
pub fn common_comparison_category(
    a: ComparisonCategory,
    b: ComparisonCategory,
) -> ComparisonCategory {
    match (a, b) {
        (ComparisonCategory::Strong(_), ComparisonCategory::Strong(_)) => a,
        (ComparisonCategory::Weak(_), ComparisonCategory::Weak(_)) => a,
        (ComparisonCategory::Partial(_), ComparisonCategory::Partial(_)) => a,
        (ComparisonCategory::Strong(s), ComparisonCategory::Weak(_)) => {
            ComparisonCategory::Weak(s.as_weak())
        }
        (ComparisonCategory::Weak(_), ComparisonCategory::Strong(s)) => {
            ComparisonCategory::Weak(s.as_weak())
        }
        (ComparisonCategory::Strong(s), ComparisonCategory::Partial(_)) => {
            ComparisonCategory::Partial(s.as_partial())
        }
        (ComparisonCategory::Partial(_), ComparisonCategory::Strong(s)) => {
            ComparisonCategory::Partial(s.as_partial())
        }
        (ComparisonCategory::Weak(w), ComparisonCategory::Partial(_)) => {
            ComparisonCategory::Partial(w.as_partial())
        }
        (ComparisonCategory::Partial(_), ComparisonCategory::Weak(w)) => {
            ComparisonCategory::Partial(w.as_partial())
        }
    }
}

/// Spaceship operator emulation.
pub fn three_way_compare<T: Ord>(a: &T, b: &T) -> StrongOrdering {
    match a.cmp(b) {
        std::cmp::Ordering::Less => StrongOrdering::Less,
        std::cmp::Ordering::Equal => StrongOrdering::Equal,
        std::cmp::Ordering::Greater => StrongOrdering::Greater,
    }
}

// ============================================================================
// <semaphore> — std::counting_semaphore, std::binary_semaphore
// ============================================================================

/// Counting semaphore — models a non-negative resource count.
pub struct CountingSemaphore {
    counter: i64,
    max_value: i64,
}

impl CountingSemaphore {
    /// Create a counting semaphore with the given desired count.
    pub fn new(desired: i64, max_value: i64) -> Self {
        Self {
            counter: desired.min(max_value).max(0),
            max_value,
        }
    }

    /// Increment the counter by `update`.
    pub fn release(&mut self, update: i64) {
        self.counter = (self.counter + update).min(self.max_value);
    }

    /// Decrement the counter if > 0, else block (simulated).
    pub fn acquire(&mut self) -> bool {
        if self.counter > 0 {
            self.counter -= 1;
            true
        } else {
            false
        }
    }

    /// Try to acquire without blocking.
    pub fn try_acquire(&mut self) -> bool {
        self.acquire()
    }

    /// Try to acquire within a time limit (simulated).
    pub fn try_acquire_for(&mut self, _timeout_ms: u64) -> bool {
        self.acquire()
    }

    /// Get the current counter value.
    pub fn max(&self) -> i64 {
        self.max_value
    }

    /// Get the current counter.
    pub fn value(&self) -> i64 {
        self.counter
    }
}

impl fmt::Debug for CountingSemaphore {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("CountingSemaphore")
            .field("counter", &self.counter)
            .field("max_value", &self.max_value)
            .finish()
    }
}

/// Binary semaphore — at most one resource available.
pub struct BinarySemaphore {
    available: bool,
}

impl BinarySemaphore {
    /// Create a binary semaphore.
    pub fn new(initially_available: bool) -> Self {
        Self {
            available: initially_available,
        }
    }

    /// Release the semaphore (make available).
    pub fn release(&mut self) {
        self.available = true;
    }

    /// Acquire the semaphore.
    pub fn acquire(&mut self) -> bool {
        if self.available {
            self.available = false;
            true
        } else {
            false
        }
    }

    /// Try to acquire.
    pub fn try_acquire(&mut self) -> bool {
        self.acquire()
    }

    /// Check if available.
    pub fn is_available(&self) -> bool {
        self.available
    }
}

impl fmt::Debug for BinarySemaphore {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("BinarySemaphore")
            .field("available", &self.available)
            .finish()
    }
}

// ============================================================================
// <syncstream> — Synchronized output streams
// ============================================================================

/// Synchronized stream buffer that wraps an output buffer.
pub struct BasicSyncbuf {
    buffer: Vec<u8>,
    emit_on_sync: bool,
    emit_on_destroy: bool,
}

impl BasicSyncbuf {
    pub fn new() -> Self {
        Self {
            buffer: Vec::new(),
            emit_on_sync: true,
            emit_on_destroy: true,
        }
    }

    /// Set whether to emit on sync.
    pub fn set_emit_on_sync(&mut self, emit: bool) {
        self.emit_on_sync = emit;
    }

    /// Get emit-on-sync setting.
    pub fn emit_on_sync(&self) -> bool {
        self.emit_on_sync
    }

    /// Write data to the buffer.
    pub fn sputn(&mut self, data: &[u8]) -> usize {
        self.buffer.extend_from_slice(data);
        data.len()
    }

    /// Write a single character.
    pub fn sputc(&mut self, c: u8) {
        self.buffer.push(c);
    }

    /// Emit all buffered data atomically.
    pub fn emit(&mut self) -> Vec<u8> {
        let result = self.buffer.clone();
        self.buffer.clear();
        result
    }

    /// Sync (emit if emit_on_sync is set).
    pub fn sync(&mut self) -> Vec<u8> {
        if self.emit_on_sync {
            self.emit()
        } else {
            self.buffer.clone()
        }
    }

    /// Get the current buffer contents.
    pub fn str(&self) -> String {
        String::from_utf8_lossy(&self.buffer).to_string()
    }
}

impl fmt::Debug for BasicSyncbuf {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("BasicSyncbuf")
            .field("buffer_len", &self.buffer.len())
            .field("emit_on_sync", &self.emit_on_sync)
            .finish()
    }
}

impl Default for BasicSyncbuf {
    fn default() -> Self {
        Self::new()
    }
}

impl Drop for BasicSyncbuf {
    fn drop(&mut self) {
        if self.emit_on_destroy && !self.buffer.is_empty() {
            // emit on destruction
        }
    }
}

/// Synchronized output stream that wraps a syncbuf.
pub struct BasicOsyncstream {
    buffer: BasicSyncbuf,
    wrapped_stream: Option<String>,
}

impl BasicOsyncstream {
    pub fn new(wrapped: Option<&str>) -> Self {
        Self {
            buffer: BasicSyncbuf::new(),
            wrapped_stream: wrapped.map(|s| s.to_string()),
        }
    }

    /// Get a mutable reference to the underlying buffer.
    pub fn rdbuf(&mut self) -> &mut BasicSyncbuf {
        &mut self.buffer
    }

    /// Emit all buffered data.
    pub fn emit(&mut self) -> Vec<u8> {
        self.buffer.emit()
    }

    /// Write a string to the sync stream.
    pub fn write(&mut self, s: &str) {
        self.buffer.sputn(s.as_bytes());
    }

    /// Flush and emit.
    pub fn flush(&mut self) -> Vec<u8> {
        self.buffer.sync()
    }

    /// Get the wrapped stream name.
    pub fn wrapped_stream(&self) -> Option<&str> {
        self.wrapped_stream.as_deref()
    }
}

impl fmt::Debug for BasicOsyncstream {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("BasicOsyncstream")
            .field("buffer", &self.buffer)
            .field("wrapped_stream", &self.wrapped_stream)
            .finish()
    }
}

// ============================================================================
// <stop_token> — Stop token for cooperative cancellation
// ============================================================================

/// Stop source — produces stop tokens and can request stop.
#[derive(Debug, Clone)]
pub struct StopSource {
    stop_requested: bool,
    stop_possible: bool,
}

impl StopSource {
    pub fn new() -> Self {
        Self {
            stop_requested: false,
            stop_possible: true,
        }
    }

    /// Request a stop.
    pub fn request_stop(&mut self) -> bool {
        if self.stop_possible {
            self.stop_requested = true;
            true
        } else {
            false
        }
    }

    /// Check if stop has been requested.
    pub fn stop_requested(&self) -> bool {
        self.stop_requested
    }

    /// Get a stop token for this source.
    pub fn get_token(&self) -> StopToken {
        StopToken {
            stop_requested: self.stop_requested,
        }
    }

    /// Check if stop is possible.
    pub fn stop_possible(&self) -> bool {
        self.stop_possible
    }
}

impl Default for StopSource {
    fn default() -> Self {
        Self::new()
    }
}

/// Stop token — can be polled for stop requests.
#[derive(Debug, Clone, Copy)]
pub struct StopToken {
    stop_requested: bool,
}

impl StopToken {
    /// Create a never-stoppable token.
    pub fn never_stoppable() -> Self {
        Self {
            stop_requested: false,
        }
    }

    /// Check if stop has been requested.
    pub fn stop_requested(&self) -> bool {
        self.stop_requested
    }

    /// Check if stop is possible.
    pub fn stop_possible(&self) -> bool {
        true
    }
}

/// Stop callback — invokes a callback when stop is requested.
pub struct StopCallback<F: FnOnce()> {
    callback: Option<F>,
    token: StopToken,
    executed: bool,
}

impl<F: FnOnce()> StopCallback<F> {
    pub fn new(token: StopToken, callback: F) -> Self {
        let mut sc = Self {
            callback: Some(callback),
            token,
            executed: false,
        };
        if token.stop_requested() {
            sc.execute();
        }
        sc
    }

    fn execute(&mut self) {
        if !self.executed {
            if let Some(cb) = self.callback.take() {
                cb();
                self.executed = true;
            }
        }
    }

    pub fn is_executed(&self) -> bool {
        self.executed
    }
}

impl<F: FnOnce()> Drop for StopCallback<F> {
    fn drop(&mut self) {
        self.execute();
    }
}

// ============================================================================
// <barrier> — Thread barrier
// ============================================================================

/// Barrier phase completion info.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BarrierPhase {
    Phase0,
    Phase1,
}

impl BarrierPhase {
    pub fn next(&self) -> Self {
        match self {
            BarrierPhase::Phase0 => BarrierPhase::Phase1,
            BarrierPhase::Phase1 => BarrierPhase::Phase0,
        }
    }
}

/// Thread barrier with completion function.
pub struct Barrier {
    expected: usize,
    arrived: usize,
    phase: BarrierPhase,
    completion_description: Option<String>,
}

impl Barrier {
    /// Create a barrier expecting `expected` threads.
    pub fn new(expected: usize) -> Self {
        Self {
            expected,
            arrived: 0,
            phase: BarrierPhase::Phase0,
            completion_description: None,
        }
    }

    /// Create a barrier with a completion function description.
    pub fn with_completion(expected: usize, completion: &str) -> Self {
        Self {
            expected,
            arrived: 0,
            phase: BarrierPhase::Phase0,
            completion_description: Some(completion.to_string()),
        }
    }

    /// Arrive at the barrier (decrement count).
    pub fn arrive(&mut self) -> usize {
        self.arrived += 1;
        self.arrived
    }

    /// Wait at the barrier.
    pub fn wait(&mut self) {
        while self.arrived < self.expected {
            // spin wait (in real impl, would use futex/condvar)
        }
    }

    /// Arrive and wait until all threads have arrived.
    pub fn arrive_and_wait(&mut self) {
        self.arrive();
        self.wait();
        // Reset for next phase
        if self.arrived >= self.expected {
            self.arrived = 0;
            self.phase = self.phase.next();
        }
    }

    /// Check if all threads have arrived.
    pub fn is_ready(&self) -> bool {
        self.arrived >= self.expected
    }

    /// Get the current phase.
    pub fn phase(&self) -> BarrierPhase {
        self.phase
    }
}

impl fmt::Debug for Barrier {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Barrier")
            .field("expected", &self.expected)
            .field("arrived", &self.arrived)
            .field("phase", &self.phase)
            .finish()
    }
}

// ============================================================================
// <latch> — Thread latch
// ============================================================================

/// Latch — a downward counter that blocks until zero.
pub struct Latch {
    count: usize,
}

impl Latch {
    /// Create a latch with the given initial count.
    pub fn new(count: usize) -> Self {
        Self { count }
    }

    /// Decrement the counter by 1.
    pub fn count_down(&mut self) {
        if self.count > 0 {
            self.count -= 1;
        }
    }

    /// Decrement the counter by n.
    pub fn count_down_by(&mut self, n: usize) {
        self.count = self.count.saturating_sub(n);
    }

    /// Wait until the latch reaches zero.
    pub fn wait(&self) {
        // In real impl, would block via condition variable
    }

    /// Try to wait — returns true if latch is zero.
    pub fn try_wait(&self) -> bool {
        self.count == 0
    }

    /// Arrive and wait (count_down then wait).
    pub fn arrive_and_wait(&mut self) {
        self.count_down();
        self.wait();
    }

    /// Check if the latch is ready (count == 0).
    pub fn is_ready(&self) -> bool {
        self.count == 0
    }

    /// Get the current count.
    pub fn count(&self) -> usize {
        self.count
    }
}

impl fmt::Debug for Latch {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Latch")
            .field("count", &self.count)
            .finish()
    }
}

// ============================================================================
// <syncstream> helper types
// ============================================================================

/// Synchronized stream for standard output.
pub type Syncbuf = BasicSyncbuf;
pub type Osyncstream = BasicOsyncstream;

// ============================================================================
// STL3 Registry
// ============================================================================

/// Registry for all STL3 features.
pub struct Stl3Registry {
    pub expected_enabled: bool,
    pub source_location_enabled: bool,
    pub bit_ops_enabled: bool,
    pub numbers_enabled: bool,
    pub concepts_enabled: bool,
    pub coroutine_enabled: bool,
    pub compare_enabled: bool,
    pub semaphore_enabled: bool,
    pub syncstream_enabled: bool,
    pub stop_token_enabled: bool,
    pub barrier_enabled: bool,
    pub latch_enabled: bool,
    pub standard_year: u32,
    pub feature_db: FeatureTestDatabase,
}

impl Stl3Registry {
    pub fn new() -> Self {
        Self {
            expected_enabled: false,
            source_location_enabled: false,
            bit_ops_enabled: false,
            numbers_enabled: false,
            concepts_enabled: false,
            coroutine_enabled: false,
            compare_enabled: false,
            semaphore_enabled: false,
            syncstream_enabled: false,
            stop_token_enabled: false,
            barrier_enabled: false,
            latch_enabled: false,
            standard_year: 201703,
            feature_db: FeatureTestDatabase::new(),
        }
    }

    pub fn with_standard(mut self, year: u32) -> Self {
        self.standard_year = year;
        self.expected_enabled = year >= 202302;
        self.source_location_enabled = year >= 202002;
        self.bit_ops_enabled = year >= 202002;
        self.numbers_enabled = year >= 202002;
        self.concepts_enabled = year >= 202002;
        self.coroutine_enabled = year >= 202002;
        self.compare_enabled = year >= 202002;
        self.semaphore_enabled = year >= 202002;
        self.syncstream_enabled = year >= 202002;
        self.stop_token_enabled = year >= 202002;
        self.barrier_enabled = year >= 202002;
        self.latch_enabled = year >= 202002;
        self
    }

    pub fn feature_count(&self) -> usize {
        [
            self.expected_enabled, self.source_location_enabled,
            self.bit_ops_enabled, self.numbers_enabled, self.concepts_enabled,
            self.coroutine_enabled, self.compare_enabled, self.semaphore_enabled,
            self.syncstream_enabled, self.stop_token_enabled, self.barrier_enabled,
            self.latch_enabled,
        ]
        .iter()
        .filter(|&&x| x)
        .count()
    }

    pub fn headers_for_standard(&self) -> Vec<&'static str> {
        let mut headers = Vec::new();
        if self.expected_enabled {
            headers.push("<expected>");
        }
        if self.source_location_enabled {
            headers.push("<source_location>");
        }
        if self.bit_ops_enabled {
            headers.push("<bit>");
        }
        if self.numbers_enabled {
            headers.push("<numbers>");
        }
        if self.concepts_enabled {
            headers.push("<concepts>");
        }
        if self.coroutine_enabled {
            headers.push("<coroutine>");
        }
        if self.compare_enabled {
            headers.push("<compare>");
        }
        if self.semaphore_enabled {
            headers.push("<semaphore>");
        }
        if self.syncstream_enabled {
            headers.push("<syncstream>");
        }
        if self.stop_token_enabled {
            headers.push("<stop_token>");
        }
        if self.barrier_enabled {
            headers.push("<barrier>");
        }
        if self.latch_enabled {
            headers.push("<latch>");
        }
        headers
    }
}

impl Default for Stl3Registry {
    fn default() -> Self {
        Self::new()
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    // ── <expected> tests ──────────────────────────────────────────────

    #[test]
    fn test_expected_value() {
        let e = StdExpected::<i32, String>::value(42);
        assert!(e.has_value());
        assert!(!e.has_error());
        assert_eq!(*e.value_ref(), 42);
    }

    #[test]
    fn test_expected_error() {
        let e = StdExpected::<i32, String>::error("fail".to_string());
        assert!(!e.has_value());
        assert!(e.has_error());
        assert_eq!(e.error_ref(), "fail");
    }

    #[test]
    fn test_expected_value_or() {
        let e1 = StdExpected::<i32, String>::value(10);
        assert_eq!(e1.value_or(0), 10);
        let e2 = StdExpected::<i32, String>::error("err".to_string());
        assert_eq!(e2.value_or(0), 0);
    }

    #[test]
    fn test_expected_value_or_else() {
        let e = StdExpected::<i32, String>::error("err".to_string());
        assert_eq!(e.value_or_else(|_| 99), 99);
    }

    #[test]
    fn test_expected_and_then() {
        let e = StdExpected::<i32, String>::value(5);
        let result = e.and_then(|v| StdExpected::value(v * 2));
        assert_eq!(result.into_value(), 10);
    }

    #[test]
    fn test_expected_and_then_error() {
        let e = StdExpected::<i32, String>::error("fail".to_string());
        let result = e.and_then(|v| StdExpected::<i32, String>::value(v * 2));
        assert!(result.has_error());
    }

    #[test]
    fn test_expected_or_else() {
        let e = StdExpected::<i32, String>::error("err".to_string());
        let result = e.or_else(|_| StdExpected::value(42));
        assert_eq!(result.into_value(), 42);
    }

    #[test]
    fn test_expected_transform() {
        let e = StdExpected::<i32, String>::value(3);
        let result = e.transform(|v| v * 10);
        assert_eq!(result.into_value(), 30);
    }

    #[test]
    fn test_expected_transform_error() {
        let e = StdExpected::<i32, String>::error("bad".to_string());
        let result = e.transform_error(|err| format!("prefix_{}", err));
        assert_eq!(result.error_ref(), "prefix_bad");
    }

    #[test]
    fn test_expected_ok_err() {
        let e1 = StdExpected::<i32, String>::value(1);
        assert_eq!(e1.ok(), Some(1));
        assert_eq!(e1.err(), None);
        let e2 = StdExpected::<i32, String>::error("e".to_string());
        assert_eq!(e2.ok(), None);
        assert_eq!(e2.err(), Some("e".to_string()));
    }

    #[test]
    fn test_expected_swap() {
        let e = StdExpected::<String, String>::value("val".to_string());
        let swapped = e.swap_error_value();
        assert!(swapped.has_error());
        assert_eq!(swapped.error_ref(), "val");
    }

    #[test]
    fn test_expected_map() {
        let e = StdExpected::<i32, String>::value(2);
        let result = e.map(|v| v + 1, |err| format!("_{}", err));
        assert_eq!(result.into_value(), 3);
    }

    #[test]
    fn test_unexpected_new() {
        let u = Unexpected::new(404);
        assert_eq!(*u.error(), 404);
    }

    // ── <source_location> tests ─────────────────────────────────────

    #[test]
    fn test_source_location_new() {
        let loc = SourceLocation::new("test.cpp", "main", 10, 5);
        assert_eq!(loc.file_name(), "test.cpp");
        assert_eq!(loc.function_name(), "main");
        assert_eq!(loc.line(), 10);
        assert_eq!(loc.column(), 5);
    }

    #[test]
    fn test_source_location_current() {
        let loc = SourceLocation::current("file.cc", "foo", 42, 3);
        assert_eq!(loc.line(), 42);
    }

    #[test]
    fn test_source_location_position_string() {
        let loc = SourceLocation::new("a.cpp", "fn", 1, 1);
        assert_eq!(loc.to_position_string(), "a.cpp:1:1");
    }

    #[test]
    fn test_source_location_full_string() {
        let loc = SourceLocation::new("b.cpp", "bar", 7, 3);
        assert_eq!(loc.to_full_string(), "bar at b.cpp:7:3");
    }

    #[test]
    fn test_source_location_default() {
        let loc = SourceLocation::default();
        assert_eq!(loc.file_name(), "<unknown>");
        assert_eq!(loc.line(), 0);
    }

    // ── <bit> tests ──────────────────────────────────────────────────

    #[test]
    fn test_has_single_bit() {
        assert!(has_single_bit(1));
        assert!(has_single_bit(2));
        assert!(has_single_bit(4));
        assert!(has_single_bit(1024));
        assert!(!has_single_bit(0));
        assert!(!has_single_bit(3));
        assert!(!has_single_bit(6));
    }

    #[test]
    fn test_bit_ceil() {
        assert_eq!(bit_ceil(0), 1);
        assert_eq!(bit_ceil(1), 1);
        assert_eq!(bit_ceil(2), 2);
        assert_eq!(bit_ceil(3), 4);
        assert_eq!(bit_ceil(5), 8);
        assert_eq!(bit_ceil(10), 16);
    }

    #[test]
    fn test_bit_floor() {
        assert_eq!(bit_floor(0), 0);
        assert_eq!(bit_floor(1), 1);
        assert_eq!(bit_floor(2), 2);
        assert_eq!(bit_floor(3), 2);
        assert_eq!(bit_floor(5), 4);
        assert_eq!(bit_floor(10), 8);
    }

    #[test]
    fn test_bit_width() {
        assert_eq!(bit_width(0), 0);
        assert_eq!(bit_width(1), 1);
        assert_eq!(bit_width(2), 2);
        assert_eq!(bit_width(3), 2);
        assert_eq!(bit_width(4), 3);
        assert_eq!(bit_width(255), 8);
    }

    #[test]
    fn test_rotl_u32() {
        assert_eq!(rotl_u32(1, 1), 2);
        assert_eq!(rotl_u32(1, 31), 0x80000000);
        assert_eq!(rotl_u32(0x80000000, 1), 1);
    }

    #[test]
    fn test_rotr_u32() {
        assert_eq!(rotr_u32(2, 1), 1);
        assert_eq!(rotr_u32(1, 1), 0x80000000);
    }

    #[test]
    fn test_countl_zero() {
        assert_eq!(countl_zero_u32(0), 32);
        assert_eq!(countl_zero_u32(1), 31);
        assert_eq!(countl_zero_u32(0x80000000), 0);
    }

    #[test]
    fn test_countr_zero() {
        assert_eq!(countr_zero_u32(0), 32);
        assert_eq!(countr_zero_u32(1), 0);
        assert_eq!(countr_zero_u32(8), 3);
    }

    #[test]
    fn test_countl_one() {
        assert_eq!(countl_one_u32(!0u32), 32);
        assert_eq!(countl_one_u32(!1u32), 31);
    }

    #[test]
    fn test_countr_one() {
        assert_eq!(countr_one_u32(!0u32), 32);
        assert_eq!(countr_one_u32(!2u32), 1);
    }

    #[test]
    fn test_popcount() {
        assert_eq!(popcount_u32(0), 0);
        assert_eq!(popcount_u32(1), 1);
        assert_eq!(popcount_u32(3), 2);
        assert_eq!(popcount_u32(0xFF), 8);
    }

    #[test]
    fn test_bit_cast_f32_u32() {
        let v: f32 = 1.0;
        assert_eq!(bit_cast_f32_to_u32(v), 0x3F800000);
        assert_eq!(bit_cast_u32_to_f32(0x3F800000), 1.0);
    }

    #[test]
    fn test_ntohs_htons() {
        assert_eq!(htons(0x1234), 0x1234u16.to_be());
        assert_eq!(ntohs(0x1234u16.to_be()), 0x1234);
    }

    #[test]
    fn test_has_single_bit_u32() {
        assert!(has_single_bit_u32(16));
        assert!(!has_single_bit_u32(18));
    }

    #[test]
    fn test_bit_ceil_u32() {
        assert_eq!(bit_ceil_u32(7), 8);
        assert_eq!(bit_ceil_u32(16), 16);
    }

    #[test]
    fn test_bit_floor_u32() {
        assert_eq!(bit_floor_u32(7), 4);
        assert_eq!(bit_floor_u32(16), 16);
    }

    // ── <numbers> tests ─────────────────────────────────────────────

    #[test]
    fn test_numbers_f64_pi() {
        assert!((numbers_f64::PI - std::f64::consts::PI).abs() < 1e-15);
    }

    #[test]
    fn test_numbers_f64_e() {
        assert!((numbers_f64::E - std::f64::consts::E).abs() < 1e-15);
    }

    #[test]
    fn test_numbers_f64_sqrt2() {
        assert!((numbers_f64::SQRT2 - 1.4142135623730951).abs() < 1e-15);
    }

    #[test]
    fn test_numbers_f64_phi() {
        // phi = (1 + sqrt(5)) / 2
        let expected = (1.0 + 5.0_f64.sqrt()) / 2.0;
        assert!((numbers_f64::PHI - expected).abs() < 1e-15);
    }

    #[test]
    fn test_numbers_f32() {
        assert!((numbers_f32::PI - std::f32::consts::PI).abs() < 1e-7);
    }

    #[test]
    fn test_math_constants_f64() {
        let mc = MathConstants::<f64>::new();
        assert!((mc.pi - std::f64::consts::PI).abs() < 1e-15);
    }

    #[test]
    fn test_math_constants_f32() {
        let mc = MathConstants::<f32>::new();
        assert!((mc.pi - std::f32::consts::PI).abs() < 1e-7);
    }

    // ── <version> tests ─────────────────────────────────────────────

    #[test]
    fn test_feature_macro_names() {
        assert_eq!(FeatureTestMacro::Byte.macro_name(), "__cpp_lib_byte");
        assert_eq!(FeatureTestMacro::Expected.macro_name(), "__cpp_lib_expected");
        assert_eq!(
            FeatureTestMacro::ThreeWayComparison.macro_name(),
            "__cpp_lib_three_way_comparison"
        );
    }

    #[test]
    fn test_feature_macro_introduced() {
        assert_eq!(FeatureTestMacro::Byte.introduced_in(), "201603");
        assert_eq!(FeatureTestMacro::Concepts.introduced_in(), "202002");
        assert_eq!(FeatureTestMacro::Expected.introduced_in(), "202211");
    }

    #[test]
    fn test_feature_macro_value_for_standard() {
        assert_eq!(
            FeatureTestMacro::Byte.value_for_standard(201703),
            Some(201603)
        );
        assert_eq!(FeatureTestMacro::Byte.value_for_standard(201000), None);
        assert_eq!(
            FeatureTestMacro::Concepts.value_for_standard(202002),
            Some(202002)
        );
    }

    #[test]
    fn test_feature_test_database_generate_defines() {
        let db = FeatureTestDatabase::new();
        let defines = db.generate_defines(202002);
        assert!(!defines.is_empty());
        assert!(defines.iter().any(|d| d.contains("__cpp_lib_span")));
    }

    #[test]
    fn test_feature_test_database_enable_disable() {
        let mut db = FeatureTestDatabase::new();
        assert!(db.is_available(FeatureTestMacro::Span, 202002));
        db.enable(FeatureTestMacro::Span); // no-op, already enabled
        assert!(db.is_available(FeatureTestMacro::Span, 202002));
    }

    #[test]
    fn test_feature_test_database_cpp23() {
        let db = FeatureTestDatabase::new();
        assert!(db.is_available(FeatureTestMacro::Expected, 202302));
        assert!(!db.is_available(FeatureTestMacro::Expected, 202002));
    }

    // ── <concepts> tests ────────────────────────────────────────────

    #[test]
    fn test_concept_same_as() {
        let mut engine = ConceptEngine::new();
        assert_eq!(engine.same_as("int", "int"), ConceptResult::Satisfied);
        assert!(matches!(
            engine.same_as("int", "float"),
            ConceptResult::NotSatisfied(_)
        ));
    }

    #[test]
    fn test_concept_derived_from() {
        let mut engine = ConceptEngine::new();
        engine.register_base("Derived", "Base");
        assert_eq!(
            engine.derived_from("Derived", "Base"),
            ConceptResult::Satisfied
        );
        assert!(matches!(
            engine.derived_from("Base", "Derived"),
            ConceptResult::NotSatisfied(_)
        ));
    }

    #[test]
    fn test_concept_integral() {
        let mut engine = ConceptEngine::new();
        engine.register_type("int", TypeCategory::Integral);
        engine.register_type("float", TypeCategory::FloatingPoint);
        assert_eq!(engine.integral("int"), ConceptResult::Satisfied);
        assert!(matches!(
            engine.integral("float"),
            ConceptResult::NotSatisfied(_)
        ));
    }

    #[test]
    fn test_concept_floating_point() {
        let mut engine = ConceptEngine::new();
        engine.register_type("double", TypeCategory::FloatingPoint);
        engine.register_type("int", TypeCategory::Integral);
        assert_eq!(engine.floating_point("double"), ConceptResult::Satisfied);
        assert!(matches!(
            engine.floating_point("int"),
            ConceptResult::NotSatisfied(_)
        ));
    }

    #[test]
    fn test_concept_movable() {
        let mut engine = ConceptEngine::new();
        engine.register_type("int", TypeCategory::Integral);
        engine.register_type("void", TypeCategory::Void);
        assert_eq!(engine.movable("int"), ConceptResult::Satisfied);
        assert!(matches!(
            engine.movable("void"),
            ConceptResult::NotSatisfied(_)
        ));
    }

    #[test]
    fn test_concept_copyable() {
        let mut engine = ConceptEngine::new();
        engine.register_type("int", TypeCategory::Integral);
        assert_eq!(engine.copyable("int"), ConceptResult::Satisfied);
    }

    #[test]
    fn test_concept_regular() {
        let mut engine = ConceptEngine::new();
        engine.register_type("int", TypeCategory::Integral);
        assert_eq!(engine.regular("int"), ConceptResult::Satisfied);
    }

    #[test]
    fn test_concept_convertible_to() {
        let mut engine = ConceptEngine::new();
        engine.register_conversion("int", "long");
        assert_eq!(
            engine.convertible_to("int", "long"),
            ConceptResult::Satisfied
        );
        assert_eq!(
            engine.convertible_to("int", "int"),
            ConceptResult::Satisfied
        );
        assert!(matches!(
            engine.convertible_to("long", "int"),
            ConceptResult::NotSatisfied(_)
        ));
    }

    #[test]
    fn test_concept_common_with() {
        let mut engine = ConceptEngine::new();
        engine.register_conversion("int", "long");
        assert_eq!(
            engine.common_with("int", "long"),
            ConceptResult::Satisfied
        );
    }

    #[test]
    fn test_concept_totally_ordered() {
        let mut engine = ConceptEngine::new();
        engine.register_type("int", TypeCategory::Integral);
        engine.register_type("void", TypeCategory::Void);
        assert_eq!(engine.totally_ordered("int"), ConceptResult::Satisfied);
        assert!(matches!(
            engine.totally_ordered("void"),
            ConceptResult::NotSatisfied(_)
        ));
    }

    // ── <coroutine> tests ───────────────────────────────────────────

    #[test]
    fn test_coroutine_handle_new() {
        let h = CoroutineHandle::new(0x1000);
        assert!(!h.done());
        assert_eq!(h.address(), 0x1000);
    }

    #[test]
    fn test_coroutine_handle_resume_destroy() {
        let mut h = CoroutineHandle::new(0x2000);
        h.resume();
        assert!(matches!(h.state, CoroutineState::Running));
        h.destroy();
        assert!(h.done());
    }

    #[test]
    fn test_suspend_never() {
        let sn = SuspendNever;
        assert!(sn.await_ready());
        assert!(!sn.await_suspend(&CoroutineHandle::new(0)));
    }

    #[test]
    fn test_suspend_always() {
        let sa = SuspendAlways;
        assert!(!sa.await_ready());
        assert!(sa.await_suspend(&CoroutineHandle::new(0)));
    }

    #[test]
    fn test_coroutine_promise() {
        let p = CoroutinePromise::new("task<int>")
            .with_promise_type("task_promise<int>")
            .with_initial_suspend(CoroutineSuspendPoint::Never);
        assert_eq!(p.return_type, "task<int>");
        assert!(matches!(p.initial_suspend, CoroutineSuspendPoint::Never));
    }

    #[test]
    fn test_coroutine_traits() {
        let ct = CoroutineTraits::new("generator<int>", "gen_promise<int>")
            .with_allocator("std::allocator<int>");
        assert_eq!(ct.return_type, "generator<int>");
        assert!(ct.allocator_type.is_some());
    }

    // ── <compare> tests ─────────────────────────────────────────────

    #[test]
    fn test_strong_ordering() {
        assert!(StrongOrdering::Less.is_lt());
        assert!(StrongOrdering::Equal.is_eq());
        assert!(StrongOrdering::Greater.is_gt());
    }

    #[test]
    fn test_strong_to_weak() {
        assert_eq!(
            StrongOrdering::Less.as_weak(),
            WeakOrdering::Less
        );
        assert_eq!(
            StrongOrdering::Equal.as_weak(),
            WeakOrdering::Equivalent
        );
    }

    #[test]
    fn test_strong_to_partial() {
        assert_eq!(
            StrongOrdering::Less.as_partial(),
            PartialOrdering::Less
        );
    }

    #[test]
    fn test_partial_ordering_unordered() {
        assert!(PartialOrdering::Unordered.is_unordered());
        assert!(!PartialOrdering::Less.is_unordered());
    }

    #[test]
    fn test_common_comparison_category() {
        let result = common_comparison_category(
            ComparisonCategory::strong(StrongOrdering::Equal),
            ComparisonCategory::weak(WeakOrdering::Equivalent),
        );
        assert!(matches!(result, ComparisonCategory::Weak(_)));
    }

    #[test]
    fn test_three_way_compare() {
        assert_eq!(three_way_compare(&1i32, &2i32), StrongOrdering::Less);
        assert_eq!(three_way_compare(&5i32, &5i32), StrongOrdering::Equal);
        assert_eq!(three_way_compare(&10i32, &1i32), StrongOrdering::Greater);
    }

    #[test]
    fn test_weak_ordering_methods() {
        assert!(WeakOrdering::Less.is_lt());
        assert!(WeakOrdering::Equivalent.is_eqv());
        assert!(WeakOrdering::Greater.is_gt());
    }

    // ── <semaphore> tests ───────────────────────────────────────────

    #[test]
    fn test_counting_semaphore_new() {
        let cs = CountingSemaphore::new(5, 10);
        assert_eq!(cs.value(), 5);
        assert_eq!(cs.max(), 10);
    }

    #[test]
    fn test_counting_semaphore_acquire_release() {
        let mut cs = CountingSemaphore::new(3, 10);
        assert!(cs.acquire());
        assert_eq!(cs.value(), 2);
        cs.release(1);
        assert_eq!(cs.value(), 3);
    }

    #[test]
    fn test_counting_semaphore_max() {
        let mut cs = CountingSemaphore::new(0, 5);
        cs.release(10);
        assert_eq!(cs.value(), 5); // capped at max
    }

    #[test]
    fn test_counting_semaphore_try_acquire_empty() {
        let mut cs = CountingSemaphore::new(0, 10);
        assert!(!cs.try_acquire());
    }

    #[test]
    fn test_binary_semaphore() {
        let mut bs = BinarySemaphore::new(true);
        assert!(bs.is_available());
        assert!(bs.acquire());
        assert!(!bs.is_available());
        assert!(!bs.acquire());
        bs.release();
        assert!(bs.is_available());
    }

    #[test]
    fn test_binary_semaphore_try_acquire() {
        let mut bs = BinarySemaphore::new(false);
        assert!(!bs.try_acquire());
    }

    // ── <syncstream> tests ─────────────────────────────────────────

    #[test]
    fn test_basic_syncbuf_write() {
        let mut buf = BasicSyncbuf::new();
        buf.sputn(b"hello");
        assert_eq!(buf.str(), "hello");
    }

    #[test]
    fn test_basic_syncbuf_emit() {
        let mut buf = BasicSyncbuf::new();
        buf.sputn(b"world");
        let emitted = buf.emit();
        assert_eq!(emitted, b"world");
        assert!(buf.str().is_empty());
    }

    #[test]
    fn test_basic_syncbuf_emit_on_sync() {
        let mut buf = BasicSyncbuf::new();
        buf.set_emit_on_sync(false);
        assert!(!buf.emit_on_sync());
        buf.set_emit_on_sync(true);
        assert!(buf.emit_on_sync());
    }

    #[test]
    fn test_basic_osyncstream_write() {
        let mut stream = BasicOsyncstream::new(Some("stdout"));
        stream.write("test message");
        assert!(stream.wrapped_stream().is_some());
        let emitted = stream.emit();
        assert_eq!(String::from_utf8_lossy(&emitted), "test message");
    }

    #[test]
    fn test_basic_osyncstream_flush() {
        let mut stream = BasicOsyncstream::new(None);
        stream.write("flush test");
        let result = stream.flush();
        assert_eq!(String::from_utf8_lossy(&result), "flush test");
    }

    // ── <stop_token> tests ─────────────────────────────────────────

    #[test]
    fn test_stop_source_request_stop() {
        let mut source = StopSource::new();
        assert!(!source.stop_requested());
        assert!(source.request_stop());
        assert!(source.stop_requested());
    }

    #[test]
    fn test_stop_token_from_source() {
        let mut source = StopSource::new();
        let token = source.get_token();
        assert!(!token.stop_requested());
        source.request_stop();
        let token2 = source.get_token();
        assert!(token2.stop_requested());
    }

    #[test]
    fn test_stop_token_never_stoppable() {
        let token = StopToken::never_stoppable();
        assert!(!token.stop_requested());
        assert!(token.stop_possible());
    }

    #[test]
    fn test_stop_callback() {
        let source = StopSource::new();
        let token = source.get_token();
        let mut called = false;
        {
            let _cb = StopCallback::new(token, || called = true);
        } // drop executes callback
        // Callback executes on drop; for our test we verify it compiles
    }

    // ── <barrier> tests ────────────────────────────────────────────

    #[test]
    fn test_barrier_new() {
        let b = Barrier::new(4);
        assert_eq!(b.expected, 4);
        assert!(!b.is_ready());
    }

    #[test]
    fn test_barrier_arrive() {
        let mut b = Barrier::new(3);
        assert_eq!(b.arrive(), 1);
        assert_eq!(b.arrive(), 2);
        assert!(!b.is_ready());
        assert_eq!(b.arrive(), 3);
        assert!(b.is_ready());
    }

    #[test]
    fn test_barrier_arrive_and_wait() {
        let mut b = Barrier::new(2);
        b.arrive();
        b.arrive_and_wait();
        assert!(b.is_ready());
    }

    #[test]
    fn test_barrier_with_completion() {
        let b = Barrier::with_completion(2, "cleanup");
        assert_eq!(b.completion_description, Some("cleanup".to_string()));
    }

    #[test]
    fn test_barrier_phase() {
        let mut b = Barrier::new(1);
        assert_eq!(b.phase(), BarrierPhase::Phase0);
        b.arrive_and_wait();
        assert_eq!(b.phase(), BarrierPhase::Phase1);
    }

    // ── <latch> tests ──────────────────────────────────────────────

    #[test]
    fn test_latch_new() {
        let l = Latch::new(5);
        assert_eq!(l.count(), 5);
        assert!(!l.is_ready());
    }

    #[test]
    fn test_latch_count_down() {
        let mut l = Latch::new(3);
        l.count_down();
        assert_eq!(l.count(), 2);
        l.count_down();
        l.count_down();
        assert_eq!(l.count(), 0);
        assert!(l.is_ready());
    }

    #[test]
    fn test_latch_count_down_by() {
        let mut l = Latch::new(10);
        l.count_down_by(3);
        assert_eq!(l.count(), 7);
        l.count_down_by(10);
        assert_eq!(l.count(), 0);
    }

    #[test]
    fn test_latch_arrive_and_wait() {
        let mut l = Latch::new(1);
        l.arrive_and_wait();
        assert!(l.is_ready());
    }

    #[test]
    fn test_latch_try_wait() {
        let l = Latch::new(0);
        assert!(l.try_wait());
        let l2 = Latch::new(1);
        assert!(!l2.try_wait());
    }

    // ── Stl3Registry tests ─────────────────────────────────────────

    #[test]
    fn test_stl3_registry_default() {
        let reg = Stl3Registry::new();
        assert!(!reg.expected_enabled);
        assert_eq!(reg.feature_count(), 0);
    }

    #[test]
    fn test_stl3_registry_cpp20() {
        let reg = Stl3Registry::new().with_standard(202002);
        assert!(reg.source_location_enabled);
        assert!(reg.bit_ops_enabled);
        assert!(reg.concepts_enabled);
        assert!(!reg.expected_enabled);
        assert!(reg.feature_count() >= 10);
    }

    #[test]
    fn test_stl3_registry_cpp23() {
        let reg = Stl3Registry::new().with_standard(202302);
        assert!(reg.expected_enabled);
        assert!(reg.feature_count() == 12);
    }

    #[test]
    fn test_stl3_registry_headers() {
        let reg = Stl3Registry::new().with_standard(202002);
        let headers = reg.headers_for_standard();
        assert!(headers.contains(&"<bit>"));
        assert!(headers.contains(&"<concepts>"));
        assert!(!headers.contains(&"<expected>"));
    }

    #[test]
    fn test_stl3_registry_headers_cpp23() {
        let reg = Stl3Registry::new().with_standard(202302);
        let headers = reg.headers_for_standard();
        assert!(headers.contains(&"<expected>"));
    }
}