sim: properly update all VCD wires when they share simulation state

also cleans up default debug formatting to use the struct/enum name
(or MaskType<StructName>) instead of the implementation detail type name.

crates/fayalite-proc-macros-impl/src/fold.rs

@@ -257,5 +257,6 @@ no_op_fold!(syn::Token![let]);
 no_op_fold!(syn::Token![mut]);
 no_op_fold!(syn::Token![static]);
 no_op_fold!(syn::Token![struct]);
+no_op_fold!(syn::Token![type]);
 no_op_fold!(syn::Token![where]);
 no_op_fold!(usize);

crates/fayalite-proc-macros-impl/src/hdl_bundle.rs

@@ -3,8 +3,9 @@
 use crate::{
     Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedField, ParsedFieldsNamed, ParsedGenerics,
-        SplitForImpl, TypesParser, WrappedInConst, common_derives, get_target,
+        CustomDebugOptions, CustomDebugTrait, ItemOptions, MakeHdlTypeExpr, MaybeParsed,
+        ParsedField, ParsedFieldsNamed, ParsedGenerics, SplitForImpl, TypesParser, WrappedInConst,
+        common_derives, create_struct_debug_impl, get_target,
     },
     kw,
 };
@@ -30,6 +31,7 @@ pub(crate) struct ParsedBundle {
     pub(crate) fields: MaybeParsed<ParsedFieldsNamed, FieldsNamed>,
     pub(crate) field_flips: Vec<Option<HdlAttr<kw::flip, kw::hdl>>>,
     pub(crate) mask_type_ident: Ident,
+    pub(crate) mask_type_name: String,
     pub(crate) mask_type_match_variant_ident: Ident,
     pub(crate) mask_type_sim_value_ident: Ident,
     pub(crate) match_variant_ident: Ident,
@@ -88,6 +90,8 @@ impl ParsedBundle {
             no_runtime_generics: _,
             cmp_eq: _,
             ref get,
+            custom_debug: _,
+            custom_sim_display: _,
         } = options.body;
         if let Some((get, ..)) = get {
             errors.error(get, "#[hdl(get(...))] is not allowed on structs");
@@ -131,6 +135,7 @@ impl ParsedBundle {
             fields,
             field_flips,
             mask_type_ident: format_ident!("__{}__MaskType", ident),
+            mask_type_name: format!("MaskType<{}>", ident),
             mask_type_match_variant_ident: format_ident!("__{}__MaskType__MatchVariant", ident),
             mask_type_sim_value_ident: format_ident!("__{}__MaskType__SimValue", ident),
             match_variant_ident: format_ident!("__{}__MatchVariant", ident),
@@ -448,6 +453,7 @@ impl ToTokens for ParsedBundle {
             fields,
             field_flips,
             mask_type_ident,
+            mask_type_name,
             mask_type_match_variant_ident,
             mask_type_sim_value_ident,
             match_variant_ident,
@@ -464,11 +470,20 @@ impl ToTokens for ParsedBundle {
             no_runtime_generics,
             cmp_eq,
             get: _,
+            custom_debug: _,
+            custom_sim_display,
         } = &options.body;
+        let CustomDebugOptions {
+            type_: custom_debug_type,
+            sim: custom_debug_sim,
+            mask_type: custom_debug_mask_type,
+            mask_sim: custom_debug_mask_sim,
+        } = options.body.custom_debug();
         let target = get_target(target, ident);
+        let struct_name = ident.to_string();
         let mut item_attrs = attrs.clone();
-        item_attrs.push(common_derives(span));
-        ItemStruct {
+        item_attrs.push(common_derives(span, false));
+        let type_struct = ItemStruct {
             attrs: item_attrs,
             vis: vis.clone(),
             struct_token: *struct_token,
@@ -476,8 +491,8 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(fields.clone().into()),
             semi_token: None,
-        }
-        .to_tokens(tokens);
+        };
+        type_struct.to_tokens(tokens);
         let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
         if let (MaybeParsed::Parsed(generics), MaybeParsed::Parsed(fields), None) =
             (generics, fields, no_runtime_generics)
@@ -503,6 +518,9 @@ impl ToTokens for ParsedBundle {
         }
         let mut wrapped_in_const = WrappedInConst::new(tokens, span);
         let tokens = wrapped_in_const.inner();
+        if custom_debug_type.is_none() {
+            create_struct_debug_impl(&type_struct, &struct_name, None).to_tokens(tokens);
+        }
         let builder = Builder {
             vis: vis.clone(),
             struct_token: *struct_token,
@@ -530,9 +548,9 @@ impl ToTokens for ParsedBundle {
         mask_type_builder.to_tokens(tokens);
         let unfilled_mask_type_builder_ty =
             mask_type_builder.builder_struct_ty(|_| BuilderFieldState::Unfilled);
-        ItemStruct {
+        let mask_type_struct = ItemStruct {
             attrs: vec![
-                common_derives(span),
+                common_derives(span, false),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -543,17 +561,20 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(mask_type_fields.clone()),
             semi_token: None,
+        };
+        mask_type_struct.to_tokens(tokens);
+        if custom_debug_mask_type.is_none() {
+            create_struct_debug_impl(&mask_type_struct, mask_type_name, None).to_tokens(tokens);
         }
-        .to_tokens(tokens);
         let mut mask_type_match_variant_fields = mask_type_fields.clone();
         for Field { ty, .. } in &mut mask_type_match_variant_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::expr::Expr<#ty>
             };
         }
-        ItemStruct {
+        let mask_type_match_variant_struct = ItemStruct {
             attrs: vec![
-                common_derives(span),
+                common_derives(span, false),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -564,17 +585,19 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(mask_type_match_variant_fields),
             semi_token: None,
-        }
-        .to_tokens(tokens);
+        };
+        mask_type_match_variant_struct.to_tokens(tokens);
+        create_struct_debug_impl(&mask_type_match_variant_struct, mask_type_name, None)
+            .to_tokens(tokens);
         let mut match_variant_fields = FieldsNamed::from(fields.clone());
         for Field { ty, .. } in &mut match_variant_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::expr::Expr<#ty>
             };
         }
-        ItemStruct {
+        let match_variant_struct = ItemStruct {
             attrs: vec![
-                common_derives(span),
+                common_derives(span, false),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -585,19 +608,19 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(match_variant_fields),
             semi_token: None,
-        }
-        .to_tokens(tokens);
+        };
+        match_variant_struct.to_tokens(tokens);
+        create_struct_debug_impl(&match_variant_struct, &struct_name, None).to_tokens(tokens);
         let mut mask_type_sim_value_fields = mask_type_fields;
         for Field { ty, .. } in &mut mask_type_sim_value_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::sim::value::SimValue<#ty>
             };
         }
-        ItemStruct {
+        let mask_type_sim_value_struct = ItemStruct {
             attrs: vec![
                 parse_quote_spanned! {span=>
                     #[::fayalite::__std::prelude::v1::derive(
-                        ::fayalite::__std::fmt::Debug,
                         ::fayalite::__std::clone::Clone,
                     )]
                 },
@@ -611,19 +634,34 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(mask_type_sim_value_fields),
             semi_token: None,
+        };
+        mask_type_sim_value_struct.to_tokens(tokens);
+        if custom_debug_mask_sim.is_none() {
+            create_struct_debug_impl(
+                &mask_type_struct,
+                mask_type_name,
+                Some(CustomDebugTrait {
+                    trait_path: &parse_quote_spanned! {span=>
+                        ::fayalite::ty::SimValueDebug
+                    },
+                    fn_name: &format_ident!("sim_value_debug", span = span),
+                    this_arg: &parse_quote_spanned! {span=>
+                        value: &<Self as ::fayalite::ty::Type>::SimValue
+                    },
+                }),
+            )
+            .to_tokens(tokens);
         }
-        .to_tokens(tokens);
         let mut sim_value_fields = FieldsNamed::from(fields.clone());
         for Field { ty, .. } in &mut sim_value_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::sim::value::SimValue<#ty>
             };
         }
-        ItemStruct {
+        let sim_value_struct = ItemStruct {
             attrs: vec![
                 parse_quote_spanned! {span=>
                     #[::fayalite::__std::prelude::v1::derive(
-                        ::fayalite::__std::fmt::Debug,
                         ::fayalite::__std::clone::Clone,
                     )]
                 },
@@ -637,8 +675,36 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(sim_value_fields),
             semi_token: None,
+        };
+        sim_value_struct.to_tokens(tokens);
+        if custom_debug_sim.is_none() {
+            create_struct_debug_impl(
+                &type_struct,
+                &struct_name,
+                Some(CustomDebugTrait {
+                    trait_path: &parse_quote_spanned! {span=>
+                        ::fayalite::ty::SimValueDebug
+                    },
+                    fn_name: &format_ident!("sim_value_debug", span = span),
+                    this_arg: &parse_quote_spanned! {span=>
+                        value: &<Self as ::fayalite::ty::Type>::SimValue
+                    },
+                }),
+            )
+            .to_tokens(tokens);
+        }
+        if custom_sim_display.is_some() {
+            quote_spanned! {span=>
+                #[automatically_derived]
+                impl #impl_generics ::fayalite::__std::fmt::Display for #sim_value_ident #type_generics
+                #where_clause
+                {
+                    fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                        <#target #type_generics as ::fayalite::ty::SimValueDisplay>::sim_value_display(self, f)
+                    }
+                }
+            }.to_tokens(tokens);
         }
-        .to_tokens(tokens);
         let this_token = Ident::new("__this", span);
         let fields_token = Ident::new("__fields", span);
         let self_token = Token![self](span);
@@ -820,6 +886,14 @@ impl ToTokens for ParsedBundle {
                 }
             }
             #[automatically_derived]
+            impl #impl_generics ::fayalite::__std::fmt::Debug for #mask_type_sim_value_ident #type_generics
+            #where_clause
+            {
+                fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                    <#mask_type_ident #type_generics as ::fayalite::ty::SimValueDebug>::sim_value_debug(self, f)
+                }
+            }
+            #[automatically_derived]
             impl #impl_generics ::fayalite::expr::ValueType for #mask_type_sim_value_ident #type_generics
             #where_clause
             {
@@ -980,6 +1054,14 @@ impl ToTokens for ParsedBundle {
                 }
             }
             #[automatically_derived]
+            impl #impl_generics ::fayalite::__std::fmt::Debug for #sim_value_ident #type_generics
+            #where_clause
+            {
+                fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                    <#target #type_generics as ::fayalite::ty::SimValueDebug>::sim_value_debug(self, f)
+                }
+            }
+            #[automatically_derived]
             impl #impl_generics ::fayalite::expr::ValueType for #sim_value_ident #type_generics
             #where_clause
             {
@@ -1141,7 +1223,7 @@ impl ToTokens for ParsedBundle {
                 valueless_eq_body = quote_spanned! {span=>
                     let __lhs = ::fayalite::expr::ValueType::ty(&__lhs);
                     let __rhs = ::fayalite::expr::ValueType::ty(&__rhs);
-                    #(#fields_valueless_eq)|*
+                    #(#fields_valueless_eq)&*
                 };
                 valueless_ne_body = quote_spanned! {span=>
                     let __lhs = ::fayalite::expr::ValueType::ty(&__lhs);

crates/fayalite-proc-macros-impl/src/hdl_enum.rs

@@ -3,8 +3,9 @@
 use crate::{
     Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType, SplitForImpl,
-        TypesParser, WrappedInConst, common_derives, get_target,
+        CustomDebugOptions, ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType,
+        SplitForImpl, TypesParser, WrappedInConst, common_derives, create_struct_debug_impl,
+        get_target,
     },
     kw,
 };
@@ -158,15 +159,32 @@ impl ParsedEnum {
             custom_bounds,
             no_static: _,
             no_runtime_generics: _,
-            cmp_eq,
+            cmp_eq: _,
             ref get,
+            custom_debug: _,
+            custom_sim_display: _,
         } = options.body;
-        if let Some((cmp_eq,)) = cmp_eq {
-            errors.error(cmp_eq, "#[hdl(cmp_eq)] is not yet implemented for enums");
-        }
         if let Some((get, ..)) = get {
             errors.error(get, "#[hdl(get(...))] is not allowed on enums");
         }
+        let CustomDebugOptions {
+            type_: _,
+            sim: _,
+            mask_type,
+            mask_sim,
+        } = options.body.custom_debug();
+        if let Some((mask_type,)) = mask_type {
+            errors.error(
+                mask_type,
+                "#[hdl(custom_debug(mask_type)] is not allowed on enums",
+            );
+        }
+        if let Some((mask_sim,)) = mask_sim {
+            errors.error(
+                mask_sim,
+                "#[hdl(custom_debug(mask_sim)] is not allowed on enums",
+            );
+        }
         attrs.retain(|attr| {
             if attr.path().is_ident("repr") {
                 errors.error(attr, "#[repr] is not supported on #[hdl] enums");
@@ -228,12 +246,21 @@ impl ToTokens for ParsedEnum {
             custom_bounds: _,
             no_static,
             no_runtime_generics,
-            cmp_eq: _, // TODO: implement cmp_eq for enums
+            cmp_eq,
             get: _,
+            custom_debug: _,
+            custom_sim_display,
         } = &options.body;
+        let CustomDebugOptions {
+            type_: custom_debug_type,
+            sim: custom_debug_sim,
+            mask_type: _,
+            mask_sim: _,
+        } = options.body.custom_debug();
         let target = get_target(target, ident);
+        let enum_name = ident.to_string();
         let mut struct_attrs = attrs.clone();
-        struct_attrs.push(common_derives(span));
+        struct_attrs.push(common_derives(span, false));
         struct_attrs.push(parse_quote_spanned! {span=>
             #[allow(non_snake_case)]
         });
@@ -273,7 +300,7 @@ impl ToTokens for ParsedEnum {
                 }
             },
         ));
-        ItemStruct {
+        let type_struct = ItemStruct {
             attrs: struct_attrs,
             vis: vis.clone(),
             struct_token: Token![struct](enum_token.span),
@@ -288,8 +315,8 @@ impl ToTokens for ParsedEnum {
                 })
             },
             semi_token: None,
-        }
-        .to_tokens(tokens);
+        };
+        type_struct.to_tokens(tokens);
         let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
         if let (MaybeParsed::Parsed(generics), None) = (generics, no_runtime_generics) {
             generics.make_runtime_generics(tokens, vis, ident, &target, |context| {
@@ -373,6 +400,9 @@ impl ToTokens for ParsedEnum {
             }
             .to_tokens(tokens);
         }
+        if custom_debug_type.is_none() {
+            create_struct_debug_impl(&type_struct, &enum_name, None).to_tokens(tokens);
+        }
         let mut enum_attrs = attrs.clone();
         enum_attrs.push(parse_quote_spanned! {span=>
             #[allow(dead_code, non_camel_case_types)]
@@ -453,7 +483,6 @@ impl ToTokens for ParsedEnum {
         let mut enum_attrs = attrs.clone();
         enum_attrs.push(parse_quote_spanned! {span=>
             #[::fayalite::__std::prelude::v1::derive(
-                ::fayalite::__std::fmt::Debug,
                 ::fayalite::__std::clone::Clone,
             )]
         });
@@ -838,6 +867,240 @@ impl ToTokens for ParsedEnum {
                     },
                 )),
         );
