fayalite/crates/fayalite/src/int/uint_in_range.rs

// SPDX-License-Identifier: LGPL-3.0-or-later
// See Notices.txt for copyright information

use crate::{
    bundle::{Bundle, BundleField, BundleType, BundleTypePropertiesBuilder, NoBuilder},
    expr::{
        CastBitsTo, CastTo, CastToBits, Expr, HdlPartialEq, HdlPartialOrd,
        ops::{ExprCastTo, ExprPartialEq, ExprPartialOrd},
    },
    int::{Bool, DynSize, KnownSize, Size, SizeType, UInt, UIntType},
    intern::{Intern, InternSlice, Interned},
    phantom_const::PhantomConst,
    sim::value::{SimValue, SimValuePartialEq, ToSimValueWithType},
    source_location::SourceLocation,
    ty::{
        CanonicalType, OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten,
        StaticType, Type, TypeProperties, impl_match_variant_as_self,
    },
};
use bitvec::{order::Lsb0, view::BitView};
use serde::{
    Deserialize, Deserializer, Serialize, Serializer,
    de::{Error, Visitor, value::UsizeDeserializer},
};
use std::{fmt, marker::PhantomData, ops::Index};

const UINT_IN_RANGE_TYPE_FIELD_NAMES: [&'static str; 2] = ["value", "range"];

#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
pub struct UIntInRangeMaskType {
    value: Bool,
    range: PhantomConstRangeMaskType,
}

impl Type for UIntInRangeMaskType {
    type BaseType = Bundle;
    type MaskType = Self;
    type SimValue = bool;
    impl_match_variant_as_self!();

    fn mask_type(&self) -> Self::MaskType {
        *self
    }

    fn canonical(&self) -> CanonicalType {
        CanonicalType::Bundle(Bundle::new(self.fields()))
    }

    fn from_canonical(canonical_type: CanonicalType) -> Self {
        let fields = Bundle::from_canonical(canonical_type).fields();
        let [
            BundleField {
                name: value_name,
                flipped: false,
                ty: value,
            },
            BundleField {
                name: range_name,
                flipped: false,
                ty: range,
            },
        ] = *fields
        else {
            panic!("expected UIntInRangeMaskType");
        };
        assert_eq!([&*value_name, &*range_name], UINT_IN_RANGE_TYPE_FIELD_NAMES);
        let value = Bool::from_canonical(value);
        let range = PhantomConstRangeMaskType::from_canonical(range);
        Self { value, range }
    }

    fn source_location() -> SourceLocation {
        SourceLocation::builtin()
    }

    fn sim_value_from_opaque(&self, opaque: OpaqueSimValueSlice<'_>) -> Self::SimValue {
        Bool.sim_value_from_opaque(opaque)
    }

    fn sim_value_clone_from_opaque(
        &self,
        value: &mut Self::SimValue,
        opaque: OpaqueSimValueSlice<'_>,
    ) {
        Bool.sim_value_clone_from_opaque(value, opaque);
    }

    fn sim_value_to_opaque<'w>(
        &self,
        value: &Self::SimValue,
        writer: OpaqueSimValueWriter<'w>,
    ) -> OpaqueSimValueWritten<'w> {
        Bool.sim_value_to_opaque(value, writer)
    }
}

impl BundleType for UIntInRangeMaskType {
    type Builder = NoBuilder;
    type FilledBuilder = Expr<UIntInRangeMaskType>;

    fn fields(&self) -> Interned<[BundleField]> {
        let [value_name, range_name] = UINT_IN_RANGE_TYPE_FIELD_NAMES;
        let Self { value, range } = self;
        [
            BundleField {
                name: value_name.intern(),
                flipped: false,
                ty: value.canonical(),
            },
            BundleField {
                name: range_name.intern(),
                flipped: false,
                ty: range.canonical(),
            },
        ]
        .intern_slice()
    }
}

