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

@@ -257,6 +257,5 @@ 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,9 +3,8 @@
 use crate::{
     Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        CustomDebugOptions, CustomDebugTrait, ItemOptions, MakeHdlTypeExpr, MaybeParsed,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedField, ParsedFieldsNamed, ParsedGenerics,
-        ParsedField, ParsedFieldsNamed, ParsedGenerics, SplitForImpl, TypesParser, WrappedInConst,
+        SplitForImpl, TypesParser, WrappedInConst, common_derives, get_target,
-        common_derives, create_struct_debug_impl, get_target,
     },
     kw,
 };
@@ -31,7 +30,6 @@ 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,
@@ -90,8 +88,6 @@ 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");
@@ -135,7 +131,6 @@ 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),
@@ -453,7 +448,6 @@ 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,
@@ -470,20 +464,11 @@ 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, false));
+        item_attrs.push(common_derives(span));
-        let type_struct = ItemStruct {
+        ItemStruct {
             attrs: item_attrs,
             vis: vis.clone(),
             struct_token: *struct_token,
@@ -491,8 +476,8 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(fields.clone().into()),
             semi_token: None,
-        };
+        }
-        type_struct.to_tokens(tokens);
+        .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)
@@ -518,9 +503,6 @@ 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,
@@ -548,9 +530,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);
-        let mask_type_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
-                common_derives(span, false),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -561,20 +543,17 @@ 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>
             };
         }
-        let mask_type_match_variant_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
-                common_derives(span, false),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -585,9 +564,7 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(mask_type_match_variant_fields),
             semi_token: None,
-        };
+        }
-        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 {
@@ -595,9 +572,9 @@ impl ToTokens for ParsedBundle {
                 ::fayalite::expr::Expr<#ty>
             };
         }
-        let match_variant_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
-                common_derives(span, false),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -608,19 +585,19 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(match_variant_fields),
             semi_token: None,
-        };
+        }
-        match_variant_struct.to_tokens(tokens);
+        .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>
             };
         }
-        let mask_type_sim_value_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
                 parse_quote_spanned! {span=>
                     #[::fayalite::__std::prelude::v1::derive(
+                        ::fayalite::__std::fmt::Debug,
                         ::fayalite::__std::clone::Clone,
                     )]
                 },
@@ -634,34 +611,19 @@ 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>
             };
         }
-        let sim_value_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
                 parse_quote_spanned! {span=>
                     #[::fayalite::__std::prelude::v1::derive(
+                        ::fayalite::__std::fmt::Debug,
                         ::fayalite::__std::clone::Clone,
                     )]
                 },
@@ -675,36 +637,8 @@ 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);
-        }
         let this_token = Ident::new("__this", span);
         let fields_token = Ident::new("__fields", span);
         let self_token = Token![self](span);
@@ -886,14 +820,6 @@ 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
             {
@@ -1054,14 +980,6 @@ 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
             {
@@ -1223,7 +1141,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,9 +3,8 @@
 use crate::{
     Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        CustomDebugOptions, ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType, SplitForImpl,
-        SplitForImpl, TypesParser, WrappedInConst, common_derives, create_struct_debug_impl,
+        TypesParser, WrappedInConst, common_derives, get_target,
-        get_target,
     },
     kw,
 };
@@ -159,32 +158,15 @@ 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");
@@ -246,21 +228,12 @@ impl ToTokens for ParsedEnum {
             custom_bounds: _,
             no_static,
             no_runtime_generics,
-            cmp_eq,
+            cmp_eq: _, // TODO: implement cmp_eq for enums
             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, false));
+        struct_attrs.push(common_derives(span));
         struct_attrs.push(parse_quote_spanned! {span=>
             #[allow(non_snake_case)]
         });
@@ -300,7 +273,7 @@ impl ToTokens for ParsedEnum {
                 }
             },
         ));