+        if custom_debug_sim.is_none() {
+            let debug_match_arms = Vec::from_iter(
+                variants
+                    .iter()
+                    .map(
+                        |ParsedVariant {
+                             attrs: _,
+                             options: _,
+                             ident,
+                             field,
+                         }| {
+                            let variant_name = ident.to_string();
+                            if let Some(_) = field {
+                                quote_spanned! {span=>
+                                    #sim_value_ident::#ident(field, _) => {
+                                        f.debug_tuple(#variant_name).field(field).finish()
+                                    }
+                                }
+                            } else {
+                                quote_spanned! {span=>
+                                    #sim_value_ident::#ident(_) => {
+                                        f.write_str(#variant_name)
+                                    }
+                                }
+                            }
+                        },
+                    )
+                    .chain(sim_value_unknown_variant_name.as_ref().map(
+                        |sim_value_unknown_variant_name| {
+                            let sim_value_unknown_variant_name_str =
+                                sim_value_unknown_variant_name.to_string();
+                            quote_spanned! {span=>
+                                #sim_value_ident::#sim_value_unknown_variant_name(_) => {
+                                    f.write_str(#sim_value_unknown_variant_name_str)
+                                }
+                            }
+                        },
+                    )),
+            );
+            quote_spanned! {span=>
+                #[automatically_derived]
+                impl #impl_generics ::fayalite::ty::SimValueDebug for #target #type_generics
+                #where_clause
+                {
+                    fn sim_value_debug(
+                        value: &<Self as ::fayalite::ty::Type>::SimValue,
+                        f: &mut ::fayalite::__std::fmt::Formatter<'_>,
+                    ) -> ::fayalite::__std::fmt::Result {
+                        match value {
+                            #(#debug_match_arms)*
+                        }
+                    }
+                }
+            }
+            .to_tokens(tokens);
+        }
+        if custom_sim_display.is_some() {
+            quote_spanned! {span=>
+                #[automatically_derived]
+                impl #impl_generics ::fayalite::__std::fmt::Display for #sim_value_ident #type_generics
+                #where_clause
+                {
+                    fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                        <#target #type_generics as ::fayalite::ty::SimValueDisplay>::sim_value_display(self, f)
+                    }
+                }
+            }.to_tokens(tokens);
+        }
+        if let Some((cmp_eq,)) = cmp_eq {
+            let mut cmp_eq_where_clause =
+                Generics::from(generics)
+                    .where_clause
+                    .unwrap_or_else(|| syn::WhereClause {
+                        where_token: Token![where](span),
+                        predicates: Punctuated::new(),
+                    });
+            let mut variants_value_eq = vec![];
+            let mut variants_expr_eq = vec![];
+            let mut fields_valueless_eq = vec![];
+            for (
+                variant_index,
+                ParsedVariant {
+                    attrs: _,
+                    options: variant_options,
+                    ident: variant_ident,
+                    field,
+                },
+            ) in variants.iter().enumerate()
+            {
+                let VariantOptions {} = variant_options.body;
+                if let Some(ParsedVariantField {
+                    paren_token: _,
+                    attrs: _,
+                    options: field_options,
+                    ty: field_ty,
+                    comma_token: _,
+                }) = field
+                {
+                    let FieldOptions {} = field_options.body;
+                    cmp_eq_where_clause
+                        .predicates
+                        .push(parse_quote_spanned! {cmp_eq.span=>
+                            #field_ty: ::fayalite::expr::HdlPartialEqImpl<#field_ty>
+                        });
+                    variants_value_eq.push(quote_spanned! {span=>
+                        (#sim_value_ident::#variant_ident(__lhs_field, _), #sim_value_ident::#variant_ident(__rhs_field, _)) => {
+                            ::fayalite::expr::HdlPartialEqImpl::cmp_value_eq(
+                                __lhs.#variant_ident,
+                                ::fayalite::__std::borrow::Cow::Borrowed(__lhs_field),
+                                __rhs.#variant_ident,
+                                ::fayalite::__std::borrow::Cow::Borrowed(__rhs_field),
+                            )
+                        }
+                    });
+                    variants_expr_eq.push(quote_spanned! {span=>
+                        {
+                            let (#match_variant_ident::#variant_ident(__lhs), __scope) =
+                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
+                                    ::fayalite::__std::iter::Iterator::next(&mut __lhs_match_variant_iter)
+                                        .expect("known to have enough variants"),
+                                )
+                            else {
+                                ::fayalite::__std::unreachable!();
+                            };
+                            let (#match_variant_ident::#variant_ident(__rhs), __scope) =
+                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
+                                    ::fayalite::__std::iter::Iterator::nth(
+                                        &mut ::fayalite::module::match_(__rhs),
+                                        #variant_index,
+                                    )
+                                        .expect("known to have variant"),
+                                )
+                            else {
+                                ::fayalite::__std::unreachable!();
+                            };
+                            ::fayalite::module::connect(__retval, ::fayalite::expr::HdlPartialEqImpl::cmp_expr_eq(__lhs, __rhs));
+                        }
+                    });
+                    fields_valueless_eq.push(quote_spanned! {span=>
+                        ::fayalite::expr::HdlPartialEqImpl::cmp_valueless_eq(
+                            ::fayalite::expr::Valueless::new(__lhs.#variant_ident),
+                            ::fayalite::expr::Valueless::new(__rhs.#variant_ident),
+                        )
+                    });
+                } else {
+                    variants_value_eq.push(quote_spanned! {span=>
+                        (#sim_value_ident::#variant_ident(_), #sim_value_ident::#variant_ident(_)) => true,
+                    });
+                    variants_expr_eq.push(quote_spanned! {span=>
+                        {
+                            let (#match_variant_ident::#variant_ident, __scope) =
+                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
+                                    ::fayalite::__std::iter::Iterator::next(&mut __lhs_match_variant_iter)
+                                        .expect("known to have enough variants"),
+                                )
+                            else {
+                                ::fayalite::__std::unreachable!();
+                            };
+                            let (#match_variant_ident::#variant_ident, __scope) =
+                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
+                                    ::fayalite::__std::iter::Iterator::nth(
+                                        &mut ::fayalite::module::match_(__rhs),
+                                        #variant_index,
+                                    )
+                                        .expect("known to have variant"),
+                                )
+                            else {
+                                ::fayalite::__std::unreachable!();
+                            };
+                            ::fayalite::module::connect(__retval, true);
+                        }
+                    });
+                }
+            }
+            if let Some(sim_value_unknown_variant_name) = &sim_value_unknown_variant_name {
+                variants_value_eq.push(quote_spanned! {span=>
+                    (#sim_value_ident::#sim_value_unknown_variant_name(__lhs_unknown), #sim_value_ident::#sim_value_unknown_variant_name(__rhs_unknown)) => {
+                        __lhs_unknown == __rhs_unknown
+                    }
+                });
+            }
+            let valueless_eq_body = if fields_valueless_eq.is_empty() {
+                quote_spanned! {span=>
+                    ::fayalite::expr::Valueless::new(::fayalite::int::Bool)
+                }
+            } else {
+                quote_spanned! {span=>
+                    let __lhs = ::fayalite::expr::ValueType::ty(&__lhs);
+                    let __rhs = ::fayalite::expr::ValueType::ty(&__rhs);
+                    #(#fields_valueless_eq)&*
+                }
+            };
+            let cmp_expr_eq_wire_name = format!("{ident}_cmp_eq");
+            quote_spanned! {span=>
+                #[automatically_derived]
+                impl #impl_generics ::fayalite::expr::HdlPartialEqImpl<Self> for #target #type_generics
+                #cmp_eq_where_clause
+                {
+                    #[track_caller]
+                    fn cmp_value_eq(
+                        __lhs: Self,
+                        __lhs_value: ::fayalite::__std::borrow::Cow<'_, <Self as ::fayalite::ty::Type>::SimValue>,
+                        __rhs: Self,
+                        __rhs_value: ::fayalite::__std::borrow::Cow<'_, <Self as ::fayalite::ty::Type>::SimValue>,
+                    ) -> ::fayalite::__std::primitive::bool {
+                        match (&*__lhs_value, &*__rhs_value) {
+                            #(#variants_value_eq)*
+                            _ => false,
+                        }
+                    }
+
+                    #[track_caller]
+                    fn cmp_expr_eq(
+                        __lhs: ::fayalite::expr::Expr<Self>,
+                        __rhs: ::fayalite::expr::Expr<Self>,
+                    ) -> ::fayalite::expr::Expr<::fayalite::int::Bool> {
+                        let __retval = ::fayalite::module::wire(::fayalite::module::ImplicitName(#cmp_expr_eq_wire_name), ::fayalite::int::Bool);
+                        ::fayalite::module::connect(__retval, false);
+                        let mut __lhs_match_variant_iter = ::fayalite::module::match_(__lhs);
+                        #(#variants_expr_eq)*
+                        __retval
+                    }
+
+                    #[track_caller]
+                    fn cmp_valueless_eq(
+                        __lhs: ::fayalite::expr::Valueless<Self>,
+                        __rhs: ::fayalite::expr::Valueless<Self>,
+                    ) -> ::fayalite::expr::Valueless<::fayalite::int::Bool> {
+                        #valueless_eq_body
+                    }
+                }
+            }
+            .to_tokens(tokens);
+        }
         let variants_len = variants.len();
         quote_spanned! {span=>
             #[automatically_derived]
@@ -934,6 +1197,14 @@ impl ToTokens for ParsedEnum {
                 }
             }
             #[automatically_derived]
+            impl #impl_generics ::fayalite::__std::fmt::Debug for #sim_value_ident #type_generics
+            #where_clause
+            {
+                fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                    <#target #type_generics as ::fayalite::ty::SimValueDebug>::sim_value_debug(self, f)
+                }
+            }
+            #[automatically_derived]
             impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#target #type_generics>
             for #sim_value_ident #type_generics
             #where_clause

crates/fayalite-proc-macros-impl/src/hdl_type_alias.rs

@@ -215,6 +215,8 @@ impl ParsedTypeAlias {
             no_runtime_generics,
             cmp_eq,
             get: _,
+            ref custom_debug,
+            custom_sim_display,
         } = options.body;
         if let Some((no_static,)) = no_static {
             errors.error(no_static, "no_static is not valid on type aliases");
@@ -234,6 +236,15 @@ impl ParsedTypeAlias {
         if let Some((cmp_eq,)) = cmp_eq {
             errors.error(cmp_eq, "cmp_eq is not valid on type aliases");
         }
+        if let Some((custom_debug, _, _)) = custom_debug {
+            errors.error(custom_debug, "custom_debug is not valid on type aliases");
+        }
+        if let Some((custom_sim_display,)) = custom_sim_display {
+            errors.error(
+                custom_sim_display,
+                "custom_sim_display is not valid on type aliases",
+            );
+        }
         if let Some((custom_bounds,)) = custom_bounds {
             errors.error(
                 custom_bounds,
@@ -287,6 +298,8 @@ impl ParsedTypeAlias {
             no_runtime_generics: _,
             cmp_eq,
             ref mut get,
+            ref custom_debug,
+            custom_sim_display,
         } = options.body;
         if let Some(get) = get.take() {
             return Self::parse_phantom_const_accessor(
@@ -311,6 +324,15 @@ impl ParsedTypeAlias {
         if let Some((cmp_eq,)) = cmp_eq {
             errors.error(cmp_eq, "cmp_eq is not valid on type aliases");
         }
+        if let Some((custom_debug, _, _)) = custom_debug {
+            errors.error(custom_debug, "custom_debug is not valid on type aliases");
+        }
+        if let Some((custom_sim_display,)) = custom_sim_display {
+            errors.error(
+                custom_sim_display,
+                "custom_sim_display is not valid on type aliases",
+            );
+        }
         let generics = if custom_bounds.is_some() {
             MaybeParsed::Unrecognized(generics)
         } else if let Some(generics) = errors.ok(ParsedGenerics::parse(&mut generics)) {
@@ -356,6 +378,8 @@ impl ToTokens for ParsedTypeAlias {
                     no_runtime_generics,
                     cmp_eq: _,
                     get: _,
+                    custom_debug: _,
+                    custom_sim_display: _,
                 } = &options.body;
                 let target = get_target(target, ident);
                 let mut type_attrs = attrs.clone();
@@ -402,6 +426,8 @@ impl ToTokens for ParsedTypeAlias {
                     no_runtime_generics: _,
                     cmp_eq: _,
                     get: _,
+                    custom_debug: _,
+                    custom_sim_display: _,
                 } = &options.body;
                 let span = ident.span();
                 let mut type_attrs = attrs.clone();
@@ -427,7 +453,7 @@ impl ToTokens for ParsedTypeAlias {
                     format_ident!("__{}__GenericsAccumulation", ident);
                 ItemStruct {
                     attrs: vec![
-                        common_derives(span),
+                        common_derives(span, true),
                         parse_quote_spanned! {span=>
                             #[allow(non_camel_case_types)]
                         },

crates/fayalite-proc-macros-impl/src/hdl_type_common.rs

@@ -7,10 +7,10 @@ use std::{collections::HashMap, fmt, mem};
 use syn::{
     AngleBracketedGenericArguments, Attribute, Block, ConstParam, Expr, ExprBlock, ExprGroup,
     ExprIndex, ExprParen, ExprPath, ExprTuple, Field, FieldMutability, Fields, FieldsNamed,
-    FieldsUnnamed, GenericArgument, GenericParam, Generics, Ident, ImplGenerics, Index, ItemStruct,
-    Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, TraitBound, Turbofish,
-    Type, TypeGenerics, TypeGroup, TypeParam, TypeParamBound, TypeParen, TypePath, TypeTuple,
-    Visibility, WhereClause, WherePredicate,
+    FieldsUnnamed, FnArg, GenericArgument, GenericParam, Generics, Ident, ImplGenerics, Index,
+    ItemStruct, Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, TraitBound,
+    Turbofish, Type, TypeGenerics, TypeGroup, TypeParam, TypeParamBound, TypeParen, TypePath,
+    TypeTuple, Visibility, WhereClause, WherePredicate,
     parse::{Parse, ParseStream},
     parse_quote, parse_quote_spanned,
     punctuated::{Pair, Punctuated},
@@ -18,6 +18,17 @@ use syn::{
     token::{Brace, Bracket, Paren},
 };
 
+crate::options! {
+    #[options = CustomDebugOptions]
+    #[no_ident_fragment]
+    pub(crate) enum CustomDebugOption {
+        Type(type_),
+        Sim(sim),
+        MaskType(mask_type),
+        MaskSim(mask_sim),
+    }
+}
+
 crate::options! {
     #[options = ItemOptions]
     pub(crate) enum ItemOption {
@@ -28,6 +39,8 @@ crate::options! {
         NoRuntimeGenerics(no_runtime_generics),
         CmpEq(cmp_eq),
         Get(get, Expr),
+        CustomDebug(custom_debug, CustomDebugOptions),
+        CustomSimDisplay(custom_sim_display),
     }
 }
 
@@ -41,8 +54,36 @@ impl ItemOptions {
         {
             self.no_static = Some((kw::no_static(custom_bounds.span),));
         }
+        if let Some((kw, _, custom_debug)) = &mut self.custom_debug {
+            if let CustomDebugOptions {
+                type_: None,
+                sim: None,
+                mask_type: None,
+                mask_sim: None,
+            } = custom_debug
+            {
+                *custom_debug = CustomDebugOptions {
+                    type_: Some((kw::type_(kw.span),)),
+                    sim: Some((kw::sim(kw.span),)),
+                    mask_type: None,
+                    mask_sim: None,
+                };
+            }
+        }
         Ok(())
     }
+    pub(crate) fn custom_debug(&self) -> &CustomDebugOptions {
+        self.custom_debug.as_ref().map(|v| &v.2).unwrap_or(
+            const {
+                &CustomDebugOptions {
+                    type_: None,
+                    sim: None,
+                    mask_type: None,
+                    mask_sim: None,
+                }
+            },
+        )
+    }
 }
 
 pub(crate) struct WrappedInConst<'a> {
@@ -84,10 +125,17 @@ pub(crate) fn get_target(target: &Option<(kw::target, Paren, Path)>, item_ident:
     }
 }
 
-pub(crate) fn common_derives(span: Span) -> Attribute {
+pub(crate) fn common_derives(span: Span, include_debug: bool) -> Attribute {
+    let debug = include_debug
+        .then(|| {
+            quote_spanned! {span=>
+                ::fayalite::__std::fmt::Debug
+            }
+        })
+        .into_iter();
     parse_quote_spanned! {span=>
         #[::fayalite::__std::prelude::v1::derive(
-            ::fayalite::__std::fmt::Debug,
+            #(#debug,)*
             ::fayalite::__std::cmp::Eq,
             ::fayalite::__std::cmp::PartialEq,
             ::fayalite::__std::hash::Hash,
@@ -2975,7 +3023,7 @@ impl ParsedGenerics {
         let span = ident.span();
         ItemStruct {
             attrs: vec![
-                common_derives(span),
+                common_derives(span, true),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types)]
                 },
@@ -4733,3 +4781,109 @@ impl ParsedVisibility {
             .map(|ord| if ord.is_lt() { self } else { other })
     }
 }
+
+pub(crate) struct CustomDebugTrait<'a> {
+    pub(crate) trait_path: &'a Path,
+    pub(crate) fn_name: &'a Ident,
+    pub(crate) this_arg: &'a FnArg,
+}
+
+#[must_use]
+pub(crate) fn create_struct_debug_impl(
+    item_struct: &ItemStruct,
+    debug_struct_name: &str,
+    custom_debug_trait: Option<CustomDebugTrait<'_>>,
+) -> TokenStream {
+    let ident = &item_struct.ident;
+    let span = ident.span();
+    let (impl_generics, type_generics, where_clause) = item_struct.generics.split_for_impl();
+    let trait_path;
+    let fn_name;
+    let this_arg;
+    let CustomDebugTrait {
+        trait_path,
+        fn_name,
+        this_arg,
+    } = match custom_debug_trait {
+        Some(v) => v,
+        None => {
+            trait_path = parse_quote_spanned! {span=>
+                ::fayalite::__std::fmt::Debug
+            };
+            fn_name = parse_quote_spanned! {span=>
+                fmt
+            };
+            this_arg = parse_quote_spanned! {span=>
+                &self
+            };
+            CustomDebugTrait {
+                trait_path: &trait_path,
+                fn_name: &fn_name,
+                this_arg: &this_arg,
+            }
+        }
+    };
+    let this_arg_name = match this_arg {
+        FnArg::Receiver(this_arg) => this_arg.self_token.to_token_stream(),
+        FnArg::Typed(this_arg) => match &*this_arg.pat {
+            syn::Pat::Ident(pat_ident) => pat_ident.ident.to_token_stream(),
+            _ => unreachable!(),
+        },
+    };
+    match &item_struct.fields {
+        Fields::Named(fields) => {
+            let field_idents = fields
+                .named
+                .iter()
+                .map(|v| v.ident.as_ref().expect("known to have field name"));
+            let field_names = field_idents.clone().map(|v| v.to_string());
+            quote_spanned! {span=>
+                #[automatically_derived]
+                impl #impl_generics #trait_path for #ident #type_generics
+                #where_clause
+                {
+                    fn #fn_name(#this_arg, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                        let _ = #this_arg_name;
+                        f.debug_struct(#debug_struct_name)
+                            #(.field(#field_names, &#this_arg_name.#field_idents))*
+                            .finish()
+                    }
+                }
+            }
+        }
+        Fields::Unnamed(fields) => {
+            let field_members = fields
+                .unnamed
+                .iter()
+                .enumerate()
+                .map(|(index, _)| syn::Index {
+                    index: index as _,
+                    span,
+                });
+            quote_spanned! {span=>
+                #[automatically_derived]
+                impl #impl_generics #trait_path for #ident #type_generics
+                #where_clause
+                {
+                    fn #fn_name(#this_arg, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                        let _ = #this_arg_name;
+                        f.debug_tuple(#debug_struct_name)
+                            #(.field(&#this_arg_name.#field_members))*
+                            .finish()
+                    }
+                }
+            }
+        }
+        Fields::Unit => quote_spanned! {ident.span()=>
+            #[automatically_derived]
+            impl #impl_generics #trait_path for #ident #type_generics
+            #where_clause
+            {
+                fn #fn_name(#this_arg, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
+                    let _ = #this_arg_name;
+                    f.write_str(#debug_struct_name)
+                }
+            }
+        },
+    }
+}

crates/fayalite-proc-macros-impl/src/lib.rs

@@ -42,6 +42,7 @@ pub(crate) trait CustomToken:
 
 mod kw {
     pub(crate) use syn::token::Extern as extern_;
+    pub(crate) use syn::token::Type as type_;
 
     macro_rules! custom_keyword {
         ($kw:ident) => {
@@ -75,6 +76,8 @@ mod kw {
     custom_keyword!(cmp_eq);
     custom_keyword!(connect_inexact);
     custom_keyword!(custom_bounds);
+    custom_keyword!(custom_debug);
+    custom_keyword!(custom_sim_display);
     custom_keyword!(flip);
     custom_keyword!(get);
     custom_keyword!(hdl);
@@ -83,6 +86,8 @@ mod kw {
     custom_keyword!(input);
     custom_keyword!(instance);
     custom_keyword!(m);
+    custom_keyword!(mask_sim);
+    custom_keyword!(mask_type);
     custom_keyword!(memory);
     custom_keyword!(memory_array);
     custom_keyword!(memory_with_init);

crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs

@@ -1096,11 +1096,9 @@ impl Visitor<'_> {
                 let (#(#bindings,)*) = {
                     type __MatchTy<T> = <T as ::fayalite::ty::Type>::SimValue;
                     let __match_value = #expr;
-                    let __match_value = {
-                        use ::fayalite::sim::value::match_sim_value::*;
-                        // use method syntax to deduce the correct trait to call
-                        ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value).__fayalite_match_sim_value()
-                    };
+                    // use method syntax to deduce what type to convert to
+                    let __match_value = ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value)
+                        .__fayalite_match_sim_value();
                     #let_token #pat #eq_token __match_value #semi_token
                     (#(#bindings_idents,)*)
                 };
@@ -1172,11 +1170,9 @@ impl Visitor<'_> {
                 {
                     type __MatchTy<T> = <T as ::fayalite::ty::Type>::SimValue;
                     let __match_value = #expr;
-                    let __match_value = {
-                        use ::fayalite::sim::value::match_sim_value::*;
-                        // use method syntax to deduce the correct trait to call
-                        ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value).__fayalite_match_sim_value()
-                    };
+                    // use method syntax to deduce what type to convert to
+                    let __match_value = ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value)
+                        .__fayalite_match_sim_value();
                     #match_token __match_value {
                         #(#arms)*
                     }

crates/fayalite/src/_docs/modules/module_bodies/hdl_let_statements/destructuring.rs

@@ -95,7 +95,23 @@
 //! }
 //!
 //! #[hdl]
-//! fn destructure_to_sim_value<'a, T: Type>(v: impl ToSimValue<Type = MyStruct<T>>) {
+//! fn destructure_inner<T: Type>(v: <MyStruct<T> as Type>::SimValue) {
+//!     #[hdl(sim)]
+//!     let MyStruct::<T> {
+//!         a,
+//!         mut b,
+//!         c,
+//!     } = v;
+//!
+//!     // that gives these types:
+//!     let _: SimValue<UInt<8>> = a;
+//!     let _: SimValue<Bool> = b;
+//!     let _: SimValue<T> = c;
+//!     *b = false; // can modify b since mut was used
+//! }
+//!
+//! #[hdl]
+//! fn destructure_inner_ref<'a, T: Type>(v: &'a <MyStruct<T> as Type>::SimValue) {
 //!     #[hdl(sim)]
 //!     let MyStruct::<T> {
 //!         a,
@@ -104,8 +120,25 @@
 //!     } = v;
 //!
 //!     // that gives these types:
-//!     let _: SimValue<UInt<8>> = a;
-//!     let _: SimValue<Bool> = b;
-//!     let _: SimValue<T> = c;
+//!     let _: &'a SimValue<UInt<8>> = a;
+//!     let _: &'a SimValue<Bool> = b;
+//!     let _: &'a SimValue<T> = c;
+//! }
+//!
+//! #[hdl]
+//! fn destructure_inner_mut<'a, T: Type>(v: &'a mut <MyStruct<T> as Type>::SimValue) {
+//!     #[hdl(sim)]
+//!     let MyStruct::<T> {
+//!         a,
+//!         b,
+//!         c,
+//!     } = v;
+//!
+//!     **b = true; // you can modify v by modifying b which borrows from it
+//!
+//!     // that gives these types:
+//!     let _: &'a mut SimValue<UInt<8>> = a;
+//!     let _: &'a mut SimValue<Bool> = b;
+//!     let _: &'a mut SimValue<T> = c;
 //! }
 //! ```

crates/fayalite/src/_docs/modules/module_bodies/hdl_match_statements.rs

@@ -72,15 +72,47 @@
 //! }
 //!
 //! #[hdl]
-//! fn match_to_sim_value<'a, T: Type>(v: impl ToSimValue<Type = MyEnum<T>>) {
+//! fn match_inner_move<T: Type>(v: <MyEnum<T> as Type>::SimValue) -> String {
 //!     #[hdl(sim)]
 //!     match v {
-//!         MyEnum::<T>::A => println!("got A"),
-//!         MyEnum::<T>::B(b) => {
+//!         MyEnum::<T>::A => String::from("got A"),
+//!         MyEnum::<T>::B(mut b) => {
 //!             let _: SimValue<Bool> = b; // b has this type
-//!             println!("got B({b})");
+//!             let text = format!("got B({b})");
+//!             *b = true; // can modify b since mut was used
+//!             text
 //!         }
-//!         _ => println!("something else"),
+//!         _ => String::from("something else"),
+//!     }
+//! }
+//!
+//! #[hdl]
+//! fn match_inner_ref<'a, T: Type>(v: &'a <MyEnum<T> as Type>::SimValue) -> u32 {
+//!     #[hdl(sim)]
+//!     match v {
+//!         MyEnum::<T>::A => 1,
+//!         MyEnum::<T>::B(b) => {
+//!             let _: &'a SimValue<Bool> = b; // b has this type
+//!             println!("got B({b})");
+//!             5
+//!         }
+//!         _ => 42,
+//!     }
+//! }
+//!
+//! #[hdl]
+//! fn match_inner_mut<'a, T: Type>(v: &'a mut <MyEnum<T> as Type>::SimValue) -> Option<&'a mut SimValue<T>> {
+//!     #[hdl(sim)]
+//!     match v {
+//!         MyEnum::<T>::A => None,
+//!         MyEnum::<T>::B(b) => {
+//!             println!("got B({b})");
+//!             **b = true; // you can modify v by modifying b which borrows from it
+//!             let _: &'a mut SimValue<Bool> = b; // b has this type
+//!             None
+//!         }
+//!         MyEnum::<T>::C(v) => Some(v), // you can return matched values
+//!         _ => None, // HDL enums can have invalid discriminants, so we need this extra match arm
 //!     }
 //! }
 //! ```

crates/fayalite/src/array.rs

@@ -13,13 +13,13 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantWithoutScope, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, StaticType, Type, TypeProperties, TypeWithDeref,
+        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties, TypeWithDeref,
         serde_impls::SerdeCanonicalType,
     },
     util::ConstUsize,
 };
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error};
-use std::{borrow::Cow, iter::FusedIterator, ops::Index};
+use std::{borrow::Cow, fmt, iter::FusedIterator, ops::Index};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayType<T: Type = CanonicalType, Len: Size = DynSize> {
@@ -28,8 +28,8 @@ pub struct ArrayType<T: Type = CanonicalType, Len: Size = DynSize> {
     type_properties: TypeProperties,
 }
 
-impl<T: Type, Len: Size> std::fmt::Debug for ArrayType<T, Len> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl<T: Type, Len: Size> fmt::Debug for ArrayType<T, Len> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Array<{:?}, {}>", self.element, self.len())
     }
 }
@@ -182,6 +182,15 @@ impl<T: Type + Visit<State>, Len: Size, State: Visitor + ?Sized> Visit<State>
     }
 }
 
+impl<T: Type, Len: Size> SimValueDebug for ArrayType<T, Len> {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl<T: Type, Len: Size> Type for ArrayType<T, Len> {
     type BaseType = Array;
     type MaskType = ArrayType<T::MaskType, Len>;

crates/fayalite/src/bundle.rs

@@ -14,8 +14,8 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantWithoutScope, OpaqueSimValue, OpaqueSimValueSize,
-        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type,
-        TypeProperties, TypeWithDeref, impl_match_variant_as_self,
+        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, SimValueDebug,
+        StaticType, Type, TypeProperties, TypeWithDeref, impl_match_variant_as_self,
     },
     util::HashMap,
 };
@@ -271,6 +271,15 @@ impl Type for Bundle {
     }
 }
 
+impl SimValueDebug for Bundle {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 pub trait BundleType: Type<BaseType = Bundle> {
     type Builder: Default;
     fn fields(&self) -> Interned<[BundleField]>;
@@ -471,6 +480,14 @@ macro_rules! impl_tuples {
                 #[var($var)]
             })*]
         }
+        impl<$($T: Type,)*> SimValueDebug for ($($T,)*) {
+            fn sim_value_debug(
+                value: &<Self as Type>::SimValue,
+                f: &mut fmt::Formatter<'_>,
+            ) -> fmt::Result {
+                fmt::Debug::fmt(value, f)
+            }
+        }
         impl<$($T: Type,)*> Type for ($($T,)*) {
             type BaseType = Bundle;
             type MaskType = ($($T::MaskType,)*);
@@ -773,6 +790,15 @@ impl_tuples! {
     ]
 }
 
+impl<T: ?Sized + Send + Sync + 'static> SimValueDebug for PhantomData<T> {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl<T: ?Sized + Send + Sync + 'static> Type for PhantomData<T> {
     type BaseType = Bundle;
     type MaskType = ();

crates/fayalite/src/clock.rs

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
+
 use crate::{
     expr::{Expr, ValueType},
     hdl,
@@ -9,10 +10,12 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties,
+        impl_match_variant_as_self,
     },
 };
 use bitvec::{bits, order::Lsb0};
+use std::fmt;
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
 pub struct Clock;
@@ -69,6 +72,15 @@ impl Type for Clock {
     }
 }
 
+impl SimValueDebug for Clock {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl Clock {
     pub fn type_properties(self) -> TypeProperties {
         Self::TYPE_PROPERTIES

crates/fayalite/src/enum_.rs

@@ -2,7 +2,7 @@
 // See Notices.txt for copyright information
 
 use crate::{
-    expr::{Expr, HdlPartialEq, HdlPartialEqImpl, ToExpr, ValueType, ops::VariantAccess},
+    expr::{Expr, ToExpr, ValueType, ops::VariantAccess},
     hdl,
     int::{Bool, UIntValue},
     intern::{Intern, Interned},
@@ -10,18 +10,18 @@ use crate::{
         EnumMatchVariantAndInactiveScopeImpl, EnumMatchVariantsIterImpl, Scope, connect,
         enum_match_variants_helper, incomplete_wire, wire,
     },
-    sim::value::SimValue,
+    sim::value::{SimValue, ToSimValue, ToSimValueWithType},
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantAndInactiveScope, OpaqueSimValue, OpaqueSimValueSize,
-        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type,
-        TypeProperties,
+        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, SimValueDebug,
+        StaticType, Type, TypeProperties,
     },
     util::HashMap,
 };
 use bitvec::{order::Lsb0, slice::BitSlice, view::BitView};
 use serde::{Deserialize, Serialize};
-use std::{borrow::Cow, convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
+use std::{convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
 pub struct EnumVariant {
@@ -410,6 +410,15 @@ impl Type for Enum {
     }
 }
 
+impl SimValueDebug for Enum {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, Hash, Debug, Default)]
 pub struct EnumPaddingSimValue {
     bits: Option<UIntValue>,
@@ -723,95 +732,12 @@ pub fn enum_type_to_sim_builder<T: EnumType>(v: T) -> T::SimBuilder {
     v.into()
 }
 
-#[hdl]
+#[hdl(cmp_eq)]
 pub enum HdlOption<T: Type> {
     HdlNone,
     HdlSome(T),
 }
 
-impl<Lhs: Type + HdlPartialEqImpl<Rhs>, Rhs: Type> HdlPartialEqImpl<HdlOption<Rhs>>
-    for HdlOption<Lhs>
-{
-    fn cmp_value_eq(
-        lhs: Self,
-        lhs_value: Cow<'_, Self::SimValue>,
-        rhs: HdlOption<Rhs>,
-        rhs_value: Cow<'_, <HdlOption<Rhs> as Type>::SimValue>,
-    ) -> bool {
-        type SimValueMatch<T> = <T as Type>::SimValue;
-        match (&*lhs_value, &*rhs_value) {
-            (SimValueMatch::<Self>::HdlNone(_), SimValueMatch::<HdlOption<Rhs>>::HdlNone(_)) => {
-                true
-            }
-            (SimValueMatch::<Self>::HdlSome(..), SimValueMatch::<HdlOption<Rhs>>::HdlNone(_))
-            | (SimValueMatch::<Self>::HdlNone(_), SimValueMatch::<HdlOption<Rhs>>::HdlSome(..)) => {
-                false
-            }
-            (
-                SimValueMatch::<Self>::HdlSome(l, _),
-                SimValueMatch::<HdlOption<Rhs>>::HdlSome(r, _),
-            ) => HdlPartialEqImpl::cmp_value_eq(
-                lhs.HdlSome,
-                Cow::Borrowed(&**l),
-                rhs.HdlSome,
-                Cow::Borrowed(&**r),
-            ),
-        }
-    }
-
-    #[hdl]
-    fn cmp_expr_eq(lhs: Expr<Self>, rhs: Expr<HdlOption<Rhs>>) -> Expr<Bool> {
-        #[hdl]
-        let cmp_eq = wire();
-        #[hdl]
-        match lhs {
-            HdlSome(lhs) =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(rhs) => connect(cmp_eq, lhs.cmp_eq(rhs)),
-                    HdlNone => connect(cmp_eq, false),
-                }
-            }
-            HdlNone =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(_) => connect(cmp_eq, false),
-                    HdlNone => connect(cmp_eq, true),
-                }
-            }
-        }
-        cmp_eq
-    }
-
-    #[hdl]
-    fn cmp_expr_ne(lhs: Expr<Self>, rhs: Expr<HdlOption<Rhs>>) -> Expr<Bool> {
-        #[hdl]
-        let cmp_ne = wire();
-        #[hdl]
-        match lhs {
-            HdlSome(lhs) =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(rhs) => connect(cmp_ne, lhs.cmp_ne(rhs)),
-                    HdlNone => connect(cmp_ne, true),
-                }
-            }
-            HdlNone =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(_) => connect(cmp_ne, true),
-                    HdlNone => connect(cmp_ne, false),
-                }
-            }
-        }
-        cmp_ne
-    }
-}
-
 #[allow(non_snake_case)]
 pub fn HdlNone<T: StaticType>() -> Expr<HdlOption<T>> {
     HdlOption[T::TYPE].HdlNone()
@@ -823,6 +749,123 @@ pub fn HdlSome<T: Type>(value: impl ToExpr<Type = T>) -> Expr<HdlOption<T>> {
     HdlOption[value.ty()].HdlSome(value)
 }
 
+impl<T: Type> From<SimValue<HdlOption<T>>> for Option<SimValue<T>> {
+    #[hdl]
+    fn from(value: SimValue<HdlOption<T>>) -> Self {
+        #[hdl(sim)]
+        match value {
+            HdlSome(v) => Some(v),
+            HdlNone => None,
+        }
+    }
+}
+
+impl<'a, T: Type> From<&'a SimValue<HdlOption<T>>> for Option<&'a SimValue<T>> {
+    #[hdl]
+    fn from(value: &'a SimValue<HdlOption<T>>) -> Self {
+        #[hdl(sim)]
+        match value {
+            HdlSome(v) => Some(v),
+            HdlNone => None,
+        }
+    }
+}
+
+impl<'a, T: Type> From<&'a mut SimValue<HdlOption<T>>> for Option<&'a mut SimValue<T>> {
+    #[hdl]
+    fn from(value: &'a mut SimValue<HdlOption<T>>) -> Self {
+        #[hdl(sim)]
+        match value {
+            HdlSome(v) => Some(v),
+            HdlNone => None,
+        }
+    }
+}
+
+impl<T: ValueType<Type: StaticType<MaskType: StaticType>>> ValueType for Option<T> {
+    type Type = HdlOption<T::Type>;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        StaticType::TYPE
+    }
+}
+
+impl<T: Type, V: ToSimValueWithType<T>> ToSimValueWithType<HdlOption<T>> for Option<V> {
+    #[hdl]
+    fn to_sim_value_with_type(&self, ty: HdlOption<T>) -> SimValue<HdlOption<T>> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                ty.HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                ty.HdlNone()
+            }
+        }
+    }
+    #[hdl]
+    fn into_sim_value_with_type(self, ty: HdlOption<T>) -> SimValue<HdlOption<T>> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                ty.HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                ty.HdlNone()
+            }
+        }
+    }
+}
+
+impl<T: ToSimValue<Type: StaticType<MaskType: StaticType>>> ToSimValue for Option<T> {
+    #[hdl]
+    fn to_sim_value(&self) -> SimValue<Self::Type> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                HdlNone()
+            }
+        }
+    }
+    #[hdl]
+    fn into_sim_value(self) -> SimValue<Self::Type> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                HdlNone()
+            }
+        }
+    }
+}
+
+impl<T: ToExpr<Type: StaticType<MaskType: StaticType>>> ToExpr for Option<T> {
+    fn to_expr(&self) -> Expr<Self::Type> {
+        match self {
+            Some(v) => HdlSome(v),
+            None => HdlNone(),
+        }
+    }
+}
+
 impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn try_map<R: Type, E>(

crates/fayalite/src/int.rs

@@ -15,8 +15,8 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, FillInDefaultedGenerics, OpaqueSimValueSize, OpaqueSimValueSlice,
-        OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type, TypeProperties,
-        impl_match_variant_as_self,
+        OpaqueSimValueWriter, OpaqueSimValueWritten, SimValueDebug, SimValueDisplay, StaticType,
+        Type, TypeProperties, impl_match_variant_as_self,
     },
     util::{ConstBool, ConstUsize, GenericConstBool, GenericConstUsize, interned_bit, slice_range},
 };