impl StaticType for UIntInRangeMaskType {
    const TYPE: Self = Self {
        value: Bool,
        range: PhantomConstRangeMaskType::TYPE,
    };
    const MASK_TYPE: Self::MaskType = Self::TYPE;
    const TYPE_PROPERTIES: TypeProperties = BundleTypePropertiesBuilder::new()
        .field(false, Bool::TYPE_PROPERTIES)
        .field(false, PhantomConstRangeMaskType::TYPE_PROPERTIES)
        .finish();
    const MASK_TYPE_PROPERTIES: TypeProperties = Self::TYPE_PROPERTIES;
}

impl ToSimValueWithType<UIntInRangeMaskType> for bool {
    fn to_sim_value_with_type(&self, ty: UIntInRangeMaskType) -> SimValue<UIntInRangeMaskType> {
        SimValue::from_value(ty, *self)
    }
}

impl ExprCastTo<Bool> for UIntInRangeMaskType {
    fn cast_to(src: Expr<Self>, to_type: Bool) -> Expr<Bool> {
        src.cast_to_bits().cast_to(to_type)
    }
}

impl ExprCastTo<UIntInRangeMaskType> for Bool {
    fn cast_to(src: Expr<Self>, to_type: UIntInRangeMaskType) -> Expr<UIntInRangeMaskType> {
        src.cast_to_static::<UInt<1>>().cast_bits_to(to_type)
    }
}

impl ExprPartialEq<Self> for UIntInRangeMaskType {
    fn cmp_eq(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
        lhs.cast_to_bits().cmp_eq(rhs.cast_to_bits())
    }
    fn cmp_ne(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
        lhs.cast_to_bits().cmp_ne(rhs.cast_to_bits())
    }
}

impl SimValuePartialEq<Self> for UIntInRangeMaskType {
    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
        **this == **other
    }
}

type PhantomConstRangeMaskType = <PhantomConst<SerdeRange<DynSize, DynSize>> as Type>::MaskType;

#[derive(Default, Copy, Clone, Debug)]
struct RangeParseError;