-        let type_struct = ItemStruct {
+        ItemStruct {
             attrs: struct_attrs,
             vis: vis.clone(),
             struct_token: Token![struct](enum_token.span),
@@ -315,8 +288,8 @@ impl ToTokens for ParsedEnum {
                 })
             },
             semi_token: None,
-        };
+        }
-        type_struct.to_tokens(tokens);
+        .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| {
@@ -400,9 +373,6 @@ 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)]
@@ -483,6 +453,7 @@ 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,
             )]
         });
@@ -867,240 +838,6 @@ 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]
@@ -1197,14 +934,6 @@ 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,8 +215,6 @@ 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");
@@ -236,15 +234,6 @@ 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,
@@ -298,8 +287,6 @@ 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(
@@ -324,15 +311,6 @@ 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)) {
@@ -378,8 +356,6 @@ 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();
@@ -426,8 +402,6 @@ 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();
@@ -453,7 +427,7 @@ impl ToTokens for ParsedTypeAlias {
                     format_ident!("__{}__GenericsAccumulation", ident);
                 ItemStruct {
                     attrs: vec![
-                        common_derives(span, true),
+                        common_derives(span),
                         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, FnArg, GenericArgument, GenericParam, Generics, Ident, ImplGenerics, Index,
+    FieldsUnnamed, GenericArgument, GenericParam, Generics, Ident, ImplGenerics, Index, ItemStruct,
-    ItemStruct, Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, TraitBound,
+    Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, TraitBound, Turbofish,
-    Turbofish, Type, TypeGenerics, TypeGroup, TypeParam, TypeParamBound, TypeParen, TypePath,
+    Type, TypeGenerics, TypeGroup, TypeParam, TypeParamBound, TypeParen, TypePath, TypeTuple,
-    TypeTuple, Visibility, WhereClause, WherePredicate,
+    Visibility, WhereClause, WherePredicate,
     parse::{Parse, ParseStream},
     parse_quote, parse_quote_spanned,
     punctuated::{Pair, Punctuated},
@@ -18,17 +18,6 @@ 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 {
@@ -39,8 +28,6 @@ crate::options! {
         NoRuntimeGenerics(no_runtime_generics),
         CmpEq(cmp_eq),
         Get(get, Expr),
-        CustomDebug(custom_debug, CustomDebugOptions),
-        CustomSimDisplay(custom_sim_display),
     }
 }
 
@@ -54,36 +41,8 @@ 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> {
@@ -125,17 +84,10 @@ pub(crate) fn get_target(target: &Option<(kw::target, Paren, Path)>, item_ident:
     }
 }
 
-pub(crate) fn common_derives(span: Span, include_debug: bool) -> Attribute {
+pub(crate) fn common_derives(span: Span) -> Attribute {
-    let debug = include_debug
-        .then(|| {
-            quote_spanned! {span=>
-                ::fayalite::__std::fmt::Debug
-            }
-        })
-        .into_iter();
     parse_quote_spanned! {span=>
         #[::fayalite::__std::prelude::v1::derive(
-            #(#debug,)*
+            ::fayalite::__std::fmt::Debug,
             ::fayalite::__std::cmp::Eq,
             ::fayalite::__std::cmp::PartialEq,
             ::fayalite::__std::hash::Hash,
@@ -3023,7 +2975,7 @@ impl ParsedGenerics {
         let span = ident.span();
         ItemStruct {
             attrs: vec![
-                common_derives(span, true),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types)]
                 },
@@ -4781,109 +4733,3 @@ 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,7 +42,6 @@ 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) => {
@@ -76,8 +75,6 @@ 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);
@@ -86,8 +83,6 @@ 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/src/array.rs

@@ -13,13 +13,13 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantWithoutScope, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties, TypeWithDeref,
+        OpaqueSimValueWritten, StaticType, Type, TypeProperties, TypeWithDeref,
         serde_impls::SerdeCanonicalType,
     },
     util::ConstUsize,
 };
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error};
-use std::{borrow::Cow, fmt, iter::FusedIterator, ops::Index};
+use std::{borrow::Cow, 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> fmt::Debug for ArrayType<T, Len> {
+impl<T: Type, Len: Size> std::fmt::Debug for ArrayType<T, Len> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Array<{:?}, {}>", self.element, self.len())
     }
 }
@@ -182,15 +182,6 @@ 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, SimValueDebug,
+        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type,
-        StaticType, Type, TypeProperties, TypeWithDeref, impl_match_variant_as_self,
+        TypeProperties, TypeWithDeref, impl_match_variant_as_self,
     },
     util::HashMap,
 };
@@ -271,15 +271,6 @@ 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]>;
@@ -480,14 +471,6 @@ 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,)*);
@@ -790,15 +773,6 @@ 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,6 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
-
 use crate::{
     expr::{Expr, ValueType},
     hdl,
@@ -10,12 +9,10 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties,
+        OpaqueSimValueWritten, StaticType, Type, TypeProperties, impl_match_variant_as_self,
-        impl_match_variant_as_self,
     },
 };
 use bitvec::{bits, order::Lsb0};