@@ -1019,6 +1019,24 @@ macro_rules! impl_int {
             }
         }
 
+        impl<Width: Size> SimValueDebug for $name<Width> {
+            fn sim_value_debug(
+                value: &<Self as Type>::SimValue,
+                f: &mut fmt::Formatter<'_>,
+            ) -> fmt::Result {
+                fmt::Debug::fmt(value, f)
+            }
+        }
+
+        impl<Width: Size> SimValueDisplay for $name<Width> {
+            fn sim_value_display(
+                value: &<Self as Type>::SimValue,
+                f: &mut fmt::Formatter<'_>,
+            ) -> fmt::Result {
+                fmt::Display::fmt(value, f)
+            }
+        }
+
         impl<Width: KnownSize> Default for $name<Width> {
             fn default() -> Self {
                 Self::TYPE
@@ -1899,6 +1917,15 @@ impl Type for Bool {
     }
 }
 
+impl SimValueDebug for Bool {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl StaticType for Bool {
     const TYPE: Self = Bool;
     const MASK_TYPE: Self::MaskType = Bool;

crates/fayalite/src/int/uint_in_range.rs

@@ -14,7 +14,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten,
-        StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        SimValueDebug, StaticType, Type, TypeProperties, impl_match_variant_as_self,
     },
 };
 use bitvec::{order::Lsb0, view::BitView};
@@ -94,6 +94,15 @@ impl Type for UIntInRangeMaskType {
     }
 }
 
+impl SimValueDebug for UIntInRangeMaskType {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl BundleType for UIntInRangeMaskType {
     type Builder = NoBuilder;
 
@@ -339,6 +348,15 @@ macro_rules! define_uint_in_range_type {
             }
         }
 
+        impl<Start: Size, End: Size> SimValueDebug for $UIntInRangeType<Start, End> {
+            fn sim_value_debug(
+                value: &<Self as Type>::SimValue,
+                f: &mut fmt::Formatter<'_>,
+            ) -> fmt::Result {
+                fmt::Debug::fmt(value, f)
+            }
+        }
+
         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;

crates/fayalite/src/phantom_const.rs

@@ -9,7 +9,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten,
-        StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        SimValueDebug, StaticType, Type, TypeProperties, impl_match_variant_as_self,
         serde_impls::{SerdeCanonicalType, SerdePhantomConst},
     },
 };
@@ -327,6 +327,15 @@ impl<T: ?Sized + PhantomConstValue> Type for PhantomConst<T> {
     }
 }
 
+impl<T: ?Sized + PhantomConstValue> SimValueDebug for PhantomConst<T> {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl<T: ?Sized + PhantomConstValue> Default for PhantomConst<T>
 where
     Interned<T>: Default,

crates/fayalite/src/reset.rs

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
+
 use crate::{
     clock::Clock,
     expr::{CastToImpl, Expr, ValueType},
@@ -8,11 +9,13 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties,
+        impl_match_variant_as_self,
     },
     util::ConstUsize,
 };
 use bitvec::{bits, order::Lsb0};
+use std::fmt;
 
 mod sealed {
     pub trait ResetTypeSealed {}
@@ -100,6 +103,15 @@ macro_rules! reset_type {
             }
         }
 