macro_rules! define_uint_in_range_type {
    (
        $UIntInRange:ident,
        $UIntInRangeType:ident,
        $UIntInRangeTypeWithoutGenerics:ident,
        $UIntInRangeTypeWithStart:ident,
        $SerdeRange:ident,
        $range_operator_str:literal,
        |$uint_range_usize_start:ident, $uint_range_usize_end:ident| $uint_range_usize:expr,
    ) => {
        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        struct $SerdeRange<Start: Size, End: Size> {
            start: Start::SizeType,
            end: End::SizeType,
        }

        impl<Start: KnownSize, End: KnownSize> Default for $SerdeRange<Start, End> {
            fn default() -> Self {
                Self {
                    start: Start::SIZE,
                    end: End::SIZE,
                }
            }
        }

        impl std::str::FromStr for $SerdeRange<DynSize, DynSize> {
            type Err = RangeParseError;

            fn from_str(s: &str) -> Result<Self, Self::Err> {
                let Some((start, end)) = s.split_once($range_operator_str) else {
                    return Err(RangeParseError);
                };
                if start.is_empty()
                    || start.bytes().any(|b| !b.is_ascii_digit())
                    || end.is_empty()
                    || end.bytes().any(|b| !b.is_ascii_digit())
                {
                    return Err(RangeParseError);
                }
                let start = start.parse().map_err(|_| RangeParseError)?;
                let end = end.parse().map_err(|_| RangeParseError)?;
                let retval = Self { start, end };
                if retval.is_empty() {
                    Err(RangeParseError)
                } else {
                    Ok(retval)
                }
            }
        }

        impl<Start: Size, End: Size> fmt::Display for $SerdeRange<Start, End> {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                let Self { start, end } = *self;
                write!(
                    f,
                    "{}{}{}",
                    Start::as_usize(start),
                    $range_operator_str,
                    End::as_usize(end),
                )
            }
        }

        impl<Start: Size, End: Size> Serialize for $SerdeRange<Start, End> {
            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
                serializer.collect_str(self)
            }
        }

        impl<'de, Start: Size, End: Size> Deserialize<'de> for $SerdeRange<Start, End> {
            fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
                struct SerdeRangeVisitor<Start: Size, End: Size>(PhantomData<(Start, End)>);
                impl<'de, Start: Size, End: Size> Visitor<'de> for SerdeRangeVisitor<Start, End> {
                    type Value = $SerdeRange<Start, End>;

                    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                        f.write_str("a string with format \"")?;
                        if let Some(start) = Start::KNOWN_VALUE {
                            write!(f, "{start}")?;
                        } else {
                            f.write_str("<int>")?;
                        };
                        f.write_str($range_operator_str)?;
                        if let Some(end) = End::KNOWN_VALUE {
                            write!(f, "{end}")?;
                        } else {
                            f.write_str("<int>")?;
                        };
                        f.write_str("\" that is a non-empty range")
                    }

                    fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
                        let $SerdeRange::<DynSize, DynSize> { start, end } =
                            v.parse().map_err(|_| {
                                Error::invalid_value(serde::de::Unexpected::Str(v), &self)
                            })?;
                        let start =
                            Start::SizeType::deserialize(UsizeDeserializer::<E>::new(start))?;
                        let end = End::SizeType::deserialize(UsizeDeserializer::<E>::new(end))?;
                        Ok($SerdeRange { start, end })
                    }

                    fn visit_bytes<E: Error>(self, v: &[u8]) -> Result<Self::Value, E> {
                        match std::str::from_utf8(v) {
                            Ok(v) => self.visit_str(v),
                            Err(_) => {
                                Err(Error::invalid_value(serde::de::Unexpected::Bytes(v), &self))
                            }
                        }
                    }
                }
                deserializer.deserialize_str(SerdeRangeVisitor(PhantomData))
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash)]
        pub struct $UIntInRangeType<Start: Size, End: Size> {
            value: UInt,
            range: PhantomConst<$SerdeRange<Start, End>>,
        }

        impl<Start: Size, End: Size> $UIntInRangeType<Start, End> {
            fn from_phantom_const_range(range: PhantomConst<$SerdeRange<Start, End>>) -> Self {
                let $SerdeRange { start, end } = *range.get();
                let $uint_range_usize_start = Start::as_usize(start);
                let $uint_range_usize_end = End::as_usize(end);
                Self {
                    value: $uint_range_usize,
                    range,
                }
            }
            pub fn new(start: Start::SizeType, end: End::SizeType) -> Self {
                Self::from_phantom_const_range(PhantomConst::new(
                    $SerdeRange { start, end }.intern_sized(),
                ))
            }
        }

        impl<Start: Size, End: Size> fmt::Debug for $UIntInRangeType<Start, End> {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                let Self { value, range } = self;
                let $SerdeRange { start, end } = *range.get();
                f.debug_struct(&format!(
                    "{}<{}, {}>",
                    stringify!($UIntInRange),
                    Start::as_usize(start),
                    End::as_usize(end),
                ))
                .field("value", value)
                .finish_non_exhaustive()
            }
        }

        impl<Start: Size, End: Size> Type for $UIntInRangeType<Start, End> {
            type BaseType = Bundle;
            type MaskType = UIntInRangeMaskType;
            type SimValue = usize;
            impl_match_variant_as_self!();

            fn mask_type(&self) -> Self::MaskType {
                UIntInRangeMaskType::TYPE
            }

            fn canonical(&self) -> CanonicalType {
                CanonicalType::Bundle(Bundle::new(self.fields()))
            }

            fn from_canonical(canonical_type: CanonicalType) -> Self {
                let fields = Bundle::from_canonical(canonical_type).fields();
                let [
                    BundleField {
                        name: value_name,
                        flipped: false,
                        ty: value,
                    },
                    BundleField {
                        name: range_name,
                        flipped: false,
                        ty: range,
                    },
                ] = *fields
                else {
                    panic!("expected {}", stringify!($UIntInRange));
                };
                assert_eq!([&*value_name, &*range_name], UINT_IN_RANGE_TYPE_FIELD_NAMES);
                let value = UInt::from_canonical(value);
                let range = PhantomConst::<$SerdeRange<Start, End>>::from_canonical(range);
                let retval = Self::from_phantom_const_range(range);
                assert_eq!(retval, Self { value, range });
                retval
            }

            fn source_location() -> SourceLocation {
                SourceLocation::builtin()
            }

            fn sim_value_from_opaque(&self, opaque: OpaqueSimValueSlice<'_>) -> Self::SimValue {
                assert_eq!(opaque.size(), self.value.type_properties().size());
                let mut retval = 0usize;
                retval.view_bits_mut::<Lsb0>()[..opaque.bit_width()]
                    .clone_from_bitslice(opaque.bits());
                retval
            }

            fn sim_value_clone_from_opaque(
                &self,
                value: &mut Self::SimValue,
                opaque: OpaqueSimValueSlice<'_>,
            ) {
                *value = self.sim_value_from_opaque(opaque);
            }

            fn sim_value_to_opaque<'w>(
                &self,
                value: &Self::SimValue,
                writer: OpaqueSimValueWriter<'w>,
            ) -> OpaqueSimValueWritten<'w> {
                writer.fill_cloned_from_slice(OpaqueSimValueSlice::from_bitslice(
                    &value.view_bits::<Lsb0>()[..self.value.width()],
                ))
            }
        }

        impl<Start: Size, End: Size> BundleType for $UIntInRangeType<Start, End> {
            type Builder = NoBuilder;
            type FilledBuilder = Expr<Self>;

            fn fields(&self) -> Interned<[BundleField]> {
                let [value_name, range_name] = UINT_IN_RANGE_TYPE_FIELD_NAMES;
                let Self { value, range } = self;
                [
                    BundleField {
                        name: value_name.intern(),
                        flipped: false,
                        ty: value.canonical(),
                    },
                    BundleField {
                        name: range_name.intern(),
                        flipped: false,
                        ty: range.canonical(),
                    },
                ]
                .intern_slice()
            }
        }

        impl<Start: KnownSize, End: KnownSize> Default for $UIntInRangeType<Start, End> {
            fn default() -> Self {
                Self::TYPE
            }
        }

        impl<Start: KnownSize, End: KnownSize> StaticType for $UIntInRangeType<Start, End> {
            const TYPE: Self = {
                let $uint_range_usize_start = Start::VALUE;
                let $uint_range_usize_end = End::VALUE;
                Self {
                    value: $uint_range_usize,
                    range: PhantomConst::<$SerdeRange<Start, End>>::TYPE,
                }
            };
            const MASK_TYPE: Self::MaskType = UIntInRangeMaskType::TYPE;
            const TYPE_PROPERTIES: TypeProperties = BundleTypePropertiesBuilder::new()
                .field(false, Self::TYPE.value.type_properties_dyn())
                .field(
                    false,
                    PhantomConst::<$SerdeRange<Start, End>>::TYPE_PROPERTIES,
                )
                .finish();
            const MASK_TYPE_PROPERTIES: TypeProperties = UIntInRangeMaskType::TYPE_PROPERTIES;
        }

        impl<Start: Size, End: Size> ToSimValueWithType<$UIntInRangeType<Start, End>> for usize {
            fn to_sim_value_with_type(
                &self,
                ty: $UIntInRangeType<Start, End>,
            ) -> SimValue<$UIntInRangeType<Start, End>> {
                SimValue::from_value(ty, *self)
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
        pub struct $UIntInRangeTypeWithoutGenerics;

        #[allow(non_upper_case_globals)]
        pub const $UIntInRangeType: $UIntInRangeTypeWithoutGenerics =
            $UIntInRangeTypeWithoutGenerics;

        impl<StartSize: SizeType> Index<StartSize> for $UIntInRangeTypeWithoutGenerics {
            type Output = $UIntInRangeTypeWithStart<StartSize::Size>;

            fn index(&self, start: StartSize) -> &Self::Output {
                Interned::into_inner($UIntInRangeTypeWithStart(start).intern_sized())
            }
        }

        #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
        pub struct $UIntInRangeTypeWithStart<Start: Size>(Start::SizeType);

        impl<Start: Size, EndSize: SizeType<Size = End>, End: Size<SizeType = EndSize>>
            Index<EndSize> for $UIntInRangeTypeWithStart<Start>
        {
            type Output = $UIntInRangeType<Start, End>;

            fn index(&self, end: EndSize) -> &Self::Output {
                Interned::into_inner($UIntInRangeType::new(self.0, end).intern_sized())
            }
        }

        impl<Start: Size, End: Size> ExprCastTo<UInt> for $UIntInRangeType<Start, End> {
            fn cast_to(src: Expr<Self>, to_type: UInt) -> Expr<UInt> {
                src.cast_to_bits().cast_to(to_type)
            }
        }

        impl<Start: Size, End: Size> ExprCastTo<$UIntInRangeType<Start, End>> for UInt {
            fn cast_to(
                src: Expr<Self>,
                to_type: $UIntInRangeType<Start, End>,
            ) -> Expr<$UIntInRangeType<Start, End>> {
                src.cast_bits_to(to_type)
            }
        }

        impl<LhsStart: Size, LhsEnd: Size, RhsStart: Size, RhsEnd: Size>
            ExprPartialEq<$UIntInRangeType<RhsStart, RhsEnd>>
            for $UIntInRangeType<LhsStart, LhsEnd>
        {
            fn cmp_eq(
                lhs: Expr<Self>,
                rhs: Expr<$UIntInRangeType<RhsStart, RhsEnd>>,
            ) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_eq(rhs.cast_to_bits())
            }
            fn cmp_ne(
                lhs: Expr<Self>,
                rhs: Expr<$UIntInRangeType<RhsStart, RhsEnd>>,
            ) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_ne(rhs.cast_to_bits())
            }
        }

        impl<LhsStart: Size, LhsEnd: Size, RhsStart: Size, RhsEnd: Size>
            ExprPartialOrd<$UIntInRangeType<RhsStart, RhsEnd>>
            for $UIntInRangeType<LhsStart, LhsEnd>
        {
            fn cmp_lt(
                lhs: Expr<Self>,
                rhs: Expr<$UIntInRangeType<RhsStart, RhsEnd>>,
            ) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_lt(rhs.cast_to_bits())
            }
            fn cmp_le(
                lhs: Expr<Self>,
                rhs: Expr<$UIntInRangeType<RhsStart, RhsEnd>>,
            ) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_le(rhs.cast_to_bits())
            }
            fn cmp_gt(
                lhs: Expr<Self>,
                rhs: Expr<$UIntInRangeType<RhsStart, RhsEnd>>,
            ) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_gt(rhs.cast_to_bits())
            }
            fn cmp_ge(
                lhs: Expr<Self>,
                rhs: Expr<$UIntInRangeType<RhsStart, RhsEnd>>,
            ) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_ge(rhs.cast_to_bits())
            }
        }

        impl<LhsStart: Size, LhsEnd: Size, RhsStart: Size, RhsEnd: Size>
            SimValuePartialEq<$UIntInRangeType<RhsStart, RhsEnd>>
            for $UIntInRangeType<LhsStart, LhsEnd>
        {
            fn sim_value_eq(
                this: &SimValue<Self>,
                other: &SimValue<$UIntInRangeType<RhsStart, RhsEnd>>,
            ) -> bool {
                **this == **other
            }
        }

        impl<Start: Size, End: Size, Width: Size> ExprPartialEq<UIntType<Width>>
            for $UIntInRangeType<Start, End>
        {
            fn cmp_eq(lhs: Expr<Self>, rhs: Expr<UIntType<Width>>) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_eq(rhs)
            }
            fn cmp_ne(lhs: Expr<Self>, rhs: Expr<UIntType<Width>>) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_ne(rhs)
            }
        }

        impl<Start: Size, End: Size, Width: Size> ExprPartialEq<$UIntInRangeType<Start, End>>
            for UIntType<Width>
        {
            fn cmp_eq(lhs: Expr<Self>, rhs: Expr<$UIntInRangeType<Start, End>>) -> Expr<Bool> {
                lhs.cmp_eq(rhs.cast_to_bits())
            }
            fn cmp_ne(lhs: Expr<Self>, rhs: Expr<$UIntInRangeType<Start, End>>) -> Expr<Bool> {
                lhs.cmp_ne(rhs.cast_to_bits())
            }
        }

        impl<Start: Size, End: Size, Width: Size> ExprPartialOrd<UIntType<Width>>
            for $UIntInRangeType<Start, End>
        {
            fn cmp_lt(lhs: Expr<Self>, rhs: Expr<UIntType<Width>>) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_lt(rhs)
            }
            fn cmp_le(lhs: Expr<Self>, rhs: Expr<UIntType<Width>>) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_le(rhs)
            }
            fn cmp_gt(lhs: Expr<Self>, rhs: Expr<UIntType<Width>>) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_gt(rhs)
            }
            fn cmp_ge(lhs: Expr<Self>, rhs: Expr<UIntType<Width>>) -> Expr<Bool> {
                lhs.cast_to_bits().cmp_ge(rhs)
            }
        }

        impl<Start: Size, End: Size, Width: Size> ExprPartialOrd<$UIntInRangeType<Start, End>>
            for UIntType<Width>
        {
            fn cmp_lt(lhs: Expr<Self>, rhs: Expr<$UIntInRangeType<Start, End>>) -> Expr<Bool> {
                lhs.cmp_lt(rhs.cast_to_bits())
            }
            fn cmp_le(lhs: Expr<Self>, rhs: Expr<$UIntInRangeType<Start, End>>) -> Expr<Bool> {
                lhs.cmp_le(rhs.cast_to_bits())
            }
            fn cmp_gt(lhs: Expr<Self>, rhs: Expr<$UIntInRangeType<Start, End>>) -> Expr<Bool> {
                lhs.cmp_gt(rhs.cast_to_bits())
            }
            fn cmp_ge(lhs: Expr<Self>, rhs: Expr<$UIntInRangeType<Start, End>>) -> Expr<Bool> {
                lhs.cmp_ge(rhs.cast_to_bits())
            }
        }
    };
}

define_uint_in_range_type! {
    UIntInRange,
    UIntInRangeType,
    UIntInRangeTypeWithoutGenerics,
    UIntInRangeTypeWithStart,
    SerdeRange,
    "..",
    |start, end| UInt::range_usize(start..end),
}

define_uint_in_range_type! {
    UIntInRangeInclusive,
    UIntInRangeInclusiveType,
    UIntInRangeInclusiveTypeWithoutGenerics,
    UIntInRangeInclusiveTypeWithStart,
    SerdeRangeInclusive,
    "..=",
    |start, end| UInt::range_inclusive_usize(start..=end),
}

impl SerdeRange<DynSize, DynSize> {
    fn is_empty(self) -> bool {
        self.start >= self.end
    }
}

impl SerdeRangeInclusive<DynSize, DynSize> {
    fn is_empty(self) -> bool {
        self.start > self.end
    }
}