From 57aae7b7fba63d3376003549e13b93fc6fe2adda Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Fri, 4 Apr 2025 01:04:26 -0700 Subject: [PATCH] implement [de]serializing `BaseType`s, `SimValue`s, and support PhantomConst in #[hdl] struct S --- .../src/hdl_bundle.rs | 17 + .../fayalite-proc-macros-impl/src/hdl_enum.rs | 9 + crates/fayalite/src/array.rs | 57 +- crates/fayalite/src/bundle.rs | 3 +- crates/fayalite/src/enum_.rs | 3 +- crates/fayalite/src/int.rs | 527 +++++++++++++++++- crates/fayalite/src/phantom_const.rs | 79 ++- crates/fayalite/src/sim/value.rs | 35 ++ crates/fayalite/src/ty.rs | 76 ++- crates/fayalite/src/ty/serde_impls.rs | 130 +++++ crates/fayalite/src/util/const_bool.rs | 42 +- crates/fayalite/src/util/const_usize.rs | 42 +- crates/fayalite/tests/hdl_types.rs | 6 + 13 files changed, 991 insertions(+), 35 deletions(-) create mode 100644 crates/fayalite/src/ty/serde_impls.rs diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs index 5d13d39..7441cb3 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs @@ -1124,6 +1124,14 @@ impl ToTokens for ParsedBundle { } })); quote_spanned! {span=> + #[automatically_derived] + impl #static_impl_generics ::fayalite::__std::default::Default for #mask_type_ident #static_type_generics + #static_where_clause + { + fn default() -> Self { + ::TYPE + } + } #[automatically_derived] impl #static_impl_generics ::fayalite::ty::StaticType for #mask_type_ident #static_type_generics #static_where_clause @@ -1146,6 +1154,15 @@ impl ToTokens for ParsedBundle { }; } #[automatically_derived] + impl #static_impl_generics ::fayalite::__std::default::Default + for #target #static_type_generics + #static_where_clause + { + fn default() -> Self { + ::TYPE + } + } + #[automatically_derived] impl #static_impl_generics ::fayalite::ty::StaticType for #target #static_type_generics #static_where_clause { diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs index 5437410..e072135 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs @@ -995,6 +995,15 @@ impl ToTokens for ParsedEnum { } })); quote_spanned! {span=> + #[automatically_derived] + impl #static_impl_generics ::fayalite::__std::default::Default + for #target #static_type_generics + #static_where_clause + { + fn default() -> Self { + ::TYPE + } + } #[automatically_derived] impl #static_impl_generics ::fayalite::ty::StaticType for #target #static_type_generics diff --git a/crates/fayalite/src/array.rs b/crates/fayalite/src/array.rs index a2df6cf..6d9b043 100644 --- a/crates/fayalite/src/array.rs +++ b/crates/fayalite/src/array.rs @@ -1,8 +1,6 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information -use bitvec::slice::BitSlice; - use crate::{ expr::{ ops::{ArrayLiteral, ExprFromIterator, ExprIntoIterator, ExprPartialEq}, @@ -14,10 +12,13 @@ use crate::{ sim::value::{SimValue, SimValuePartialEq}, source_location::SourceLocation, ty::{ - CanonicalType, MatchVariantWithoutScope, StaticType, Type, TypeProperties, TypeWithDeref, + serde_impls::SerdeCanonicalType, CanonicalType, MatchVariantWithoutScope, StaticType, Type, + TypeProperties, TypeWithDeref, }, util::ConstUsize, }; +use bitvec::slice::BitSlice; +use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer}; use std::{iter::FusedIterator, ops::Index}; #[derive(Copy, Clone, PartialEq, Eq, Hash)] @@ -97,6 +98,12 @@ impl> ArrayType { } } +impl Default for ArrayType { + fn default() -> Self { + Self::TYPE + } +} + impl StaticType for ArrayType { const TYPE: Self = Self { element: LazyInterned::new_lazy(&|| T::TYPE.intern_sized()), @@ -226,6 +233,50 @@ impl Type for ArrayType { } } +impl Serialize for ArrayType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + SerdeCanonicalType::::Array { + element: self.element(), + len: self.len(), + } + .serialize(serializer) + } +} + +impl<'de, T: Type + Deserialize<'de>, Len: Size> Deserialize<'de> for ArrayType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let name = |len| -> String { + if let Some(len) = len { + format!("an Array<_, {len}>") + } else { + "an Array<_>".to_string() + } + }; + match SerdeCanonicalType::::deserialize(deserializer)? { + SerdeCanonicalType::Array { element, len } => { + if let Some(len) = Len::try_from_usize(len) { + Ok(Self::new(element, len)) + } else { + Err(Error::invalid_value( + serde::de::Unexpected::Other(&name(Some(len))), + &&*name(Len::KNOWN_VALUE), + )) + } + } + ty => Err(Error::invalid_value( + serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), + &&*name(Len::KNOWN_VALUE), + )), + } + } +} + impl TypeWithDeref for ArrayType { fn expr_deref(this: &Expr) -> &Self::MatchVariant { let retval = Vec::from_iter(*this); diff --git a/crates/fayalite/src/bundle.rs b/crates/fayalite/src/bundle.rs index 9279b57..0fd89f1 100644 --- a/crates/fayalite/src/bundle.rs +++ b/crates/fayalite/src/bundle.rs @@ -17,9 +17,10 @@ use crate::{ }; use bitvec::{slice::BitSlice, vec::BitVec}; use hashbrown::HashMap; +use serde::{Deserialize, Serialize}; use std::{fmt, marker::PhantomData}; -#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)] pub struct BundleField { pub name: Interned, pub flipped: bool, diff --git a/crates/fayalite/src/enum_.rs b/crates/fayalite/src/enum_.rs index e37b7a5..6205855 100644 --- a/crates/fayalite/src/enum_.rs +++ b/crates/fayalite/src/enum_.rs @@ -22,9 +22,10 @@ use crate::{ }; use bitvec::{order::Lsb0, slice::BitSlice, view::BitView}; use hashbrown::HashMap; +use serde::{Deserialize, Serialize}; use std::{convert::Infallible, fmt, iter::FusedIterator, sync::Arc}; -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)] pub struct EnumVariant { pub name: Interned, pub ty: Option, diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs index 373e150..13b8cf1 100644 --- a/crates/fayalite/src/int.rs +++ b/crates/fayalite/src/int.rs @@ -13,15 +13,20 @@ use crate::{ ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, util::{interned_bit, ConstBool, ConstUsize, GenericConstBool, GenericConstUsize}, }; -use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec}; +use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec, view::BitView}; use num_bigint::{BigInt, BigUint, Sign}; -use num_traits::{Signed, Zero}; +use num_traits::{One, Signed, Zero}; +use serde::{ + de::{DeserializeOwned, Error, Visitor}, + Deserialize, Deserializer, Serialize, Serializer, +}; use std::{ borrow::{BorrowMut, Cow}, fmt, marker::PhantomData, num::NonZero, ops::{Bound, Index, Not, Range, RangeBounds, RangeInclusive}, + str::FromStr, sync::Arc, }; @@ -93,13 +98,31 @@ macro_rules! known_widths { known_widths!([2 2 2 2 2 2 2 2 2]); pub trait SizeType: - sealed::SizeTypeSealed + Copy + Ord + std::hash::Hash + std::fmt::Debug + Send + Sync + 'static + sealed::SizeTypeSealed + + Copy + + Ord + + std::hash::Hash + + std::fmt::Debug + + Send + + Sync + + 'static + + Serialize + + DeserializeOwned { type Size: Size; } pub trait Size: - sealed::SizeSealed + Copy + Ord + std::hash::Hash + std::fmt::Debug + Send + Sync + 'static + sealed::SizeSealed + + Copy + + Ord + + std::hash::Hash + + std::fmt::Debug + + Send + + Sync + + 'static + + Serialize + + DeserializeOwned { type ArrayMatch: AsRef<[Expr]> + AsMut<[Expr]> @@ -191,6 +214,305 @@ impl Size for T { } } +#[derive(Clone, PartialEq, Eq, Debug)] +pub enum ParseIntValueError { + Empty, + InvalidDigit, + MissingDigits, + InvalidRadix, + MissingType, + InvalidType, + TypeMismatch { + parsed_signed: bool, + parsed_width: usize, + expected_signed: bool, + expected_width: usize, + }, + PosOverflow, + NegOverflow, + WidthOverflow, + MissingWidth, +} + +impl std::error::Error for ParseIntValueError {} + +impl fmt::Display for ParseIntValueError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + Self::Empty => "can't parse integer from empty string", + Self::InvalidDigit => "invalid digit", + Self::MissingDigits => "missing digits", + Self::InvalidRadix => "invalid radix", + Self::MissingType => "missing type", + Self::InvalidType => "invalid type", + Self::TypeMismatch { + parsed_signed, + parsed_width, + expected_signed, + expected_width, + } => { + return write!( + f, + "type mismatch: parsed type {parsed_signed_str}{parsed_width}, \ + expected type {expected_signed_str}{expected_width}", + parsed_signed_str = if *parsed_signed { "i" } else { "u" }, + expected_signed_str = if *expected_signed { "i" } else { "u" }, + ); + } + Self::PosOverflow => "value too large to fit in type", + Self::NegOverflow => "value too small to fit in type", + Self::WidthOverflow => "width is too large", + Self::MissingWidth => "missing width", + }) + } +} + +fn parse_int_value( + s: &str, + type_is_signed: bool, + type_width: Option, + parse_type: bool, +) -> Result, ParseIntValueError> { + if !parse_type && type_width.is_none() { + return Err(ParseIntValueError::MissingWidth); + } + let mut s = s.trim(); + if s.is_empty() { + return Err(ParseIntValueError::Empty); + } + let negative = match s.bytes().next() { + Some(ch @ (b'+' | b'-')) => { + s = s[1..].trim_start(); + ch == b'-' + } + _ => false, + }; + let radix = match s.bytes().next() { + Some(b'0') => match s.bytes().nth(1) { + Some(b'x' | b'X') => { + s = &s[2..]; + 16 + } + Some(b'b' | b'B') => { + s = &s[2..]; + 2 + } + Some(b'o' | b'O') => { + s = &s[2..]; + 8 + } + _ => 10, + }, + Some(b'1'..=b'9') => 10, + _ => return Err(ParseIntValueError::InvalidDigit), + }; + let mut any_digits = false; + let digits_end = s + .as_bytes() + .iter() + .position(|&ch| { + if ch == b'_' { + false + } else if (ch as char).to_digit(radix).is_some() { + any_digits = true; + false + } else { + true + } + }) + .unwrap_or(s.len()); + let digits = &s[..digits_end]; + s = &s[digits_end..]; + if !any_digits { + return Err(ParseIntValueError::MissingDigits); + } + let width = if parse_type { + const HDL_PREFIX: &[u8] = b"hdl_"; + let mut missing_type = ParseIntValueError::MissingType; + if s.as_bytes() + .get(..HDL_PREFIX.len()) + .is_some_and(|bytes| bytes.eq_ignore_ascii_case(HDL_PREFIX)) + { + s = &s[HDL_PREFIX.len()..]; + missing_type = ParseIntValueError::InvalidType; + } + let signed = match s.bytes().next() { + Some(b'u' | b'U') => false, + Some(b'i' | b'I') => true, + Some(_) => return Err(ParseIntValueError::InvalidType), + None => return Err(missing_type), + }; + s = &s[1..]; + let mut width = 0usize; + let mut any_digits = false; + for ch in s.bytes() { + let digit = (ch as char) + .to_digit(10) + .ok_or(ParseIntValueError::InvalidDigit)?; + any_digits = true; + width = width + .checked_mul(10) + .and_then(|v| v.checked_add(digit as usize)) + .ok_or(ParseIntValueError::WidthOverflow)?; + } + if !any_digits { + return Err(ParseIntValueError::MissingDigits); + } + if width > ::MAX_BITS { + return Err(ParseIntValueError::WidthOverflow); + } + let expected_width = type_width.unwrap_or(width); + if type_is_signed != signed || expected_width != width { + let expected_width = type_width.unwrap_or(width); + return Err(ParseIntValueError::TypeMismatch { + parsed_signed: signed, + parsed_width: width, + expected_signed: type_is_signed, + expected_width, + }); + } + width + } else { + if !s.is_empty() { + return Err(ParseIntValueError::InvalidDigit); + } + type_width.expect("checked earlier") + }; + if !type_is_signed && negative { + return Err(ParseIntValueError::InvalidDigit); + } + if radix == 10 { + let mut value: BigInt = digits + .replace("_", "") + .parse() + .expect("checked that the digits are valid already"); + if negative { + value = -value; + } + let uint_value: UIntValue = UInt::new(width).from_bigint_wrapping(&value); + if value.is_zero() { + Ok(uint_value.into_bits()) + } else { + for i in 0..width { + value.set_bit(i as u64, type_is_signed && negative); + } + if value.is_zero() { + Ok(uint_value.into_bits()) + } else if type_is_signed && negative { + if value.sign() == Sign::Minus && value.magnitude().is_one() { + Ok(uint_value.into_bits()) + } else { + Err(ParseIntValueError::NegOverflow) + } + } else { + Err(ParseIntValueError::PosOverflow) + } + } + } else { + let mut value = BitVec::repeat(false, width); + let bits_per_digit = match radix { + 2 => 1, + 8 => 3, + 16 => 4, + _ => unreachable!(), + }; + let mut digits = digits + .bytes() + .rev() + .filter_map(|ch| (ch as char).to_digit(radix)); + let overflow_error = if negative { + ParseIntValueError::NegOverflow + } else { + ParseIntValueError::PosOverflow + }; + for chunk in value.chunks_mut(bits_per_digit) { + if let Some(mut digit) = digits.next() { + let digit_bits = &mut digit.view_bits_mut::()[..chunk.len()]; + chunk.clone_from_bitslice(digit_bits); + digit_bits.fill(false); + if digit != 0 { + return Err(overflow_error); + } + } else { + break; + } + } + for digit in digits { + if digit != 0 { + return Err(overflow_error); + } + } + let negative_zero = if negative { + // negating a value happens in three regions: + // * the least-significant zeros, which are left as zeros + // * the least-significant one bit, which is left as a one bit + // * all the most-significant bits, which are inverted + // e.g.: + const { + let inp = 0b1010_1_000_u8; + let out = 0b0101_1_000_u8; + assert!(inp.wrapping_neg() == out); + }; + if let Some(first_one) = value.first_one() { + let most_significant_bits = &mut value[first_one + 1..]; + // modifies in-place despite using `Not::not` + let _ = Not::not(most_significant_bits); + false + } else { + true + } + } else { + false + }; + if !negative_zero && type_is_signed && negative != value[value.len() - 1] { + Err(overflow_error) + } else { + Ok(Arc::new(value)) + } + } +} + +fn deserialize_int_value<'de, D: Deserializer<'de>>( + deserializer: D, + type_is_signed: bool, + type_width: Option, +) -> Result, D::Error> { + struct IntValueVisitor { + type_is_signed: bool, + type_width: Option, + } + impl<'de> Visitor<'de> for IntValueVisitor { + type Value = Arc; + + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(if self.type_is_signed { + "SIntValue" + } else { + "UIntValue" + })?; + if let Some(type_width) = self.type_width { + write!(f, "<{type_width}>")?; + } + Ok(()) + } + + fn visit_str(self, v: &str) -> Result { + parse_int_value(v, self.type_is_signed, self.type_width, true).map_err(E::custom) + } + + fn visit_bytes(self, v: &[u8]) -> Result { + 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(IntValueVisitor { + type_is_signed, + type_width, + }) +} + macro_rules! impl_int { ($pretty_name:ident, $name:ident, $generic_name:ident, $value:ident, $SIGNED:literal) => { #[derive(Copy, Clone, PartialEq, Eq, Hash)] @@ -289,6 +611,12 @@ macro_rules! impl_int { } Expr::from_dyn_int(MemoizeBitsToExpr.get_cow(bits)) } + fn from_str_without_ty( + self, + s: &str, + ) -> Result::Err> { + parse_int_value(s, $SIGNED, Some(self.width()), false).map(Self::Value::new) + } } impl IntType for $name { @@ -324,7 +652,7 @@ macro_rules! impl_int { #[track_caller] fn from_canonical(canonical_type: CanonicalType) -> Self { let CanonicalType::$pretty_name(retval) = canonical_type else { - panic!("expected {}", stringify!($name)); + panic!("expected {}", stringify!($pretty_name)); }; $name { width: Width::from_usize(retval.width), @@ -349,6 +677,12 @@ macro_rules! impl_int { } } + impl Default for $name { + fn default() -> Self { + Self::TYPE + } + } + impl StaticType for $name { const TYPE: Self = Self { width: Width::SIZE }; const MASK_TYPE: Self::MaskType = Bool; @@ -361,6 +695,46 @@ macro_rules! impl_int { const MASK_TYPE_PROPERTIES: TypeProperties = Bool::TYPE_PROPERTIES; } + impl Serialize for $name { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.canonical().serialize(serializer) + } + } + + impl<'de, Width: Size> Deserialize<'de> for $name { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let name = |width| -> String { + if let Some(width) = width { + format!("a {}<{width}>", stringify!($pretty_name)) + } else { + format!("a {}", stringify!($pretty_name)) + } + }; + match CanonicalType::deserialize(deserializer)? { + CanonicalType::$pretty_name(retval) => { + if let Some(width) = Width::try_from_usize(retval.width()) { + Ok($name { width }) + } else { + Err(Error::invalid_value( + serde::de::Unexpected::Other(&name(Some(retval.width()))), + &&*name(Width::KNOWN_VALUE), + )) + } + } + ty => Err(Error::invalid_value( + serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), + &&*name(Width::KNOWN_VALUE), + )), + } + } + } + #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)] pub struct $generic_name; @@ -378,7 +752,7 @@ macro_rules! impl_int { _phantom: PhantomData, } - impl fmt::Debug for $value { + impl fmt::Display for $value { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let value = self.to_bigint(); let (sign, magnitude) = value.into_parts(); @@ -392,6 +766,32 @@ macro_rules! impl_int { } } + impl fmt::Debug for $value { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(self, f) + } + } + + impl std::str::FromStr for $value { + type Err = ParseIntValueError; + + fn from_str(s: &str) -> Result { + parse_int_value(s, $SIGNED, Width::KNOWN_VALUE, true).map(Self::new) + } + } + + impl Serialize for $value { + fn serialize(&self, serializer: S) -> Result { + self.to_string().serialize(serializer) + } + } + + impl<'de, Width: Size> Deserialize<'de> for $value { + fn deserialize>(deserializer: D) -> Result { + deserialize_int_value(deserializer, $SIGNED, Width::KNOWN_VALUE).map(Self::new) + } + } + impl PartialEq<$value> for $value { fn eq(&self, other: &$value) -> bool { self.to_bigint() == other.to_bigint() @@ -633,11 +1033,13 @@ pub trait BoolOrIntType: Type + sealed::BoolOrIntTypeSealed { + Ord + std::hash::Hash + fmt::Debug + + fmt::Display + Send + Sync + 'static + ToExpr - + Into; + + Into + + std::str::FromStr; fn width(self) -> usize; fn new(width: ::SizeType) -> Self; fn new_static() -> Self @@ -710,9 +1112,12 @@ pub trait BoolOrIntType: Type + sealed::BoolOrIntTypeSealed { bytes, bit_width, ))) } + fn from_str_without_ty(self, s: &str) -> Result::Err>; } -pub trait IntType: BoolOrIntType::Dyn> { +pub trait IntType: + BoolOrIntType::Dyn, Value: FromStr> +{ type Dyn: IntType; fn as_dyn_int(self) -> Self::Dyn { Self::new_dyn(self.width()) @@ -752,7 +1157,7 @@ pub trait IntType: BoolOrIntType::Dyn> { } } -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)] pub struct Bool; impl sealed::BoolOrIntTypeSealed for Bool {} @@ -784,6 +1189,10 @@ impl BoolOrIntType for Bool { assert_eq!(bits.len(), 1); bits[0] } + + fn from_str_without_ty(self, s: &str) -> Result::Err> { + FromStr::from_str(s) + } } impl Bool { @@ -874,4 +1283,104 @@ mod tests { assert_eq!(SInt::for_value(3).width, 3); assert_eq!(SInt::for_value(4).width, 4); } + + #[test] + fn test_serde_round_trip() { + use serde_json::json; + #[track_caller] + fn check( + value: T, + expected: serde_json::Value, + ) { + assert_eq!(serde_json::to_value(&value).unwrap(), expected); + assert_eq!(value, T::deserialize(expected).unwrap()); + } + check(UInt[0], json! { { "UInt": { "width": 0 } } }); + check(UInt::<0>::TYPE, json! { { "UInt": { "width": 0 } } }); + check(UInt::<35>::TYPE, json! { { "UInt": { "width": 35 } } }); + check(SInt[0], json! { { "SInt": { "width": 0 } } }); + check(SInt::<0>::TYPE, json! { { "SInt": { "width": 0 } } }); + check(SInt::<35>::TYPE, json! { { "SInt": { "width": 35 } } }); + check(Bool, json! { "Bool" }); + check(UIntValue::from(0u8), json! { "0x0_u8" }); + check(SIntValue::from(-128i8), json! { "-0x80_i8" }); + check(UInt[3].from_int_wrapping(5), json! { "0x5_u3" }); + check(UInt[12].from_int_wrapping(0x1123), json! { "0x123_u12" }); + check(SInt[12].from_int_wrapping(0xFEE), json! { "-0x12_i12" }); + check(SInt[12].from_int_wrapping(0x7EE), json! { "0x7EE_i12" }); + } + + #[test] + fn test_deserialize() { + use serde_json::json; + #[track_caller] + fn check( + expected: Result, + input: serde_json::Value, + ) { + let mut error = String::new(); + let value = T::deserialize(input).map_err(|e| -> &str { + error = e.to_string(); + &error + }); + assert_eq!(value, expected); + } + check::>( + Err("invalid value: a UInt<2>, expected a UInt<0>"), + json! { { "UInt": { "width": 2 } } }, + ); + check::>( + Err("invalid value: a Bool, expected a UInt<0>"), + json! { "Bool" }, + ); + check::>( + Err("invalid value: a Bool, expected a SInt<0>"), + json! { "Bool" }, + ); + check::( + Err("invalid value: a Bool, expected a UInt"), + json! { "Bool" }, + ); + check::( + Err("invalid value: a Bool, expected a SInt"), + json! { "Bool" }, + ); + check::(Err("value too large to fit in type"), json! { "2_u1" }); + check::(Err("value too large to fit in type"), json! { "10_u1" }); + check::(Err("value too large to fit in type"), json! { "0x2_u1" }); + check::(Err("value too large to fit in type"), json! { "0b10_u1" }); + check::(Err("value too large to fit in type"), json! { "0o2_u1" }); + check::(Err("value too large to fit in type"), json! { "0o377_i8" }); + check::(Err("value too large to fit in type"), json! { "0o200_i8" }); + check(Ok(SInt[8].from_int_wrapping(i8::MAX)), json! { "0o177_i8" }); + check::(Err("value too small to fit in type"), json! { "-0o201_i8" }); + check::(Err("value too small to fit in type"), json! { "-0o377_i8" }); + check::(Err("value too small to fit in type"), json! { "-0o400_i8" }); + check::( + Err("value too small to fit in type"), + json! { "-0o4000_i8" }, + ); + check(Ok(UIntValue::from(0u8)), json! { "0_u8" }); + check(Ok(UIntValue::from(0u8)), json! { "0b0_u8" }); + check(Ok(UIntValue::from(0u8)), json! { "00_u8" }); + check(Ok(UIntValue::from(0u8)), json! { "0x0_u8" }); + check(Ok(UIntValue::from(0u8)), json! { "0o0_u8" }); + check(Ok(SIntValue::from(-128i8)), json! { "-0x000_80_i8" }); + check(Ok(SIntValue::from(-128i8)), json! { "-0o002_00_hdl_i8" }); + check(Ok(SIntValue::from(-128i8)), json! { "-0b1__000_0000_i8" }); + check(Ok(UInt[3].from_int_wrapping(5)), json! { " + 0x5_u3 " }); + check( + Ok(UInt[12].from_int_wrapping(0x1123)), + json! { "0x1_2_3_hdl_u12" }, + ); + check(Ok(SInt[12].from_int_wrapping(0xFEE)), json! { "-0x12_i12" }); + check( + Ok(SInt[12].from_int_wrapping(0x7EE)), + json! { " + \t0x7__E_e_i012\n" }, + ); + check(Ok(SInt[0].from_int_wrapping(0)), json! { "-0i0" }); + check(Ok(SInt[1].from_int_wrapping(0)), json! { "-0i1" }); + check(Ok(SInt[0].from_int_wrapping(0)), json! { "-0x0i0" }); + check(Ok(SInt[1].from_int_wrapping(0)), json! { "-0x0i1" }); + } } diff --git a/crates/fayalite/src/phantom_const.rs b/crates/fayalite/src/phantom_const.rs index 8422ae0..d2e94d9 100644 --- a/crates/fayalite/src/phantom_const.rs +++ b/crates/fayalite/src/phantom_const.rs @@ -1,9 +1,6 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information -use bitvec::slice::BitSlice; -use serde::{de::DeserializeOwned, Deserialize, Serialize}; - use crate::{ expr::{ ops::{ExprPartialEq, ExprPartialOrd}, @@ -13,13 +10,23 @@ use crate::{ intern::{Intern, Interned, InternedCompare, LazyInterned, Memoize}, sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType}, source_location::SourceLocation, - ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, + ty::{ + impl_match_variant_as_self, + serde_impls::{SerdeCanonicalType, SerdePhantomConst}, + CanonicalType, StaticType, Type, TypeProperties, + }, +}; +use bitvec::slice::BitSlice; +use serde::{ + de::{DeserializeOwned, Error}, + Deserialize, Deserializer, Serialize, Serializer, }; use std::{ any::Any, fmt, hash::{Hash, Hasher}, marker::PhantomData, + ops::Index, }; #[derive(Clone)] @@ -115,6 +122,20 @@ pub struct PhantomConst, } +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)] +pub struct PhantomConstWithoutGenerics; + +#[allow(non_upper_case_globals)] +pub const PhantomConst: PhantomConstWithoutGenerics = PhantomConstWithoutGenerics; + +impl Index for PhantomConstWithoutGenerics { + type Output = PhantomConst; + + fn index(&self, value: T) -> &Self::Output { + Interned::into_inner(PhantomConst::new(value.intern()).intern_sized()) + } +} + impl fmt::Debug for PhantomConst { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("PhantomConst").field(&self.get()).finish() @@ -201,17 +222,6 @@ impl Memoize for PhantomConstCanonicalMemoize PhantomConst -where - Interned: Default, -{ - pub const fn default() -> Self { - PhantomConst { - value: LazyInterned::new_lazy(&Interned::::default), - } - } -} - impl PhantomConst { pub fn new(value: Interned) -> Self { Self { @@ -286,16 +296,53 @@ impl Type for PhantomConst { } } +impl Default for PhantomConst +where + Interned: Default, +{ + fn default() -> Self { + Self::TYPE + } +} + impl StaticType for PhantomConst where Interned: Default, { - const TYPE: Self = Self::default(); + const TYPE: Self = PhantomConst { + value: LazyInterned::new_lazy(&Interned::::default), + }; const MASK_TYPE: Self::MaskType = (); const TYPE_PROPERTIES: TypeProperties = <()>::TYPE_PROPERTIES; const MASK_TYPE_PROPERTIES: TypeProperties = <()>::TYPE_PROPERTIES; } +type SerdeType = SerdeCanonicalType>>; + +impl Serialize for PhantomConst { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + SerdeType::::PhantomConst(SerdePhantomConst(self.get())).serialize(serializer) + } +} + +impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for PhantomConst { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + match SerdeType::::deserialize(deserializer)? { + SerdeCanonicalType::PhantomConst(SerdePhantomConst(value)) => Ok(Self::new(value)), + ty => Err(Error::invalid_value( + serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), + &"a PhantomConst", + )), + } + } +} + impl ExprPartialEq for PhantomConst { fn cmp_eq(lhs: Expr, rhs: Expr) -> Expr { assert_eq!(Expr::ty(lhs), Expr::ty(rhs)); diff --git a/crates/fayalite/src/sim/value.rs b/crates/fayalite/src/sim/value.rs index d415af4..737043a 100644 --- a/crates/fayalite/src/sim/value.rs +++ b/crates/fayalite/src/sim/value.rs @@ -16,6 +16,7 @@ use crate::{ }, }; use bitvec::{slice::BitSlice, vec::BitVec}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::{ fmt, ops::{Deref, DerefMut}, @@ -94,6 +95,40 @@ impl AlternatingCellMethods for SimValueInner { fn shared_to_unique(&mut self) {} } +#[derive(Serialize, Deserialize)] +#[serde(rename = "SimValue")] +#[serde(bound( + serialize = "T: Type + Serialize", + deserialize = "T: Type> + Deserialize<'de>" +))] +struct SerdeSimValue<'a, T: Type> { + ty: T, + value: std::borrow::Cow<'a, T::SimValue>, +} + +impl + Serialize> Serialize for SimValue { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + SerdeSimValue { + ty: SimValue::ty(self), + value: std::borrow::Cow::Borrowed(&*self), + } + .serialize(serializer) + } +} + +impl<'de, T: Type> + Deserialize<'de>> Deserialize<'de> for SimValue { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let SerdeSimValue { ty, value } = SerdeSimValue::::deserialize(deserializer)?; + Ok(SimValue::from_value(ty, value.into_owned())) + } +} + pub struct SimValue { inner: AlternatingCell>, } diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs index 23680f7..8f41c5c 100644 --- a/crates/fayalite/src/ty.rs +++ b/crates/fayalite/src/ty.rs @@ -16,8 +16,11 @@ use crate::{ util::ConstUsize, }; use bitvec::slice::BitSlice; +use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize, Serializer}; use std::{fmt, hash::Hash, iter::FusedIterator, ops::Index, sync::Arc}; +pub(crate) mod serde_impls; + #[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)] #[non_exhaustive] pub struct TypeProperties { @@ -60,6 +63,24 @@ impl fmt::Debug for CanonicalType { } } +impl Serialize for CanonicalType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serde_impls::SerdeCanonicalType::from(*self).serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for CanonicalType { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + Ok(serde_impls::SerdeCanonicalType::deserialize(deserializer)?.into()) + } +} + impl CanonicalType { pub fn type_properties(self) -> TypeProperties { match self { @@ -158,6 +179,9 @@ impl CanonicalType { } } } + pub(crate) fn as_serde_unexpected_str(self) -> &'static str { + serde_impls::SerdeCanonicalType::from(self).as_serde_unexpected_str() + } } pub trait MatchVariantAndInactiveScope: Sized { @@ -224,6 +248,34 @@ macro_rules! impl_base_type { }; } +macro_rules! impl_base_type_serde { + ($name:ident, $expected:literal) => { + impl Serialize for $name { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.canonical().serialize(serializer) + } + } + + impl<'de> Deserialize<'de> for $name { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + match CanonicalType::deserialize(deserializer)? { + CanonicalType::$name(retval) => Ok(retval), + ty => Err(serde::de::Error::invalid_value( + serde::de::Unexpected::Other(ty.as_serde_unexpected_str()), + &$expected, + )), + } + } + } + }; +} + impl_base_type!(UInt); impl_base_type!(SInt); impl_base_type!(Bool); @@ -236,6 +288,14 @@ impl_base_type!(Reset); impl_base_type!(Clock); impl_base_type!(PhantomConst); +impl_base_type_serde!(Bool, "a Bool"); +impl_base_type_serde!(Enum, "an Enum"); +impl_base_type_serde!(Bundle, "a Bundle"); +impl_base_type_serde!(AsyncReset, "an AsyncReset"); +impl_base_type_serde!(SyncReset, "a SyncReset"); +impl_base_type_serde!(Reset, "a Reset"); +impl_base_type_serde!(Clock, "a Clock"); + impl sealed::BaseTypeSealed for CanonicalType {} impl BaseType for CanonicalType {} @@ -293,7 +353,17 @@ pub trait Type: fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice); } -pub trait BaseType: Type + sealed::BaseTypeSealed + Into {} +pub trait BaseType: + Type< + BaseType = Self, + MaskType: Serialize + DeserializeOwned, + SimValue: Serialize + DeserializeOwned, + > + sealed::BaseTypeSealed + + Into + + Serialize + + DeserializeOwned +{ +} macro_rules! impl_match_variant_as_self { () => { @@ -362,7 +432,7 @@ impl Type for CanonicalType { } } -#[derive(Clone, PartialEq, Eq, Hash, Debug)] +#[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)] pub struct OpaqueSimValue { bits: UIntValue, } @@ -399,7 +469,7 @@ impl> ToSimValueWithType for OpaqueSimValu } } -pub trait StaticType: Type { +pub trait StaticType: Type + Default { const TYPE: Self; const MASK_TYPE: Self::MaskType; const TYPE_PROPERTIES: TypeProperties; diff --git a/crates/fayalite/src/ty/serde_impls.rs b/crates/fayalite/src/ty/serde_impls.rs new file mode 100644 index 0000000..2ea4362 --- /dev/null +++ b/crates/fayalite/src/ty/serde_impls.rs @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: LGPL-3.0-or-later +// See Notices.txt for copyright information + +use crate::{ + array::Array, + bundle::{Bundle, BundleType}, + clock::Clock, + enum_::{Enum, EnumType}, + int::{Bool, SInt, UInt}, + intern::Interned, + phantom_const::{PhantomConstCanonicalValue, PhantomConstValue}, + prelude::PhantomConst, + reset::{AsyncReset, Reset, SyncReset}, + ty::{BaseType, CanonicalType}, +}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +pub(crate) struct SerdePhantomConst(pub T); + +impl Serialize for SerdePhantomConst> { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + self.0.serialize(serializer) + } +} + +impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for SerdePhantomConst> { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + T::deserialize_value(deserializer).map(Self) + } +} + +#[derive(Serialize, Deserialize)] +#[serde(rename = "CanonicalType")] +pub(crate) enum SerdeCanonicalType< + ArrayElement = CanonicalType, + ThePhantomConst = SerdePhantomConst>, +> { + UInt { + width: usize, + }, + SInt { + width: usize, + }, + Bool, + Array { + element: ArrayElement, + len: usize, + }, + Enum { + variants: Interned<[crate::enum_::EnumVariant]>, + }, + Bundle { + fields: Interned<[crate::bundle::BundleField]>, + }, + AsyncReset, + SyncReset, + Reset, + Clock, + PhantomConst(ThePhantomConst), +} + +impl SerdeCanonicalType { + pub(crate) fn as_serde_unexpected_str(&self) -> &'static str { + match self { + Self::UInt { .. } => "a UInt", + Self::SInt { .. } => "a SInt", + Self::Bool => "a Bool", + Self::Array { .. } => "an Array", + Self::Enum { .. } => "an Enum", + Self::Bundle { .. } => "a Bundle", + Self::AsyncReset => "an AsyncReset", + Self::SyncReset => "a SyncReset", + Self::Reset => "a Reset", + Self::Clock => "a Clock", + Self::PhantomConst(_) => "a PhantomConst", + } + } +} + +impl From for SerdeCanonicalType { + fn from(ty: T) -> Self { + let ty: CanonicalType = ty.into(); + match ty { + CanonicalType::UInt(ty) => Self::UInt { width: ty.width() }, + CanonicalType::SInt(ty) => Self::SInt { width: ty.width() }, + CanonicalType::Bool(Bool {}) => Self::Bool, + CanonicalType::Array(ty) => Self::Array { + element: ty.element(), + len: ty.len(), + }, + CanonicalType::Enum(ty) => Self::Enum { + variants: ty.variants(), + }, + CanonicalType::Bundle(ty) => Self::Bundle { + fields: ty.fields(), + }, + CanonicalType::AsyncReset(AsyncReset {}) => Self::AsyncReset, + CanonicalType::SyncReset(SyncReset {}) => Self::SyncReset, + CanonicalType::Reset(Reset {}) => Self::Reset, + CanonicalType::Clock(Clock {}) => Self::Clock, + CanonicalType::PhantomConst(ty) => Self::PhantomConst(SerdePhantomConst(ty.get())), + } + } +} + +impl From for CanonicalType { + fn from(ty: SerdeCanonicalType) -> Self { + match ty { + SerdeCanonicalType::UInt { width } => Self::UInt(UInt::new(width)), + SerdeCanonicalType::SInt { width } => Self::SInt(SInt::new(width)), + SerdeCanonicalType::Bool => Self::Bool(Bool), + SerdeCanonicalType::Array { element, len } => Self::Array(Array::new(element, len)), + SerdeCanonicalType::Enum { variants } => Self::Enum(Enum::new(variants)), + SerdeCanonicalType::Bundle { fields } => Self::Bundle(Bundle::new(fields)), + SerdeCanonicalType::AsyncReset => Self::AsyncReset(AsyncReset), + SerdeCanonicalType::SyncReset => Self::SyncReset(SyncReset), + SerdeCanonicalType::Reset => Self::Reset(Reset), + SerdeCanonicalType::Clock => Self::Clock(Clock), + SerdeCanonicalType::PhantomConst(value) => { + Self::PhantomConst(PhantomConst::new(value.0)) + } + } + } +} diff --git a/crates/fayalite/src/util/const_bool.rs b/crates/fayalite/src/util/const_bool.rs index 7033d6a..7def3b5 100644 --- a/crates/fayalite/src/util/const_bool.rs +++ b/crates/fayalite/src/util/const_bool.rs @@ -1,5 +1,9 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information +use serde::{ + de::{DeserializeOwned, Error, Unexpected}, + Deserialize, Deserializer, Serialize, Serializer, +}; use std::{fmt::Debug, hash::Hash, mem::ManuallyDrop, ptr}; mod sealed { @@ -9,7 +13,17 @@ mod sealed { /// # Safety /// the only implementation is `ConstBool` pub unsafe trait GenericConstBool: - sealed::Sealed + Copy + Ord + Hash + Default + Debug + 'static + Send + Sync + sealed::Sealed + + Copy + + Ord + + Hash + + Default + + Debug + + 'static + + Send + + Sync + + Serialize + + DeserializeOwned { const VALUE: bool; } @@ -30,6 +44,32 @@ unsafe impl GenericConstBool for ConstBool { const VALUE: bool = VALUE; } +impl Serialize for ConstBool { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + VALUE.serialize(serializer) + } +} + +impl<'de, const VALUE: bool> Deserialize<'de> for ConstBool { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value = bool::deserialize(deserializer)?; + if value == VALUE { + Ok(ConstBool) + } else { + Err(D::Error::invalid_value( + Unexpected::Bool(value), + &if VALUE { "true" } else { "false" }, + )) + } + } +} + pub trait ConstBoolDispatchTag { type Type; } diff --git a/crates/fayalite/src/util/const_usize.rs b/crates/fayalite/src/util/const_usize.rs index a605336..e098a12 100644 --- a/crates/fayalite/src/util/const_usize.rs +++ b/crates/fayalite/src/util/const_usize.rs @@ -1,5 +1,9 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information +use serde::{ + de::{DeserializeOwned, Error, Unexpected}, + Deserialize, Deserializer, Serialize, Serializer, +}; use std::{fmt::Debug, hash::Hash}; mod sealed { @@ -8,7 +12,17 @@ mod sealed { /// the only implementation is `ConstUsize` pub trait GenericConstUsize: - sealed::Sealed + Copy + Ord + Hash + Default + Debug + 'static + Send + Sync + sealed::Sealed + + Copy + + Ord + + Hash + + Default + + Debug + + 'static + + Send + + Sync + + Serialize + + DeserializeOwned { const VALUE: usize; } @@ -27,3 +41,29 @@ impl sealed::Sealed for ConstUsize {} impl GenericConstUsize for ConstUsize { const VALUE: usize = VALUE; } + +impl Serialize for ConstUsize { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + VALUE.serialize(serializer) + } +} + +impl<'de, const VALUE: usize> Deserialize<'de> for ConstUsize { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value = usize::deserialize(deserializer)?; + if value == VALUE { + Ok(ConstUsize) + } else { + Err(D::Error::invalid_value( + Unexpected::Unsigned(value as u64), + &&*VALUE.to_string(), + )) + } + } +} diff --git a/crates/fayalite/tests/hdl_types.rs b/crates/fayalite/tests/hdl_types.rs index b191016..8802fd4 100644 --- a/crates/fayalite/tests/hdl_types.rs +++ b/crates/fayalite/tests/hdl_types.rs @@ -4,11 +4,17 @@ use fayalite::{ bundle::BundleType, enum_::EnumType, int::{BoolOrIntType, IntType}, + phantom_const::PhantomConst, prelude::*, ty::StaticType, }; use std::marker::PhantomData; +#[hdl(outline_generated)] +pub struct MyConstSize { + pub size: PhantomConst>, +} + #[hdl(outline_generated)] pub struct S { pub a: T,