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 {
+                        <Self as ::fayalite::ty::StaticType>::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 {
+                        <Self as ::fayalite::ty::StaticType>::TYPE
+                    }
+                }
+                #[automatically_derived]
                 impl #static_impl_generics ::fayalite::ty::StaticType for #target #static_type_generics
                 #static_where_clause
                 {

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 {
+                        <Self as ::fayalite::ty::StaticType>::TYPE
+                    }
+                }
                 #[automatically_derived]
                 impl #static_impl_generics ::fayalite::ty::StaticType
                 for #target #static_type_generics

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<T: Type, Len: KnownSize + Size<SizeType = Len>> ArrayType<T, Len> {
     }
 }
 
+impl<T: StaticType, Len: KnownSize> Default for ArrayType<T, Len> {
+    fn default() -> Self {
+        Self::TYPE
+    }
+}
+
 impl<T: StaticType, Len: KnownSize> StaticType for ArrayType<T, Len> {
     const TYPE: Self = Self {
         element: LazyInterned::new_lazy(&|| T::TYPE.intern_sized()),
@@ -226,6 +233,50 @@ impl<T: Type, Len: Size> Type for ArrayType<T, Len> {
     }
 }
 
+impl<T: Type + Serialize, Len: Size> Serialize for ArrayType<T, Len> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        SerdeCanonicalType::<T>::Array {
+            element: self.element(),
+            len: self.len(),
+        }
+        .serialize(serializer)
+    }
+}
+
+impl<'de, T: Type + Deserialize<'de>, Len: Size> Deserialize<'de> for ArrayType<T, Len> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let name = |len| -> String {
+            if let Some(len) = len {
+                format!("an Array<_, {len}>")
+            } else {
+                "an Array<_>".to_string()
+            }
+        };
+        match SerdeCanonicalType::<T>::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<T: Type, Len: Size> TypeWithDeref for ArrayType<T, Len> {
     fn expr_deref(this: &Expr<Self>) -> &Self::MatchVariant {
         let retval = Vec::from_iter(*this);

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<str>,
     pub flipped: bool,

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<str>,
     pub ty: Option<CanonicalType>,

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<SizeType = Self>;
 }
 
 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<Element: Type>: AsRef<[Expr<Element>]>
         + AsMut<[Expr<Element>]>
@@ -191,6 +214,305 @@ impl<T: KnownSize> 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<usize>,
+    parse_type: bool,
+) -> Result<Arc<BitVec>, 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 > <BitSlice>::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::<Lsb0>()[..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<usize>,
+) -> Result<Arc<BitVec>, D::Error> {
+    struct IntValueVisitor {
+        type_is_signed: bool,
+        type_width: Option<usize>,
+    }
+    impl<'de> Visitor<'de> for IntValueVisitor {
+        type Value = Arc<BitVec>;
+
+        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<E: Error>(self, v: &str) -> Result<Self::Value, E> {
+            parse_int_value(v, self.type_is_signed, self.type_width, true).map_err(E::custom)
+        }
+
+        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(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<Self::Value, <Self::Value as FromStr>::Err> {
+                parse_int_value(s, $SIGNED, Some(self.width()), false).map(Self::Value::new)
+            }
         }
 
         impl<Width: Size> IntType for $name<Width> {
@@ -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<Width: KnownSize> Default for $name<Width> {
+            fn default() -> Self {
+                Self::TYPE
+            }
+        }
+
         impl<Width: KnownSize> StaticType for $name<Width> {
             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<Width: Size> Serialize for $name<Width> {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                self.canonical().serialize(serializer)
+            }
+        }
+
+        impl<'de, Width: Size> Deserialize<'de> for $name<Width> {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            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<Width>,
         }
 
-        impl<Width: Size> fmt::Debug for $value<Width> {
+        impl<Width: Size> fmt::Display for $value<Width> {
             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<Width: Size> fmt::Debug for $value<Width> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt::Display::fmt(self, f)
+            }
+        }
+
+        impl<Width: Size> std::str::FromStr for $value<Width> {
+            type Err = ParseIntValueError;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                parse_int_value(s, $SIGNED, Width::KNOWN_VALUE, true).map(Self::new)
+            }
+        }
+
+        impl<Width: Size> Serialize for $value<Width> {
+            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+                self.to_string().serialize(serializer)
+            }
+        }
+
+        impl<'de, Width: Size> Deserialize<'de> for $value<Width> {
+            fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+                deserialize_int_value(deserializer, $SIGNED, Width::KNOWN_VALUE).map(Self::new)
+            }
+        }
+
         impl<LhsWidth: Size, RhsWidth: Size> PartialEq<$value<RhsWidth>> for $value<LhsWidth> {
             fn eq(&self, other: &$value<RhsWidth>) -> 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<Type = Self>
-        + Into<BigInt>;
+        + Into<BigInt>
+        + std::str::FromStr;
     fn width(self) -> usize;
     fn new(width: <Self::Width as Size>::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<Self::Value, <Self::Value as FromStr>::Err>;
 }
 
-pub trait IntType: BoolOrIntType<BaseType = <Self as IntType>::Dyn> {
+pub trait IntType:
+    BoolOrIntType<BaseType = <Self as IntType>::Dyn, Value: FromStr<Err = ParseIntValueError>>
+{
     type Dyn: IntType<Dyn = Self::Dyn, Signed = Self::Signed, Width = DynSize>;
     fn as_dyn_int(self) -> Self::Dyn {
         Self::new_dyn(self.width())
@@ -752,7 +1157,7 @@ pub trait IntType: BoolOrIntType<BaseType = <Self as IntType>::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<Self::Value, <Self::Value as FromStr>::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<T: Serialize + DeserializeOwned + PartialEq + fmt::Debug>(
+            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<T: DeserializeOwned + fmt::Debug + PartialEq>(
+            expected: Result<T, &str>,
+            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::<UInt<0>>(
+            Err("invalid value: a UInt<2>, expected a UInt<0>"),
+            json! { { "UInt": { "width": 2 } } },
+        );
+        check::<UInt<0>>(
+            Err("invalid value: a Bool, expected a UInt<0>"),
+            json! { "Bool" },
+        );
+        check::<SInt<0>>(
+            Err("invalid value: a Bool, expected a SInt<0>"),
+            json! { "Bool" },
+        );
+        check::<UInt>(
+            Err("invalid value: a Bool, expected a UInt"),
+            json! { "Bool" },
+        );
+        check::<SInt>(
+            Err("invalid value: a Bool, expected a SInt"),
+            json! { "Bool" },
+        );
+        check::<UIntValue>(Err("value too large to fit in type"), json! { "2_u1" });
+        check::<UIntValue>(Err("value too large to fit in type"), json! { "10_u1" });
+        check::<UIntValue>(Err("value too large to fit in type"), json! { "0x2_u1" });
+        check::<UIntValue>(Err("value too large to fit in type"), json! { "0b10_u1" });
+        check::<UIntValue>(Err("value too large to fit in type"), json! { "0o2_u1" });
+        check::<SIntValue>(Err("value too large to fit in type"), json! { "0o377_i8" });
+        check::<SIntValue>(Err("value too large to fit in type"), json! { "0o200_i8" });
+        check(Ok(SInt[8].from_int_wrapping(i8::MAX)), json! { "0o177_i8" });
+        check::<SIntValue>(Err("value too small to fit in type"), json! { "-0o201_i8" });
+        check::<SIntValue>(Err("value too small to fit in type"), json! { "-0o377_i8" });
+        check::<SIntValue>(Err("value too small to fit in type"), json! { "-0o400_i8" });
+        check::<SIntValue>(
+            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" });
+    }
 }

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<T: ?Sized + PhantomConstValue = PhantomConstCanonicalVal
     value: LazyInterned<T>,
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
+pub struct PhantomConstWithoutGenerics;
+
+#[allow(non_upper_case_globals)]
+pub const PhantomConst: PhantomConstWithoutGenerics = PhantomConstWithoutGenerics;
+
+impl<T: Type + PhantomConstValue> Index<T> for PhantomConstWithoutGenerics {
+    type Output = PhantomConst<T>;
+
+    fn index(&self, value: T) -> &Self::Output {
+        Interned::into_inner(PhantomConst::new(value.intern()).intern_sized())
+    }
+}
+
 impl<T: ?Sized + PhantomConstValue> fmt::Debug for PhantomConst<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("PhantomConst").field(&self.get()).finish()
@@ -201,17 +222,6 @@ impl<T: ?Sized + PhantomConstValue> Memoize for PhantomConstCanonicalMemoize<T,
     }
 }
 
-impl<T: ?Sized + PhantomConstValue> PhantomConst<T>
-where
-    Interned<T>: Default,
-{
-    pub const fn default() -> Self {
-        PhantomConst {
-            value: LazyInterned::new_lazy(&Interned::<T>::default),
-        }
-    }
-}
-
 impl<T: ?Sized + PhantomConstValue> PhantomConst<T> {
     pub fn new(value: Interned<T>) -> Self {
         Self {
@@ -286,16 +296,53 @@ impl<T: ?Sized + PhantomConstValue> Type for PhantomConst<T> {
     }
 }
 
+impl<T: ?Sized + PhantomConstValue> Default for PhantomConst<T>
+where
+    Interned<T>: Default,
+{
+    fn default() -> Self {
+        Self::TYPE
+    }
+}
+
 impl<T: ?Sized + PhantomConstValue> StaticType for PhantomConst<T>
 where
     Interned<T>: Default,
 {
-    const TYPE: Self = Self::default();
+    const TYPE: Self = PhantomConst {
+        value: LazyInterned::new_lazy(&Interned::<T>::default),
+    };
     const MASK_TYPE: Self::MaskType = ();
     const TYPE_PROPERTIES: TypeProperties = <()>::TYPE_PROPERTIES;
     const MASK_TYPE_PROPERTIES: TypeProperties = <()>::TYPE_PROPERTIES;
 }
 
+type SerdeType<T> = SerdeCanonicalType<CanonicalType, SerdePhantomConst<Interned<T>>>;
+
+impl<T: ?Sized + PhantomConstValue> Serialize for PhantomConst<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        SerdeType::<T>::PhantomConst(SerdePhantomConst(self.get())).serialize(serializer)
+    }
+}
+
+impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for PhantomConst<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        match SerdeType::<T>::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<T: ?Sized + PhantomConstValue> ExprPartialEq<Self> for PhantomConst<T> {
     fn cmp_eq(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
         assert_eq!(Expr::ty(lhs), Expr::ty(rhs));

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<T: Type> AlternatingCellMethods for SimValueInner<T> {
     fn shared_to_unique(&mut self) {}
 }
 
+#[derive(Serialize, Deserialize)]
+#[serde(rename = "SimValue")]
+#[serde(bound(
+    serialize = "T: Type<SimValue: Serialize> + Serialize",
+    deserialize = "T: Type<SimValue: Deserialize<'de>> + Deserialize<'de>"
+))]
+struct SerdeSimValue<'a, T: Type> {
+    ty: T,
+    value: std::borrow::Cow<'a, T::SimValue>,
+}
+
+impl<T: Type<SimValue: Serialize> + Serialize> Serialize for SimValue<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        SerdeSimValue {
+            ty: SimValue::ty(self),
+            value: std::borrow::Cow::Borrowed(&*self),
+        }
+        .serialize(serializer)
+    }
+}
+
+impl<'de, T: Type<SimValue: Deserialize<'de>> + Deserialize<'de>> Deserialize<'de> for SimValue<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let SerdeSimValue { ty, value } = SerdeSimValue::<T>::deserialize(deserializer)?;
+        Ok(SimValue::from_value(ty, value.into_owned()))
+    }
+}
+
 pub struct SimValue<T: Type> {
     inner: AlternatingCell<SimValueInner<T>>,
 }

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<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serde_impls::SerdeCanonicalType::from(*self).serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for CanonicalType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    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<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                self.canonical().serialize(serializer)
+            }
+        }
+
+        impl<'de> Deserialize<'de> for $name {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            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<BaseType = Self> + sealed::BaseTypeSealed + Into<CanonicalType> {}
+pub trait BaseType:
+    Type<
+        BaseType = Self,
+        MaskType: Serialize + DeserializeOwned,
+        SimValue: Serialize + DeserializeOwned,
+    > + sealed::BaseTypeSealed
+    + Into<CanonicalType>
+    + 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<T: Type<SimValue = OpaqueSimValue>> ToSimValueWithType<T> for OpaqueSimValu
     }
 }
 