+        impl SimValueDebug for $name {
+            fn sim_value_debug(
+                value: &<Self as Type>::SimValue,
+                f: &mut fmt::Formatter<'_>,
+            ) -> fmt::Result {
+                fmt::Debug::fmt(value, f)
+            }
+        }
+
         impl $name {
             pub fn type_properties(self) -> TypeProperties {
                 Self::TYPE_PROPERTIES

crates/fayalite/src/sim.rs

@@ -828,6 +828,7 @@ where
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub(crate) struct SimTrace<K, S> {
     kind: K,
+    maybe_changed: bool,
     state: S,
     last_state: S,
 }
@@ -848,12 +849,14 @@ impl<K: fmt::Debug> SimTraceDebug<TraceScalarId> for SimTrace<K, ()> {
     fn fmt(&self, id: TraceScalarId, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let Self {
             kind,
+            maybe_changed,
             state,
             last_state,
         } = self;
         f.debug_struct("SimTrace")
             .field("id", &id)
             .field("kind", kind)
+            .field("maybe_changed", maybe_changed)
             .field("state", state)
             .field("last_state", last_state)
             .finish()
@@ -864,12 +867,14 @@ impl<K: fmt::Debug> SimTraceDebug<TraceScalarId> for SimTrace<K, SimTraceState>
     fn fmt(&self, id: TraceScalarId, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let Self {
             kind,
+            maybe_changed,
             state,
             last_state,
         } = self;
         f.debug_struct("SimTrace")
             .field("id", &id)
             .field("kind", kind)
+            .field("maybe_changed", maybe_changed)
             .field("state", state)
             .field("last_state", last_state)
             .finish()
@@ -2078,10 +2083,12 @@ impl SimulationImpl {
             traces: SimTraces(Box::from_iter(compiled.traces.0.iter().map(
                 |&SimTrace {
                      kind,
+                     maybe_changed: _,
                      state: _,
                      last_state: _,
                  }| SimTrace {
                     kind,
+                    maybe_changed: true,
                     state: kind.make_state(),
                     last_state: kind.make_state(),
                 },
@@ -2126,13 +2133,16 @@ impl SimulationImpl {
             id,
             &SimTrace {
                 kind,
+                maybe_changed,
                 ref state,
                 ref last_state,
             },
         ) in self.traces.0.iter().enumerate()
         {
-            if ONLY_IF_CHANGED && state == last_state {
-                continue;
+            if ONLY_IF_CHANGED {
+                if !(maybe_changed && state != last_state) {
+                    continue;
+                }
             }
             let id = TraceScalarId(id);
             match kind {
@@ -2193,10 +2203,45 @@ impl SimulationImpl {
     fn read_traces<const IS_INITIAL_STEP: bool>(&mut self) {
         for &mut SimTrace {
             kind,
+            ref mut maybe_changed,
             ref mut state,
             ref mut last_state,
         } in &mut self.traces.0
         {
+            let new_maybe_changed = match kind {
+                SimTraceKind::BigUInt { index, ty: _ }
+                | SimTraceKind::BigSInt { index, ty: _ }
+                | SimTraceKind::BigBool { index }
+                | SimTraceKind::BigAsyncReset { index }
+                | SimTraceKind::BigSyncReset { index }
+                | SimTraceKind::BigClock { index } => self
+                    .state
+                    .big_slots
+                    .state_index_fetch_maybe_modified_flag(index),
+                SimTraceKind::SmallUInt { index, ty: _ }
+                | SimTraceKind::SmallSInt { index, ty: _ }
+                | SimTraceKind::SmallBool { index }
+                | SimTraceKind::SmallAsyncReset { index }
+                | SimTraceKind::SmallSyncReset { index }
+                | SimTraceKind::SmallClock { index }
+                | SimTraceKind::EnumDiscriminant { index, ty: _ } => self
+                    .state
+                    .small_slots
+                    .state_index_fetch_maybe_modified_flag(index),
+                SimTraceKind::SimOnly { index, ty: _ } => self
+                    .state
+                    .sim_only_slots
+                    .state_index_fetch_maybe_modified_flag(index),
+                SimTraceKind::PhantomConst { ty: _ } => IS_INITIAL_STEP,
+            };
+            if !new_maybe_changed && !IS_INITIAL_STEP {
+                if *maybe_changed {
+                    last_state.clone_from(state);
+                }
+                *maybe_changed = false;
+                continue;
+            }
+            *maybe_changed = new_maybe_changed;
             if !IS_INITIAL_STEP {
                 mem::swap(state, last_state);
             }
@@ -2246,6 +2291,7 @@ impl SimulationImpl {
                 last_state.clone_from(state);
             }
         }
+        self.state.clear_all_maybe_modified_flags();
     }
     #[track_caller]
     fn advance_time(this_ref: &Rc<RefCell<Self>>, duration: SimDuration) {

crates/fayalite/src/sim/compiler.rs

@@ -2234,6 +2234,7 @@ impl Compiler {
         let id = TraceScalarId(self.traces.0.len());
         self.traces.0.push(SimTrace {
             kind,
+            maybe_changed: true,
             state: (),
             last_state: (),
         });

crates/fayalite/src/sim/interpreter.rs

@@ -17,12 +17,11 @@ use bitvec::slice::BitSlice;
 use num_bigint::BigInt;
 use num_traits::{One, Signed, ToPrimitive, Zero};
 use std::{
-    borrow::BorrowMut,
     convert::Infallible,
     fmt::{self, Write},
     hash::Hash,
     marker::PhantomData,
-    ops::{ControlFlow, Deref, DerefMut, Index, IndexMut},
+    ops::{ControlFlow, Deref, Index, IndexMut},
 };
 use vec_map::VecMap;
 
@@ -915,6 +914,15 @@ impl<K: StatePartKind> StatePart<K> {
             value: K::borrow_state(&mut self.value),
         }
     }
+    pub(crate) fn state_index_fetch_maybe_modified_flag(
+        &self,
+        part_index: StatePartIndex<K>,
+    ) -> bool {
+        K::state_index_fetch_maybe_modified_flag(&self.value, part_index)
+    }
+    pub(crate) fn clear_all_maybe_modified_flags(&mut self) {
+        K::clear_all_maybe_modified_flags(&mut self.value)
+    }
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -922,56 +930,38 @@ pub(crate) struct BorrowedStatePart<'a, K: StatePartKind> {
     pub(crate) value: K::BorrowedState<'a>,
 }
 
-impl<
-    'a,
-    K: StatePartKind<
-        BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T> + BorrowMut<[T]>>,
-    >,
-    T,
-> BorrowedStatePart<'a, K>
-{
+impl<K: StatePartKind> BorrowedStatePart<'_, K> {
     pub(crate) fn get_disjoint_mut<const N: usize>(
         &mut self,
         indexes: [StatePartIndex<K>; N],
-    ) -> [&mut T; N] {
-        (*self.value)
-            .borrow_mut()
-            .get_disjoint_mut(indexes.map(|v| v.value as usize))
-            .expect("indexes are disjoint")
+    ) -> [&mut K::StateElement; N] {
+        K::borrowed_state_get_disjoint_mut(&mut self.value, indexes)
     }
 }
 
-impl<K: StatePartKind<State: Deref<Target: Index<usize, Output = T>>>, T> Index<StatePartIndex<K>>
-    for StatePart<K>
-{
-    type Output = T;
+impl<K: StatePartKind> Index<StatePartIndex<K>> for StatePart<K> {
+    type Output = K::StateElement;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        &self.value[index.value as usize]
+        K::state_index(&self.value, index)
     }
 }
 
-impl<K: StatePartKind<State: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
-    IndexMut<StatePartIndex<K>> for StatePart<K>
-{
+impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for StatePart<K> {
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        &mut self.value[index.value as usize]
+        K::state_index_mut(&mut self.value, index)
     }
 }
 
-impl<'a, K: StatePartKind<BorrowedState<'a>: Deref<Target: Index<usize, Output = T>>>, T>
-    Index<StatePartIndex<K>> for BorrowedStatePart<'a, K>
-{
-    type Output = T;
+impl<K: StatePartKind> Index<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
+    type Output = K::StateElement;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        &self.value[index.value as usize]
+        K::borrowed_state_index(&self.value, index)
     }
 }
 
-impl<'a, K: StatePartKind<BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
-    IndexMut<StatePartIndex<K>> for BorrowedStatePart<'a, K>
-{
+impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        &mut self.value[index.value as usize]
+        K::borrowed_state_index_mut(&mut self.value, index)
     }
 }
 
@@ -1028,6 +1018,10 @@ macro_rules! make_state {
                     $($type_plural_field: self.$type_plural_field.borrow(),)*
                 }
             }
+            pub(crate) fn clear_all_maybe_modified_flags(&mut self) {
+                $(self.$state_plural_field.clear_all_maybe_modified_flags();)*
+                $(self.$type_plural_field.clear_all_maybe_modified_flags();)*
+            }
         }
 
         #[derive(Debug)]

crates/fayalite/src/sim/interpreter/parts.rs

@@ -236,6 +236,7 @@ pub(crate) trait StatePartKind:
     type LayoutData: Send + Sync + Eq + Hash + fmt::Debug + 'static + Copy;
     type State: fmt::Debug + 'static + Clone;
     type BorrowedState<'a>: 'a;
+    type StateElement;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State;
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a>;
     fn part_debug_data<BK: InsnsBuildingKind>(
@@ -247,6 +248,31 @@ pub(crate) trait StatePartKind:
         index: StatePartIndex<Self>,
         f: &mut impl fmt::Write,
     ) -> fmt::Result;
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement;
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement;
+    fn state_index_fetch_maybe_modified_flag(
+        state: &Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool;
+    fn clear_all_maybe_modified_flags(state: &mut Self::State);
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement;
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement;
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N];
 }
 
 macro_rules! make_state_part_kinds {
@@ -272,6 +298,7 @@ impl StatePartKind for StatePartKindMemories {
     type LayoutData = MemoryData<Interned<BitSlice>>;
     type State = Box<[MemoryData<BitBox>]>;
     type BorrowedState<'a> = &'a mut [MemoryData<BitBox>];
+    type StateElement = MemoryData<BitBox>;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
         layout_data
             .iter()
@@ -297,19 +324,89 @@ impl StatePartKind for StatePartKindMemories {
     ) -> fmt::Result {
         write!(f, "{:#?}", &state.memories[index])
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        &mut state[part_index.as_usize()]
+    }
+    fn state_index_fetch_maybe_modified_flag(
+        _state: &Self::State,
+        _part_index: StatePartIndex<Self>,
+    ) -> bool {
+        true
+    }
+    fn clear_all_maybe_modified_flags(_state: &mut Self::State) {}
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        &mut state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
+pub(crate) struct StateAndModified<T, M> {
+    pub(crate) state: T,
+    pub(crate) modified: M,
+}
+
+impl<T: Deref<Target = [E]>, M: Deref<Target = [bool]>, E: fmt::Debug> fmt::Debug
+    for StateAndModified<T, M>
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list()
+            .entries(self.state.iter().zip(self.modified.iter().copied()).map(
+                |(state, modified)| {
+                    fmt::from_fn(move |f| {
+                        state.fmt(f)?;
+                        if modified {
+                            f.write_str(" (modified)")?;
+                        }
+                        Ok(())
+                    })
+                },
+            ))
+            .finish()
+    }
 }
 
 impl StatePartKind for StatePartKindSmallSlots {
     const NAME: &'static str = "SmallSlots";
     type DebugData = SlotDebugData;
     type LayoutData = ();
-    type State = Box<[SmallUInt]>;
-    type BorrowedState<'a> = &'a mut [SmallUInt];
+    type State = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type StateElement = SmallUInt;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        vec![0; layout_data.len()].into_boxed_slice()
+        StateAndModified {
+            state: vec![0; layout_data.len()].into_boxed_slice(),
+            modified: vec![false; layout_data.len()].into_boxed_slice(),
+        }
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        state
+        let StateAndModified { state, modified } = state;
+        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -330,19 +427,72 @@ impl StatePartKind for StatePartKindSmallSlots {
         write!(f, "{value:#x} {}", value as SmallSInt)?;
         Ok(())
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn state_index_fetch_maybe_modified_flag(
+        state: &Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool {
+        state.modified[part_index.as_usize()]
+    }
+    fn clear_all_maybe_modified_flags(state: &mut Self::State) {
+        state.modified.fill(false);
+    }
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        for part_index in part_indexes {
+            state.modified[part_index.as_usize()] = true;
+        }
+        state
+            .state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
 }
 
 impl StatePartKind for StatePartKindBigSlots {
     const NAME: &'static str = "BigSlots";
     type DebugData = SlotDebugData;
     type LayoutData = ();
-    type State = Box<[BigInt]>;
-    type BorrowedState<'a> = &'a mut [BigInt];
+    type State = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type StateElement = BigInt;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        layout_data.iter().map(|_| BigInt::default()).collect()
+        let state: Box<[_]> = layout_data.iter().map(|_| BigInt::default()).collect();
+        StateAndModified {
+            modified: vec![false; state.len()].into_boxed_slice(),
+            state,
+        }
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        state
+        let StateAndModified { state, modified } = state;
+        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -361,19 +511,72 @@ impl StatePartKind for StatePartKindBigSlots {
     ) -> fmt::Result {
         write!(f, "{:#x}", state.big_slots[index])
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn state_index_fetch_maybe_modified_flag(
+        state: &Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool {
+        state.modified[part_index.as_usize()]
+    }
+    fn clear_all_maybe_modified_flags(state: &mut Self::State) {
+        state.modified.fill(false);
+    }
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        for part_index in part_indexes {
+            state.modified[part_index.as_usize()] = true;
+        }
+        state
+            .state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
 }
 
 impl StatePartKind for StatePartKindSimOnlySlots {
     const NAME: &'static str = "SimOnlySlots";
     type DebugData = SlotDebugData;
     type LayoutData = DynSimOnly;
-    type State = Box<[DynSimOnlyValue]>;
-    type BorrowedState<'a> = &'a mut [DynSimOnlyValue];
+    type State = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type StateElement = DynSimOnlyValue;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        layout_data.iter().map(|ty| ty.default_value()).collect()
+        let state: Box<[_]> = layout_data.iter().map(|ty| ty.default_value()).collect();
+        StateAndModified {
+            modified: vec![false; state.len()].into_boxed_slice(),
+            state,
+        }
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        state
+        let StateAndModified { state, modified } = state;
+        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -392,6 +595,53 @@ impl StatePartKind for StatePartKindSimOnlySlots {
     ) -> fmt::Result {
         write!(f, "{:?}", state.sim_only_slots[index])
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn state_index_fetch_maybe_modified_flag(
+        state: &Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool {
+        state.modified[part_index.as_usize()]
+    }
+    fn clear_all_maybe_modified_flags(state: &mut Self::State) {
+        state.modified.fill(false);
+    }
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        for part_index in part_indexes {
+            state.modified[part_index.as_usize()] = true;
+        }
+        state
+            .state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

crates/fayalite/src/sim/value.rs

@@ -15,7 +15,8 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValue, OpaqueSimValueSize, OpaqueSimValueSlice,
-        OpaqueSimValueWriter, StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        OpaqueSimValueWriter, SimValueDebug, StaticType, Type, TypeProperties,
+        impl_match_variant_as_self,
     },
     util::{
         ConstUsize, HashMap,
@@ -551,113 +552,119 @@ impl_sim_value_cmp_as_bool!(AsyncReset);
 
 #[doc(hidden)]
 pub mod match_sim_value {
-    use crate::{
-        sim::value::{SimValue, ToSimValue},
-        ty::Type,
-    };
+    use crate::{sim::value::SimValue, ty::Type};
+    use std::ops::{Deref, DerefMut};
+
+    macro_rules! wrapper {
+        (
+            $(pub struct $wrapper:ident<$T:ident>($inner:ty);)*
+        ) => {
+            $(#[doc(hidden)]
+            pub struct $wrapper<$T>($inner);
+
+            impl<$T> $wrapper<$T> {
+                #[inline(always)]
+                pub fn new(value: $T) -> Self {
+                    Self(<$inner>::new(value))
+                }
+            }
+
+            impl<$T> Deref for $wrapper<$T> {
+                type Target = $inner;
+
+                #[inline(always)]
+                fn deref(&self) -> &Self::Target {
+                    &self.0
+                }
+            }
+
+            impl<$T> DerefMut for $wrapper<$T> {
+                #[inline(always)]
+                fn deref_mut(&mut self) -> &mut Self::Target {
+                    &mut self.0
+                }
+            })*
+        };
+    }
+
+    wrapper! {
+        pub struct MatchSimValueHelperCheckSimValue<T>(MatchSimValueHelperCheckMutSimValue<T>);
+        pub struct MatchSimValueHelperCheckMutSimValue<T>(MatchSimValueHelperCheckRefSimValue<T>);
+        pub struct MatchSimValueHelperCheckRefSimValue<T>(MatchSimValueHelperCheckRefRefSimValue<T>);
+        pub struct MatchSimValueHelperCheckRefRefSimValue<T>(MatchSimValueHelperCheckRefMutSimValue<T>);
+        pub struct MatchSimValueHelperCheckRefMutSimValue<T>(MatchSimValueHelperCheckMutRefSimValue<T>);
+        pub struct MatchSimValueHelperCheckMutRefSimValue<T>(MatchSimValueHelperCheckMutMutSimValue<T>);
+        pub struct MatchSimValueHelperCheckMutMutSimValue<T>(MatchSimValueHelperIdentity<T>);
+    }
+
+    impl<T: Type> MatchSimValueHelperCheckSimValue<SimValue<T>> {
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> T::SimValue {
+            SimValue::into_value(self.take())
+        }
+    }
+
+    impl<'a, T: Type> MatchSimValueHelperCheckMutSimValue<&'a mut SimValue<T>> {
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> &'a mut T::SimValue {
+            self.take()
+        }
+    }
+
+    impl<'a, T: Type> MatchSimValueHelperCheckRefSimValue<&'a SimValue<T>> {
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> &'a T::SimValue {
+            self.take()
+        }
+    }
+
+    impl<'a, 'b, T: Type> MatchSimValueHelperCheckRefRefSimValue<&'a &'b SimValue<T>> {
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> &'b T::SimValue {
+            self.take()
+        }
+    }
+
+    impl<'a, 'b, T: Type> MatchSimValueHelperCheckRefMutSimValue<&'a &'b mut SimValue<T>> {
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> &'a T::SimValue {
+            self.take()
+        }
+    }
+
+    impl<'a, 'b, T: Type> MatchSimValueHelperCheckMutRefSimValue<&'a mut &'b SimValue<T>> {
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> &'b T::SimValue {
+            self.take()
+        }
+    }
+
+    impl<'a, 'b, T: Type> MatchSimValueHelperCheckMutMutSimValue<&'a mut &'b mut SimValue<T>> {
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> &'a mut T::SimValue {
+            self.take()
+        }
+    }
 
     #[doc(hidden)]
-    pub struct MatchSimValueHelper<T>(Option<T>);
+    pub struct MatchSimValueHelperIdentity<T>(Option<T>);
 
-    impl<T> MatchSimValueHelper<T> {
-        pub fn new(v: T) -> Self {
+    impl<T> MatchSimValueHelperIdentity<T> {
+        fn new(v: T) -> Self {
             Self(Some(v))
         }
-    }
-
-    #[doc(hidden)]
-    pub trait MatchSimValue {
-        type MatchValue;
-
-        /// use `self` so it comes first in the method resolution order
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue
-        where
-            Self: Sized;
-    }
-
-    impl<T: Type> MatchSimValue for MatchSimValueHelper<SimValue<T>> {
-        type MatchValue = T::SimValue;
-
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
-            SimValue::into_value(self.0.expect("should be Some"))
+        #[inline(always)]
+        fn take(&mut self) -> T {
+            self.0.take().expect("known to be Some")
         }
-    }
-
-    impl<'a, T: Type> MatchSimValue for MatchSimValueHelper<&'a SimValue<T>> {
-        type MatchValue = &'a T::SimValue;
-
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
-            SimValue::value(self.0.expect("should be Some"))
-        }
-    }
-
-    impl<'a, T: Type> MatchSimValue for MatchSimValueHelper<&'a mut SimValue<T>> {
-        type MatchValue = &'a mut T::SimValue;
-
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
-            SimValue::value_mut(self.0.expect("should be Some"))
-        }
-    }
-
-    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'_ &'a T>
-    where
-        MatchSimValueHelper<&'a T>: MatchSimValue,
-    {
-        type MatchValue = <MatchSimValueHelper<&'a T> as MatchSimValue>::MatchValue;
-
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
-            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| *v)))
-        }
-    }
-
-    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'_ mut &'a T>
-    where
-        MatchSimValueHelper<&'a T>: MatchSimValue,
-    {
-        type MatchValue = <MatchSimValueHelper<&'a T> as MatchSimValue>::MatchValue;
-
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
-            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| *v)))
-        }
-    }
-
-    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'a &'_ mut T>
-    where
-        MatchSimValueHelper<&'a T>: MatchSimValue,
-    {
-        type MatchValue = <MatchSimValueHelper<&'a T> as MatchSimValue>::MatchValue;
-
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
-            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| &**v)))
-        }
-    }
-
-    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'a mut &'_ mut T>
-    where
-        MatchSimValueHelper<&'a mut T>: MatchSimValue,
-    {
-        type MatchValue = <MatchSimValueHelper<&'a mut T> as MatchSimValue>::MatchValue;
-
-        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
-            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| &mut **v)))
+        #[inline(always)]
+        pub fn __fayalite_match_sim_value(&mut self) -> T {
+            self.take()
         }
     }
 
     #[doc(hidden)]
-    pub trait MatchSimValueFallback {
-        type MatchValue;
-
-        /// use `&mut self` so it comes later in the method resolution order than MatchSimValue
-        fn __fayalite_match_sim_value(&mut self) -> Self::MatchValue;
-    }
-
-    impl<T: ToSimValue> MatchSimValueFallback for MatchSimValueHelper<T> {
-        type MatchValue = <T::Type as Type>::SimValue;
-
-        fn __fayalite_match_sim_value(&mut self) -> Self::MatchValue {
-            SimValue::into_value(self.0.take().expect("should be Some").into_sim_value())
-        }
-    }
+    pub type MatchSimValueHelper<T> = MatchSimValueHelperCheckSimValue<T>;
 }
 
 pub trait ToSimValue: ToSimValueWithType<<Self as ValueType>::Type> + ValueType {
@@ -1394,6 +1401,15 @@ impl Type for DynSimOnly {
     }
 }
 