-use std::fmt;
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
 pub struct Clock;
@@ -72,15 +69,6 @@ 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, ToExpr, ValueType, ops::VariantAccess},
+    expr::{Expr, HdlPartialEq, HdlPartialEqImpl, 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, ToSimValue, ToSimValueWithType},
+    sim::value::SimValue,
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantAndInactiveScope, OpaqueSimValue, OpaqueSimValueSize,
-        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, SimValueDebug,
+        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type,
-        StaticType, Type, TypeProperties,
+        TypeProperties,
     },
     util::HashMap,
 };
 use bitvec::{order::Lsb0, slice::BitSlice, view::BitView};
 use serde::{Deserialize, Serialize};
-use std::{convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
+use std::{borrow::Cow, convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
 pub struct EnumVariant {
@@ -410,15 +410,6 @@ 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>,
@@ -732,12 +723,95 @@ pub fn enum_type_to_sim_builder<T: EnumType>(v: T) -> T::SimBuilder {
     v.into()
 }
 
-#[hdl(cmp_eq)]
+#[hdl]
 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()
@@ -749,123 +823,6 @@ 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, SimValueDebug, SimValueDisplay, StaticType,
+        OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type, TypeProperties,
-        Type, TypeProperties, impl_match_variant_as_self,
+        impl_match_variant_as_self,
     },
     util::{ConstBool, ConstUsize, GenericConstBool, GenericConstUsize, interned_bit, slice_range},
 };
@@ -1019,24 +1019,6 @@ 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
@@ -1917,15 +1899,6 @@ 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,
-        SimValueDebug, StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        StaticType, Type, TypeProperties, impl_match_variant_as_self,
     },
 };
 use bitvec::{order::Lsb0, view::BitView};
@@ -94,15 +94,6 @@ 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;
 
@@ -348,15 +339,6 @@ 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,
-        SimValueDebug, StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        StaticType, Type, TypeProperties, impl_match_variant_as_self,
         serde_impls::{SerdeCanonicalType, SerdePhantomConst},
     },
 };
@@ -327,15 +327,6 @@ 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,6 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
-
 use crate::{
     clock::Clock,
     expr::{CastToImpl, Expr, ValueType},
@@ -9,13 +8,11 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties,
+        OpaqueSimValueWritten, StaticType, Type, TypeProperties, impl_match_variant_as_self,
-        impl_match_variant_as_self,
     },
     util::ConstUsize,
 };
 use bitvec::{bits, order::Lsb0};