-pub trait StaticType: Type {
+pub trait StaticType: Type + Default {
     const TYPE: Self;
     const MASK_TYPE: Self::MaskType;
     const TYPE_PROPERTIES: TypeProperties;

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<T>(pub T);
+
+impl<T: ?Sized + PhantomConstValue> Serialize for SerdePhantomConst<Interned<T>> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for SerdePhantomConst<Interned<T>> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        T::deserialize_value(deserializer).map(Self)
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename = "CanonicalType")]
+pub(crate) enum SerdeCanonicalType<
+    ArrayElement = CanonicalType,
+    ThePhantomConst = SerdePhantomConst<Interned<PhantomConstCanonicalValue>>,
+> {
+    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<ArrayElement, PhantomConstInner> SerdeCanonicalType<ArrayElement, PhantomConstInner> {
+    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<T: BaseType> From<T> 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<SerdeCanonicalType> 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))
+            }
+        }
+    }
+}

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<Self::VALUE>`
 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<const VALUE: bool> GenericConstBool for ConstBool<VALUE> {
     const VALUE: bool = VALUE;
 }
 
+impl<const VALUE: bool> Serialize for ConstBool<VALUE> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        VALUE.serialize(serializer)
+    }
+}
+
+impl<'de, const VALUE: bool> Deserialize<'de> for ConstBool<VALUE> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    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<Select: GenericConstBool>;
 }

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<Self::VALUE>`
 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<const VALUE: usize> sealed::Sealed for ConstUsize<VALUE> {}
 impl<const VALUE: usize> GenericConstUsize for ConstUsize<VALUE> {
     const VALUE: usize = VALUE;
 }
+
+impl<const VALUE: usize> Serialize for ConstUsize<VALUE> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        VALUE.serialize(serializer)
+    }
+}
+
+impl<'de, const VALUE: usize> Deserialize<'de> for ConstUsize<VALUE> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    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(),
+            ))
+        }
+    }
+}

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<V: Size> {
+    pub size: PhantomConst<UIntType<V>>,
+}
+
 #[hdl(outline_generated)]
 pub struct S<T, Len: Size, T2> {
     pub a: T,