+impl SimValueDebug for DynSimOnly {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl<T: SimOnlyValueTrait> Type for SimOnly<T> {
     type BaseType = DynSimOnly;
     type MaskType = Bool;
@@ -1459,6 +1475,15 @@ impl<T: SimOnlyValueTrait> Type for SimOnly<T> {
     }
 }
 
+impl<T: SimOnlyValueTrait> SimValueDebug for SimOnly<T> {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 impl<T: SimOnlyValueTrait> StaticType for SimOnly<T> {
     const TYPE: Self = Self::new();
 

crates/fayalite/src/ty.rs

@@ -367,7 +367,15 @@ impl<D: Type> TypeOrDefault<D> for crate::__ {
 }
 
 pub trait Type:
-    Copy + Hash + Eq + fmt::Debug + Send + Sync + 'static + FillInDefaultedGenerics<Type = Self>
+    Copy
+    + Hash
+    + Eq
+    + fmt::Debug
+    + Send
+    + Sync
+    + 'static
+    + FillInDefaultedGenerics<Type = Self>
+    + SimValueDebug
 {
     type BaseType: BaseType;
     type MaskType: Type<MaskType = Self::MaskType>;
@@ -402,6 +410,16 @@ pub trait Type:
     ) -> OpaqueSimValueWritten<'w>;
 }
 
+pub trait SimValueDebug {
+    fn sim_value_debug(value: &<Self as Type>::SimValue, f: &mut fmt::Formatter<'_>) -> fmt::Result
+    where
+        Self: Type;
+}
+
+pub trait SimValueDisplay: Type {
+    fn sim_value_display(value: &Self::SimValue, f: &mut fmt::Formatter<'_>) -> fmt::Result;
+}
+
 pub trait BaseType:
     Type<
         BaseType = Self,
@@ -490,6 +508,15 @@ impl Type for CanonicalType {
     }
 }
 
+impl SimValueDebug for CanonicalType {
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        fmt::Debug::fmt(value, f)
+    }
+}
+
 #[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize, Default)]
 #[non_exhaustive]
 pub struct OpaqueSimValueSizeRange {

crates/fayalite/tests/hdl_types_fmt.rs

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+use fayalite::{prelude::*, ty::SimValueDebug};
+use std::fmt;
+
+#[hdl(outline_generated)]
+struct MyStruct0<T, S: Size> {
+    v: T,
+    a: ArrayType<UInt<8>, S>,
+}
+
+#[hdl]
+#[test]
+fn check_my_struct0() {
+    let ty = MyStruct0[UInt[8]][3];
+    assert_eq!(
+        format!("{ty:?}"),
+        "MyStruct0 { v: UInt<8>, a: Array<UInt<8>, 3> }",
+    );
+    assert_eq!(
+        format!("{:?}", ty.mask_type()),
+        "MaskType<MyStruct0> { v: Bool, a: Array<Bool, 3> }",
+    );
+    let v = #[hdl(sim)]
+    MyStruct0::<_, _> {
+        v: 0x23u8,
+        a: [1u8, 2, 3],
+    };
+    assert_eq!(
+        format!("{v:?}"),
+        "MyStruct0 { v: 0x23_u8, a: [0x1_u8, 0x2_u8, 0x3_u8] }",
+    );
+}
+
+#[hdl(outline_generated, custom_debug())]
+struct MyStruct1<T, S: Size> {
+    v: T,
+    a: ArrayType<UInt<8>, S>,
+}
+
+impl<T: Type, S: Size> fmt::Debug for MyStruct1<T, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self { v, a } = self;
+        f.debug_struct("Custom<MyStruct1>")
+            .field("v", v)
+            .field("a", a)
+            .finish()
+    }
+}
+
+impl<T: Type, S: Size> SimValueDebug for MyStruct1<T, S> {
+    #[hdl]
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        #[hdl(sim)]
+        let Self { v, a } = value;
+        f.debug_struct("Custom<MyStruct1>")
+            .field("v", &v)
+            .field("a", &a)
+            .finish()
+    }
+}
+
+#[hdl]
+#[test]
+fn check_my_struct1() {
+    let ty = MyStruct1[UInt[8]][3];
+    assert_eq!(
+        format!("{ty:?}"),
+        "Custom<MyStruct1> { v: UInt<8>, a: Array<UInt<8>, 3> }",
+    );
+    assert_eq!(
+        format!("{:?}", ty.mask_type()),
+        "MaskType<MyStruct1> { v: Bool, a: Array<Bool, 3> }",
+    );
+    let v = #[hdl(sim)]
+    MyStruct1::<_, _> {
+        v: 0x23u8,
+        a: [1u8, 2, 3],
+    };
+    assert_eq!(
+        format!("{v:?}"),
+        "Custom<MyStruct1> { v: 0x23_u8, a: [0x1_u8, 0x2_u8, 0x3_u8] }",
+    );
+}
+
+#[hdl(outline_generated)]
+enum MyEnum0<T, S: Size> {
+    Unit,
+    V(T),
+    A(ArrayType<UInt<8>, S>),
+}
+
+#[hdl]
+#[test]
+fn check_my_enum0() {
+    let ty = MyEnum0[UInt[8]][3];
+    assert_eq!(
+        format!("{ty:?}"),
+        "MyEnum0 { Unit: (), V: UInt<8>, A: Array<UInt<8>, 3> }",
+    );
+    let v = #[hdl(sim)]
+    ty.Unit();
+    assert_eq!(format!("{v:?}"), "Unit");
+    let v = #[hdl(sim)]
+    ty.V(0x23u8);
+    assert_eq!(format!("{v:?}"), "V(0x23_u8)");
+    let v = #[hdl(sim)]
+    ty.A([1u8, 2, 3]);
+    assert_eq!(format!("{v:?}"), "A([0x1_u8, 0x2_u8, 0x3_u8])");
+}
+
+#[hdl(outline_generated, custom_debug())]
+enum MyEnum1<T, S: Size> {
+    Unit,
+    V(T),
+    A(ArrayType<UInt<8>, S>),
+}
+
+impl<T: Type, S: Size> fmt::Debug for MyEnum1<T, S> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self { Unit, V, A } = self;
+        f.debug_struct("Custom<MyEnum1>")
+            .field("Unit", Unit)
+            .field("V", V)
+            .field("A", A)
+            .finish()
+    }
+}
+
+impl<T: Type, S: Size> SimValueDebug for MyEnum1<T, S> {
+    #[hdl]
+    fn sim_value_debug(
+        value: &<Self as Type>::SimValue,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        type SimValueT<T> = <T as Type>::SimValue;
+        match value {
+            SimValueT::<Self>::Unit(_) => f.write_str("MyEnum1::Unit"),
+            SimValueT::<Self>::V(v, _) => f.debug_tuple("MyEnum1::V").field(v).finish(),
+            SimValueT::<Self>::A(a, _) => f.debug_tuple("MyEnum1::A").field(a).finish(),
+            SimValueT::<Self>::Unknown(_) => f.write_str("MyEnum1::Unknown"),
+        }
+    }
+}
+
+#[hdl]
+#[test]
+fn check_my_enum1() {
+    let ty = MyEnum1[UInt[8]][3];
+    assert_eq!(
+        format!("{ty:?}"),
+        "Custom<MyEnum1> { Unit: (), V: UInt<8>, A: Array<UInt<8>, 3> }",
+    );
+    let v = #[hdl(sim)]
+    ty.Unit();
+    assert_eq!(format!("{v:?}"), "MyEnum1::Unit");
+    let v = #[hdl(sim)]
+    ty.V(0x23u8);
+    assert_eq!(format!("{v:?}"), "MyEnum1::V(0x23_u8)");
+    let v = #[hdl(sim)]
+    ty.A([1u8, 2, 3]);
+    assert_eq!(format!("{v:?}"), "MyEnum1::A([0x1_u8, 0x2_u8, 0x3_u8])");
+}

crates/fayalite/tests/module.rs

@@ -13,7 +13,7 @@ use fayalite::{
 };
 use serde_json::json;
 
-#[hdl(outline_generated)]
+#[hdl(outline_generated, cmp_eq)]
 pub enum TestEnum {
     A,
     B(UInt<8>),
@@ -679,6 +679,366 @@ circuit check_enum_literals:
     };
 }
 