-use std::fmt;
 
 mod sealed {
     pub trait ResetTypeSealed {}
@@ -103,15 +100,6 @@ 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,7 +828,6 @@ where
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub(crate) struct SimTrace<K, S> {
     kind: K,
-    maybe_changed: bool,
     state: S,
     last_state: S,
 }
@@ -849,14 +848,12 @@ 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()
@@ -867,14 +864,12 @@ 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()
@@ -2083,12 +2078,10 @@ 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(),
                 },
@@ -2133,17 +2126,14 @@ impl SimulationImpl {
             id,
             &SimTrace {
                 kind,
-                maybe_changed,
                 ref state,
                 ref last_state,
             },
         ) in self.traces.0.iter().enumerate()
         {
-            if ONLY_IF_CHANGED {
+            if ONLY_IF_CHANGED && state == last_state {
-                if !(maybe_changed && state != last_state) {
                 continue;
             }
-            }
             let id = TraceScalarId(id);
             match kind {
                 SimTraceKind::BigUInt { .. } | SimTraceKind::SmallUInt { .. } => {
@@ -2203,45 +2193,10 @@ 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_and_clear_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_and_clear_maybe_modified_flag(index),
-                SimTraceKind::SimOnly { index, ty: _ } => self
-                    .state
-                    .sim_only_slots
-                    .state_index_fetch_and_clear_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);
             }

crates/fayalite/src/sim/compiler.rs

@@ -2234,7 +2234,6 @@ 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,11 +17,12 @@ 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, Index, IndexMut},
+    ops::{ControlFlow, Deref, DerefMut, Index, IndexMut},
 };
 use vec_map::VecMap;
 
@@ -914,12 +915,6 @@ impl<K: StatePartKind> StatePart<K> {
             value: K::borrow_state(&mut self.value),
         }
     }
-    pub(crate) fn state_index_fetch_and_clear_maybe_modified_flag(
-        &mut self,
-        part_index: StatePartIndex<K>,
-    ) -> bool {
-        K::state_index_fetch_and_clear_maybe_modified_flag(&mut self.value, part_index)
-    }
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -927,38 +922,56 @@ pub(crate) struct BorrowedStatePart<'a, K: StatePartKind> {
     pub(crate) value: K::BorrowedState<'a>,
 }
 
-impl<K: StatePartKind> BorrowedStatePart<'_, K> {
+impl<
+    'a,
+    K: StatePartKind<
+        BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T> + BorrowMut<[T]>>,
+    >,
+    T,
+> BorrowedStatePart<'a, K>
+{
     pub(crate) fn get_disjoint_mut<const N: usize>(
         &mut self,
         indexes: [StatePartIndex<K>; N],
-    ) -> [&mut K::StateElement; N] {
+    ) -> [&mut T; N] {
-        K::borrowed_state_get_disjoint_mut(&mut self.value, indexes)
+        (*self.value)
+            .borrow_mut()
+            .get_disjoint_mut(indexes.map(|v| v.value as usize))
+            .expect("indexes are disjoint")
     }
 }
 
-impl<K: StatePartKind> Index<StatePartIndex<K>> for StatePart<K> {
+impl<K: StatePartKind<State: Deref<Target: Index<usize, Output = T>>>, T> Index<StatePartIndex<K>>
-    type Output = K::StateElement;
+    for StatePart<K>
+{
+    type Output = T;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        K::state_index(&self.value, index)
+        &self.value[index.value as usize]
     }
 }
 
-impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for StatePart<K> {
+impl<K: StatePartKind<State: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
+    IndexMut<StatePartIndex<K>> for StatePart<K>
+{
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        K::state_index_mut(&mut self.value, index)
+        &mut self.value[index.value as usize]
     }
 }
 
-impl<K: StatePartKind> Index<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
+impl<'a, K: StatePartKind<BorrowedState<'a>: Deref<Target: Index<usize, Output = T>>>, T>
-    type Output = K::StateElement;
+    Index<StatePartIndex<K>> for BorrowedStatePart<'a, K>
+{
+    type Output = T;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        K::borrowed_state_index(&self.value, index)
+        &self.value[index.value as usize]
     }
 }
 
-impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
+impl<'a, K: StatePartKind<BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
+    IndexMut<StatePartIndex<K>> for BorrowedStatePart<'a, K>
+{
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        K::borrowed_state_index_mut(&mut self.value, index)
+        &mut self.value[index.value as usize]
     }
 }
 

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

@@ -236,7 +236,6 @@ 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>(
@@ -248,30 +247,6 @@ 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_and_clear_maybe_modified_flag(
-        state: &mut Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool;
-    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 {
@@ -297,7 +272,6 @@ 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()
@@ -323,88 +297,19 @@ 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_and_clear_maybe_modified_flag(
-        _state: &mut Self::State,
-        _part_index: StatePartIndex<Self>,
-    ) -> bool {
-        true
-    }
-    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 = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type State = Box<[SmallUInt]>;
-    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type BorrowedState<'a> = &'a mut [SmallUInt];
-    type StateElement = SmallUInt;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        StateAndModified {
+        vec![0; layout_data.len()].into_boxed_slice()
-            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> {
-        let StateAndModified { state, modified } = state;
+        state
-        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -425,69 +330,19 @@ 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_and_clear_maybe_modified_flag(
-        state: &mut Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool {
-        std::mem::replace(&mut state.modified[part_index.as_usize()], 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 = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type State = Box<[BigInt]>;
-    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type BorrowedState<'a> = &'a mut [BigInt];
-    type StateElement = BigInt;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        let state: Box<[_]> = layout_data.iter().map(|_| BigInt::default()).collect();
+        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> {
-        let StateAndModified { state, modified } = state;
+        state
-        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -506,69 +361,19 @@ 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_and_clear_maybe_modified_flag(
-        state: &mut Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool {
-        std::mem::replace(&mut state.modified[part_index.as_usize()], 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 = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type State = Box<[DynSimOnlyValue]>;
-    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type BorrowedState<'a> = &'a mut [DynSimOnlyValue];
-    type StateElement = DynSimOnlyValue;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        let state: Box<[_]> = layout_data.iter().map(|ty| ty.default_value()).collect();
+        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> {
-        let StateAndModified { state, modified } = state;
+        state
-        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -587,50 +392,6 @@ 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_and_clear_maybe_modified_flag(
-        state: &mut Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool {
-        std::mem::replace(&mut state.modified[part_index.as_usize()], 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,8 +15,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValue, OpaqueSimValueSize, OpaqueSimValueSlice,
-        OpaqueSimValueWriter, SimValueDebug, StaticType, Type, TypeProperties,
+        OpaqueSimValueWriter, StaticType, Type, TypeProperties, impl_match_variant_as_self,
-        impl_match_variant_as_self,
     },
     util::{
         ConstUsize, HashMap,
@@ -1395,15 +1394,6 @@ 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;
@@ -1469,15 +1459,6 @@ 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,15 +367,7 @@ impl<D: Type> TypeOrDefault<D> for crate::__ {
 }
 
 pub trait Type:
-    Copy
+    Copy + Hash + Eq + fmt::Debug + Send + Sync + 'static + FillInDefaultedGenerics<Type = Self>
-    + Hash
-    + Eq
-    + fmt::Debug
-    + Send
-    + Sync
-    + 'static
-    + FillInDefaultedGenerics<Type = Self>
-    + SimValueDebug
 {
     type BaseType: BaseType;
     type MaskType: Type<MaskType = Self::MaskType>;
@@ -410,16 +402,6 @@ 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,
@@ -508,15 +490,6 @@ 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

@@ -1,166 +0,0 @@
-// 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, cmp_eq)]
+#[hdl(outline_generated)]
 pub enum TestEnum {
     A,
     B(UInt<8>),
@@ -679,366 +679,6 @@ 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/expected/array_rw.txt

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

@@ -86,8 +86,8 @@ Simulation {
             value: [
                 1,
                 0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
             ],
         },
         sim_only_slots: StatePart {
@@ -155,7 +155,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -164,7 +163,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },

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

@@ -63,7 +63,7 @@ Simulation {
         big_slots: StatePart {
             value: [
                 5,
-                5 (modified),
+                5,
             ],
         },
         sim_only_slots: StatePart {
@@ -124,7 +124,6 @@ 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

@@ -90,9 +90,9 @@ Simulation {
             value: [
                 1,
                 1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
             ],
         },
         sim_only_slots: StatePart {
@@ -175,7 +175,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -184,7 +183,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },

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

@@ -185,10 +185,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
             ],
         },
         big_slots: StatePart {
@@ -197,12 +197,12 @@ Simulation {
                 0,
                 3,
                 3,
-                4 (modified),
+                4,
-                3 (modified),
+                3,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                4 (modified),
+                4,
-                4 (modified),
+                4,
             ],
         },
         sim_only_slots: StatePart {
@@ -332,7 +332,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -341,7 +340,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -351,7 +349,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -361,7 +358,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },

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

@@ -167,10 +167,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
             ],
         },
         big_slots: StatePart {
@@ -179,11 +179,11 @@ Simulation {
                 0,
                 3,
                 3,
-                4 (modified),
+                4,
-                3 (modified),
+                3,
-                1 (modified),
+                1,
-                4 (modified),
+                4,
-                4 (modified),
+                4,
             ],
         },
         sim_only_slots: StatePart {
@@ -313,7 +313,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -322,7 +321,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -332,7 +330,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -342,7 +339,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },

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

@@ -81,9 +81,9 @@ Simulation {
         big_slots: StatePart {
             value: [
                 5,
-                5 (modified),
+                5,
+                6,
                 6,
-                6 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -137,7 +137,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x05,
             last_state: 0x05,
         },
@@ -147,7 +146,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x06,
             last_state: 0x06,
         },

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

@@ -1191,10 +1191,10 @@ Simulation {
             value: [
                 0,
                 0,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
                 2,
             ],
         },
@@ -1207,110 +1207,110 @@ Simulation {
                 15,
                 2,
                 15,
-                0 (modified),
                 0,
                 0,
-                0 (modified),
-                0 (modified),
-                0 (modified),
-                0 (modified),
-                0 (modified),
-                0 (modified),
                 0,
                 0,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                62 (modified),
+                0,
-                62 (modified),
+                0,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                62,
+                62,
+                0,
+                0,
+                1,
+                1,
+                62,
+                3,
+                1,
                 1,
                 1,
-                62 (modified),
-                3 (modified),
-                1 (modified),
-                1 (modified),
-                1 (modified),
                 1,
                 1,
                 -1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                15 (modified),
+                15,
-                3 (modified),
+                3,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                3 (modified),
+                3,
-                -1 (modified),
+                -1,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                2 (modified),
+                2,
-                3 (modified),
+                3,
-                12 (modified),
+                12,
-                13 (modified),
+                13,
-                13 (modified),
+                13,
-                13 (modified),
+                13,
-                2 (modified),
+                2,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                -1 (modified),
+                -1,
-                2 (modified),
+                2,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                -1 (modified),
+                -1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                3 (modified),
+                3,
-                -1 (modified),
+                -1,
-                2 (modified),
+                2,
-                3 (modified),
+                3,
-                3 (modified),
+                3,
-                12 (modified),
+                12,
-                15 (modified),
+                15,
-                60 (modified),
+                60,
-                62 (modified),
+                62,
-                62 (modified),
+                62,
-                62 (modified),
+                62,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                2 (modified),
+                2,
-                3 (modified),
+                3,
-                3 (modified),
+                3,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                1 (modified),
+                1,
-                2 (modified),
+                2,
-                3 (modified),
+                3,
-                6 (modified),
+                6,
-                7 (modified),
+                7,
-                7 (modified),
+                7,
-                7 (modified),
+                7,
-                2 (modified),
+                2,
-                3 (modified),
+                3,
-                3 (modified),
+                3,
-                12 (modified),
+                12,
-                15 (modified),
+                15,
             ],
         },
         sim_only_slots: StatePart {
@@ -1746,7 +1746,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -1755,7 +1754,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1764,7 +1762,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1774,7 +1771,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<2>,
             },
-            maybe_changed: false,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1784,7 +1780,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
-            maybe_changed: false,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1794,7 +1789,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1804,7 +1798,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1817,7 +1810,6 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1827,7 +1819,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1836,7 +1827,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1849,7 +1839,6 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1859,7 +1848,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1868,7 +1856,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1882,7 +1869,6 @@ Simulation {
                     C(Bundle {a: Array<UInt<1>, 2>, b: SInt<2>}),
                 },
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1892,7 +1878,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(27),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1901,7 +1886,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(28),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1911,7 +1895,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1921,7 +1904,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1931,7 +1913,6 @@ 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,7 +221,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -230,7 +229,6 @@ 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 (modified),
+                1,
                 101,
             ],
         },
@@ -280,7 +280,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -289,7 +288,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -299,7 +297,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x65,
             last_state: 0x65,
         },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -259,10 +259,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
             ],
         },
         big_slots: StatePart {
@@ -272,14 +272,14 @@ Simulation {
                 0,
                 0,
                 0,
-                0 (modified),
-                0 (modified),
                 0,
-                0 (modified),
                 0,
-                0 (modified),
                 0,
-                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                0,
             ],
         },
         sim_only_slots: StatePart {
@@ -458,7 +458,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -467,7 +466,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -476,7 +474,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -485,7 +482,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -494,7 +490,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -503,7 +498,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -512,7 +506,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -521,7 +514,6 @@ 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,
-                49 (modified),
+                0,
-                50 (modified),
+                49,
-                50 (modified),
+                50,
+                50,
             ],
         },
         sim_only_slots: StatePart {
@@ -356,7 +356,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -365,7 +364,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -374,7 +372,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -384,7 +381,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -394,7 +390,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -404,7 +399,6 @@ 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,
-                49 (modified),
+                0,
-                50 (modified),
+                49,
-                50 (modified),
+                50,
+                50,
             ],
         },
         sim_only_slots: StatePart {
@@ -356,7 +356,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -365,7 +364,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -374,7 +372,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -384,7 +381,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -394,7 +390,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -404,7 +399,6 @@ 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

@@ -380,10 +380,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
             ],
         },
         big_slots: StatePart {
@@ -392,15 +392,15 @@ Simulation {
                 0,
                 1,
                 0,
-                1 (modified),
-                0,
-                0,
-                0 (modified),
-                1 (modified),
-                0 (modified),
                 1,
                 0,
-                1 (modified),
+                0,
+                0,
+                1,
+                0,
+                1,
+                0,
+                1,
                 0,
             ],
         },
@@ -443,8 +443,8 @@ Simulation {
                 },
                 {
                     "extra": "value",
-                } (modified),
+                },
-                {} (modified),
+                {},
                 {
                     "bar": "",
                     "extra": "value",
@@ -1252,7 +1252,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1261,7 +1260,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1271,7 +1269,6 @@ 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",
             },
@@ -1285,7 +1282,6 @@ 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",
             },
@@ -1299,7 +1295,6 @@ 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",
@@ -1317,7 +1312,6 @@ 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",
@@ -1334,7 +1328,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(4),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1343,7 +1336,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(5),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1353,7 +1345,6 @@ 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",
             },
@@ -1367,7 +1358,6 @@ 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",
@@ -1384,7 +1374,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1393,7 +1382,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1403,7 +1391,6 @@ 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",
             },
@@ -1417,7 +1404,6 @@ 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",
@@ -1435,7 +1421,6 @@ 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",
             },
@@ -1448,7 +1433,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1457,7 +1441,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1466,7 +1449,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1476,7 +1458,6 @@ 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",
@@ -1494,7 +1475,6 @@ 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",
@@ -1511,7 +1491,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(10),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1520,7 +1499,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(11),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1530,7 +1508,6 @@ 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",
@@ -1548,7 +1525,6 @@ 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

@@ -517,67 +517,67 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                1 (modified),
+                1,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
-                1 (modified),
+                1,
-                0 (modified),
+                0,
-                0 (modified),
+                0,
             ],
         },
         big_slots: StatePart {
             value: [
-                0 (modified),
                 0,
                 0,
-                49 (modified),
+                0,
-                50 (modified),
+                49,
-                50 (modified),
+                50,
-                0 (modified),
+                50,
-                1 (modified),
+                0,
-                0 (modified),
+                1,
-                49 (modified),
+                0,
-                49 (modified),
+                49,
-                50 (modified),
+                49,
-                1 (modified),
+                50,
-                0 (modified),
+                1,
-                0 (modified),
+                0,
-                48 (modified),
+                0,
-                49 (modified),
+                48,
-                49 (modified),
+                49,
-                0 (modified),
+                49,
-                0 (modified),
+                0,
-                1 (modified),
+                0,
-                48 (modified),
+                1,
-                49 (modified),
+                48,
-                48 (modified),
+                49,
-                0 (modified),
+                48,
-                1 (modified),
+                0,
-                0 (modified),
+                1,
-                49 (modified),
+                0,
-                49 (modified),
+                49,
-                50 (modified),
+                49,
-                0 (modified),
+                50,
-                0 (modified),
+                0,
-                1 (modified),
+                0,
-                49 (modified),
+                1,
-                49 (modified),
+                49,
-                49 (modified),
+                49,
-                0 (modified),
+                49,
-                0 (modified),
+                0,
-                1 (modified),
+                0,
-                49 (modified),
+                1,
-                50 (modified),
+                49,
-                50 (modified),
+                50,
-                0 (modified),
+                50,
-                1 (modified),
+                0,
-                0 (modified),
+                1,
-                49 (modified),
+                0,
-                49 (modified),
+                49,
-                50 (modified),
+                49,
+                50,
             ],
         },
         sim_only_slots: StatePart {
@@ -9500,7 +9500,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9509,7 +9508,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9518,7 +9516,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -9528,7 +9525,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9538,7 +9534,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9548,7 +9543,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9557,7 +9551,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9566,7 +9559,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -9575,7 +9567,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(8),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9585,7 +9576,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9595,7 +9585,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9605,7 +9594,6 @@ 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 (modified),
+                0,
-                0 (modified),
+                0,
                 3,
             ],
         },
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ 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 (modified),
+                0,
-                0 (modified),
+                0,
                 3,
             ],
         },
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ 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 (modified),
+                0,
                 0,
                 3,
             ],
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ 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 (modified),
+                0,
                 0,
                 3,
             ],
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ 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
      |
- 761 | pub struct OpaqueSimValue {
+ 734 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  52 | struct SimValueInner<T: Type> {
+  51 | 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
      |
- 161 | pub struct SimValue<T: Type> {
+ 160 | 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
      |
- 761 | pub struct OpaqueSimValue {
+ 734 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  52 | struct SimValueInner<T: Type> {
+  51 | 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
      |
- 161 | pub struct SimValue<T: Type> {
+ 160 | 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
      |
- 761 | pub struct OpaqueSimValue {
+ 734 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  52 | struct SimValueInner<T: Type> {
+  51 | 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
      |
- 161 | pub struct SimValue<T: Type> {
+ 160 | pub struct SimValue<T: Type> {
      |            ^^^^^^^^
 note: required by a bound in `fayalite::intern::Interned`
     --> src/intern.rs