+#[hdl_module(outline_generated)]
+pub fn check_enum_cmp_eq() {
+    #[hdl]
+    let lhs: TestEnum = m.input();
+    #[hdl]
+    let rhs: TestEnum = m.input();
+    #[hdl]
+    let eq: Bool = m.output();
+    connect(eq, lhs.cmp_eq(rhs));
+}
+
+#[test]
+fn test_enum_cmp_eq() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    let m = check_enum_cmp_eq();
+    dbg!(m);
+    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
+    assert_export_firrtl! {
+        m =>
+        options: ExportOptions {
+            simplify_enums: None,
+            ..ExportOptions::default()
+        },
+        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
+circuit check_enum_cmp_eq:
+    type Ty0 = {|A, B: UInt<8>, C: UInt<1>[3]|}
+    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
+        input lhs: Ty0 @[module-XXXXXXXXXX.rs 2:1]
+        input rhs: Ty0 @[module-XXXXXXXXXX.rs 3:1]
+        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
+        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
+        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
+        match lhs: @[module-XXXXXXXXXX.rs 5:1]
+            A:
+                match rhs: @[module-XXXXXXXXXX.rs 5:1]
+                    A:
+                        connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
+                    B(_match_arm_value):
+                        skip
+                    C(_match_arm_value_1):
+                        skip
+            B(_match_arm_value_2):
+                match rhs: @[module-XXXXXXXXXX.rs 5:1]
+                    A:
+                        skip
+                    B(_match_arm_value_3):
+                        connect TestEnum_cmp_eq, eq(_match_arm_value_2, _match_arm_value_3) @[module-XXXXXXXXXX.rs 5:1]
+                    C(_match_arm_value_4):
+                        skip
+            C(_match_arm_value_5):
+                match rhs: @[module-XXXXXXXXXX.rs 5:1]
+                    A:
+                        skip
+                    B(_match_arm_value_6):
+                        skip
+                    C(_match_arm_value_7):
+                        wire _array_literal_expr: UInt<1>[3]
+                        connect _array_literal_expr[0], eq(_match_arm_value_5[0], _match_arm_value_7[0])
+                        connect _array_literal_expr[1], eq(_match_arm_value_5[1], _match_arm_value_7[1])
+                        connect _array_literal_expr[2], eq(_match_arm_value_5[2], _match_arm_value_7[2])
+                        wire _cast_array_to_bits_expr: UInt<1>[3]
+                        connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
+                        connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
+                        connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
+                        wire _cast_to_bits_expr: UInt<3>
+                        connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
+                        connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
+        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
+",
+    };
+    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
+    assert_export_firrtl! {
+        m =>
+        options: ExportOptions {
+            simplify_enums: Some(SimplifyEnumsKind::SimplifyToEnumsWithNoBody),
+            ..ExportOptions::default()
+        },
+        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
+circuit check_enum_cmp_eq:
+    type Ty0 = {|A, B, C|}
+    type Ty1 = {tag: Ty0, body: UInt<8>}
+    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
+        input lhs: Ty1 @[module-XXXXXXXXXX.rs 2:1]
+        input rhs: Ty1 @[module-XXXXXXXXXX.rs 3:1]
+        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
+        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
+        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
+        match lhs.tag: @[module-XXXXXXXXXX.rs 5:1]
+            A:
+                match rhs.tag: @[module-XXXXXXXXXX.rs 5:1]
+                    A:
+                        connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
+                    B:
+                        skip
+                    C:
+                        skip
+            B:
+                match rhs.tag: @[module-XXXXXXXXXX.rs 5:1]
+                    A:
+                        skip
+                    B:
+                        connect TestEnum_cmp_eq, eq(bits(lhs.body, 7, 0), bits(rhs.body, 7, 0)) @[module-XXXXXXXXXX.rs 5:1]
+                    C:
+                        skip
+            C:
+                match rhs.tag: @[module-XXXXXXXXXX.rs 5:1]
+                    A:
+                        skip
+                    B:
+                        skip
+                    C:
+                        wire _array_literal_expr: UInt<1>[3]
+                        wire _cast_bits_to_array_expr: UInt<1>[3]
+                        wire _cast_bits_to_array_expr_flattened: UInt<1>[3]
+                        connect _cast_bits_to_array_expr_flattened[0], bits(bits(lhs.body, 2, 0), 0, 0)
+                        connect _cast_bits_to_array_expr[0], _cast_bits_to_array_expr_flattened[0]
+                        connect _cast_bits_to_array_expr_flattened[1], bits(bits(lhs.body, 2, 0), 1, 1)
+                        connect _cast_bits_to_array_expr[1], _cast_bits_to_array_expr_flattened[1]
+                        connect _cast_bits_to_array_expr_flattened[2], bits(bits(lhs.body, 2, 0), 2, 2)
+                        connect _cast_bits_to_array_expr[2], _cast_bits_to_array_expr_flattened[2]
+                        wire _cast_bits_to_array_expr_1: UInt<1>[3]
+                        wire _cast_bits_to_array_expr_flattened_1: UInt<1>[3]
+                        connect _cast_bits_to_array_expr_flattened_1[0], bits(bits(rhs.body, 2, 0), 0, 0)
+                        connect _cast_bits_to_array_expr_1[0], _cast_bits_to_array_expr_flattened_1[0]
+                        connect _cast_bits_to_array_expr_flattened_1[1], bits(bits(rhs.body, 2, 0), 1, 1)
+                        connect _cast_bits_to_array_expr_1[1], _cast_bits_to_array_expr_flattened_1[1]
+                        connect _cast_bits_to_array_expr_flattened_1[2], bits(bits(rhs.body, 2, 0), 2, 2)
+                        connect _cast_bits_to_array_expr_1[2], _cast_bits_to_array_expr_flattened_1[2]
+                        connect _array_literal_expr[0], eq(_cast_bits_to_array_expr[0], _cast_bits_to_array_expr_1[0])
+                        wire _cast_bits_to_array_expr_2: UInt<1>[3]
+                        wire _cast_bits_to_array_expr_flattened_2: UInt<1>[3]
+                        connect _cast_bits_to_array_expr_flattened_2[0], bits(bits(lhs.body, 2, 0), 0, 0)
+                        connect _cast_bits_to_array_expr_2[0], _cast_bits_to_array_expr_flattened_2[0]
+                        connect _cast_bits_to_array_expr_flattened_2[1], bits(bits(lhs.body, 2, 0), 1, 1)
+                        connect _cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_flattened_2[1]
+                        connect _cast_bits_to_array_expr_flattened_2[2], bits(bits(lhs.body, 2, 0), 2, 2)
+                        connect _cast_bits_to_array_expr_2[2], _cast_bits_to_array_expr_flattened_2[2]
+                        wire _cast_bits_to_array_expr_3: UInt<1>[3]
+                        wire _cast_bits_to_array_expr_flattened_3: UInt<1>[3]
+                        connect _cast_bits_to_array_expr_flattened_3[0], bits(bits(rhs.body, 2, 0), 0, 0)
+                        connect _cast_bits_to_array_expr_3[0], _cast_bits_to_array_expr_flattened_3[0]
+                        connect _cast_bits_to_array_expr_flattened_3[1], bits(bits(rhs.body, 2, 0), 1, 1)
+                        connect _cast_bits_to_array_expr_3[1], _cast_bits_to_array_expr_flattened_3[1]
+                        connect _cast_bits_to_array_expr_flattened_3[2], bits(bits(rhs.body, 2, 0), 2, 2)
+                        connect _cast_bits_to_array_expr_3[2], _cast_bits_to_array_expr_flattened_3[2]
+                        connect _array_literal_expr[1], eq(_cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_3[1])
+                        wire _cast_bits_to_array_expr_4: UInt<1>[3]
+                        wire _cast_bits_to_array_expr_flattened_4: UInt<1>[3]
+                        connect _cast_bits_to_array_expr_flattened_4[0], bits(bits(lhs.body, 2, 0), 0, 0)
+                        connect _cast_bits_to_array_expr_4[0], _cast_bits_to_array_expr_flattened_4[0]
+                        connect _cast_bits_to_array_expr_flattened_4[1], bits(bits(lhs.body, 2, 0), 1, 1)
+                        connect _cast_bits_to_array_expr_4[1], _cast_bits_to_array_expr_flattened_4[1]
+                        connect _cast_bits_to_array_expr_flattened_4[2], bits(bits(lhs.body, 2, 0), 2, 2)
+                        connect _cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_flattened_4[2]
+                        wire _cast_bits_to_array_expr_5: UInt<1>[3]
+                        wire _cast_bits_to_array_expr_flattened_5: UInt<1>[3]
+                        connect _cast_bits_to_array_expr_flattened_5[0], bits(bits(rhs.body, 2, 0), 0, 0)
+                        connect _cast_bits_to_array_expr_5[0], _cast_bits_to_array_expr_flattened_5[0]
+                        connect _cast_bits_to_array_expr_flattened_5[1], bits(bits(rhs.body, 2, 0), 1, 1)
+                        connect _cast_bits_to_array_expr_5[1], _cast_bits_to_array_expr_flattened_5[1]
+                        connect _cast_bits_to_array_expr_flattened_5[2], bits(bits(rhs.body, 2, 0), 2, 2)
+                        connect _cast_bits_to_array_expr_5[2], _cast_bits_to_array_expr_flattened_5[2]
+                        connect _array_literal_expr[2], eq(_cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_5[2])
+                        wire _cast_array_to_bits_expr: UInt<1>[3]
+                        connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
+                        connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
+                        connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
+                        wire _cast_to_bits_expr: UInt<3>
+                        connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
+                        connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
+        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
+",
+    };
+    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
+    assert_export_firrtl! {
+        m =>
+        options: ExportOptions {
+            simplify_enums: Some(SimplifyEnumsKind::ReplaceWithBundleOfUInts),
+            ..ExportOptions::default()
+        },
+        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
+circuit check_enum_cmp_eq:
+    type Ty0 = {tag: UInt<2>, body: UInt<8>}
+    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
+        input lhs: Ty0 @[module-XXXXXXXXXX.rs 2:1]
+        input rhs: Ty0 @[module-XXXXXXXXXX.rs 3:1]
+        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
+        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
+        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
+        when eq(lhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+            when eq(rhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+                connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
+            else when eq(rhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+                skip
+        else when eq(lhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+            when eq(rhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+                skip
+            else when eq(rhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+                connect TestEnum_cmp_eq, eq(bits(lhs.body, 7, 0), bits(rhs.body, 7, 0)) @[module-XXXXXXXXXX.rs 5:1]
+        else when eq(rhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+            skip
+        else when eq(rhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+            skip
+        else:
+            wire _array_literal_expr: UInt<1>[3]
+            wire _cast_bits_to_array_expr: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened[0], bits(bits(lhs.body, 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr[0], _cast_bits_to_array_expr_flattened[0]
+            connect _cast_bits_to_array_expr_flattened[1], bits(bits(lhs.body, 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr[1], _cast_bits_to_array_expr_flattened[1]
+            connect _cast_bits_to_array_expr_flattened[2], bits(bits(lhs.body, 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr[2], _cast_bits_to_array_expr_flattened[2]
+            wire _cast_bits_to_array_expr_1: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_1: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_1[0], bits(bits(rhs.body, 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_1[0], _cast_bits_to_array_expr_flattened_1[0]
+            connect _cast_bits_to_array_expr_flattened_1[1], bits(bits(rhs.body, 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_1[1], _cast_bits_to_array_expr_flattened_1[1]
+            connect _cast_bits_to_array_expr_flattened_1[2], bits(bits(rhs.body, 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_1[2], _cast_bits_to_array_expr_flattened_1[2]
+            connect _array_literal_expr[0], eq(_cast_bits_to_array_expr[0], _cast_bits_to_array_expr_1[0])
+            wire _cast_bits_to_array_expr_2: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_2: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_2[0], bits(bits(lhs.body, 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_2[0], _cast_bits_to_array_expr_flattened_2[0]
+            connect _cast_bits_to_array_expr_flattened_2[1], bits(bits(lhs.body, 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_flattened_2[1]
+            connect _cast_bits_to_array_expr_flattened_2[2], bits(bits(lhs.body, 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_2[2], _cast_bits_to_array_expr_flattened_2[2]
+            wire _cast_bits_to_array_expr_3: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_3: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_3[0], bits(bits(rhs.body, 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_3[0], _cast_bits_to_array_expr_flattened_3[0]
+            connect _cast_bits_to_array_expr_flattened_3[1], bits(bits(rhs.body, 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_3[1], _cast_bits_to_array_expr_flattened_3[1]
+            connect _cast_bits_to_array_expr_flattened_3[2], bits(bits(rhs.body, 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_3[2], _cast_bits_to_array_expr_flattened_3[2]
+            connect _array_literal_expr[1], eq(_cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_3[1])
+            wire _cast_bits_to_array_expr_4: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_4: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_4[0], bits(bits(lhs.body, 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_4[0], _cast_bits_to_array_expr_flattened_4[0]
+            connect _cast_bits_to_array_expr_flattened_4[1], bits(bits(lhs.body, 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_4[1], _cast_bits_to_array_expr_flattened_4[1]
+            connect _cast_bits_to_array_expr_flattened_4[2], bits(bits(lhs.body, 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_flattened_4[2]
+            wire _cast_bits_to_array_expr_5: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_5: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_5[0], bits(bits(rhs.body, 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_5[0], _cast_bits_to_array_expr_flattened_5[0]
+            connect _cast_bits_to_array_expr_flattened_5[1], bits(bits(rhs.body, 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_5[1], _cast_bits_to_array_expr_flattened_5[1]
+            connect _cast_bits_to_array_expr_flattened_5[2], bits(bits(rhs.body, 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_5[2], _cast_bits_to_array_expr_flattened_5[2]
+            connect _array_literal_expr[2], eq(_cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_5[2])
+            wire _cast_array_to_bits_expr: UInt<1>[3]
+            connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
+            connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
+            connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
+            wire _cast_to_bits_expr: UInt<3>
+            connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
+            connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
+        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
+",
+    };
+    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
+    assert_export_firrtl! {
+        m =>
+        options: ExportOptions {
+            simplify_enums: Some(SimplifyEnumsKind::ReplaceWithUInt),
+            ..ExportOptions::default()
+        },
+        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
+circuit check_enum_cmp_eq:
+    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
+        input lhs: UInt<10> @[module-XXXXXXXXXX.rs 2:1]
+        input rhs: UInt<10> @[module-XXXXXXXXXX.rs 3:1]
+        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
+        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
+        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
+        when eq(bits(lhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+            when eq(bits(rhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+                connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
+            else when eq(bits(rhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+                skip
+        else when eq(bits(lhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+            when eq(bits(rhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+                skip
+            else when eq(bits(rhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+                connect TestEnum_cmp_eq, eq(bits(bits(lhs, 9, 2), 7, 0), bits(bits(rhs, 9, 2), 7, 0)) @[module-XXXXXXXXXX.rs 5:1]
+        else when eq(bits(rhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
+            skip
+        else when eq(bits(rhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
+            skip
+        else:
+            wire _array_literal_expr: UInt<1>[3]
+            wire _cast_bits_to_array_expr: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened[0], bits(bits(bits(lhs, 9, 2), 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr[0], _cast_bits_to_array_expr_flattened[0]
+            connect _cast_bits_to_array_expr_flattened[1], bits(bits(bits(lhs, 9, 2), 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr[1], _cast_bits_to_array_expr_flattened[1]
+            connect _cast_bits_to_array_expr_flattened[2], bits(bits(bits(lhs, 9, 2), 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr[2], _cast_bits_to_array_expr_flattened[2]
+            wire _cast_bits_to_array_expr_1: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_1: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_1[0], bits(bits(bits(rhs, 9, 2), 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_1[0], _cast_bits_to_array_expr_flattened_1[0]
+            connect _cast_bits_to_array_expr_flattened_1[1], bits(bits(bits(rhs, 9, 2), 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_1[1], _cast_bits_to_array_expr_flattened_1[1]
+            connect _cast_bits_to_array_expr_flattened_1[2], bits(bits(bits(rhs, 9, 2), 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_1[2], _cast_bits_to_array_expr_flattened_1[2]
+            connect _array_literal_expr[0], eq(_cast_bits_to_array_expr[0], _cast_bits_to_array_expr_1[0])
+            wire _cast_bits_to_array_expr_2: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_2: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_2[0], bits(bits(bits(lhs, 9, 2), 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_2[0], _cast_bits_to_array_expr_flattened_2[0]
+            connect _cast_bits_to_array_expr_flattened_2[1], bits(bits(bits(lhs, 9, 2), 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_flattened_2[1]
+            connect _cast_bits_to_array_expr_flattened_2[2], bits(bits(bits(lhs, 9, 2), 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_2[2], _cast_bits_to_array_expr_flattened_2[2]
+            wire _cast_bits_to_array_expr_3: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_3: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_3[0], bits(bits(bits(rhs, 9, 2), 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_3[0], _cast_bits_to_array_expr_flattened_3[0]
+            connect _cast_bits_to_array_expr_flattened_3[1], bits(bits(bits(rhs, 9, 2), 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_3[1], _cast_bits_to_array_expr_flattened_3[1]
+            connect _cast_bits_to_array_expr_flattened_3[2], bits(bits(bits(rhs, 9, 2), 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_3[2], _cast_bits_to_array_expr_flattened_3[2]
+            connect _array_literal_expr[1], eq(_cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_3[1])
+            wire _cast_bits_to_array_expr_4: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_4: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_4[0], bits(bits(bits(lhs, 9, 2), 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_4[0], _cast_bits_to_array_expr_flattened_4[0]
+            connect _cast_bits_to_array_expr_flattened_4[1], bits(bits(bits(lhs, 9, 2), 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_4[1], _cast_bits_to_array_expr_flattened_4[1]
+            connect _cast_bits_to_array_expr_flattened_4[2], bits(bits(bits(lhs, 9, 2), 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_flattened_4[2]
+            wire _cast_bits_to_array_expr_5: UInt<1>[3]
+            wire _cast_bits_to_array_expr_flattened_5: UInt<1>[3]
+            connect _cast_bits_to_array_expr_flattened_5[0], bits(bits(bits(rhs, 9, 2), 2, 0), 0, 0)
+            connect _cast_bits_to_array_expr_5[0], _cast_bits_to_array_expr_flattened_5[0]
+            connect _cast_bits_to_array_expr_flattened_5[1], bits(bits(bits(rhs, 9, 2), 2, 0), 1, 1)
+            connect _cast_bits_to_array_expr_5[1], _cast_bits_to_array_expr_flattened_5[1]
+            connect _cast_bits_to_array_expr_flattened_5[2], bits(bits(bits(rhs, 9, 2), 2, 0), 2, 2)
+            connect _cast_bits_to_array_expr_5[2], _cast_bits_to_array_expr_flattened_5[2]
+            connect _array_literal_expr[2], eq(_cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_5[2])
+            wire _cast_array_to_bits_expr: UInt<1>[3]
+            connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
+            connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
+            connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
+            wire _cast_to_bits_expr: UInt<3>
+            connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
+            connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
+        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
+",
+    };
+}
+
 #[hdl_module(outline_generated)]
 pub fn check_struct_enum_match() {
     #[hdl]

crates/fayalite/tests/sim.rs

@@ -550,6 +550,150 @@ fn test_enums() {
     }
 }
 
+#[hdl]
+pub enum EnumWithSimpleBody {
+    A(UInt<8>),
+    B(UInt<8>),
+    C(UInt<8>),
+}
+
+#[hdl_module(outline_generated)]
+pub fn enum_with_simple_body() {
+    #[hdl]
+    let which_in: UInt<8> = m.input();
+    #[hdl]
+    let data_in: UInt<8> = m.input();
+    #[hdl]
+    let which_out: UInt<8> = m.output();
+    #[hdl]
+    let data_out: UInt<8> = m.output();
+    #[hdl]
+    let enum_out: EnumWithSimpleBody = m.output();
+
+    #[hdl]
+    if which_in.cmp_eq(0u8) {
+        connect(enum_out, EnumWithSimpleBody.A(data_in));
+    } else if which_in.cmp_eq(1u8) {
+        connect(enum_out, EnumWithSimpleBody.B(data_in));
+    } else {
+        connect(enum_out, EnumWithSimpleBody.C(data_in));
+    }
+
+    #[hdl]
+    match enum_out {
+        EnumWithSimpleBody::A(v) => {
+            connect(which_out, 0u8);
+            connect(data_out, v);
+        }
+        EnumWithSimpleBody::B(v) => {
+            connect(which_out, 1u8);
+            connect(data_out, v);
+        }
+        EnumWithSimpleBody::C(v) => {
+            connect(which_out, 2u8);
+            connect(data_out, v);
+        }
+    }
+}
+
+#[hdl]
+#[test]
+fn test_enum_with_simple_body() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    let mut sim = Simulation::new(enum_with_simple_body());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    for which in 0u8..=2 {
+        for data in (0..u8::MAX).step_by(45) {
+            sim.write(sim.io().which_in, which);
+            sim.write(sim.io().data_in, data);
+            sim.advance_time(SimDuration::from_micros(1));
+            assert_eq!(sim.read(sim.io().which_out).as_int(), which);
+            assert_eq!(sim.read(sim.io().data_out).as_int(), data);
+        }
+    }
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    #[derive(Debug)]
+    struct WireState<'a> {
+        name: &'a str,
+        space_then_id: Option<&'a str>,
+        value: Option<&'a str>,
+    }
+    impl<'a> WireState<'a> {
+        fn new(name: &'a str) -> Self {
+            Self {
+                name,
+                space_then_id: None,
+                value: None,
+            }
+        }
+    }
+    let mut variant_wires = [
+        WireState::new("A"),
+        WireState::new("B"),
+        WireState::new("C"),
+    ];
+    // check that output .vcd has the proper values for all variants' wires
+    for (is_last, line) in vcd.lines().map(|line| (false, line)).chain([(true, "")]) {
+        if let Some(line) = line.strip_prefix("$var wire 8")
+            && let Some(line) = line.strip_suffix(" $end")
+            && let Some((space_then_id, state)) = variant_wires
+                .iter_mut()
+                .find_map(|state| Some((line.strip_suffix(state.name)?.strip_suffix(" ")?, state)))
+        {
+            assert_eq!(space_then_id.chars().next(), Some(' '));
+            assert!(
+                space_then_id
+                    .chars()
+                    .skip(1)
+                    .all(|ch| matches!(ch, '!'..='~'))
+            );
+            assert_eq!(state.space_then_id.replace(space_then_id), None);
+        } else if line.starts_with("#") || is_last {
+            let Some(expected_value) = variant_wires[0].value else {
+                panic!(
+                    "variant {} hasn't been initialized before a timestamp or EOF: {variant_wires:#?}\n\
+                    line={line:?}",
+                    variant_wires[0].name,
+                );
+            };
+            for state in &variant_wires {
+                assert_eq!(
+                    state.value,
+                    Some(expected_value),
+                    "at a timestamp or EOF: variant value for {} doesn't match expected value.\n\
+                    {variant_wires:#?}\nline={line:?}",
+                    state.name,
+                );
+            }
+        } else if line.starts_with("b") {
+            for state in &mut variant_wires {
+                let Some(space_then_id) = state.space_then_id else {
+                    let name = state.name;
+                    panic!(
+                        "variant {name} hasn't had an id assigned yet: {variant_wires:#?}\n\
+                        line={line:?}",
+                    );
+                };
+                if let Some(value) = line.strip_suffix(space_then_id) {
+                    state.value = Some(value);
+                    break;
+                }
+            }
+        }
+    }
+    if vcd != include_str!("sim/expected/enum_with_simple_body.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/enum_with_simple_body.txt") {
+        panic!();
+    }
+}
+
 #[hdl_module(outline_generated)]
 pub fn memories() {
     #[hdl]

crates/fayalite/tests/sim/expected/array_rw.txt

@@ -1218,6 +1218,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1227,6 +1228,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1236,6 +1238,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1245,6 +1248,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1254,6 +1258,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1263,6 +1268,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1272,6 +1278,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1281,6 +1288,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1290,6 +1298,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1299,6 +1308,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1308,6 +1318,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1317,6 +1328,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1326,6 +1338,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1335,6 +1348,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(13),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1344,6 +1358,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1353,6 +1368,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfe,
             last_state: 0xfe,
         },
@@ -1362,6 +1378,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1371,6 +1388,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1380,6 +1398,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1389,6 +1408,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(19),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1398,6 +1418,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1407,6 +1428,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1416,6 +1438,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1425,6 +1448,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(23),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1434,6 +1458,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(24),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1443,6 +1468,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1452,6 +1478,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(26),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1461,6 +1488,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(27),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1470,6 +1498,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(28),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1479,6 +1508,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(29),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1488,6 +1518,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(30),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1497,6 +1528,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(31),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfe,
             last_state: 0xe1,
         },
@@ -1506,6 +1538,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(32),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1515,6 +1548,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(33),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1524,6 +1558,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x10,
             last_state: 0x0f,
         },
@@ -1533,6 +1568,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0xe1,
         },
@@ -1541,6 +1577,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1550,6 +1587,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1559,6 +1597,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(38),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1568,6 +1607,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(39),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1577,6 +1617,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(40),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1586,6 +1627,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(41),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1595,6 +1637,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1604,6 +1647,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(43),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1613,6 +1657,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(44),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1622,6 +1667,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(45),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1631,6 +1677,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(46),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1640,6 +1687,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(47),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1649,6 +1697,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(48),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1658,6 +1707,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(49),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1667,6 +1717,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(50),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1676,6 +1727,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(51),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1685,6 +1737,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(52),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfe,
             last_state: 0xe1,
         },

crates/fayalite/tests/sim/expected/conditional_assignment_last.txt

@@ -155,6 +155,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -163,6 +164,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },

crates/fayalite/tests/sim/expected/connect_const.txt

@@ -124,6 +124,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x05,
             last_state: 0x05,
         },

crates/fayalite/tests/sim/expected/connect_const_reset.txt

@@ -175,6 +175,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -183,6 +184,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },

crates/fayalite/tests/sim/expected/counter_async.txt

@@ -332,6 +332,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -340,6 +341,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -349,6 +351,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -358,6 +361,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },

crates/fayalite/tests/sim/expected/counter_sync.txt

@@ -313,6 +313,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -321,6 +322,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -330,6 +332,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -339,6 +342,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },

crates/fayalite/tests/sim/expected/duplicate_names.txt

@@ -137,6 +137,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x05,
             last_state: 0x05,
         },
@@ -146,6 +147,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x06,
             last_state: 0x06,
         },

crates/fayalite/tests/sim/expected/enum_with_simple_body.txt

@@ -0,0 +1,749 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Enum {
+                                    A,
+                                    B,
+                                    C,
+                                },
+                            },
+                        ],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 33,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_in",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out",
+                                ty: Enum {
+                                    A(UInt<8>),
+                                    B(UInt<8>),
+                                    C(UInt<8>),
+                                },
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: ".0",
+                                ty: UInt<2>,
+                            },
+                            SlotDebugData {
+                                name: ".1",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<2>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Enum {
+                                    A(UInt<8>),
+                                    B(UInt<8>),
+                                    C(UInt<8>),
+                                },
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: ".0",
+                                ty: UInt<2>,
+                            },
+                            SlotDebugData {
+                                name: ".1",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<2>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Enum {
+                                    A(UInt<8>),
+                                    B(UInt<8>),
+                                    C(UInt<8>),
+                                },
+                            },
+                            SlotDebugData {
+                                name: ".0",
+                                ty: UInt<2>,
+                            },
+                            SlotDebugData {
+                                name: ".1",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<2>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<10>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Enum {
+                                    A(UInt<8>),
+                                    B(UInt<8>),
+                                    C(UInt<8>),
+                                },
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<8>,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 0,
+                    debug_data: [],
+                    layout_data: [],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Const {
+                    dest: StatePartIndex<BigSlots>(32), // (0x2) SlotDebugData { name: "", ty: UInt<8> },
+                    value: 0x2,
+                },
+                1: Const {
+                    dest: StatePartIndex<BigSlots>(27), // (0x2) SlotDebugData { name: "", ty: UInt<2> },
+                    value: 0x2,
+                },
+                2: Copy {
+                    dest: StatePartIndex<BigSlots>(25), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> },
+                    src: StatePartIndex<BigSlots>(27), // (0x2) SlotDebugData { name: "", ty: UInt<2> },
+                },
+                3: Copy {
+                    dest: StatePartIndex<BigSlots>(26), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(1), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in", ty: UInt<8> },
+                },
+                4: Shl {
+                    dest: StatePartIndex<BigSlots>(28), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                    lhs: StatePartIndex<BigSlots>(26), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
+                    rhs: 2,
+                },
+                5: Or {
+                    dest: StatePartIndex<BigSlots>(29), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
+                    lhs: StatePartIndex<BigSlots>(25), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> },
+                    rhs: StatePartIndex<BigSlots>(28), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                },
+                6: CastToUInt {
+                    dest: StatePartIndex<BigSlots>(30), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
+                    src: StatePartIndex<BigSlots>(29), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
+                    dest_width: 10,
+                },
+                7: Copy {
+                    dest: StatePartIndex<BigSlots>(31), // (0x386) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                    src: StatePartIndex<BigSlots>(30), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
+                },
+                8: Const {
+                    dest: StatePartIndex<BigSlots>(20), // (0x1) SlotDebugData { name: "", ty: UInt<2> },
+                    value: 0x1,
+                },
+                9: Copy {
+                    dest: StatePartIndex<BigSlots>(18), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> },
+                    src: StatePartIndex<BigSlots>(20), // (0x1) SlotDebugData { name: "", ty: UInt<2> },
+                },
+                10: Copy {
+                    dest: StatePartIndex<BigSlots>(19), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(1), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in", ty: UInt<8> },
+                },
+                11: Shl {
+                    dest: StatePartIndex<BigSlots>(21), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                    lhs: StatePartIndex<BigSlots>(19), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
+                    rhs: 2,
+                },
+                12: Or {
+                    dest: StatePartIndex<BigSlots>(22), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
+                    lhs: StatePartIndex<BigSlots>(18), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> },
+                    rhs: StatePartIndex<BigSlots>(21), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                },
+                13: CastToUInt {
+                    dest: StatePartIndex<BigSlots>(23), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
+                    src: StatePartIndex<BigSlots>(22), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
+                    dest_width: 10,
+                },
+                14: Copy {
+                    dest: StatePartIndex<BigSlots>(24), // (0x385) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                    src: StatePartIndex<BigSlots>(23), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
+                },
+                15: Const {
+                    dest: StatePartIndex<BigSlots>(16), // (0x1) SlotDebugData { name: "", ty: UInt<8> },
+                    value: 0x1,
+                },
+                16: CmpEq {
+                    dest: StatePartIndex<BigSlots>(17), // (0x0) SlotDebugData { name: "", ty: Bool },
+                    lhs: StatePartIndex<BigSlots>(0), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_in", ty: UInt<8> },
+                    rhs: StatePartIndex<BigSlots>(16), // (0x1) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                17: Const {
+                    dest: StatePartIndex<BigSlots>(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> },
+                    value: 0x0,
+                },
+                18: Copy {
+                    dest: StatePartIndex<BigSlots>(9), // (0x0) SlotDebugData { name: ".0", ty: UInt<2> },
+                    src: StatePartIndex<BigSlots>(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> },
+                },
+                19: Copy {
+                    dest: StatePartIndex<BigSlots>(10), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(1), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in", ty: UInt<8> },
+                },
+                20: Shl {
+                    dest: StatePartIndex<BigSlots>(12), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                    lhs: StatePartIndex<BigSlots>(10), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
+                    rhs: 2,
+                },
+                21: Or {
+                    dest: StatePartIndex<BigSlots>(13), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                    lhs: StatePartIndex<BigSlots>(9), // (0x0) SlotDebugData { name: ".0", ty: UInt<2> },
+                    rhs: StatePartIndex<BigSlots>(12), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                },
+                22: CastToUInt {
+                    dest: StatePartIndex<BigSlots>(14), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                    src: StatePartIndex<BigSlots>(13), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                    dest_width: 10,
+                },
+                23: Copy {
+                    dest: StatePartIndex<BigSlots>(15), // (0x384) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                    src: StatePartIndex<BigSlots>(14), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
+                },
+                24: Const {
+                    dest: StatePartIndex<BigSlots>(7), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
+                    value: 0x0,
+                },
+                25: CmpEq {
+                    dest: StatePartIndex<BigSlots>(8), // (0x0) SlotDebugData { name: "", ty: Bool },
+                    lhs: StatePartIndex<BigSlots>(0), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_in", ty: UInt<8> },
+                    rhs: StatePartIndex<BigSlots>(7), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                // at: module-XXXXXXXXXX.rs:7:1
+                26: BranchIfZero {
+                    target: 28,
+                    value: StatePartIndex<BigSlots>(8), // (0x0) SlotDebugData { name: "", ty: Bool },
+                },
+                // at: module-XXXXXXXXXX.rs:8:1
+                27: Copy {
+                    dest: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                    src: StatePartIndex<BigSlots>(15), // (0x384) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                },
+                // at: module-XXXXXXXXXX.rs:7:1
+                28: BranchIfNonZero {
+                    target: 33,
+                    value: StatePartIndex<BigSlots>(8), // (0x0) SlotDebugData { name: "", ty: Bool },
+                },
+                // at: module-XXXXXXXXXX.rs:9:1
+                29: BranchIfZero {
+                    target: 31,
+                    value: StatePartIndex<BigSlots>(17), // (0x0) SlotDebugData { name: "", ty: Bool },
+                },
+                // at: module-XXXXXXXXXX.rs:10:1
+                30: Copy {
+                    dest: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                    src: StatePartIndex<BigSlots>(24), // (0x385) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                },
+                // at: module-XXXXXXXXXX.rs:9:1
+                31: BranchIfNonZero {
+                    target: 33,
+                    value: StatePartIndex<BigSlots>(17), // (0x0) SlotDebugData { name: "", ty: Bool },
+                },
+                // at: module-XXXXXXXXXX.rs:11:1
+                32: Copy {
+                    dest: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                    src: StatePartIndex<BigSlots>(31), // (0x386) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                },
+                // at: module-XXXXXXXXXX.rs:1:1
+                33: Copy {
+                    dest: StatePartIndex<BigSlots>(5), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
+                    src: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                },
+                34: SliceInt {
+                    dest: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(5), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
+                    start: 2,
+                    len: 8,
+                },
+                // at: module-XXXXXXXXXX.rs:6:1
+                35: AndBigWithSmallImmediate {
+                    dest: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
+                    lhs: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
+                    rhs: 0x3,
+                },
+                // at: module-XXXXXXXXXX.rs:12:1
+                36: BranchIfSmallNeImmediate {
+                    target: 39,
+                    lhs: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
+                    rhs: 0x0,
+                },
+                // at: module-XXXXXXXXXX.rs:13:1
+                37: Copy {
+                    dest: StatePartIndex<BigSlots>(2), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(7), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                // at: module-XXXXXXXXXX.rs:14:1
+                38: Copy {
+                    dest: StatePartIndex<BigSlots>(3), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                // at: module-XXXXXXXXXX.rs:12:1
+                39: BranchIfSmallNeImmediate {
+                    target: 42,
+                    lhs: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
+                    rhs: 0x1,
+                },
+                // at: module-XXXXXXXXXX.rs:15:1
+                40: Copy {
+                    dest: StatePartIndex<BigSlots>(2), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(16), // (0x1) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                // at: module-XXXXXXXXXX.rs:16:1
+                41: Copy {
+                    dest: StatePartIndex<BigSlots>(3), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                // at: module-XXXXXXXXXX.rs:12:1
+                42: BranchIfSmallNeImmediate {
+                    target: 45,
+                    lhs: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
+                    rhs: 0x2,
+                },
+                // at: module-XXXXXXXXXX.rs:17:1
+                43: Copy {
+                    dest: StatePartIndex<BigSlots>(2), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(32), // (0x2) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                // at: module-XXXXXXXXXX.rs:18:1
+                44: Copy {
+                    dest: StatePartIndex<BigSlots>(3), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out", ty: UInt<8> },
+                    src: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
+                },
+                // at: module-XXXXXXXXXX.rs:1:1
+                45: Return,
+            ],
+            ..
+        },
+        pc: 45,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [],
+        },
+        small_slots: StatePart {
+            value: [
+                2,
+            ],
+        },
+        big_slots: StatePart {
+            value: [
+                2,
+                225,
+                2 (modified),
+                225 (modified),
+                902,
+                902,
+                225,
+                0,
+                0,
+                0,
+                225,
+                0,
+                900,
+                900,
+                900,
+                900,
+                1,
+                0,
+                1,
+                225,
+                1,
+                900,
+                901,
+                901,
+                901,
+                2,
+                225,
+                2,
+                900,
+                902,
+                902,
+                902,
+                2,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::enum_with_simple_body,
+        instantiated: Module {
+            name: enum_with_simple_body,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.which_in,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.data_in,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.which_out,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.data_out,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.enum_out,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.data_in,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.data_out,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.enum_out,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.which_in,
+            Instance {
+                name: <simulator>::enum_with_simple_body,
+                instantiated: Module {
+                    name: enum_with_simple_body,
+                    ..
+                },
+            }.which_out,
+        },
+        did_initial_settle: true,
+        clocks_for_past: {},
+    },
+    extern_modules: [],
+    trace_decls: TraceModule {
+        name: "enum_with_simple_body",
+        children: [
+            TraceModuleIO {
+                name: "which_in",
+                child: TraceUInt {
+                    location: TraceScalarId(0),
+                    name: "which_in",
+                    ty: UInt<8>,
+                    flow: Source,
+                },
+                ty: UInt<8>,
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "data_in",
+                child: TraceUInt {
+                    location: TraceScalarId(1),
+                    name: "data_in",
+                    ty: UInt<8>,
+                    flow: Source,
+                },
+                ty: UInt<8>,
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "which_out",
+                child: TraceUInt {
+                    location: TraceScalarId(2),
+                    name: "which_out",
+                    ty: UInt<8>,
+                    flow: Sink,
+                },
+                ty: UInt<8>,
+                flow: Sink,
+            },
+            TraceModuleIO {
+                name: "data_out",
+                child: TraceUInt {
+                    location: TraceScalarId(3),
+                    name: "data_out",
+                    ty: UInt<8>,
+                    flow: Sink,
+                },
+                ty: UInt<8>,
+                flow: Sink,
+            },
+            TraceModuleIO {
+                name: "enum_out",
+                child: TraceEnumWithFields {
+                    name: "enum_out",
+                    discriminant: TraceEnumDiscriminant {
+                        location: TraceScalarId(4),
+                        name: "$tag",
+                        ty: Enum {
+                            A(UInt<8>),
+                            B(UInt<8>),
+                            C(UInt<8>),
+                        },
+                        flow: Sink,
+                    },
+                    non_empty_fields: [
+                        TraceUInt {
+                            location: TraceScalarId(5),
+                            name: "A",
+                            ty: UInt<8>,
+                            flow: Source,
+                        },
+                        TraceUInt {
+                            location: TraceScalarId(6),
+                            name: "B",
+                            ty: UInt<8>,
+                            flow: Source,
+                        },
+                        TraceUInt {
+                            location: TraceScalarId(7),
+                            name: "C",
+                            ty: UInt<8>,
+                            flow: Source,
+                        },
+                    ],
+                    ty: Enum {
+                        A(UInt<8>),
+                        B(UInt<8>),
+                        C(UInt<8>),
+                    },
+                    flow: Sink,
+                },
+                ty: Enum {
+                    A(UInt<8>),
+                    B(UInt<8>),
+                    C(UInt<8>),
+                },
+                flow: Sink,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(0),
+                ty: UInt<8>,
+            },
+            maybe_changed: true,
+            state: 0x02,
+            last_state: 0x02,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(1),
+                ty: UInt<8>,
+            },
+            maybe_changed: true,
+            state: 0xe1,
+            last_state: 0xb4,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(2),
+                ty: UInt<8>,
+            },
+            maybe_changed: true,
+            state: 0x02,
+            last_state: 0x02,
+        },
+        SimTrace {
+            id: TraceScalarId(3),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(3),
+                ty: UInt<8>,
+            },
+            maybe_changed: true,
+            state: 0xe1,
+            last_state: 0xb4,
+        },
+        SimTrace {
+            id: TraceScalarId(4),
+            kind: EnumDiscriminant {
+                index: StatePartIndex<SmallSlots>(0),
+                ty: Enum {
+                    A(UInt<8>),
+                    B(UInt<8>),
+                    C(UInt<8>),
+                },
+            },
+            maybe_changed: true,
+            state: 0x2,
+            last_state: 0x2,
+        },
+        SimTrace {
+            id: TraceScalarId(5),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(6),
+                ty: UInt<8>,
+            },
+            maybe_changed: true,
+            state: 0xe1,
+            last_state: 0xb4,
+        },
+        SimTrace {
+            id: TraceScalarId(6),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(6),
+                ty: UInt<8>,
+            },
+            maybe_changed: true,
+            state: 0xe1,
+            last_state: 0xb4,
+        },
+        SimTrace {
+            id: TraceScalarId(7),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(6),
+                ty: UInt<8>,
+            },
+            maybe_changed: true,
+            state: 0xe1,
+            last_state: 0xb4,
+        },
+    ],
+    trace_memories: {},
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 18 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
+    ..
+}

crates/fayalite/tests/sim/expected/enum_with_simple_body.vcd

@@ -0,0 +1,133 @@
+$timescale 1 ps $end
+$scope module enum_with_simple_body $end
+$var wire 8 J&-ne which_in $end
+$var wire 8 \7mo/ data_in $end
+$var wire 8 ,`>ir which_out $end
+$var wire 8 0_gMP data_out $end
+$scope struct enum_out $end
+$var string 1 kFH/w \$tag $end
+$var wire 8 |EI_= A $end
+$var wire 8 !pRd4 B $end
+$var wire 8 &RAbd C $end
+$upscope $end
+$upscope $end
+$enddefinitions $end
+$dumpvars
+b0 J&-ne
+b0 \7mo/
+b0 ,`>ir
+b0 0_gMP
+sA\x20(0) kFH/w
+b0 |EI_=
+b0 !pRd4
+b0 &RAbd
+$end
+#1000000
+b101101 \7mo/
+b101101 0_gMP
+b101101 |EI_=
+b101101 !pRd4
+b101101 &RAbd
+#2000000
+b1011010 \7mo/
+b1011010 0_gMP
+b1011010 |EI_=
+b1011010 !pRd4
+b1011010 &RAbd
+#3000000
+b10000111 \7mo/
+b10000111 0_gMP
+b10000111 |EI_=
+b10000111 !pRd4
+b10000111 &RAbd
+#4000000
+b10110100 \7mo/
+b10110100 0_gMP
+b10110100 |EI_=
+b10110100 !pRd4
+b10110100 &RAbd
+#5000000
+b11100001 \7mo/
+b11100001 0_gMP
+b11100001 |EI_=
+b11100001 !pRd4
+b11100001 &RAbd
+#6000000
+b1 J&-ne
+b0 \7mo/
+b1 ,`>ir
+b0 0_gMP
+sB\x20(1) kFH/w
+b0 |EI_=
+b0 !pRd4
+b0 &RAbd
+#7000000
+b101101 \7mo/
+b101101 0_gMP
+b101101 |EI_=
+b101101 !pRd4
+b101101 &RAbd
+#8000000
+b1011010 \7mo/
+b1011010 0_gMP
+b1011010 |EI_=
+b1011010 !pRd4
+b1011010 &RAbd
+#9000000
+b10000111 \7mo/
+b10000111 0_gMP
+b10000111 |EI_=
+b10000111 !pRd4
+b10000111 &RAbd
+#10000000
+b10110100 \7mo/
+b10110100 0_gMP
+b10110100 |EI_=
+b10110100 !pRd4
+b10110100 &RAbd
+#11000000
+b11100001 \7mo/
+b11100001 0_gMP
+b11100001 |EI_=
+b11100001 !pRd4
+b11100001 &RAbd
+#12000000
+b10 J&-ne
+b0 \7mo/
+b10 ,`>ir
+b0 0_gMP
+sC\x20(2) kFH/w
+b0 |EI_=
+b0 !pRd4
+b0 &RAbd
+#13000000
+b101101 \7mo/
+b101101 0_gMP
+b101101 |EI_=
+b101101 !pRd4
+b101101 &RAbd
+#14000000
+b1011010 \7mo/
+b1011010 0_gMP
+b1011010 |EI_=
+b1011010 !pRd4
+b1011010 &RAbd
+#15000000
+b10000111 \7mo/
+b10000111 0_gMP
+b10000111 |EI_=
+b10000111 !pRd4
+b10000111 &RAbd
+#16000000
+b10110100 \7mo/
+b10110100 0_gMP
+b10110100 |EI_=
+b10110100 !pRd4
+b10110100 &RAbd
+#17000000
+b11100001 \7mo/
+b11100001 0_gMP
+b11100001 |EI_=
+b11100001 !pRd4
+b11100001 &RAbd
+#18000000

crates/fayalite/tests/sim/expected/enums.txt

@@ -1746,6 +1746,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -1754,6 +1755,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1762,6 +1764,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1771,6 +1774,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<2>,
             },
+            maybe_changed: false,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1780,6 +1784,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
+            maybe_changed: false,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1789,6 +1794,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1798,6 +1804,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1810,6 +1817,7 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1819,6 +1827,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1827,6 +1836,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1839,6 +1849,7 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1848,6 +1859,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1856,6 +1868,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1869,6 +1882,7 @@ Simulation {
                     C(Bundle {a: Array<UInt<1>, 2>, b: SInt<2>}),
                 },
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1878,6 +1892,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(27),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1886,6 +1901,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(28),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1895,6 +1911,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1904,6 +1921,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1913,6 +1931,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(36),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },

crates/fayalite/tests/sim/expected/extern_module.txt

@@ -221,6 +221,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -229,6 +230,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/extern_module2.txt

@@ -57,7 +57,7 @@ Simulation {
         big_slots: StatePart {
             value: [
                 0,
-                1,
+                1 (modified),
                 101,
             ],
         },
@@ -280,6 +280,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -288,6 +289,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -297,6 +299,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x65,
             last_state: 0x65,
         },

crates/fayalite/tests/sim/expected/last_connect.txt

@@ -433,7 +433,7 @@ Simulation {
                 1,
                 1,
                 1,
-                7,
+                7 (modified),
                 7,
                 3,
                 0,
@@ -614,6 +614,7 @@ Simulation {
                     HdlSome(Array<Bool, 4>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -622,6 +623,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -630,6 +632,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -638,6 +641,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -646,6 +650,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -658,6 +663,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -667,6 +673,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x02,
         },
@@ -676,6 +683,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x02,
         },

crates/fayalite/tests/sim/expected/memories.txt

@@ -1168,6 +1168,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1176,6 +1177,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1184,6 +1186,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1193,6 +1196,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xb0,
             last_state: 0xb0,
         },
@@ -1202,6 +1206,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1211,6 +1216,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1219,6 +1225,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1227,6 +1234,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1236,6 +1244,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xd0,
             last_state: 0xd0,
         },
@@ -1245,6 +1254,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1253,6 +1263,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(10),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1261,6 +1272,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1270,6 +1282,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1278,6 +1291,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1286,6 +1300,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(14),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1295,6 +1310,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xb0,
             last_state: 0xb0,
         },
@@ -1304,6 +1320,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1313,6 +1330,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1321,6 +1339,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(18),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1329,6 +1348,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1338,6 +1358,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xd0,
             last_state: 0xd0,
         },
@@ -1347,6 +1368,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1355,6 +1377,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(22),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1363,6 +1386,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(23),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },

crates/fayalite/tests/sim/expected/memories2.txt

@@ -943,6 +943,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -951,6 +952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -959,6 +961,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -968,6 +971,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -976,6 +980,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -985,6 +990,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<2>,
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -993,6 +999,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1002,6 +1009,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1010,6 +1018,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(8),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1018,6 +1027,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(9),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1030,6 +1040,7 @@ Simulation {
                     HdlSome(Bool),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1038,6 +1049,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1046,6 +1058,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1058,6 +1071,7 @@ Simulation {
                     HdlSome(Bool),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1066,6 +1080,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1074,6 +1089,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/memories3.txt

@@ -2391,6 +2391,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2399,6 +2400,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2407,6 +2409,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2416,6 +2419,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2425,6 +2429,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2434,6 +2439,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2443,6 +2449,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2452,6 +2459,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2461,6 +2469,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2470,6 +2479,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2479,6 +2489,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2488,6 +2499,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2496,6 +2508,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2504,6 +2517,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2513,6 +2527,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2522,6 +2537,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2531,6 +2547,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2540,6 +2557,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2549,6 +2567,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2558,6 +2577,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(19),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2567,6 +2587,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2576,6 +2597,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2584,6 +2606,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(22),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2592,6 +2615,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(23),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2600,6 +2624,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(24),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2608,6 +2633,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(25),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2616,6 +2642,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(26),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2624,6 +2651,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2632,6 +2660,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(28),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2640,6 +2669,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(29),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2649,6 +2679,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(30),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2657,6 +2688,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2665,6 +2697,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2674,6 +2707,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(33),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2683,6 +2717,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2692,6 +2727,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2701,6 +2737,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(36),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2710,6 +2747,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2719,6 +2757,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(38),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2728,6 +2767,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(39),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2737,6 +2777,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(40),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2746,6 +2787,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(57),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2754,6 +2796,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(58),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2762,6 +2805,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(59),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2771,6 +2815,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(60),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2780,6 +2825,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(61),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2789,6 +2835,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(62),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2798,6 +2845,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(63),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2807,6 +2855,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(64),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2816,6 +2865,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(65),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2825,6 +2875,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2834,6 +2885,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(67),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2842,6 +2894,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(68),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2850,6 +2903,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(69),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2858,6 +2912,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(70),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2866,6 +2921,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(71),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2874,6 +2930,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(72),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2882,6 +2939,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(73),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2890,6 +2948,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(74),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2898,6 +2957,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(75),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/mod1.txt

@@ -445,6 +445,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -454,6 +455,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -463,6 +465,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -472,6 +475,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },
@@ -481,6 +485,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -490,6 +495,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -499,6 +505,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -508,6 +515,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },
@@ -517,6 +525,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -526,6 +535,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -535,6 +545,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -544,6 +555,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },

crates/fayalite/tests/sim/expected/phantom_const.txt

@@ -373,6 +373,7 @@ Simulation {
                     ["a","b"],
                 ),
             },
+            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },
@@ -383,6 +384,7 @@ Simulation {
                     ["a","b"],
                 ),
             },
+            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },
@@ -392,6 +394,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -400,6 +403,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -408,6 +412,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -418,6 +423,7 @@ Simulation {
                     "mem_element",
                 ),
             },
+            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },

crates/fayalite/tests/sim/expected/queue_1_false_false.txt

@@ -1722,6 +1722,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1730,6 +1731,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1742,6 +1744,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1751,6 +1754,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1759,6 +1763,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1771,6 +1776,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1780,6 +1786,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1788,6 +1795,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1797,6 +1805,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1806,6 +1815,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1814,6 +1824,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1822,6 +1833,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1831,6 +1843,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1840,6 +1853,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1848,6 +1862,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1856,6 +1871,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1865,6 +1881,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1873,6 +1890,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1882,6 +1900,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1891,6 +1910,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1899,6 +1919,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1907,6 +1928,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1915,6 +1937,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1923,6 +1946,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1931,6 +1955,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1939,6 +1964,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1947,6 +1973,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1955,6 +1982,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1964,6 +1992,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1973,6 +2002,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/queue_1_false_true.txt

@@ -1701,6 +1701,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1709,6 +1710,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1721,6 +1723,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1730,6 +1733,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1738,6 +1742,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1750,6 +1755,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1759,6 +1765,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1767,6 +1774,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1776,6 +1784,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1785,6 +1794,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1793,6 +1803,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1801,6 +1812,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1810,6 +1822,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1819,6 +1832,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1827,6 +1841,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1835,6 +1850,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1844,6 +1860,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1852,6 +1869,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1861,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1870,6 +1889,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1878,6 +1898,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1886,6 +1907,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1894,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1902,6 +1925,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1910,6 +1934,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1918,6 +1943,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1926,6 +1952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1934,6 +1961,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1943,6 +1971,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1952,6 +1981,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(64),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/queue_1_true_false.txt

@@ -1732,6 +1732,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1740,6 +1741,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1752,6 +1754,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1761,6 +1764,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1769,6 +1773,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1781,6 +1786,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1790,6 +1796,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1798,6 +1805,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1807,6 +1815,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1816,6 +1825,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1824,6 +1834,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1832,6 +1843,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1841,6 +1853,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1850,6 +1863,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1858,6 +1872,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1866,6 +1881,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1875,6 +1891,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1883,6 +1900,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1892,6 +1910,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1901,6 +1920,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1909,6 +1929,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1917,6 +1938,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1925,6 +1947,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1933,6 +1956,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1941,6 +1965,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1949,6 +1974,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1957,6 +1983,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1992,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1974,6 +2002,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1983,6 +2012,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/queue_1_true_true.txt

@@ -1711,6 +1711,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1719,6 +1720,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1731,6 +1733,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1740,6 +1743,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1748,6 +1752,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1760,6 +1765,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1769,6 +1775,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1777,6 +1784,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1786,6 +1794,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1795,6 +1804,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1803,6 +1813,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1811,6 +1822,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1820,6 +1832,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1829,6 +1842,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1837,6 +1851,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1845,6 +1860,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1854,6 +1870,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1862,6 +1879,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1871,6 +1889,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1880,6 +1899,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1888,6 +1908,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1896,6 +1917,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1904,6 +1926,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1912,6 +1935,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1920,6 +1944,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1928,6 +1953,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1936,6 +1962,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,6 +1971,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1953,6 +1981,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1962,6 +1991,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(64),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/queue_2_false_false.txt

@@ -1740,6 +1740,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1748,6 +1749,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1760,6 +1762,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1769,6 +1772,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1777,6 +1781,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1789,6 +1794,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1798,6 +1804,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1806,6 +1813,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1815,6 +1823,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1824,6 +1833,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1832,6 +1842,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1840,6 +1851,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1849,6 +1861,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1858,6 +1871,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1866,6 +1880,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1874,6 +1889,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1883,6 +1899,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1891,6 +1908,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1900,6 +1918,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1909,6 +1928,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1917,6 +1937,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1925,6 +1946,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1933,6 +1955,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1941,6 +1964,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1949,6 +1973,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1957,6 +1982,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1991,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1973,6 +2000,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1982,6 +2010,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1991,6 +2020,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },

crates/fayalite/tests/sim/expected/queue_2_false_true.txt

@@ -1719,6 +1719,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1727,6 +1728,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1739,6 +1741,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1748,6 +1751,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1756,6 +1760,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1768,6 +1773,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1777,6 +1783,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1785,6 +1792,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1794,6 +1802,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1803,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1811,6 +1821,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1819,6 +1830,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1828,6 +1840,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1837,6 +1850,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1845,6 +1859,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1853,6 +1868,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1862,6 +1878,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1870,6 +1887,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1879,6 +1897,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1888,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1896,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1904,6 +1925,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1912,6 +1934,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1920,6 +1943,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1928,6 +1952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1936,6 +1961,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,6 +1970,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1952,6 +1979,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1961,6 +1989,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1970,6 +1999,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },

crates/fayalite/tests/sim/expected/queue_2_true_false.txt

@@ -1750,6 +1750,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1758,6 +1759,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1770,6 +1772,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1779,6 +1782,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1787,6 +1791,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1799,6 +1804,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1808,6 +1814,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1816,6 +1823,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1825,6 +1833,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1834,6 +1843,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1842,6 +1852,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1850,6 +1861,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1859,6 +1871,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1868,6 +1881,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1876,6 +1890,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1884,6 +1899,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1893,6 +1909,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1901,6 +1918,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1910,6 +1928,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1919,6 +1938,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1927,6 +1947,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1935,6 +1956,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1943,6 +1965,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1951,6 +1974,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1959,6 +1983,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1967,6 +1992,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1975,6 +2001,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1983,6 +2010,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1992,6 +2020,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -2001,6 +2030,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/queue_2_true_true.txt

@@ -1729,6 +1729,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1737,6 +1738,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1749,6 +1751,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1758,6 +1761,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1766,6 +1770,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1778,6 +1783,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1787,6 +1793,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1795,6 +1802,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1804,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1813,6 +1822,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1821,6 +1831,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1829,6 +1840,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1838,6 +1850,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1847,6 +1860,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1855,6 +1869,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1863,6 +1878,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1872,6 +1888,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1880,6 +1897,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1889,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1898,6 +1917,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1906,6 +1926,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1914,6 +1935,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1922,6 +1944,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1930,6 +1953,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1938,6 +1962,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1946,6 +1971,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1954,6 +1980,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1962,6 +1989,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1971,6 +1999,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1980,6 +2009,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/queue_3_false_false.txt

@@ -1759,6 +1759,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1767,6 +1768,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1779,6 +1781,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1788,6 +1791,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },
@@ -1796,6 +1800,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1808,6 +1813,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1817,6 +1823,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1825,6 +1832,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1834,6 +1842,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1843,6 +1852,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1851,6 +1861,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1859,6 +1870,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1868,6 +1880,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1877,6 +1890,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1885,6 +1899,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1893,6 +1908,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1902,6 +1918,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },
@@ -1910,6 +1927,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1919,6 +1937,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1928,6 +1947,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1936,6 +1956,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1944,6 +1965,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1952,6 +1974,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1960,6 +1983,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1968,6 +1992,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1976,6 +2001,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1984,6 +2010,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1992,6 +2019,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2001,6 +2029,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },

crates/fayalite/tests/sim/expected/queue_3_false_true.txt

@@ -1738,6 +1738,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1746,6 +1747,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1758,6 +1760,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1767,6 +1770,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1775,6 +1779,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1787,6 +1792,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1796,6 +1802,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1804,6 +1811,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1813,6 +1821,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1822,6 +1831,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1830,6 +1840,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1838,6 +1849,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1847,6 +1859,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1856,6 +1869,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1864,6 +1878,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1872,6 +1887,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1881,6 +1897,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1889,6 +1906,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1898,6 +1916,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1907,6 +1926,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1915,6 +1935,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1923,6 +1944,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1931,6 +1953,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1939,6 +1962,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1947,6 +1971,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1955,6 +1980,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1963,6 +1989,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1971,6 +1998,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1980,6 +2008,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },

crates/fayalite/tests/sim/expected/queue_3_true_false.txt

@@ -1769,6 +1769,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1777,6 +1778,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1789,6 +1791,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1798,6 +1801,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1806,6 +1810,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1818,6 +1823,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1827,6 +1833,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1835,6 +1842,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1844,6 +1852,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1853,6 +1862,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1861,6 +1871,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1869,6 +1880,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1878,6 +1890,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1887,6 +1900,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1895,6 +1909,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1903,6 +1918,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1912,6 +1928,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1920,6 +1937,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1929,6 +1947,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1938,6 +1957,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1946,6 +1966,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1954,6 +1975,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1962,6 +1984,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1970,6 +1993,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1978,6 +2002,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1986,6 +2011,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1994,6 +2020,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2002,6 +2029,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2011,6 +2039,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },

crates/fayalite/tests/sim/expected/queue_3_true_true.txt

@@ -1748,6 +1748,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1756,6 +1757,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1768,6 +1770,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1777,6 +1780,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1785,6 +1789,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1797,6 +1802,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1806,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1814,6 +1821,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1823,6 +1831,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1832,6 +1841,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1840,6 +1850,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1848,6 +1859,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1857,6 +1869,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1866,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1874,6 +1888,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1882,6 +1897,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1891,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1899,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1908,6 +1926,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1917,6 +1936,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1925,6 +1945,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1933,6 +1954,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1941,6 +1963,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1949,6 +1972,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1957,6 +1981,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1990,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1973,6 +1999,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1981,6 +2008,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1990,6 +2018,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },

crates/fayalite/tests/sim/expected/queue_4_false_false.txt

@@ -1748,6 +1748,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1756,6 +1757,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1768,6 +1770,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1777,6 +1780,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1785,6 +1789,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1797,6 +1802,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1806,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1814,6 +1821,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1823,6 +1831,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1832,6 +1841,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1840,6 +1850,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1848,6 +1859,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1857,6 +1869,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1866,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1874,6 +1888,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1882,6 +1897,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1891,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1899,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1908,6 +1926,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1917,6 +1936,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1925,6 +1945,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1933,6 +1954,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1941,6 +1963,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1949,6 +1972,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1957,6 +1981,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1990,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1973,6 +1999,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1981,6 +2008,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1990,6 +2018,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1999,6 +2028,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },

crates/fayalite/tests/sim/expected/queue_4_false_true.txt

@@ -1727,6 +1727,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1735,6 +1736,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1747,6 +1749,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1756,6 +1759,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1764,6 +1768,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1776,6 +1781,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1785,6 +1791,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1793,6 +1800,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1802,6 +1810,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1811,6 +1820,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1819,6 +1829,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1827,6 +1838,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1836,6 +1848,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1845,6 +1858,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1853,6 +1867,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1861,6 +1876,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1870,6 +1886,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1878,6 +1895,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1887,6 +1905,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1896,6 +1915,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1904,6 +1924,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1912,6 +1933,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1920,6 +1942,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1928,6 +1951,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1936,6 +1960,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,6 +1969,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1952,6 +1978,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1960,6 +1987,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1969,6 +1997,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1978,6 +2007,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },

crates/fayalite/tests/sim/expected/queue_4_true_false.txt

@@ -1758,6 +1758,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1766,6 +1767,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1778,6 +1780,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1787,6 +1790,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1795,6 +1799,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1807,6 +1812,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1816,6 +1822,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1824,6 +1831,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1833,6 +1841,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x4,
             last_state: 0x4,
         },
@@ -1842,6 +1851,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1850,6 +1860,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1858,6 +1869,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1867,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1876,6 +1889,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1884,6 +1898,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1892,6 +1907,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1901,6 +1917,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1909,6 +1926,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1918,6 +1936,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1927,6 +1946,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1935,6 +1955,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1943,6 +1964,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1951,6 +1973,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1959,6 +1982,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1967,6 +1991,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1975,6 +2000,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1983,6 +2009,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1991,6 +2018,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2000,6 +2028,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -2009,6 +2038,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/queue_4_true_true.txt

@@ -1737,6 +1737,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1745,6 +1746,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1757,6 +1759,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1766,6 +1769,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1774,6 +1778,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1786,6 +1791,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1795,6 +1801,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1803,6 +1810,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1812,6 +1820,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x4,
             last_state: 0x4,
         },
@@ -1821,6 +1830,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1829,6 +1839,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1837,6 +1848,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1846,6 +1858,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1855,6 +1868,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1863,6 +1877,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1871,6 +1886,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1880,6 +1896,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1888,6 +1905,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1897,6 +1915,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1906,6 +1925,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1914,6 +1934,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1922,6 +1943,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1930,6 +1952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1938,6 +1961,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1946,6 +1970,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1954,6 +1979,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1962,6 +1988,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1970,6 +1997,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1979,6 +2007,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1988,6 +2017,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/ripple_counter.txt

@@ -687,18 +687,7 @@ Simulation {
                 1,
                 0,
                 0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
+                0 (modified),
                 0,
                 0,
                 0,
@@ -709,9 +698,20 @@ Simulation {
                 1,
                 0,
                 0,
+                0 (modified),
                 0,
                 0,
                 0,
+                1,
+                0,
+                0,
+                0,
+                1,
+                0,
+                0,
+                0 (modified),
+                0,
+                0,
             ],
         },
         sim_only_slots: StatePart {
@@ -1284,6 +1284,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1293,6 +1294,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: UInt<6>,
             },
+            maybe_changed: false,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1301,6 +1303,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1309,6 +1312,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1317,6 +1321,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1325,6 +1330,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(5),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1333,6 +1339,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1341,6 +1348,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1349,6 +1357,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(24),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1357,6 +1366,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1365,6 +1375,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1373,6 +1384,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1381,6 +1393,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1389,6 +1402,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1397,6 +1411,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(44),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1405,6 +1420,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(45),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1413,6 +1429,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(42),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1421,6 +1438,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(43),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1429,6 +1447,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(47),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1437,6 +1456,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(55),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1445,6 +1465,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(56),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1453,6 +1474,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(53),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1461,6 +1483,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(54),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/shift_register.txt

@@ -458,6 +458,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -466,6 +467,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -474,6 +476,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -482,6 +485,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -490,6 +494,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -498,6 +503,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -506,6 +512,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -514,6 +521,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },

crates/fayalite/tests/sim/expected/sim_fork_join.txt

@@ -68,12 +68,12 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
+                0 (modified),
                 0,
                 0,
-                0,
-                49,
-                50,
-                50,
+                49 (modified),
+                50 (modified),
+                50 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -356,6 +356,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -364,6 +365,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -372,6 +374,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -381,6 +384,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -390,6 +394,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -399,6 +404,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },

crates/fayalite/tests/sim/expected/sim_fork_join_scope.txt

@@ -68,12 +68,12 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
+                0 (modified),
                 0,
                 0,
-                0,
-                49,
-                50,
-                50,
+                49 (modified),
+                50 (modified),
+                50 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -356,6 +356,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -364,6 +365,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -372,6 +374,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -381,6 +384,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -390,6 +394,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -399,6 +404,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },

crates/fayalite/tests/sim/expected/sim_only_connects.txt

@@ -392,7 +392,7 @@ Simulation {
                 0,
                 1,
                 0,
-                1,
+                1 (modified),
                 0,
                 0,
                 0,
@@ -400,7 +400,7 @@ Simulation {
                 0,
                 1,
                 0,
-                1,
+                1 (modified),
                 0,
             ],
         },
@@ -1252,6 +1252,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1260,6 +1261,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1269,6 +1271,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(0),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1282,6 +1285,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(1),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1295,6 +1299,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(2),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1312,6 +1317,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(3),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "baz",
                 "extra": "value",
@@ -1328,6 +1334,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1336,6 +1343,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(5),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1345,6 +1353,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(6),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1358,6 +1367,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(7),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1374,6 +1384,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1382,6 +1393,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1391,6 +1403,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(4),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1404,6 +1417,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(5),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1421,6 +1435,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(8),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1433,6 +1448,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1441,6 +1457,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1449,6 +1466,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1458,6 +1476,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(13),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1475,6 +1494,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(14),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "baz",
                 "extra": "value",
@@ -1491,6 +1511,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(10),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1499,6 +1520,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1508,6 +1530,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(11),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1525,6 +1548,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(12),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "baz",
                 "extra": "value",

crates/fayalite/tests/sim/expected/sim_read_past.txt

@@ -530,18 +530,18 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
+                0 (modified),
                 0,
                 0,
-                0,
-                49,
-                50,
-                50,
-                0,
-                1,
-                0,
-                49,
-                49,
-                50,
+                49 (modified),
+                50 (modified),
+                50 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                49 (modified),
+                49 (modified),
+                50 (modified),
                 1,
                 0,
                 0,
@@ -9500,6 +9500,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9508,6 +9509,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9516,6 +9518,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -9525,6 +9528,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9534,6 +9538,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9543,6 +9548,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9551,6 +9557,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9559,6 +9566,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -9567,6 +9575,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(8),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9576,6 +9585,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9585,6 +9595,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9594,6 +9605,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },

crates/fayalite/tests/sim/expected/sim_resettable_counter_async.txt

@@ -56,8 +56,8 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
-                0,
+                0 (modified),
+                0 (modified),
                 3,
             ],
         },
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },

crates/fayalite/tests/sim/expected/sim_resettable_counter_async_immediate_reset.txt

@@ -56,8 +56,8 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
-                0,
+                0 (modified),
+                0 (modified),
                 3,
             ],
         },
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },

crates/fayalite/tests/sim/expected/sim_resettable_counter_sync.txt

@@ -56,7 +56,7 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
+                0 (modified),
                 0,
                 3,
             ],
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },

crates/fayalite/tests/sim/expected/sim_resettable_counter_sync_immediate_reset.txt

@@ -56,7 +56,7 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
+                0 (modified),
                 0,
                 3,
             ],
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },

crates/fayalite/tests/ui/simvalue_is_not_internable.stderr

@@ -75,12 +75,12 @@ note: required because it appears within the type `Vec<DynSimOnlyValue>`
 note: required because it appears within the type `OpaqueSimValue`
     --> src/ty.rs
      |
- 734 | pub struct OpaqueSimValue {
+ 761 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  51 | struct SimValueInner<T: Type> {
+  52 | struct SimValueInner<T: Type> {
      |        ^^^^^^^^^^^^^
 note: required because it appears within the type `UnsafeCell<value::SimValueInner<()>>`
     --> $RUST/core/src/cell.rs
@@ -95,7 +95,7 @@ note: required because it appears within the type `util::alternating_cell::Alter
 note: required because it appears within the type `fayalite::prelude::SimValue<()>`
     --> src/sim/value.rs
      |
- 160 | pub struct SimValue<T: Type> {
+ 161 | pub struct SimValue<T: Type> {
      |            ^^^^^^^^
 note: required by a bound in `fayalite::intern::Interned`
     --> src/intern.rs
@@ -214,12 +214,12 @@ note: required because it appears within the type `Vec<DynSimOnlyValue>`
 note: required because it appears within the type `OpaqueSimValue`
     --> src/ty.rs
      |
- 734 | pub struct OpaqueSimValue {
+ 761 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  51 | struct SimValueInner<T: Type> {
+  52 | struct SimValueInner<T: Type> {
      |        ^^^^^^^^^^^^^
 note: required because it appears within the type `UnsafeCell<value::SimValueInner<()>>`
     --> $RUST/core/src/cell.rs
@@ -234,7 +234,7 @@ note: required because it appears within the type `util::alternating_cell::Alter
 note: required because it appears within the type `fayalite::prelude::SimValue<()>`
     --> src/sim/value.rs
      |
- 160 | pub struct SimValue<T: Type> {
+ 161 | pub struct SimValue<T: Type> {
      |            ^^^^^^^^
 note: required by a bound in `intern_sized`
     --> src/intern.rs
@@ -326,12 +326,12 @@ note: required because it appears within the type `Vec<DynSimOnlyValue>`
 note: required because it appears within the type `OpaqueSimValue`
     --> src/ty.rs
      |
- 734 | pub struct OpaqueSimValue {
+ 761 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  51 | struct SimValueInner<T: Type> {
+  52 | struct SimValueInner<T: Type> {
      |        ^^^^^^^^^^^^^
 note: required because it appears within the type `UnsafeCell<value::SimValueInner<()>>`
     --> $RUST/core/src/cell.rs
@@ -346,7 +346,7 @@ note: required because it appears within the type `util::alternating_cell::Alter
 note: required because it appears within the type `fayalite::prelude::SimValue<()>`
     --> src/sim/value.rs
      |
- 160 | pub struct SimValue<T: Type> {
+ 161 | pub struct SimValue<T: Type> {
      |            ^^^^^^^^
 note: required by a bound in `fayalite::intern::Interned`
     --> src/intern.rs