add ExternModuleSimulationState::fork_join_scope

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

@@ -87,7 +87,11 @@ impl ParsedBundle {
             no_static: _,
             no_runtime_generics: _,
             cmp_eq: _,
+            ref get,
         } = options.body;
+        if let Some((get, ..)) = get {
+            errors.error(get, "#[hdl(get(...))] is not allowed on structs");
+        }
         let mut fields = match fields {
             syn::Fields::Named(fields) => fields,
             syn::Fields::Unnamed(fields) => {
@@ -220,7 +224,7 @@ impl Builder {
                 .args
                 .push_value(match get_field_state(field_index) {
                     BuilderFieldState::Unfilled => parse_quote_spanned! {self.ident.span()=>
-                        ::fayalite::bundle::Unfilled<#ty>
+                        ()
                     },
                     BuilderFieldState::Generic => {
                         let type_var = type_var_for_field_name(ident);
@@ -379,7 +383,7 @@ impl ToTokens for Builder {
                 fn default() -> Self {
                     #ident {
                         #phantom_field_name: ::fayalite::__std::marker::PhantomData,
-                        #(#field_idents: ::fayalite::__std::default::Default::default(),)*
+                        #(#field_idents: (),)*
                     }
                 }
             }
@@ -391,7 +395,7 @@ impl ToTokens for Builder {
         let type_generics = self.generics.split_for_impl().1;
         quote_spanned! {self.ident.span()=>
             #[automatically_derived]
-            #[allow(non_camel_case_types, dead_code)]
+            #[allow(non_camel_case_types, dead_code, private_interfaces)]
             impl #filled_impl_generics ::fayalite::expr::ToExpr for #filled_ty
             #filled_where_clause
             {
@@ -445,6 +449,7 @@ impl ToTokens for ParsedBundle {
             no_static,
             no_runtime_generics,
             cmp_eq,
+            get: _,
         } = &options.body;
         let target = get_target(target, ident);
         let mut item_attrs = attrs.clone();
@@ -494,7 +499,6 @@ impl ToTokens for ParsedBundle {
         };
         builder.to_tokens(tokens);
         let unfilled_builder_ty = builder.builder_struct_ty(|_| BuilderFieldState::Unfilled);
-        let filled_builder_ty = builder.builder_struct_ty(|_| BuilderFieldState::Filled);
         let mut mask_type_fields = FieldsNamed::from(fields.clone());
         for Field { ty, .. } in &mut mask_type_fields.named {
             *ty = parse_quote_spanned! {span=>
@@ -512,8 +516,6 @@ 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 filled_mask_type_builder_ty =
-            mask_type_builder.builder_struct_ty(|_| BuilderFieldState::Filled);
         ItemStruct {
             attrs: vec![
                 common_derives(span),
@@ -780,7 +782,6 @@ impl ToTokens for ParsedBundle {
             #where_clause
             {
                 type Builder = #unfilled_mask_type_builder_ty;
-                type FilledBuilder = #filled_mask_type_builder_ty;
                 fn fields(&#self_token) -> ::fayalite::intern::Interned<[::fayalite::bundle::BundleField]> {
                     ::fayalite::intern::Intern::intern(&[#(#fields_body_fields)*][..])
                 }
@@ -930,7 +931,6 @@ impl ToTokens for ParsedBundle {
             #where_clause
             {
                 type Builder = #unfilled_builder_ty;
-                type FilledBuilder = #filled_builder_ty;
                 fn fields(&#self_token) -> ::fayalite::intern::Interned<[::fayalite::bundle::BundleField]> {
                     ::fayalite::intern::Intern::intern(&[#(#fields_body_fields)*][..])
                 }

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

@@ -159,10 +159,14 @@ impl ParsedEnum {
             no_static: _,
             no_runtime_generics: _,
             cmp_eq,
+            ref get,
         } = 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");
+        }
         attrs.retain(|attr| {
             if attr.path().is_ident("repr") {
                 errors.error(attr, "#[repr] is not supported on #[hdl] enums");
@@ -225,6 +229,7 @@ impl ToTokens for ParsedEnum {
             no_static,
             no_runtime_generics,
             cmp_eq: _, // TODO: implement cmp_eq for enums
+            get: _,
         } = &options.body;
         let target = get_target(target, ident);
         let mut struct_attrs = attrs.clone();

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

@@ -3,29 +3,264 @@
 use crate::{
     Errors, HdlAttr,
     hdl_type_common::{
-        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType, TypesParser,
-        get_target,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType,
+        PhantomConstGetBound, TypesParser, WrappedInConst, common_derives, get_target, known_items,
     },
     kw,
 };
 use proc_macro2::TokenStream;
-use quote::ToTokens;
-use syn::{Attribute, Generics, Ident, ItemType, Token, Type, Visibility, parse_quote_spanned};
+use quote::{ToTokens, format_ident, quote_spanned};
+use syn::{
+    Attribute, Expr, Fields, GenericParam, Generics, Ident, ItemStruct, ItemType, Token, Type,
+    TypeGroup, TypeParam, TypeParen, Visibility, parse_quote_spanned, punctuated::Pair,
+    token::Paren,
+};
 
 #[derive(Clone, Debug)]
-pub(crate) struct ParsedTypeAlias {
-    pub(crate) attrs: Vec<Attribute>,
-    pub(crate) options: HdlAttr<ItemOptions, kw::hdl>,
-    pub(crate) vis: Visibility,
-    pub(crate) type_token: Token![type],
-    pub(crate) ident: Ident,
-    pub(crate) generics: MaybeParsed<ParsedGenerics, Generics>,
-    pub(crate) eq_token: Token![=],
-    pub(crate) ty: MaybeParsed<ParsedType, Type>,
-    pub(crate) semi_token: Token![;],
+pub(crate) struct PhantomConstAccessorTypeParam {
+    attrs: Vec<Attribute>,
+    ident: Ident,
+    colon_token: Token![:],
+    phantom_const_get_bound: PhantomConstGetBound,
+    plus_token: Option<Token![+]>,
+}
+
+impl From<PhantomConstAccessorTypeParam> for TypeParam {
+    fn from(value: PhantomConstAccessorTypeParam) -> Self {
+        let PhantomConstAccessorTypeParam {
+            attrs,
+            ident,
+            colon_token,
+            phantom_const_get_bound,
+            plus_token,
+        } = value;
+        TypeParam {
+            attrs,
+            ident,
+            colon_token: Some(colon_token),
+            bounds: FromIterator::from_iter([Pair::new(
+                phantom_const_get_bound.into(),
+                plus_token,
+            )]),
+            eq_token: None,
+            default: None,
+        }
+    }
+}
+
+impl From<PhantomConstAccessorTypeParam> for GenericParam {
+    fn from(value: PhantomConstAccessorTypeParam) -> Self {
+        TypeParam::from(value).into()
+    }
+}
+
+impl PhantomConstAccessorTypeParam {
+    fn parse_opt(generic_param: GenericParam) -> Option<Self> {
+        let GenericParam::Type(TypeParam {
+            attrs,
+            ident,
+            colon_token,
+            bounds,
+            eq_token: None,
+            default: None,
+        }) = generic_param
+        else {
+            return None;
+        };
+        let colon_token = colon_token.unwrap_or(Token![:](ident.span()));
+        let mut bounds = bounds.into_pairs();
+        let (bound, plus_token) = bounds.next()?.into_tuple();
+        let phantom_const_get_bound = PhantomConstGetBound::parse_type_param_bound(bound)
+            .ok()?
+            .ok()?;
+        let None = bounds.next() else {
+            return None;
+        };
+        Some(Self {
+            attrs,
+            ident,
+            colon_token,
+            phantom_const_get_bound,
+            plus_token,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct PhantomConstAccessorGenerics {
+    lt_token: Token![<],
+    type_param: PhantomConstAccessorTypeParam,
+    comma_token: Option<Token![,]>,
+    gt_token: Token![>],
+}
+
+impl From<PhantomConstAccessorGenerics> for Generics {
+    fn from(value: PhantomConstAccessorGenerics) -> Self {
+        let PhantomConstAccessorGenerics {
+            lt_token,
+            type_param,
+            comma_token,
+            gt_token,
+        } = value;
+        Generics {
+            lt_token: Some(lt_token),
+            params: FromIterator::from_iter([Pair::new(type_param.into(), comma_token)]),
+            gt_token: Some(gt_token),
+            where_clause: None,
+        }
+    }
+}
+
+impl<'a> From<&'a PhantomConstAccessorGenerics> for Generics {
+    fn from(value: &'a PhantomConstAccessorGenerics) -> Self {
+        value.clone().into()
+    }
+}
+
+impl PhantomConstAccessorGenerics {
+    fn parse_opt(generics: Generics) -> Option<Self> {
+        let Generics {
+            lt_token,
+            params,
+            gt_token,
+            where_clause: None,
+        } = generics
+        else {
+            return None;
+        };
+        let mut params = params.into_pairs();
+        let (generic_param, comma_token) = params.next()?.into_tuple();
+        let type_param = PhantomConstAccessorTypeParam::parse_opt(generic_param)?;
+        let span = type_param.ident.span();
+        let lt_token = lt_token.unwrap_or(Token![<](span));
+        let gt_token = gt_token.unwrap_or(Token![>](span));
+        let None = params.next() else {
+            return None;
+        };
+        Some(Self {
+            lt_token,
+            type_param,
+            comma_token,
+            gt_token,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum ParsedTypeAlias {
+    TypeAlias {
+        attrs: Vec<Attribute>,
+        options: HdlAttr<ItemOptions, kw::hdl>,
+        vis: Visibility,
+        type_token: Token![type],
+        ident: Ident,
+        generics: MaybeParsed<ParsedGenerics, Generics>,
+        eq_token: Token![=],
+        ty: MaybeParsed<ParsedType, Type>,
+        semi_token: Token![;],
+    },
+    PhantomConstAccessor {
+        attrs: Vec<Attribute>,
+        options: HdlAttr<ItemOptions, kw::hdl>,
+        get: (kw::get, Paren, Expr),
+        vis: Visibility,
+        type_token: Token![type],
+        ident: Ident,
+        generics: PhantomConstAccessorGenerics,
+        eq_token: Token![=],
+        ty: Type,
+        ty_is_dyn_size: Option<known_items::DynSize>,
+        semi_token: Token![;],
+    },
 }
 
 impl ParsedTypeAlias {
+    fn ty_is_dyn_size(ty: &Type) -> Option<known_items::DynSize> {
+        match ty {
+            Type::Group(TypeGroup {
+                group_token: _,
+                elem,
+            }) => Self::ty_is_dyn_size(elem),
+            Type::Paren(TypeParen {
+                paren_token: _,
+                elem,
+            }) => Self::ty_is_dyn_size(elem),
+            Type::Path(syn::TypePath { qself: None, path }) => {
+                known_items::DynSize::parse_path(path.clone()).ok()
+            }
+            _ => None,
+        }
+    }
+    fn parse_phantom_const_accessor(
+        item: ItemType,
+        mut errors: Errors,
+        options: HdlAttr<ItemOptions, kw::hdl>,
+        get: (kw::get, Paren, Expr),
+    ) -> syn::Result<Self> {
+        let ItemType {
+            attrs,
+            vis,
+            type_token,
+            ident,
+            generics,
+            eq_token,
+            ty,
+            semi_token,
+        } = item;
+        let ItemOptions {
+            outline_generated: _,
+            ref target,
+            custom_bounds,
+            no_static,
+            no_runtime_generics,
+            cmp_eq,
+            get: _,
+        } = options.body;
+        if let Some((no_static,)) = no_static {
+            errors.error(no_static, "no_static is not valid on type aliases");
+        }
+        if let Some((target, ..)) = target {
+            errors.error(
+                target,
+                "target is not implemented on PhantomConstGet type aliases",
+            );
+        }
+        if let Some((no_runtime_generics,)) = no_runtime_generics {
+            errors.error(
+                no_runtime_generics,
+                "no_runtime_generics is not implemented on PhantomConstGet type aliases",
+            );
+        }
+        if let Some((cmp_eq,)) = cmp_eq {
+            errors.error(cmp_eq, "cmp_eq is not valid on type aliases");
+        }
+        if let Some((custom_bounds,)) = custom_bounds {
+            errors.error(
+                custom_bounds,
+                "custom_bounds is not implemented on PhantomConstGet type aliases",
+            );
+        }
+        let Some(generics) = PhantomConstAccessorGenerics::parse_opt(generics) else {
+            errors.error(ident, "#[hdl(get(...))] type alias must be of the form:\ntype MyTypeGetter<P: PhantomConstGet<MyType>> = RetType;");
+            errors.finish()?;
+            unreachable!();
+        };
+        errors.finish()?;
+        let ty_is_dyn_size = Self::ty_is_dyn_size(&ty);
+        Ok(Self::PhantomConstAccessor {
+            attrs,
+            options,
+            get,
+            vis,
+            type_token,
+            ident,
+            generics,
+            eq_token,
+            ty: *ty,
+            ty_is_dyn_size,
+            semi_token,
+        })
+    }
     fn parse(item: ItemType) -> syn::Result<Self> {
         let ItemType {
             mut attrs,
@@ -51,7 +286,25 @@ impl ParsedTypeAlias {
             no_static,
             no_runtime_generics: _,
             cmp_eq,
+            ref mut get,
         } = options.body;
+        if let Some(get) = get.take() {
+            return Self::parse_phantom_const_accessor(
+                ItemType {
+                    attrs,
+                    vis,
+                    type_token,
+                    ident,
+                    generics,
+                    eq_token,
+                    ty,
+                    semi_token,
+                },
+                errors,
+                options,
+                get,
+            );
+        }
         if let Some((no_static,)) = no_static {
             errors.error(no_static, "no_static is not valid on type aliases");
         }
@@ -67,7 +320,7 @@ impl ParsedTypeAlias {
         };
         let ty = TypesParser::maybe_run(generics.as_ref(), *ty, &mut errors);
         errors.finish()?;
-        Ok(Self {
+        Ok(Self::TypeAlias {
             attrs,
             options,
             vis,
@@ -83,54 +336,155 @@ impl ParsedTypeAlias {
 
 impl ToTokens for ParsedTypeAlias {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let Self {
-            attrs,
-            options,
-            vis,
-            type_token,
-            ident,
-            generics,
-            eq_token,
-            ty,
-            semi_token,
-        } = self;
-        let ItemOptions {
-            outline_generated: _,
-            target,
-            custom_bounds: _,
-            no_static: _,
-            no_runtime_generics,
-            cmp_eq: _,
-        } = &options.body;
-        let target = get_target(target, ident);
-        let mut type_attrs = attrs.clone();
-        type_attrs.push(parse_quote_spanned! {ident.span()=>
-            #[allow(type_alias_bounds)]
-        });
-        ItemType {
-            attrs: type_attrs,
-            vis: vis.clone(),
-            type_token: *type_token,
-            ident: ident.clone(),
-            generics: generics.into(),
-            eq_token: *eq_token,
-            ty: Box::new(ty.clone().into()),
-            semi_token: *semi_token,
-        }
-        .to_tokens(tokens);
-        if let (MaybeParsed::Parsed(generics), MaybeParsed::Parsed(ty), None) =
-            (generics, ty, no_runtime_generics)
-        {
-            generics.make_runtime_generics(tokens, vis, ident, &target, |context| {
-                ty.make_hdl_type_expr(context)
-            })
+        match self {
+            Self::TypeAlias {
+                attrs,
+                options,
+                vis,
+                type_token,
+                ident,
+                generics,
+                eq_token,
+                ty,
+                semi_token,
+            } => {
+                let ItemOptions {
+                    outline_generated: _,
+                    target,
+                    custom_bounds: _,
+                    no_static: _,
+                    no_runtime_generics,
+                    cmp_eq: _,
+                    get: _,
+                } = &options.body;
+                let target = get_target(target, ident);
+                let mut type_attrs = attrs.clone();
+                type_attrs.push(parse_quote_spanned! {ident.span()=>
+                    #[allow(type_alias_bounds)]
+                });
+                ItemType {
+                    attrs: type_attrs,
+                    vis: vis.clone(),
+                    type_token: *type_token,
+                    ident: ident.clone(),
+                    generics: generics.into(),
+                    eq_token: *eq_token,
+                    ty: Box::new(ty.clone().into()),
+                    semi_token: *semi_token,
+                }
+                .to_tokens(tokens);
+                if let (MaybeParsed::Parsed(generics), MaybeParsed::Parsed(ty), None) =
+                    (generics, ty, no_runtime_generics)
+                {
+                    generics.make_runtime_generics(tokens, vis, ident, &target, |context| {
+                        ty.make_hdl_type_expr(context)
+                    })
+                }
+            }
+            Self::PhantomConstAccessor {
+                attrs,
+                options,
+                get: (_get_kw, _get_paren, get_expr),
+                vis,
+                type_token,
+                ident,
+                generics,
+                eq_token,
+                ty,
+                ty_is_dyn_size,
+                semi_token,
+            } => {
+                let ItemOptions {
+                    outline_generated: _,
+                    target: _,
+                    custom_bounds: _,
+                    no_static: _,
+                    no_runtime_generics: _,
+                    cmp_eq: _,
+                    get: _,
+                } = &options.body;
+                let span = ident.span();
+                let mut type_attrs = attrs.clone();
+                type_attrs.push(parse_quote_spanned! {span=>
+                    #[allow(type_alias_bounds)]
+                });
+                let type_param_ident = &generics.type_param.ident;
+                let syn_generics = Generics::from(generics);
+                ItemType {
+                    attrs: type_attrs,
+                    vis: vis.clone(),
+                    type_token: *type_token,
+                    ident: ident.clone(),
+                    generics: syn_generics.clone(),
+                    eq_token: *eq_token,
+                    ty: parse_quote_spanned! {span=>
+                        <#ty as ::fayalite::phantom_const::ReturnSelfUnchanged<#type_param_ident>>::Type
+                    },
+                    semi_token: *semi_token,
+                }
+                .to_tokens(tokens);
+                let generics_accumulation_ident =
+                    format_ident!("__{}__GenericsAccumulation", ident);
+                ItemStruct {
+                    attrs: vec![
+                        common_derives(span),
+                        parse_quote_spanned! {span=>
+                            #[allow(non_camel_case_types)]
+                        },
+                    ],
+                    vis: vis.clone(),
+                    struct_token: Token![struct](span),
+                    ident: generics_accumulation_ident.clone(),
+                    generics: Generics::default(),
+                    fields: Fields::Unnamed(parse_quote_spanned! {span=>
+                        (())
+                    }),
+                    semi_token: Some(Token![;](span)),
+                }
+                .to_tokens(tokens);
+                quote_spanned! {span=>
+                    #[allow(non_upper_case_globals, dead_code)]
+                    #vis const #ident: #generics_accumulation_ident = #generics_accumulation_ident(());
+                }
+                .to_tokens(tokens);
+                let mut wrapped_in_const = WrappedInConst::new(tokens, span);
+                let tokens = wrapped_in_const.inner();
+                let (impl_generics, _type_generics, where_clause) = syn_generics.split_for_impl();
+                let phantom_const_get_ty = &generics.type_param.phantom_const_get_bound.ty;
+                let index_output = if let Some(ty_is_dyn_size) = ty_is_dyn_size {
+                    known_items::usize(ty_is_dyn_size.span).to_token_stream()
+                } else {
+                    ty.to_token_stream()
+                };
+                quote_spanned! {span=>
+                    #[allow(non_upper_case_globals)]
+                    #[automatically_derived]
+                    impl #impl_generics ::fayalite::__std::ops::Index<#type_param_ident>
+                    for #generics_accumulation_ident
+                    #where_clause
+                    {
+                        type Output = #index_output;
+
+                        fn index(&self, __param: #type_param_ident) -> &Self::Output {
+                            ::fayalite::phantom_const::type_alias_phantom_const_get_helper::<#phantom_const_get_ty, #index_output>(
+                                __param,
+                                #get_expr,
+                            )
+                        }
+                    }
+                }
+                .to_tokens(tokens);
+            }
         }
     }
 }
 
 pub(crate) fn hdl_type_alias_impl(item: ItemType) -> syn::Result<TokenStream> {
     let item = ParsedTypeAlias::parse(item)?;
-    let outline_generated = item.options.body.outline_generated;
+    let outline_generated = match &item {
+        ParsedTypeAlias::TypeAlias { options, .. }
+        | ParsedTypeAlias::PhantomConstAccessor { options, .. } => options.body.outline_generated,
+    };
     let mut contents = item.to_token_stream();
     if outline_generated.is_some() {
         contents = crate::outline_generated(contents, "hdl-type-alias-");

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

@@ -8,9 +8,9 @@ use syn::{
     AngleBracketedGenericArguments, Attribute, Block, ConstParam, Expr, ExprBlock, ExprGroup,
     ExprIndex, ExprParen, ExprPath, ExprTuple, Field, FieldMutability, Fields, FieldsNamed,
     FieldsUnnamed, GenericArgument, GenericParam, Generics, Ident, ImplGenerics, Index, ItemStruct,
-    Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, Turbofish, Type,
-    TypeGenerics, TypeGroup, TypeParam, TypeParen, TypePath, TypeTuple, Visibility, WhereClause,
-    WherePredicate,
+    Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, TraitBound, Turbofish,
+    Type, TypeGenerics, TypeGroup, TypeParam, TypeParamBound, TypeParen, TypePath, TypeTuple,
+    Visibility, WhereClause, WherePredicate,
     parse::{Parse, ParseStream},
     parse_quote, parse_quote_spanned,
     punctuated::{Pair, Punctuated},
@@ -27,6 +27,7 @@ crate::options! {
         NoStatic(no_static),
         NoRuntimeGenerics(no_runtime_generics),
         CmpEq(cmp_eq),
+        Get(get, Expr),
     }
 }
 
@@ -2045,6 +2046,7 @@ pub(crate) mod known_items {
     impl_known_item!(::fayalite::int::Size);
     impl_known_item!(::fayalite::int::UInt);
     impl_known_item!(::fayalite::int::UIntType);
+    impl_known_item!(::fayalite::phantom_const::PhantomConstGet);
     impl_known_item!(::fayalite::reset::ResetType);
     impl_known_item!(::fayalite::ty::CanonicalType);
     impl_known_item!(::fayalite::ty::StaticType);
@@ -2063,6 +2065,174 @@ pub(crate) mod known_items {
     );
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct PhantomConstGetBound {
+    pub(crate) phantom_const_get: known_items::PhantomConstGet,
+    pub(crate) colon2_token: Option<Token![::]>,
+    pub(crate) lt_token: Token![<],
+    pub(crate) ty: Type,
+    pub(crate) comma_token: Option<Token![,]>,
+    pub(crate) gt_token: Token![>],
+}
+
+impl PhantomConstGetBound {
+    pub(crate) fn parse_path_with_arguments(path: Path) -> syn::Result<Result<Self, Path>> {
+        match known_items::PhantomConstGet::parse_path_with_arguments(path) {
+            Ok((phantom_const_get, arguments)) => {
+                Self::parse_path_and_arguments(phantom_const_get, arguments).map(Ok)
+            }
+            Err(path) => Ok(Err(path)),
+        }
+    }
+    pub(crate) fn parse_path_and_arguments(
+        phantom_const_get: known_items::PhantomConstGet,
+        arguments: PathArguments,
+    ) -> syn::Result<Self> {
+        let error = |arguments: PathArguments, message: &str| {
+            let mut path = phantom_const_get.path.clone();
+            path.segments.last_mut().expect("known to exist").arguments = arguments;
+            syn::Error::new_spanned(path, message)
+        };
+        match arguments {
+            PathArguments::None => Err(error(arguments, "missing generics for PhantomConstGet")),
+            PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                colon2_token,
+                lt_token,
+                args,
+                gt_token,
+            }) => {
+                let error = |args: Punctuated<GenericArgument, Token![,]>, message| {
+                    error(
+                        PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                            colon2_token,
+                            lt_token,
+                            args,
+                            gt_token,
+                        }),
+                        message,
+                    )
+                };
+                let mut args = args.into_pairs().peekable();
+                let Some((generic_argument, comma_token)) = args.next().map(Pair::into_tuple)
+                else {
+                    return Err(error(
+                        Default::default(),
+                        "PhantomConstGet takes a type argument but no generic arguments were supplied",
+                    ));
+                };
+                if args.peek().is_some() {
+                    return Err(error(
+                        [Pair::new(generic_argument, comma_token)]
+                            .into_iter()
+                            .chain(args)
+                            .collect(),
+                        "PhantomConstGet takes a single type argument but too many generic arguments were supplied",
+                    ));
+                };
+                let GenericArgument::Type(ty) = generic_argument else {
+                    return Err(error(
+                        Punctuated::from_iter([Pair::new(generic_argument, comma_token)]),
+                        "PhantomConstGet requires a type argument",
+                    ));
+                };
+                Ok(Self {
+                    phantom_const_get,
+                    colon2_token,
+                    lt_token,
+                    ty,
+                    comma_token,
+                    gt_token,
+                })
+            }
+            PathArguments::Parenthesized(_) => Err(error(
+                arguments,
+                "parenthetical generics are not valid for PhantomConstGet",
+            )),
+        }
+    }
+    pub(crate) fn parse_type_param_bound(
+        bound: TypeParamBound,
+    ) -> syn::Result<Result<Self, TypeParamBound>> {
+        let TypeParamBound::Trait(TraitBound {
+            paren_token: None,
+            modifier: syn::TraitBoundModifier::None,
+            lifetimes: None,
+            path,
+        }) = bound
+        else {
+            return Ok(Err(bound));
+        };
+        Ok(match Self::parse_path_with_arguments(path)? {
+            Ok(v) => Ok(v),
+            Err(path) => Err(TypeParamBound::Trait(TraitBound {
+                paren_token: None,
+                modifier: syn::TraitBoundModifier::None,
+                lifetimes: None,
+                path,
+            })),
+        })
+    }
+}
+
+impl ToTokens for PhantomConstGetBound {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let Self {
+            phantom_const_get,
+            colon2_token,
+            lt_token,
+            ty,
+            comma_token,
+            gt_token,
+        } = self;
+        phantom_const_get.to_tokens(tokens);
+        colon2_token.to_tokens(tokens);
+        lt_token.to_tokens(tokens);
+        ty.to_tokens(tokens);
+        comma_token.to_tokens(tokens);
+        gt_token.to_tokens(tokens);
+    }
+}
+
+impl From<PhantomConstGetBound> for Path {
+    fn from(value: PhantomConstGetBound) -> Self {
+        let PhantomConstGetBound {
+            phantom_const_get,
+            colon2_token,
+            lt_token,
+            ty,
+            comma_token,
+            gt_token,
+        } = value;
+        let mut path = phantom_const_get.path;
+        path.segments.last_mut().expect("known to exist").arguments =
+            PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                colon2_token,
+                lt_token,
+                args: FromIterator::from_iter([Pair::new(GenericArgument::Type(ty), comma_token)]),
+                gt_token,
+            });
+        path
+    }
+}
+
+impl From<PhantomConstGetBound> for TraitBound {
+    fn from(value: PhantomConstGetBound) -> Self {
+        let path = Path::from(value);
+        TraitBound {
+            paren_token: None,
+            modifier: syn::TraitBoundModifier::None,
+            lifetimes: None,
+            path,
+        }
+    }
+}
+
+impl From<PhantomConstGetBound> for TypeParamBound {
+    fn from(value: PhantomConstGetBound) -> Self {
+        TraitBound::from(value).into()
+    }
+}
+
 macro_rules! impl_bounds {
     (
         #[struct = $struct_type:ident]
@@ -2070,6 +2240,10 @@ macro_rules! impl_bounds {
             $(
                 $Variant:ident,
             )*
+            $(
+                #[has_body]
+                $VariantHasBody:ident($variant_has_body_ty:ty),
+            )*
             $(
                 #[unknown]
                 $Unknown:ident,
@@ -2079,6 +2253,7 @@ macro_rules! impl_bounds {
         #[derive(Clone, Debug)]
         $vis enum $enum_type {
             $($Variant(known_items::$Variant),)*
+            $($VariantHasBody($variant_has_body_ty),)*
             $($Unknown(syn::TypeParamBound),)?
         }
 
@@ -2088,31 +2263,42 @@ macro_rules! impl_bounds {
             }
         })*
 
+        $(impl From<$variant_has_body_ty> for $enum_type {
+            fn from(v: $variant_has_body_ty) -> Self {
+                Self::$VariantHasBody(v)
+            }
+        })*
+
         impl ToTokens for $enum_type {
             fn to_tokens(&self, tokens: &mut TokenStream) {
                 match self {
                     $(Self::$Variant(v) => v.to_tokens(tokens),)*
+                    $(Self::$VariantHasBody(v) => v.to_tokens(tokens),)*
                     $(Self::$Unknown(v) => v.to_tokens(tokens),)?
                 }
             }
         }
 
         impl $enum_type {
-            $vis fn parse_path(path: Path) -> Result<Self, Path> {
+            $vis fn parse_path_with_arguments(path: Path) -> syn::Result<Result<Self, Path>> {
                 #![allow(unreachable_code)]
                 $(let path = match known_items::$Variant::parse_path(path) {
-                    Ok(v) => return Ok(Self::$Variant(v)),
+                    Ok(v) => return Ok(Ok(Self::$Variant(v))),
                     Err(path) => path,
                 };)*
-                $(return Ok(Self::$Unknown(syn::TraitBound {
+                $(let path = match <$variant_has_body_ty>::parse_path_with_arguments(path)? {
+                    Ok(v) => return Ok(Ok(Self::$VariantHasBody(v))),
+                    Err(path) => path,
+                };)*
+                $(return Ok(Ok(Self::$Unknown(syn::TraitBound {
                     paren_token: None,
                     modifier: syn::TraitBoundModifier::None,
                     lifetimes: None,
                     path,
-                }.into()));)?
-                Err(path)
+                }.into())));)?
+                Ok(Err(path))
             }
-            $vis fn parse_type_param_bound(mut type_param_bound: syn::TypeParamBound) -> Result<Self, syn::TypeParamBound> {
+            $vis fn parse_type_param_bound(mut type_param_bound: syn::TypeParamBound) -> syn::Result<Result<Self, syn::TypeParamBound>> {
                 #![allow(unreachable_code)]
                 if let syn::TypeParamBound::Trait(mut trait_bound) = type_param_bound {
                     if let syn::TraitBound {
@@ -2121,24 +2307,24 @@ macro_rules! impl_bounds {
                         lifetimes: None,
                         path: _,
                     } = trait_bound {
-                        match Self::parse_path(trait_bound.path) {
-                            Ok(retval) => return Ok(retval),
+                        match Self::parse_path_with_arguments(trait_bound.path)? {
+                            Ok(retval) => return Ok(Ok(retval)),
                             Err(path) => trait_bound.path = path,
                         }
                     }
                     type_param_bound = trait_bound.into();
                 }
-                $(return Ok(Self::$Unknown(type_param_bound));)?
-                Err(type_param_bound)
+                $(return Ok(Ok(Self::$Unknown(type_param_bound)));)?
+                Ok(Err(type_param_bound))
             }
         }
 
         impl Parse for $enum_type {
             fn parse(input: ParseStream) -> syn::Result<Self> {
-                Self::parse_type_param_bound(input.parse()?)
+                Self::parse_type_param_bound(input.parse()?)?
                     .map_err(|type_param_bound| syn::Error::new_spanned(
                         type_param_bound,
-                        format_args!("expected one of: {}", [$(stringify!($Variant)),*].join(", ")),
+                        format_args!("expected one of: {}", [$(stringify!($Variant),)* $(stringify!($VariantHasBody)),*].join(", ")),
                     ))
             }
         }
@@ -2147,6 +2333,7 @@ macro_rules! impl_bounds {
         #[allow(non_snake_case)]
         $vis struct $struct_type {
             $($vis $Variant: Option<known_items::$Variant>,)*
+            $($vis $VariantHasBody: Option<$variant_has_body_ty>,)*
             $($vis $Unknown: Vec<syn::TypeParamBound>,)?
         }
 
@@ -2159,6 +2346,11 @@ macro_rules! impl_bounds {
                     separator = Some(<Token![+]>::default());
                     v.to_tokens(tokens);
                 })*
+                $(if let Some(v) = &self.$VariantHasBody {
+                    separator.to_tokens(tokens);
+                    separator = Some(<Token![+]>::default());
+                    v.to_tokens(tokens);
+                })*
                 $(for v in &self.$Unknown {
                     separator.to_tokens(tokens);
                     separator = Some(<Token![+]>::default());
@@ -2172,6 +2364,7 @@ macro_rules! impl_bounds {
             #[allow(non_snake_case)]
             $vis struct Iter {
                 $($Variant: Option<known_items::$Variant>,)*
+                $($VariantHasBody: Option<$variant_has_body_ty>,)*
                 $($Unknown: std::vec::IntoIter<syn::TypeParamBound>,)?
             }
 
@@ -2182,6 +2375,7 @@ macro_rules! impl_bounds {
                 fn into_iter(self) -> Self::IntoIter {
                     Iter {
                         $($Variant: self.$Variant,)*
+                        $($VariantHasBody: self.$VariantHasBody,)*
                         $($Unknown: self.$Unknown.into_iter(),)?
                     }
                 }
@@ -2196,6 +2390,11 @@ macro_rules! impl_bounds {
                             return Some($enum_type::$Variant(value));
                         }
                     )*
+                    $(
+                        if let Some(value) = self.$VariantHasBody.take() {
+                            return Some($enum_type::$VariantHasBody(value));
+                        }
+                    )*
                     $(
                         if let Some(value) = self.$Unknown.next() {
                             return Some($enum_type::$Unknown(value));
@@ -2211,6 +2410,11 @@ macro_rules! impl_bounds {
                             init = f(init, $enum_type::$Variant(value));
                         }
                     )*
+                    $(
+                        if let Some(value) = self.$VariantHasBody.take() {
+                            init = f(init, $enum_type::$VariantHasBody(value));
+                        }
+                    )*
                     $(
                         if let Some(value) = self.$Unknown.next() {
                             init = f(init, $enum_type::$Unknown(value));
@@ -2227,6 +2431,9 @@ macro_rules! impl_bounds {
                     $($enum_type::$Variant(v) => {
                         self.$Variant = Some(v);
                     })*
+                    $($enum_type::$VariantHasBody(v) => {
+                        self.$VariantHasBody = Some(v);
+                    })*
                     $($enum_type::$Unknown(v) => {
                         self.$Unknown.push(v);
                     })?
@@ -2248,6 +2455,9 @@ macro_rules! impl_bounds {
                     $(if let Some(v) = v.$Variant {
                         self.$Variant = Some(v);
                     })*
+                    $(if let Some(v) = v.$VariantHasBody {
+                        self.$VariantHasBody = Some(v);
+                    })*
                     $(self.$Unknown.extend(v.$Unknown);)*
                 });
             }
@@ -2302,6 +2512,8 @@ impl_bounds! {
         Size,
         StaticType,
         Type,
+        #[has_body]
+        PhantomConstGet(PhantomConstGetBound),
         #[unknown]
         Unknown,
     }
@@ -2317,6 +2529,8 @@ impl_bounds! {
         ResetType,
         StaticType,
         Type,
+        #[has_body]
+        PhantomConstGet(PhantomConstGetBound),
         #[unknown]
         Unknown,
     }
@@ -2332,6 +2546,7 @@ impl From<ParsedTypeBound> for ParsedBound {
             ParsedTypeBound::ResetType(v) => ParsedBound::ResetType(v),
             ParsedTypeBound::StaticType(v) => ParsedBound::StaticType(v),
             ParsedTypeBound::Type(v) => ParsedBound::Type(v),
+            ParsedTypeBound::PhantomConstGet(v) => ParsedBound::PhantomConstGet(v),
             ParsedTypeBound::Unknown(v) => ParsedBound::Unknown(v),
         }
     }
@@ -2347,6 +2562,7 @@ impl From<ParsedTypeBounds> for ParsedBounds {
             ResetType,
             StaticType,
             Type,
+            PhantomConstGet,
             Unknown,
         } = value;
         Self {
@@ -2359,6 +2575,7 @@ impl From<ParsedTypeBounds> for ParsedBounds {
             Size: None,
             StaticType,
             Type,
+            PhantomConstGet,
             Unknown,
         }
     }
@@ -2395,6 +2612,10 @@ impl ParsedTypeBound {
                 ParsedTypeBound::Type(known_items::Type(span)),
             ]),
             Self::Type(v) => ParsedTypeBounds::from_iter([ParsedTypeBound::from(v)]),
+            Self::PhantomConstGet(v) => ParsedTypeBounds::from_iter([
+                ParsedTypeBound::from(v),
+                ParsedTypeBound::Type(known_items::Type(span)),
+            ]),
             Self::Unknown(v) => ParsedTypeBounds::from_iter([ParsedTypeBound::Unknown(v)]),
         }
     }
@@ -2430,6 +2651,7 @@ impl From<ParsedSizeTypeBounds> for ParsedBounds {
             Size,
             StaticType: None,
             Type: None,
+            PhantomConstGet: None,
             Unknown: vec![],
         }
     }
@@ -2532,6 +2754,9 @@ impl ParsedBound {
             Self::Size(v) => ParsedBoundCategory::SizeType(ParsedSizeTypeBound::Size(v)),
             Self::StaticType(v) => ParsedBoundCategory::Type(ParsedTypeBound::StaticType(v)),
             Self::Type(v) => ParsedBoundCategory::Type(ParsedTypeBound::Type(v)),
+            Self::PhantomConstGet(v) => {
+                ParsedBoundCategory::Type(ParsedTypeBound::PhantomConstGet(v))
+            }
             Self::Unknown(v) => ParsedBoundCategory::Unknown(v),
         }
     }
@@ -3417,7 +3642,8 @@ impl ParsedGenerics {
                                 | ParsedTypeBound::BundleType(_)
                                 | ParsedTypeBound::EnumType(_)
                                 | ParsedTypeBound::IntType(_)
-                                | ParsedTypeBound::ResetType(_) => {
+                                | ParsedTypeBound::ResetType(_)
+                                | ParsedTypeBound::PhantomConstGet(_) => {
                                     errors.error(bound, "bounds on mask types are not implemented");
                                 }
                                 ParsedTypeBound::StaticType(bound) => {
@@ -4386,3 +4612,124 @@ impl MakeHdlTypeExpr for ParsedTypeTuple {
         })
     }
 }
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ParsedSimpleVisibility {
+    Public(Token![pub]),
+    PubCrate {
+        pub_token: Token![pub],
+        paren_token: Paren,
+        crate_token: Token![crate],
+    },
+    Inherited,
+}
+
+impl From<ParsedSimpleVisibility> for Visibility {
+    fn from(value: ParsedSimpleVisibility) -> Self {
+        match value {
+            ParsedSimpleVisibility::Public(v) => Visibility::Public(v),
+            ParsedSimpleVisibility::PubCrate {
+                pub_token,
+                paren_token,
+                crate_token,
+            } => Visibility::Restricted(syn::VisRestricted {
+                pub_token,
+                paren_token,
+                in_token: None,
+                path: Box::new(Ident::new("crate", crate_token.span).into()),
+            }),
+            ParsedSimpleVisibility::Inherited => Visibility::Inherited,
+        }
+    }
+}
+
+impl PartialOrd for ParsedSimpleVisibility {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ParsedSimpleVisibility {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.visibility_level().cmp(&other.visibility_level())
+    }
+}
+
+impl ParsedSimpleVisibility {
+    const VISIBILITY_LEVEL_INHERITED: u8 = 0;
+    const VISIBILITY_LEVEL_RESTRICTED: u8 = 1 + Self::VISIBILITY_LEVEL_INHERITED;
+    const VISIBILITY_LEVEL_PUB_CRATE: u8 = 1 + Self::VISIBILITY_LEVEL_RESTRICTED;
+    const VISIBILITY_LEVEL_PUB: u8 = 1 + Self::VISIBILITY_LEVEL_PUB_CRATE;
+    fn visibility_level(self) -> u8 {
+        match self {
+            Self::Public(_) => Self::VISIBILITY_LEVEL_PUB,
+            Self::PubCrate { .. } => Self::VISIBILITY_LEVEL_PUB_CRATE,
+            Self::Inherited => Self::VISIBILITY_LEVEL_INHERITED,
+        }
+    }
+    pub(crate) fn parse(vis: Visibility) -> Result<Self, syn::VisRestricted> {
+        match vis {
+            Visibility::Public(v) => Ok(Self::Public(v)),
+            Visibility::Restricted(syn::VisRestricted {
+                pub_token,
+                paren_token,
+                in_token: None,
+                path,
+            }) if path.is_ident("crate") => Ok(Self::PubCrate {
+                pub_token,
+                paren_token,
+                crate_token: Token![crate](path.get_ident().expect("just checked").span()),
+            }),
+            Visibility::Restricted(v) => Err(v),
+            Visibility::Inherited => Ok(Self::Inherited),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ParsedVisibility {
+    Simple(ParsedSimpleVisibility),
+    Restricted(syn::VisRestricted),
+}
+
+impl From<ParsedVisibility> for Visibility {
+    fn from(value: ParsedVisibility) -> Self {
+        match value {
+            ParsedVisibility::Simple(v) => v.into(),
+            ParsedVisibility::Restricted(v) => Visibility::Restricted(v),
+        }
+    }
+}
+
+impl PartialOrd for ParsedVisibility {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match (self, other) {
+            (ParsedVisibility::Simple(l), ParsedVisibility::Simple(r)) => Some(l.cmp(r)),
+            (ParsedVisibility::Simple(l), ParsedVisibility::Restricted(_)) => Some(
+                l.visibility_level()
+                    .cmp(&ParsedSimpleVisibility::VISIBILITY_LEVEL_RESTRICTED),
+            ),
+            (ParsedVisibility::Restricted(_), ParsedVisibility::Simple(r)) => {
+                Some(ParsedSimpleVisibility::VISIBILITY_LEVEL_RESTRICTED.cmp(&r.visibility_level()))
+            }
+            (ParsedVisibility::Restricted(l), ParsedVisibility::Restricted(r)) => {
+                (l == r).then_some(std::cmp::Ordering::Equal)
+            }
+        }
+    }
+}
+
+impl ParsedVisibility {
+    #[allow(dead_code)]
+    pub(crate) fn parse(vis: Visibility) -> Self {
+        match ParsedSimpleVisibility::parse(vis) {
+            Ok(simple) => Self::Simple(simple),
+            Err(restricted) => Self::Restricted(restricted),
+        }
+    }
+    #[allow(dead_code)]
+    pub(crate) fn min<'a>(&'a self, other: &'a Self) -> Option<&'a Self> {
+        self.partial_cmp(other)
+            .map(|ord| if ord.is_lt() { self } else { other })
+    }
+}

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

@@ -76,6 +76,7 @@ mod kw {
     custom_keyword!(connect_inexact);
     custom_keyword!(custom_bounds);
     custom_keyword!(flip);
+    custom_keyword!(get);
     custom_keyword!(hdl);
     custom_keyword!(hdl_module);
     custom_keyword!(incomplete_wire);

crates/fayalite/src/build/graph.rs

@@ -703,8 +703,12 @@ impl JobGraph {
             }
             let mut running_jobs = HashMap::default();
             let (finished_jobs_sender, finished_jobs_receiver) = mpsc::channel();
+            let mut next_finished_job = None;
             loop {
-                while let Some(finished_job) = finished_jobs_receiver.try_recv().ok() {
+                if let Some(finished_job) = next_finished_job
+                    .take()
+                    .or_else(|| finished_jobs_receiver.try_recv().ok())
+                {
                     let Some(RunningJob { job, thread }) = running_jobs.remove(&finished_job)
                     else {
                         unreachable!();
@@ -736,6 +740,7 @@ impl JobGraph {
                             }
                         }
                     }
+                    continue;
                 }
                 if let Some(WaitingJobState {
                     job_node_id,
@@ -791,12 +796,15 @@ impl JobGraph {
                                 .expect("failed to spawn thread for job"),
                         },
                     );
+                    continue;
                 }
                 if running_jobs.is_empty() {
                     assert!(item_name_to_waiting_jobs_map.is_empty());
                     assert!(ready_jobs.is_empty());
                     return Ok(());
                 }
+                // nothing to do yet, block to avoid busy waiting
+                next_finished_job = finished_jobs_receiver.recv().ok();
             }
         })
     }

crates/fayalite/src/bundle.rs

@@ -271,7 +271,6 @@ impl Type for Bundle {
 
 pub trait BundleType: Type<BaseType = Bundle> {
     type Builder: Default;
-    type FilledBuilder: ToExpr<Type = Self>;
     fn fields(&self) -> Interned<[BundleField]>;
 }
 
@@ -374,17 +373,8 @@ impl<'a> BundleSimValueToOpaque<'a> {
 #[derive(Default)]
 pub struct NoBuilder;
 
-pub struct Unfilled<T: Type>(PhantomData<T>);
-
-impl<T: Type> Default for Unfilled<T> {
-    fn default() -> Self {
-        Self(PhantomData)
-    }
-}
-
 impl BundleType for Bundle {
     type Builder = NoBuilder;
-    type FilledBuilder = Expr<Bundle>;
     fn fields(&self) -> Interned<[BundleField]> {
         self.0.fields
     }
@@ -420,15 +410,14 @@ macro_rules! impl_tuple_builder_fields {
     ) => {
         impl<
                 $($head_type_var,)*
-                $cur_type_var: Type,
                 $($tail_type_var,)*
             > TupleBuilder<(
                 $($head_type_var,)*
-                Unfilled<$cur_type_var>,
+                (),
                 $($tail_type_var,)*
             )>
         {
-            pub fn $cur_field(self, $cur_var: impl ToExpr<Type = $cur_type_var>) -> TupleBuilder<(
+            pub fn $cur_field<$cur_type_var: Type>(self, $cur_var: impl ToExpr<Type = $cur_type_var>) -> TupleBuilder<(
                     $($head_type_var,)*
                     Expr<$cur_type_var>,
                     $($tail_type_var,)*
@@ -452,6 +441,12 @@ macro_rules! impl_tuple_builder_fields {
     ($global:tt []) => {};
 }
 
+macro_rules! get_unit_ty {
+    ($($tt:tt)*) => {
+        ()
+    };
+}
+
 macro_rules! impl_tuples {
     (
         [$({
@@ -545,8 +540,7 @@ macro_rules! impl_tuples {
             }
         }
         impl<$($T: Type,)*> BundleType for ($($T,)*) {
-            type Builder = TupleBuilder<($(Unfilled<$T>,)*)>;
-            type FilledBuilder = TupleBuilder<($(Expr<$T>,)*)>;
+            type Builder = TupleBuilder<($(get_unit_ty!($T),)*)>;
             fn fields(&self) -> Interned<[BundleField]> {
                 let ($($var,)*) = self;
                 [$(BundleField { name: stringify!($num).intern(), flipped: false, ty: $var.canonical() }),*].intern_slice()
@@ -791,7 +785,6 @@ impl<T: ?Sized + Send + Sync + 'static> ToExpr for PhantomDataBuilder<T> {
 
 impl<T: ?Sized + Send + Sync + 'static> BundleType for PhantomData<T> {
     type Builder = PhantomDataBuilder<T>;
-    type FilledBuilder = PhantomDataBuilder<T>;
     fn fields(&self) -> Interned<[BundleField]> {
         Interned::default()
     }

crates/fayalite/src/int/uint_in_range.rs

@@ -96,7 +96,6 @@ impl Type for UIntInRangeMaskType {
 
 impl BundleType for UIntInRangeMaskType {
     type Builder = NoBuilder;
-    type FilledBuilder = Expr<UIntInRangeMaskType>;
 
     fn fields(&self) -> Interned<[BundleField]> {
         let [value_name, range_name] = UINT_IN_RANGE_TYPE_FIELD_NAMES;
@@ -300,9 +299,7 @@ macro_rules! define_uint_in_range_type {
                 }
             }
             pub fn new(start: Start::SizeType, end: End::SizeType) -> Self {
-                Self::from_phantom_const_range(PhantomConst::new(
-                    $SerdeRange { start, end }.intern_sized(),
-                ))
+                Self::from_phantom_const_range(PhantomConst::new_sized($SerdeRange { start, end }))
             }
             pub fn bit_width(self) -> usize {
                 self.value.width()
@@ -402,7 +399,6 @@ macro_rules! define_uint_in_range_type {
 
         impl<Start: Size, End: Size> BundleType for $UIntInRangeType<Start, End> {
             type Builder = NoBuilder;
-            type FilledBuilder = Expr<Self>;
 
             fn fields(&self) -> Interned<[BundleField]> {
                 let [value_name, range_name] = UINT_IN_RANGE_TYPE_FIELD_NAMES;

crates/fayalite/src/lib.rs

@@ -86,6 +86,135 @@ macro_rules! __cfg_expansion_helper {
 pub use fayalite_proc_macros::hdl_module;
 
 #[doc(inline)]
+/// The `#[hdl]` attribute is supported on several different kinds of [Rust Items](https://doc.rust-lang.org/reference/items.html):
+///
+/// # Functions and Methods
+/// Enable's the stuff that you can use inside a [module's body](crate::_docs::modules::module_bodies),
+/// but without being a module or changing the function's signature.
+/// The only exception is that you can't use stuff that requires the automatically-provided `m` variable.
+///
+/// # Structs
+// TODO: expand on struct docs
+/// e.g.:
+/// ```
+/// # use fayalite::prelude::*;
+/// # #[hdl]
+/// # pub struct OtherStruct {}
+/// #[hdl]
+/// pub struct MyStruct {
+///     #[hdl(flip)]
+///     pub a: UInt<5>,
+///     pub b: Bool,
+///     #[hdl(flip)]
+///     pub c: OtherStruct,
+/// }
+/// ```
+///
+/// # Enums
+// TODO: expand on enum docs
+/// e.g.:
+/// ```
+/// # use fayalite::prelude::*;
+/// # #[hdl]
+/// # pub struct MyStruct {}
+/// #[hdl]
+/// pub enum MyEnum {
+///     A(UInt<3>),
+///     B,
+///     C(MyStruct),
+/// }
+/// ```
+///
+/// # Type Aliases
+///
+/// There's three different ways you can create a type alias:
+///
+/// # Normal Type Alias
+///
+/// This works exactly how you'd expect:
+/// ```
+/// # use fayalite::prelude::*;
+/// # #[hdl]
+/// # pub struct MyStruct<T: Type> {
+/// #     v: T,
+/// # }
+/// #[hdl]
+/// pub type MyType<T: Type> = MyStruct<T>;
+///
+/// // you can then use Fayalite's standard syntax for creating dynamic types at runtime:
+///
+/// let ty = MyType[UInt[3]];
+/// assert_eq!(ty, MyStruct[UInt[3]]);
+/// ```
+///
+/// # Type Alias that gets a [`Type`] from a [`PhantomConst`]
+///
+/// This allows you to use some computed property of a [`PhantomConst`] to get a [`Type`] that you can use in other #[hdl] types.
+///
+/// ```
+/// # use fayalite::prelude::*;
+/// #[derive(Clone, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+/// pub struct Config {
+///     pub foo: usize,
+///     pub bar: Bundle,
+/// }
+///
+/// // the expression inside `get` is called with `Interned<Config>` and returns `Array<Bundle>`
+/// #[hdl(get(|config| Array[config.bar][config.foo]))]
+/// pub type GetMyArray<P: PhantomConstGet<Config>> = Array<Bundle>;
+///
+/// // you can then use it in other types:
+///
+/// #[hdl(no_static)]
+/// pub struct WrapMyArray<P: PhantomConstGet<Config>> {
+///     pub my_array: GetMyArray<P>,
+/// }
+///
+/// // you can then use Fayalite's standard syntax for creating dynamic types at runtime:
+/// let bar = Bundle::new(Default::default());
+/// let config = PhantomConst::new_sized(Config { foo: 12, bar });
+/// let ty = WrapMyArray[config];
+/// assert_eq!(ty.my_array, Array[bar][12]);
+/// ```
+///
+/// # Type Alias that gets a [`Size`] from a [`PhantomConst`]
+///
+/// This allows you to use some computed property of a [`PhantomConst`] to get a [`Size`] that you can use in other #[hdl] types.
+///
+/// ```
+/// # use fayalite::prelude::*;
+/// # #[derive(Clone, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+/// # pub struct ConfigItem {}
+/// # impl ConfigItem {
+/// #     pub fn new() -> Self {
+/// #         Self {}
+/// #     }
+/// # }
+/// #[derive(Clone, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+/// pub struct Config {
+///     pub items: Vec<ConfigItem>,
+/// }
+///
+/// // the expression inside `get` is called with `Interned<Config>` and returns `usize` (not DynSize)
+/// #[hdl(get(|config| config.items.len()))]
+/// pub type GetItemsLen<P: PhantomConstGet<Config>> = DynSize; // must be DynSize
+///
+/// // you can then use it in other types:
+///
+/// #[hdl(no_static)]
+/// pub struct FlagPerItem<P: PhantomConstGet<Config>> {
+///     pub flags: ArrayType<Bool, GetItemsLen<P>>,
+/// }
+///
+/// // you can then use Fayalite's standard syntax for creating dynamic types at runtime:
+/// let config = PhantomConst::new_sized(Config { items: vec![ConfigItem::new(); 5] });
+/// let ty = FlagPerItem[config];
+/// assert_eq!(ty.flags, Array[Bool][5]);
+/// ```
+///
+/// [`PhantomConst`]: crate::phantom_const::PhantomConst
+/// [`Size`]: crate::int::Size
+/// [`Type`]: crate::ty::Type
 pub use fayalite_proc_macros::hdl;
 
 pub use bitvec;

crates/fayalite/src/phantom_const.rs

@@ -131,7 +131,7 @@ impl<T: Type + PhantomConstValue> Index<T> for PhantomConstWithoutGenerics {
     type Output = PhantomConst<T>;
 
     fn index(&self, value: T) -> &Self::Output {
-        Interned::into_inner(PhantomConst::new(value.intern()).intern_sized())
+        Interned::into_inner(PhantomConst::new(&value).intern_sized())
     }
 }
 
@@ -222,11 +222,26 @@ impl<T: ?Sized + PhantomConstValue> Memoize for PhantomConstCanonicalMemoize<T,
 }
 
 impl<T: ?Sized + PhantomConstValue> PhantomConst<T> {
-    pub fn new(value: Interned<T>) -> Self {
+    pub fn new_interned(value: Interned<T>) -> Self {
         Self {
             value: LazyInterned::Interned(value),
         }
     }
+    pub fn new_sized(value: T) -> Self
+    where
+        T: Clone,
+    {
+        Self::new_interned(value.intern_sized())
+    }
+    pub fn new(value: &T) -> Self {
+        Self::new_interned(value.intern())
+    }
+    pub fn new_deref<U: Intern + std::ops::Deref<Target = T>>(value: U) -> Self
+    where
+        T: ToOwned<Owned = U>,
+    {
+        Self::new_interned(value.intern_deref())
+    }
     pub const fn new_lazy(v: &'static dyn LazyInternedTrait<T>) -> Self {
         Self {
             value: LazyInterned::new_lazy(v),
@@ -245,7 +260,7 @@ impl<T: ?Sized + PhantomConstValue> PhantomConst<T> {
         if let Some(&retval) = <dyn Any>::downcast_ref::<PhantomConst>(&self) {
             return retval;
         }
-        <PhantomConst>::new(
+        <PhantomConst>::new_interned(
             PhantomConstCanonicalMemoize::<T, false>(PhantomData).get_owned(self.get()),
         )
     }
@@ -253,7 +268,7 @@ impl<T: ?Sized + PhantomConstValue> PhantomConst<T> {
         if let Some(&retval) = <dyn Any>::downcast_ref::<Self>(&canonical_type) {
             return retval;
         }
-        Self::new(
+        Self::new_interned(
             PhantomConstCanonicalMemoize::<T, true>(PhantomData).get_owned(canonical_type.get()),
         )
     }
@@ -346,7 +361,9 @@ impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for PhantomConst<T> {
         D: Deserializer<'de>,
     {
         match SerdeType::<T>::deserialize(deserializer)? {
-            SerdeCanonicalType::PhantomConst(SerdePhantomConst(value)) => Ok(Self::new(value)),
+            SerdeCanonicalType::PhantomConst(SerdePhantomConst(value)) => {
+                Ok(Self::new_interned(value))
+            }
             ty => Err(Error::invalid_value(
                 serde::de::Unexpected::Other(ty.as_serde_unexpected_str()),
                 &"a PhantomConst",
@@ -415,3 +432,71 @@ impl<T: ?Sized + PhantomConstValue> ToSimValueWithType<CanonicalType> for Phanto
         SimValue::into_canonical(SimValue::from_value(Self::from_canonical(ty), *self))
     }
 }
+
+mod sealed {
+    pub trait Sealed<T: ?Sized> {}
+}
+
+pub trait PhantomConstGet<T: ?Sized + PhantomConstValue>: sealed::Sealed<T> {
+    fn get(&self) -> Interned<T>;
+}
+
+impl<T: ?Sized + PhantomConstValue, This: ?Sized + std::ops::Deref<Target: PhantomConstGet<T>>>
+    sealed::Sealed<T> for This
+{
+}
+
+impl<T: ?Sized + PhantomConstValue, This: ?Sized + std::ops::Deref<Target: PhantomConstGet<T>>>
+    PhantomConstGet<T> for This
+{
+    fn get(&self) -> Interned<T> {
+        This::Target::get(&**self)
+    }
+}
+
+macro_rules! impl_phantom_const_get {
+    (
+        impl PhantomConstGet<$T:ident> for $ty:ty {
+            fn $get:ident(&$get_self:ident) -> _ $get_body:block
+        }
+    ) => {
+        impl<$T: ?Sized + PhantomConstValue> sealed::Sealed<$T> for $ty {}
+
+        impl<$T: ?Sized + PhantomConstValue> PhantomConstGet<$T> for $ty {
+            fn $get(&$get_self) -> Interned<$T> $get_body
+        }
+    };
+}
+
+impl_phantom_const_get! {
+    impl PhantomConstGet<T> for PhantomConst<T> {
+        fn get(&self) -> _ {
+            PhantomConst::get(*self)
+        }
+    }
+}
+
+impl_phantom_const_get! {
+    impl PhantomConstGet<T> for Expr<PhantomConst<T>> {
+        fn get(&self) -> _ {
+            PhantomConst::get(Expr::ty(*self))
+        }
+    }
+}
+
+#[doc(hidden)]
+pub trait ReturnSelfUnchanged<T: ?Sized> {
+    type Type: ?Sized;
+}
+
+impl<This: ?Sized, T: ?Sized> ReturnSelfUnchanged<T> for This {
+    type Type = This;
+}
+
+#[doc(hidden)]
+pub fn type_alias_phantom_const_get_helper<T: ?Sized + PhantomConstValue, R: Intern + Clone>(
+    param: impl PhantomConstGet<T>,
+    get: impl FnOnce(Interned<T>) -> R,
+) -> &'static R {
+    Interned::into_inner(get(param.get()).intern_sized())
+}

crates/fayalite/src/platform/peripherals.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 
-use crate::{intern::Intern, prelude::*};
+use crate::prelude::*;
 use ordered_float::NotNan;
 use serde::{Deserialize, Serialize};
 
@@ -26,12 +26,9 @@ impl ClockInput {
         );
         Self {
             clk: Clock,
-            properties: PhantomConst::new(
-                ClockInputProperties {
-                    frequency: NotNan::new(frequency).expect("just checked"),
-                }
-                .intern_sized(),
-            ),
+            properties: PhantomConst::new_sized(ClockInputProperties {
+                frequency: NotNan::new(frequency).expect("just checked"),
+            }),
         }
     }
     pub fn frequency(self) -> f64 {

crates/fayalite/src/prelude.rs

@@ -27,7 +27,7 @@ pub use crate::{
         Instance, Module, ModuleBuilder, annotate, connect, connect_any, incomplete_wire, instance,
         memory, memory_array, memory_with_init, reg_builder, wire,
     },
-    phantom_const::PhantomConst,
+    phantom_const::{PhantomConst, PhantomConstGet},
     platform::{DynPlatform, Platform, PlatformIOBuilder, peripherals},
     reg::Reg,
     reset::{AsyncReset, Reset, SyncReset, ToAsyncReset, ToReset, ToSyncReset},

crates/fayalite/src/sim/compiler.rs

@@ -28,8 +28,8 @@ use crate::{
         ExternModuleSimulation, SimTrace, SimTraceKind, SimTraces, TraceArray, TraceAsyncReset,
         TraceBool, TraceBundle, TraceClock, TraceDecl, TraceEnumDiscriminant, TraceEnumWithFields,
         TraceFieldlessEnum, TraceInstance, TraceLocation, TraceMem, TraceMemPort, TraceMemoryId,
-        TraceMemoryLocation, TraceModule, TraceModuleIO, TraceReg, TraceSInt, TraceScalarId,
-        TraceScope, TraceSimOnly, TraceSyncReset, TraceUInt, TraceWire,
+        TraceMemoryLocation, TraceModule, TraceModuleIO, TracePhantomConst, TraceReg, TraceSInt,
+        TraceScalarId, TraceScope, TraceSimOnly, TraceSyncReset, TraceUInt, TraceWire,
         interpreter::{
             Insn, InsnField, InsnFieldKind, InsnFieldType, InsnOrLabel, Insns, InsnsBuilding,
             InsnsBuildingDone, InsnsBuildingKind, Label, SmallUInt, StatePartArrayIndex,
@@ -85,6 +85,7 @@ pub(crate) struct CompiledBundleField {
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
 pub(crate) enum CompiledTypeLayoutBody {
     Scalar,
+    PhantomConst,
     Array {
         /// debug names are ignored, use parent's layout instead
         element: Interned<CompiledTypeLayout<CanonicalType>>,
@@ -165,14 +166,11 @@ impl<T: Type> CompiledTypeLayout<T> {
                             body: CompiledTypeLayoutBody::Array { element },
                         }
                     }
-                    CanonicalType::PhantomConst(_) => {
-                        let unit_layout = CompiledTypeLayout::get(());
-                        CompiledTypeLayout {
-                            ty: *input,
-                            layout: unit_layout.layout,
-                            body: unit_layout.body,
-                        }
-                    }
+                    CanonicalType::PhantomConst(_) => CompiledTypeLayout {
+                        ty: *input,
+                        layout: TypeLayout::empty(),
+                        body: CompiledTypeLayoutBody::PhantomConst,
+                    },
                     CanonicalType::Bundle(bundle) => {
                         let mut layout = TypeLayout::empty();
                         let fields = bundle
@@ -1681,18 +1679,23 @@ macro_rules! impl_compiler {
                 instantiated_module: InstantiatedModule,
                 target: MakeTraceDeclTarget,
                 source_location: SourceLocation,
+                empty_kind: impl FnOnce() -> SimTraceKind,
                 $($type_singular_field: impl FnOnce(StatePartIndex<$type_kind>) -> SimTraceKind,)*
             ) -> TraceLocation {
                 match target {
                     MakeTraceDeclTarget::Expr(target) => {
                         let compiled_value = self.compile_expr(instantiated_module, target);
                         let compiled_value = self.compiled_expr_to_value(compiled_value, source_location);
-                        TraceLocation::Scalar(self.new_sim_trace(match compiled_value.range.len().as_single() {
-                            $(Some(TypeLenSingle::$type_singular_variant) => {
-                                $type_singular_field(compiled_value.range.$type_plural_field.start)
-                            })*
-                            None => unreachable!(),
-                        }))
+                        if compiled_value.range.is_empty() {
+                            TraceLocation::Scalar(self.new_sim_trace(empty_kind()))
+                        } else {
+                            TraceLocation::Scalar(self.new_sim_trace(match compiled_value.range.len().as_single() {
+                                $(Some(TypeLenSingle::$type_singular_variant) => {
+                                    $type_singular_field(compiled_value.range.$type_plural_field.start)
+                                })*
+                                None => unreachable!(),
+                            }))
+                        }
                     }
                     MakeTraceDeclTarget::Memory {
                         id,
@@ -1723,9 +1726,10 @@ macro_rules! impl_compiler {
                             instantiated_module,
                             target,
                             source_location,
+                            || unreachable!(),
                             |index| SimTraceKind::SmallUInt { index, ty },
                             |index| SimTraceKind::BigUInt { index, ty },
-                            |_| unreachable!(""),
+                            |_| unreachable!(),
                         ),
                         name,
                         ty,
@@ -1737,9 +1741,10 @@ macro_rules! impl_compiler {
                             instantiated_module,
                             target,
                             source_location,
+                            || unreachable!(),
                             |index| SimTraceKind::SmallSInt { index, ty },
                             |index| SimTraceKind::BigSInt { index, ty },
-                            |_| unreachable!(""),
+                            |_| unreachable!(),
                         ),
                         name,
                         ty,
@@ -1751,9 +1756,10 @@ macro_rules! impl_compiler {
                             instantiated_module,
                             target,
                             source_location,
+                            || unreachable!(),
                             |index| SimTraceKind::SmallBool { index },
                             |index| SimTraceKind::BigBool { index },
-                            |_| unreachable!(""),
+                            |_| unreachable!(),
                         ),
                         name,
                         flow,
@@ -1798,15 +1804,16 @@ macro_rules! impl_compiler {
                         }
                         .into()
                     }
-                    CanonicalType::Bundle(_) | CanonicalType::PhantomConst(_) => unreachable!(),
+                    CanonicalType::Bundle(_) => unreachable!(),
                     CanonicalType::AsyncReset(_) => TraceAsyncReset {
                         location: self.make_trace_scalar_helper(
                             instantiated_module,
                             target,
                             source_location,
+                            || unreachable!(),
                             |index| SimTraceKind::SmallAsyncReset { index },
                             |index| SimTraceKind::BigAsyncReset { index },
-                            |_| unreachable!(""),
+                            |_| unreachable!(),
                         ),
                         name,
                         flow,
@@ -1817,9 +1824,10 @@ macro_rules! impl_compiler {
                             instantiated_module,
                             target,
                             source_location,
+                            || unreachable!(),
                             |index| SimTraceKind::SmallSyncReset { index },
                             |index| SimTraceKind::BigSyncReset { index },
-                            |_| unreachable!(""),
+                            |_| unreachable!(),
                         ),
                         name,
                         flow,
@@ -1831,21 +1839,38 @@ macro_rules! impl_compiler {
                             instantiated_module,
                             target,
                             source_location,
+                            || unreachable!(),
                             |index| SimTraceKind::SmallClock { index },
                             |index| SimTraceKind::BigClock { index },
-                            |_| unreachable!(""),
+                            |_| unreachable!(),
                         ),
                         name,
                         flow,
                     }
                     .into(),
+                    CanonicalType::PhantomConst(ty) => TracePhantomConst {
+                        location: self.make_trace_scalar_helper(
+                            instantiated_module,
+                            target,
+                            source_location,
+                            || SimTraceKind::PhantomConst { ty },
+                            |_| unreachable!(),
+                            |_| unreachable!(),
+                            |_| unreachable!(),
+                        ),
+                        name,
+                        ty,
+                        flow,
+                    }
+                    .into(),
                     CanonicalType::DynSimOnly(ty) => TraceSimOnly {
                         location: self.make_trace_scalar_helper(
                             instantiated_module,
                             target,
                             source_location,
-                            |_| unreachable!(""),
-                            |_| unreachable!(""),
+                            || unreachable!(),
+                            |_| unreachable!(),
+                            |_| unreachable!(),
                             |index| SimTraceKind::SimOnly { index, ty },
                         ),
                         name,
@@ -2295,16 +2320,10 @@ impl Compiler {
             | CanonicalType::SyncReset(_)
             | CanonicalType::Reset(_)
             | CanonicalType::Clock(_)
-            | CanonicalType::DynSimOnly(_) => {
+            | CanonicalType::DynSimOnly(_)
+            | CanonicalType::PhantomConst(_) => {
                 self.make_trace_scalar(instantiated_module, target, name, source_location)
             }
-            CanonicalType::PhantomConst(_) => TraceBundle {
-                name,
-                fields: Interned::default(),
-                ty: Bundle::new(Interned::default()),
-                flow: target.flow(),
-            }
-            .into(),
         }
     }
     fn make_trace_decl(
@@ -4293,6 +4312,7 @@ impl Compiler {
                     start += element_bit_width;
                 }
             }
+            CompiledTypeLayoutBody::PhantomConst => {}
             CompiledTypeLayoutBody::Bundle { fields } => {
                 let CompiledTypeLayoutBody::Bundle {
                     fields: mask_fields,

crates/fayalite/src/sim/vcd.rs

@@ -6,12 +6,14 @@ use crate::{
     expr::Flow,
     int::UInt,
     intern::{Intern, Interned},
+    prelude::PhantomConst,
     sim::{
         TraceArray, TraceAsyncReset, TraceBool, TraceBundle, TraceClock, TraceDecl,
         TraceEnumDiscriminant, TraceEnumWithFields, TraceFieldlessEnum, TraceInstance,
         TraceLocation, TraceMem, TraceMemPort, TraceMemoryId, TraceMemoryLocation, TraceModule,
-        TraceModuleIO, TraceReg, TraceSInt, TraceScalar, TraceScalarId, TraceScope, TraceSimOnly,
-        TraceSyncReset, TraceUInt, TraceWire, TraceWriter, TraceWriterDecls,
+        TraceModuleIO, TracePhantomConst, TraceReg, TraceSInt, TraceScalar, TraceScalarId,
+        TraceScope, TraceSimOnly, TraceSyncReset, TraceUInt, TraceWire, TraceWriter,
+        TraceWriterDecls,
         time::{SimDuration, SimInstant},
         value::DynSimOnlyValue,
     },
@@ -283,6 +285,7 @@ impl WriteTrace for TraceScalar {
             Self::Clock(v) => v.write_trace(writer, arg),
             Self::SyncReset(v) => v.write_trace(writer, arg),
             Self::AsyncReset(v) => v.write_trace(writer, arg),
+            Self::PhantomConst(v) => v.write_trace(writer, arg),
             Self::SimOnly(v) => v.write_trace(writer, arg),
         }
     }
@@ -549,6 +552,33 @@ impl WriteTrace for TraceAsyncReset {
     }
 }
 
+impl WriteTrace for TracePhantomConst {
+    fn write_trace<W: io::Write, A: Arg>(self, writer: &mut W, mut arg: A) -> io::Result<()> {
+        let ArgInType {
+            source_var_type: _,
+            sink_var_type: _,
+            duplex_var_type: _,
+            properties,
+            scope,
+        } = arg.in_type();
+        let Self {
+            location,
+            name,
+            ty: _,
+            flow: _,
+        } = self;
+        write_vcd_var(
+            properties,
+            MemoryElementPartBody::Scalar,
+            writer,
+            "string",
+            1,
+            location,
+            scope.new_identifier(name),
+        )
+    }
+}
+
 impl WriteTrace for TraceSimOnly {
     fn write_trace<W: io::Write, A: Arg>(self, writer: &mut W, mut arg: A) -> io::Result<()> {
         let ArgInType {
@@ -1091,6 +1121,16 @@ impl<W: io::Write> TraceWriter for VcdWriter<W> {
         write_enum_discriminant_value_change(&mut self.writer, variant_index, ty, id.as_usize())
     }
 
+    fn set_signal_phantom_const(
+        &mut self,
+        id: TraceScalarId,
+        ty: PhantomConst,
+    ) -> Result<(), Self::Error> {
+        // avoid multi-line strings because GTKWave can't display them properly:
+        // https://github.com/gtkwave/gtkwave/issues/460
+        write_string_value_change(&mut self.writer, format_args!("{ty:?}"), id.as_usize())
+    }
+
     fn set_signal_sim_only_value(
         &mut self,
         id: TraceScalarId,

crates/fayalite/src/ty/serde_impls.rs

@@ -127,7 +127,7 @@ impl From<SerdeCanonicalType> for CanonicalType {
             SerdeCanonicalType::Reset => Self::Reset(Reset),
             SerdeCanonicalType::Clock => Self::Clock(Clock),
             SerdeCanonicalType::PhantomConst(value) => {
-                Self::PhantomConst(PhantomConst::new(value.0))
+                Self::PhantomConst(PhantomConst::new_interned(value.0))
             }
             SerdeCanonicalType::DynSimOnly(value) => Self::DynSimOnly(value),
         }

crates/fayalite/tests/hdl_types.rs

@@ -4,7 +4,6 @@ use fayalite::{
     bundle::BundleType,
     enum_::EnumType,
     int::{BoolOrIntType, IntType},
-    phantom_const::PhantomConst,
     prelude::*,
     ty::StaticType,
 };
@@ -197,3 +196,51 @@ check_bounds!(CheckBoundsTTT2<#[a, Type] A: BundleType +, #[b, Type] B: Type +,
 check_bounds!(CheckBoundsTTT3<#[a, Type] A: EnumType +, #[b, Type] B: Type +, #[c, Type] C: Type +>);
 check_bounds!(CheckBoundsTTT4<#[a, Type] A: IntType +, #[b, Type] B: Type +, #[c, Type] C: Type +>);
 check_bounds!(CheckBoundsTTT5<#[a, Type] A: StaticType +, #[b, Type] B: Type +, #[c, Type] C: Type +>);
+
+#[derive(Clone, PartialEq, Eq, Hash, Debug, serde::Serialize, serde::Deserialize)]
+pub struct MyPhantomConstInner {
+    pub a: usize,
+    pub b: UInt,
+}
+
+#[hdl(outline_generated, get(|v| v.a))]
+pub type GetA<P: PhantomConstGet<MyPhantomConstInner>> = DynSize;
+
+#[hdl(outline_generated, get(|v| v.b))]
+pub type GetB<P: PhantomConstGet<MyPhantomConstInner>> = UInt;
+
+#[hdl(outline_generated, no_static)]
+pub struct MyTypeWithPhantomConstParameter<P: PhantomConstGet<MyPhantomConstInner>> {
+    pub a: ArrayType<Bool, GetA<P>>,
+    pub b: HdlOption<GetB<P>>,
+}
+
+#[hdl(outline_generated)]
+struct MyPrivateType {}
+
+#[hdl(outline_generated)]
+pub(crate) struct MyPubCrateType {}
+
+#[hdl(outline_generated)]
+pub struct MyTypeWithPrivateMembers {
+    a: MyPrivateType,
+    pub(crate) b: MyPubCrateType,
+    pub c: Bool,
+}
+
+#[hdl(outline_generated)]
+struct MyPrivateTypeWithArg<T> {
+    v: T,
+}
+
+#[hdl(outline_generated)]
+pub(crate) struct MyPubCrateTypeWithArg<T> {
+    v: T,
+}
+
+#[hdl(outline_generated)]
+pub struct MyTypeWithPrivateMembersWithArg<T> {
+    a: MyPrivateTypeWithArg<T>,
+    pub(crate) b: MyPubCrateTypeWithArg<T>,
+    pub c: T,
+}

crates/fayalite/tests/sim.rs

@@ -2026,3 +2026,352 @@ fn test_sim_only_connects() {
         panic!();
     }
 }
+
+#[hdl_module(outline_generated, extern)]
+pub fn sim_fork_join<const N: usize>()
+where
+    ConstUsize<N>: KnownSize,
+{
+    #[hdl]
+    let clocks: Array<Clock, N> = m.input();
+    #[hdl]
+    let outputs: Array<UInt<8>, N> = m.output();
+    m.extern_module_simulation_fn((clocks, outputs), |(clocks, outputs), mut sim| async move {
+        sim.write(outputs, [0u8; N]).await;
+        loop {
+            sim.fork_join(
+                clocks
+                    .into_iter()
+                    .zip(outputs)
+                    .map(|(clock, output)| {
+                        move |mut sim: ExternModuleSimulationState| async move {
+                            sim.wait_for_clock_edge(clock).await;
+                            let v = sim
+                                .read_bool_or_int(output)
+                                .await
+                                .to_bigint()
+                                .try_into()
+                                .expect("known to be in range");
+                            sim.write(output, 1u8.wrapping_add(v)).await;
+                        }
+                    })
+                    .collect::<Vec<_>>(),
+            )
+            .await;
+        }
+    });
+}
+
+#[test]
+fn test_sim_fork_join() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    const N: usize = 3;
+    let mut sim = Simulation::new(sim_fork_join::<N>());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    sim.write(sim.io().clocks, [false; N]);
+    let mut clocks_triggered = [false; N];
+    let mut expected = [0u8; N];
+    for i0 in 0..N {
+        for i1 in 0..N {
+            for i2 in 0..N {
+                for i3 in 0..N {
+                    let indexes = [i0, i1, i2, i3];
+                    for i in indexes {
+                        sim.advance_time(SimDuration::from_micros(1));
+                        sim.write(sim.io().clocks[i], true);
+                        sim.advance_time(SimDuration::from_micros(1));
+                        sim.write(sim.io().clocks[i], false);
+                        if !clocks_triggered[i] {
+                            expected[i] = expected[i].wrapping_add(1);
+                        }
+                        clocks_triggered[i] = true;
+                        if clocks_triggered == [true; N] {
+                            clocks_triggered = [false; N];
+                        }
+                        let output = sim.read(sim.io().outputs);
+                        assert_eq!(output, expected.to_sim_value(), "indexes={indexes:?} i={i}");
+                    }
+                }
+            }
+        }
+    }
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    if vcd != include_str!("sim/expected/sim_fork_join.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/sim_fork_join.txt") {
+        panic!();
+    }
+}
+
+#[hdl_module(outline_generated, extern)]
+pub fn sim_fork_join_scope<const N: usize>()
+where
+    ConstUsize<N>: KnownSize,
+{
+    #[hdl]
+    let clocks: Array<Clock, N> = m.input();
+    #[hdl]
+    let outputs: Array<UInt<8>, N> = m.output();
+    m.extern_module_simulation_fn((clocks, outputs), |(clocks, outputs), mut sim| async move {
+        sim.write(outputs, [0u8; N]).await;
+        loop {
+            let written = vec![std::cell::Cell::new(false); N]; // test shared scope
+            let written = &written; // work around move in async move
+            sim.fork_join_scope(|scope, _| async move {
+                let mut spawned = vec![];
+                for i in 0..N {
+                    let join_handle =
+                        scope.spawn(move |_, mut sim: ExternModuleSimulationState| async move {
+                            sim.wait_for_clock_edge(clocks[i]).await;
+                            let v = sim
+                                .read_bool_or_int(outputs[i])
+                                .await
+                                .to_bigint()
+                                .try_into()
+                                .expect("known to be in range");
+                            sim.write(outputs[i], 1u8.wrapping_add(v)).await;
+                            written[i].set(true);
+                            i
+                        });
+                    if i % 2 == 0 && i < N - 1 {
+                        spawned.push((i, join_handle));
+                    }
+                }
+                for (i, join_handle) in spawned {
+                    assert_eq!(i, join_handle.join().await);
+                }
+            })
+            .await;
+            for written in written {
+                assert!(written.get());
+            }
+        }
+    });
+}
+
+#[test]
+fn test_sim_fork_join_scope() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    const N: usize = 3;
+    let mut sim = Simulation::new(sim_fork_join_scope::<N>());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    sim.write(sim.io().clocks, [false; N]);
+    let mut clocks_triggered = [false; N];
+    let mut expected = [0u8; N];
+    for i0 in 0..N {
+        for i1 in 0..N {
+            for i2 in 0..N {
+                for i3 in 0..N {
+                    let indexes = [i0, i1, i2, i3];
+                    for i in indexes {
+                        sim.advance_time(SimDuration::from_micros(1));
+                        sim.write(sim.io().clocks[i], true);
+                        sim.advance_time(SimDuration::from_micros(1));
+                        sim.write(sim.io().clocks[i], false);
+                        if !clocks_triggered[i] {
+                            expected[i] = expected[i].wrapping_add(1);
+                        }
+                        clocks_triggered[i] = true;
+                        if clocks_triggered == [true; N] {
+                            clocks_triggered = [false; N];
+                        }
+                        let output = sim.read(sim.io().outputs);
+                        assert_eq!(output, expected.to_sim_value(), "indexes={indexes:?} i={i}");
+                    }
+                }
+            }
+        }
+    }
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    if vcd != include_str!("sim/expected/sim_fork_join_scope.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/sim_fork_join_scope.txt") {
+        panic!();
+    }
+}
+
+#[hdl_module(outline_generated, extern)]
+pub fn sim_resettable_counter<R: ResetType>() {
+    #[hdl]
+    let cd: ClockDomain<R> = m.input();
+    #[hdl]
+    let out: UInt<8> = m.output();
+    m.extern_module_simulation_fn((cd, out), |(cd, out), mut sim| async move {
+        sim.resettable(
+            cd,
+            |mut sim: ExternModuleSimulationState| async move {
+                sim.write(out, 0u8).await;
+            },
+            |mut sim: ExternModuleSimulationState, ()| async move {
+                loop {
+                    sim.wait_for_clock_edge(cd.clk).await;
+                    let v: u8 = sim
+                        .read(out)
+                        .await
+                        .to_bigint()
+                        .try_into()
+                        .expect("known to be in range");
+                    sim.write(out, v.wrapping_add(1)).await;
+                }
+            },
+        )
+        .await
+    });
+}
+
+fn test_sim_resettable_counter_helper<R: ResetType>(
+    sim: &mut Simulation<sim_resettable_counter<R>>,
+    immediate_reset: bool,
+) {
+    sim.write_clock(sim.io().cd.clk, false);
+    sim.write_reset(sim.io().cd.rst, immediate_reset);
+    for _ in 0..2 {
+        sim.advance_time(SimDuration::from_micros(1));
+        sim.write_clock(sim.io().cd.clk, true);
+        sim.advance_time(SimDuration::from_micros(1));
+        sim.write_clock(sim.io().cd.clk, false);
+        sim.write_reset(sim.io().cd.rst, true);
+        sim.advance_time(SimDuration::from_micros(1));
+        sim.write_clock(sim.io().cd.clk, true);
+        sim.advance_time(SimDuration::from_micros(1));
+        sim.write_clock(sim.io().cd.clk, false);
+        sim.write_reset(sim.io().cd.rst, false);
+        for expected in 0..3u8 {
+            assert_eq!(sim.read(sim.io().out), expected.to_sim_value());
+            sim.advance_time(SimDuration::from_micros(1));
+            sim.write_clock(sim.io().cd.clk, true);
+            sim.advance_time(SimDuration::from_micros(1));
+            sim.write_clock(sim.io().cd.clk, false);
+        }
+    }
+}
+
+#[test]
+fn test_sim_resettable_counter_sync() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    let mut sim = Simulation::new(sim_resettable_counter::<SyncReset>());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    test_sim_resettable_counter_helper(&mut sim, false);
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    if vcd != include_str!("sim/expected/sim_resettable_counter_sync.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/sim_resettable_counter_sync.txt") {
+        panic!();
+    }
+}
+
+#[test]
+fn test_sim_resettable_counter_sync_immediate_reset() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    let mut sim = Simulation::new(sim_resettable_counter::<SyncReset>());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    test_sim_resettable_counter_helper(&mut sim, true);
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    if vcd != include_str!("sim/expected/sim_resettable_counter_sync_immediate_reset.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/sim_resettable_counter_sync_immediate_reset.txt") {
+        panic!();
+    }
+}
+
+#[test]
+fn test_sim_resettable_counter_async() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    let mut sim = Simulation::new(sim_resettable_counter::<AsyncReset>());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    test_sim_resettable_counter_helper(&mut sim, false);
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    if vcd != include_str!("sim/expected/sim_resettable_counter_async.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/sim_resettable_counter_async.txt") {
+        panic!();
+    }
+}
+
+#[test]
+fn test_sim_resettable_counter_async_immediate_reset() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    let mut sim = Simulation::new(sim_resettable_counter::<AsyncReset>());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    test_sim_resettable_counter_helper(&mut sim, true);
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    if vcd != include_str!("sim/expected/sim_resettable_counter_async_immediate_reset.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/sim_resettable_counter_async_immediate_reset.txt") {
+        panic!();
+    }
+}
+
+#[hdl_module(outline_generated)]
+pub fn phantom_const() {
+    #[hdl]
+    let out: Array<PhantomConst<Vec<String>>, 2> =
+        m.output(Array::new_static(PhantomConst::new_sized(vec![
+            "a".into(),
+            "b".into(),
+        ])));
+    let _ = out;
+    #[hdl]
+    let mut mem = memory(PhantomConst::new("mem_element"));
+    mem.depth(1);
+    let port = mem.new_read_port();
+    connect_any(port.addr, 0u8);
+    connect(port.clk, false.to_clock());
+    connect(port.en, false);
+}
+
+#[test]
+fn test_phantom_const() {
+    let _n = SourceLocation::normalize_files_for_tests();
+    let mut sim = Simulation::new(phantom_const());
+    let mut writer = RcWriter::default();
+    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
+    sim.advance_time(SimDuration::from_micros(1));
+    sim.flush_traces().unwrap();
+    let vcd = String::from_utf8(writer.take()).unwrap();
+    println!("####### VCD:\n{vcd}\n#######");
+    if vcd != include_str!("sim/expected/phantom_const.vcd") {
+        panic!();
+    }
+    let sim_debug = format!("{sim:#?}");
+    println!("#######\n{sim_debug}\n#######");
+    if sim_debug != include_str!("sim/expected/phantom_const.txt") {
+        panic!();
+    }
+}

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

@@ -828,7 +828,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "array_rw",
         children: [
@@ -1699,7 +1698,12 @@ Simulation {
             },
         ),
     ],
-    instant: 34 μs,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 34 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -124,7 +124,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "conditional_assignment_last",
         children: [
@@ -177,7 +176,12 @@ Simulation {
             },
         ),
     ],
-    instant: 2 μs,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 2 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -100,7 +100,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "connect_const",
         children: [
@@ -130,7 +129,12 @@ Simulation {
     ],
     trace_memories: {},
     trace_writers: [],
-    instant: 0 s,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 0 s,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -143,7 +143,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "connect_const_reset",
         children: [
@@ -197,7 +196,12 @@ Simulation {
             },
         ),
     ],
-    instant: 1 μs,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 1 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -263,7 +263,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "counter",
         children: [
@@ -329,7 +328,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
             },
             state: 0x1,
-            last_state: 0x1,
+            last_state: 0x0,
         },
         SimTrace {
             id: TraceScalarId(1),
@@ -355,7 +354,7 @@ Simulation {
                 ty: UInt<4>,
             },
             state: 0x3,
-            last_state: 0x3,
+            last_state: 0x2,
         },
     ],
     trace_memories: {},
@@ -368,9 +367,14 @@ Simulation {
             },
         ),
     ],
-    instant: 66 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 66 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -26,192 +26,192 @@ b11 $
 0!
 #3000000
 1!
-b100 $
 b100 #
+b100 $
 #4000000
 0!
 #5000000
 1!
-b101 $
 b101 #
+b101 $
 #6000000
 0!
 #7000000
 1!
-b110 $
 b110 #
+b110 $
 #8000000
 0!
 #9000000
 1!
-b111 $
 b111 #
+b111 $
 #10000000
 0!
 #11000000
 1!
-b1000 $
 b1000 #
+b1000 $
 #12000000
 0!
 #13000000
 1!
-b1001 $
 b1001 #
+b1001 $
 #14000000
 0!
 #15000000
 1!
-b1010 $
 b1010 #
+b1010 $
 #16000000
 0!
 #17000000
 1!
-b1011 $
 b1011 #
+b1011 $
 #18000000
 0!
 #19000000
 1!
-b1100 $
 b1100 #
+b1100 $
 #20000000
 0!
 #21000000
 1!
-b1101 $
 b1101 #
+b1101 $
 #22000000
 0!
 #23000000
 1!
-b1110 $
 b1110 #
+b1110 $
 #24000000
 0!
 #25000000
 1!
-b1111 $
 b1111 #
+b1111 $
 #26000000
 0!
 #27000000
 1!
-b0 $
 b0 #
+b0 $
 #28000000
 0!
 #29000000
 1!
-b1 $
 b1 #
+b1 $
 #30000000
 0!
 #31000000
 1!
-b10 $
 b10 #
+b10 $
 #32000000
 0!
 #33000000
 1!
-b11 $
 b11 #
+b11 $
 #34000000
 0!
 #35000000
 1!
-b100 $
 b100 #
+b100 $
 #36000000
 0!
 #37000000
 1!
-b101 $
 b101 #
+b101 $
 #38000000
 0!
 #39000000
 1!
-b110 $
 b110 #
+b110 $
 #40000000
 0!
 #41000000
 1!
-b111 $
 b111 #
+b111 $
 #42000000
 0!
 #43000000
 1!
-b1000 $
 b1000 #
+b1000 $
 #44000000
 0!
 #45000000
 1!
-b1001 $
 b1001 #
+b1001 $
 #46000000
 0!
 #47000000
 1!
-b1010 $
 b1010 #
+b1010 $
 #48000000
 0!
 #49000000
 1!
-b1011 $
 b1011 #
+b1011 $
 #50000000
 0!
 #51000000
 1!
-b1100 $
 b1100 #
+b1100 $
 #52000000
 0!
 #53000000
 1!
-b1101 $
 b1101 #
+b1101 $
 #54000000
 0!
 #55000000
 1!
-b1110 $
 b1110 #
+b1110 $
 #56000000
 0!
 #57000000
 1!
-b1111 $
 b1111 #
+b1111 $
 #58000000
 0!
 #59000000
 1!
-b0 $
 b0 #
+b0 $
 #60000000
 0!
 #61000000
 1!
-b1 $
 b1 #
+b1 $
 #62000000
 0!
 #63000000
 1!
-b10 $
 b10 #
+b10 $
 #64000000
 0!
 #65000000
 1!
-b11 $
 b11 #
+b11 $
 #66000000

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

@@ -244,7 +244,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "counter",
         children: [
@@ -310,7 +309,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
             },
             state: 0x1,
-            last_state: 0x1,
+            last_state: 0x0,
         },
         SimTrace {
             id: TraceScalarId(1),
@@ -336,7 +335,7 @@ Simulation {
                 ty: UInt<4>,
             },
             state: 0x3,
-            last_state: 0x3,
+            last_state: 0x2,
         },
     ],
     trace_memories: {},
@@ -349,9 +348,14 @@ Simulation {
             },
         ),
     ],
-    instant: 66 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 66 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -16,199 +16,199 @@ b0 $
 $end
 #1000000
 1!
-b11 $
 b11 #
+b11 $
 0"
 #2000000
 0!
 #3000000
 1!
-b100 $
 b100 #
+b100 $
 #4000000
 0!
 #5000000
 1!
-b101 $
 b101 #
+b101 $
 #6000000
 0!
 #7000000
 1!
-b110 $
 b110 #
+b110 $
 #8000000
 0!
 #9000000
 1!
-b111 $
 b111 #
+b111 $
 #10000000
 0!
 #11000000
 1!
-b1000 $
 b1000 #
+b1000 $
 #12000000
 0!
 #13000000
 1!
-b1001 $
 b1001 #
+b1001 $
 #14000000
 0!
 #15000000
 1!
-b1010 $
 b1010 #
+b1010 $
 #16000000
 0!
 #17000000
 1!
-b1011 $
 b1011 #
+b1011 $
 #18000000
 0!
 #19000000
 1!
-b1100 $
 b1100 #
+b1100 $
 #20000000
 0!
 #21000000
 1!
-b1101 $
 b1101 #
+b1101 $
 #22000000
 0!
 #23000000
 1!
-b1110 $
 b1110 #
+b1110 $
 #24000000
 0!
 #25000000
 1!
-b1111 $
 b1111 #
+b1111 $
 #26000000
 0!
 #27000000
 1!
-b0 $
 b0 #
+b0 $
 #28000000
 0!
 #29000000
 1!
-b1 $
 b1 #
+b1 $
 #30000000
 0!
 #31000000
 1!
-b10 $
 b10 #
+b10 $
 #32000000
 0!
 #33000000
 1!
-b11 $
 b11 #
+b11 $
 #34000000
 0!
 #35000000
 1!
-b100 $
 b100 #
+b100 $
 #36000000
 0!
 #37000000
 1!
-b101 $
 b101 #
+b101 $
 #38000000
 0!
 #39000000
 1!
-b110 $
 b110 #
+b110 $
 #40000000
 0!
 #41000000
 1!
-b111 $
 b111 #
+b111 $
 #42000000
 0!
 #43000000
 1!
-b1000 $
 b1000 #
+b1000 $
 #44000000
 0!
 #45000000
 1!
-b1001 $
 b1001 #
+b1001 $
 #46000000
 0!
 #47000000
 1!
-b1010 $
 b1010 #
+b1010 $
 #48000000
 0!
 #49000000
 1!
-b1011 $
 b1011 #
+b1011 $
 #50000000
 0!
 #51000000
 1!
-b1100 $
 b1100 #
+b1100 $
 #52000000
 0!
 #53000000
 1!
-b1101 $
 b1101 #
+b1101 $
 #54000000
 0!
 #55000000
 1!
-b1110 $
 b1110 #
+b1110 $
 #56000000
 0!
 #57000000
 1!
-b1111 $
 b1111 #
+b1111 $
 #58000000
 0!
 #59000000
 1!
-b0 $
 b0 #
+b0 $
 #60000000
 0!
 #61000000
 1!
-b1 $
 b1 #
+b1 $
 #62000000
 0!
 #63000000
 1!
-b10 $
 b10 #
+b10 $
 #64000000
 0!
 #65000000
 1!
-b11 $
 b11 #
+b11 $
 #66000000

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

@@ -104,7 +104,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "duplicate_names",
         children: [
@@ -160,7 +159,12 @@ Simulation {
             },
         ),
     ],
-    instant: 1 μs,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 1 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -1456,7 +1456,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "enums",
         children: [
@@ -1744,7 +1743,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
             },
             state: 0x1,
-            last_state: 0x1,
+            last_state: 0x0,
         },
         SimTrace {
             id: TraceScalarId(1),
@@ -1924,9 +1923,14 @@ Simulation {
             },
         ),
     ],
-    instant: 16 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(3),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 16 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -186,14 +186,8 @@ Simulation {
             running_generator: Some(
                 ...,
             ),
-            wait_targets: {
-                Instant(
-                    20.500000000000 μs,
-                ),
-            },
         },
     ],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "extern_module",
         children: [
@@ -247,7 +241,14 @@ Simulation {
             },
         ),
     ],
-    instant: 20 μs,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 20 μs,
+        events: {
+            Event { instant: 20.500000000000 μs, kind: ExternModule(0) }: 1,
+        },
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -6,8 +6,9 @@ $upscope $end
 $enddefinitions $end
 $dumpvars
 0!
-1"
+0"
 $end
+1"
 #500000
 #1500000
 0"

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

@@ -234,55 +234,8 @@ Simulation {
             running_generator: Some(
                 ...,
             ),
-            wait_targets: {
-                Change {
-                    key: CompiledValue {
-                        layout: CompiledTypeLayout {
-                            ty: Clock,
-                            layout: TypeLayout {
-                                small_slots: StatePartLayout<SmallSlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    ..
-                                },
-                                big_slots: StatePartLayout<BigSlots> {
-                                    len: 1,
-                                    debug_data: [
-                                        SlotDebugData {
-                                            name: "InstantiatedModule(extern_module2: extern_module2).extern_module2::clk",
-                                            ty: Clock,
-                                        },
-                                    ],
-                                    ..
-                                },
-                                sim_only_slots: StatePartLayout<SimOnlySlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    layout_data: [],
-                                    ..
-                                },
-                            },
-                            body: Scalar,
-                        },
-                        range: TypeIndexRange {
-                            small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
-                            big_slots: StatePartIndexRange<BigSlots> { start: 1, len: 1 },
-                            sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
-                        },
-                        write: None,
-                    },
-                    value: SimValue {
-                        ty: Clock,
-                        value: OpaqueSimValue {
-                            bits: 0x1_u1,
-                            sim_only_values: [],
-                        },
-                    },
-                },
-            },
         },
     ],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "extern_module2",
         children: [
@@ -356,7 +309,113 @@ Simulation {
             },
         ),
     ],
-    instant: 60 μs,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 60 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 59,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "InstantiatedModule(extern_module2: extern_module2).extern_module2::clk",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 1, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x1_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(extern_module2: extern_module2).extern_module2::clk",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 1, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x1_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 59,
+                    ..
+                },
+            },
+        ),
+    },
     ..
 }

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

@@ -8,8 +8,9 @@ $enddefinitions $end
 $dumpvars
 1!
 0"
-b1001000 #
+b0 #
 $end
+b1001000 #
 #1000000
 1"
 b1100101 #

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

@@ -3836,7 +3836,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "many_memories",
         children: [
@@ -7759,7 +7758,6 @@ Simulation {
             },
         ),
     ],
-    instant: 38 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
         StatePartIndex<SmallSlots>(6),
@@ -7778,5 +7776,11 @@ Simulation {
         StatePartIndex<SmallSlots>(85),
         StatePartIndex<SmallSlots>(90),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 38 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -1052,12 +1052,16 @@ $end
 1U#
 1e#
 1#
+1$
 1'
 1+
+1,
 1/
 13
+14
 17
 1;
+1<
 1?
 1C
 1H
@@ -1068,29 +1072,25 @@ $end
 1a
 1f
 1k
+1l
 1o
 1t
 1x
 1}
+1~
 1#"
 1("
 1,"
 11"
+12"
 15"
 1:"
 1>"
 1C"
+1D"
 1G"
 1L"
 1P"
-1$
-1,
-14
-1<
-1l
-1~
-12"
-1D"
 #4000000
 0#
 0'
@@ -1150,13 +1150,21 @@ $end
 0U#
 0e#
 1#
+0$
 1'
+0(
 1+
+0,
 1/
+00
 13
+04
 17
+08
 1;
+0<
 1?
+0@
 1C
 1H
 1M
@@ -1166,37 +1174,29 @@ $end
 1a
 1f
 1k
+0l
 1o
 1t
+0u
 1x
 1}
+0~
 1#"
 1("
+0)"
 1,"
 11"
+02"
 15"
 1:"
+0;"
 1>"
 1C"
+0D"
 1G"
 1L"
-1P"
-0$
-0(
-0,
-00
-04
-08
-0<
-0@
-0l
-0u
-0~
-0)"
-02"
-0;"
-0D"
 0M"
+1P"
 #6000000
 0#
 0'

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

@@ -721,7 +721,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "memories",
         children: [
@@ -1616,10 +1615,15 @@ Simulation {
             },
         ),
     ],
-    instant: 22 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
         StatePartIndex<SmallSlots>(6),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 22 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -234,13 +234,13 @@ b100000 6
 b10000 9
 b100000 I
 1#
-1(
-1/
-14
 b10000 $
 b100000 %
+1(
+1/
 b10000 0
 b100000 1
+14
 #4000000
 0#
 0(
@@ -256,11 +256,11 @@ b1000000 6
 b10000 9
 b1000000 I
 1#
+b1000000 %
 1(
 1/
-14
-b1000000 %
 b1000000 1
+14
 #6000000
 0#
 0(
@@ -278,11 +278,11 @@ b1100000 6
 b1010000 9
 b1000000 I
 1#
+b1010000 $
 1(
 1/
-14
-b1010000 $
 b1010000 0
+14
 #8000000
 0#
 0(

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

@@ -679,7 +679,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "memories2",
         children: [
@@ -1260,9 +1259,14 @@ Simulation {
             },
         ),
     ],
-    instant: 22 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(3),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 22 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -100,8 +100,8 @@ $end
 1)
 #1250000
 1#
-1*
 b11 $
+1*
 sHdlSome\x20(1) +
 1,
 #1500000
@@ -113,8 +113,8 @@ sHdlSome\x20(1) +
 0)
 #2250000
 1#
-1*
 b0 $
+1*
 sHdlNone\x20(0) +
 0,
 #2500000
@@ -303,8 +303,8 @@ b11 !
 b11 (
 #17250000
 1#
-1*
 b11 $
+1*
 sHdlSome\x20(1) +
 1,
 #17500000
@@ -316,8 +316,8 @@ b10 !
 b10 (
 #18250000
 1#
-1*
 b0 $
+1*
 sHdlNone\x20(0) +
 0,
 #18500000
@@ -339,8 +339,8 @@ b1 !
 b1 (
 #20250000
 1#
-1*
 b1 $
+1*
 sHdlSome\x20(1) +
 #20500000
 #20750000
@@ -353,8 +353,8 @@ b0 (
 0)
 #21250000
 1#
-1*
 b0 $
+1*
 sHdlNone\x20(0) +
 #21500000
 #21750000

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

@@ -1763,7 +1763,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "memories3",
         children: [
@@ -3275,10 +3274,15 @@ Simulation {
             },
         ),
     ],
-    instant: 15 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
         StatePartIndex<SmallSlots>(6),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 15 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -420,6 +420,10 @@ b10000 T
 1\
 #3250000
 1#
+b110100 %
+b1111000 '
+b10011010 (
+b11110000 +
 1.
 1A
 b110100 C
@@ -427,10 +431,6 @@ b1111000 E
 b10011010 F
 b11110000 I
 1L
-b110100 %
-b1111000 '
-b10011010 (
-b11110000 +
 #3500000
 #3750000
 0#
@@ -508,6 +508,14 @@ b1010100 '"
 b110010 /"
 b10000 7"
 1#
+b11111110 $
+b11011100 %
+b10111010 &
+b10011000 '
+b1110110 (
+b1010100 )
+b110010 *
+b10000 +
 1.
 1A
 b11111110 B
@@ -519,14 +527,6 @@ b1010100 G
 b110010 H
 b10000 I
 1L
-b11111110 $
-b11011100 %
-b10111010 &
-b10011000 '
-b1110110 (
-b1010100 )
-b110010 *
-b10000 +
 #6500000
 #6750000
 0#
@@ -562,6 +562,14 @@ b1000110 ("
 b10001010 0"
 b11001110 8"
 1#
+b0 $
+b0 %
+b0 &
+b0 '
+b0 (
+b0 )
+b0 *
+b0 +
 1.
 1A
 b0 B
@@ -573,14 +581,6 @@ b0 G
 b0 H
 b0 I
 1L
-b0 $
-b0 %
-b0 &
-b0 '
-b0 (
-b0 )
-b0 *
-b0 +
 #7500000
 #7750000
 0#
@@ -688,6 +688,14 @@ b1 !
 b1 ?
 #10250000
 1#
+b11111110 $
+b11011100 %
+b10111010 &
+b10011000 '
+b1110110 (
+b1010100 )
+b110010 *
+b10000 +
 1.
 1A
 b11111110 B
@@ -699,14 +707,6 @@ b1010100 G
 b110010 H
 b10000 I
 1L
-b11111110 $
-b11011100 %
-b10111010 &
-b10011000 '
-b1110110 (
-b1010100 )
-b110010 *
-b10000 +
 #10500000
 #10750000
 0#
@@ -718,6 +718,14 @@ b10 !
 b10 ?
 #11250000
 1#
+b10011 $
+b1010111 %
+b10011011 &
+b11011111 '
+b10 (
+b1000110 )
+b10001010 *
+b11001110 +
 1.
 1A
 b10011 B
@@ -729,14 +737,6 @@ b1000110 G
 b10001010 H
 b11001110 I
 1L
-b10011 $
-b1010111 %
-b10011011 &
-b11011111 '
-b10 (
-b1000110 )
-b10001010 *
-b11001110 +
 #11500000
 #11750000
 0#
@@ -748,6 +748,14 @@ b11 !
 b11 ?
 #12250000
 1#
+b1110100 $
+b1100101 %
+b1110011 &
+b1110100 '
+b1101001 (
+b1101110 )
+b1100111 *
+b100001 +
 1.
 1A
 b1110100 B
@@ -759,14 +767,6 @@ b1101110 G
 b1100111 H
 b100001 I
 1L
-b1110100 $
-b1100101 %
-b1110011 &
-b1110100 '
-b1101001 (
-b1101110 )
-b1100111 *
-b100001 +
 #12500000
 #12750000
 0#
@@ -780,6 +780,14 @@ b0 ?
 0@
 #13250000
 1#
+b1101101 $
+b1101111 %
+b1110010 &
+b1100101 '
+b100000 (
+b1110100 )
+b1110011 *
+b1110100 +
 1.
 1A
 b1101101 B
@@ -791,14 +799,6 @@ b1110100 G
 b1110011 H
 b1110100 I
 1L
-b1101101 $
-b1101111 %
-b1110010 &
-b1100101 '
-b100000 (
-b1110100 )
-b1110011 *
-b1110100 +
 #13500000
 #13750000
 0#
@@ -808,6 +808,14 @@ b1110100 +
 #14000000
 #14250000
 1#
+b0 $
+b0 %
+b0 &
+b0 '
+b0 (
+b0 )
+b0 *
+b0 +
 1.
 1A
 b0 B
@@ -819,14 +827,6 @@ b0 G
 b0 H
 b0 I
 1L
-b0 $
-b0 %
-b0 &
-b0 '
-b0 (
-b0 )
-b0 *
-b0 +
 #14500000
 #14750000
 0#

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

@@ -276,7 +276,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "mod1",
         children: [
@@ -558,7 +557,12 @@ Simulation {
             },
         ),
     ],
-    instant: 2 μs,
     clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 2 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -0,0 +1,514 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 5,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<0>,
+                            },
+                        ],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 7,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.addr",
+                                ty: UInt<0>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.en",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.clk",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: UInt<0>,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Bool,
+                            },
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 1,
+                    debug_data: [
+                        (),
+                    ],
+                    layout_data: [
+                        MemoryData {
+                            array_type: Array<PhantomConst("mem_element"), 1>,
+                            data: [
+                                // len = 0x1
+                                [0x0]: 0x0,
+                            ],
+                        },
+                    ],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Const {
+                    dest: StatePartIndex<BigSlots>(5), // (0x0) SlotDebugData { name: "", ty: Bool },
+                    value: 0x0,
+                },
+                1: Copy {
+                    dest: StatePartIndex<BigSlots>(6), // (0x0) SlotDebugData { name: "", ty: Clock },
+                    src: StatePartIndex<BigSlots>(5), // (0x0) SlotDebugData { name: "", ty: Bool },
+                },
+                // at: module-XXXXXXXXXX.rs:6:1
+                2: Copy {
+                    dest: StatePartIndex<BigSlots>(2), // (0x0) SlotDebugData { name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.clk", ty: Clock },
+                    src: StatePartIndex<BigSlots>(6), // (0x0) SlotDebugData { name: "", ty: Clock },
+                },
+                // at: module-XXXXXXXXXX.rs:7:1
+                3: Copy {
+                    dest: StatePartIndex<BigSlots>(1), // (0x0) SlotDebugData { name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.en", ty: Bool },
+                    src: StatePartIndex<BigSlots>(5), // (0x0) SlotDebugData { name: "", ty: Bool },
+                },
+                // at: module-XXXXXXXXXX.rs:1:1
+                4: Const {
+                    dest: StatePartIndex<BigSlots>(3), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
+                    value: 0x0,
+                },
+                5: CastToUInt {
+                    dest: StatePartIndex<BigSlots>(4), // (0x0) SlotDebugData { name: "", ty: UInt<0> },
+                    src: StatePartIndex<BigSlots>(3), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
+                    dest_width: 0,
+                },
+                // at: module-XXXXXXXXXX.rs:5:1
+                6: Copy {
+                    dest: StatePartIndex<BigSlots>(0), // (0x0) SlotDebugData { name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.addr", ty: UInt<0> },
+                    src: StatePartIndex<BigSlots>(4), // (0x0) SlotDebugData { name: "", ty: UInt<0> },
+                },
+                // at: module-XXXXXXXXXX.rs:3:1
+                7: CastBigToArrayIndex {
+                    dest: StatePartIndex<SmallSlots>(4), // (0x0 0) SlotDebugData { name: "", ty: UInt<0> },
+                    src: StatePartIndex<BigSlots>(0), // (0x0) SlotDebugData { name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.addr", ty: UInt<0> },
+                },
+                8: IsNonZeroDestIsSmall {
+                    dest: StatePartIndex<SmallSlots>(3), // (0x0 0) SlotDebugData { name: "", ty: Bool },
+                    src: StatePartIndex<BigSlots>(1), // (0x0) SlotDebugData { name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.en", ty: Bool },
+                },
+                9: BranchIfSmallZero {
+                    target: 11,
+                    value: StatePartIndex<SmallSlots>(3), // (0x0 0) SlotDebugData { name: "", ty: Bool },
+                },
+                10: Branch {
+                    target: 11,
+                },
+                11: IsNonZeroDestIsSmall {
+                    dest: StatePartIndex<SmallSlots>(2), // (0x0 0) SlotDebugData { name: "", ty: Bool },
+                    src: StatePartIndex<BigSlots>(2), // (0x0) SlotDebugData { name: "InstantiatedModule(phantom_const: phantom_const).phantom_const::mem::r0.clk", ty: Clock },
+                },
+                12: AndSmall {
+                    dest: StatePartIndex<SmallSlots>(1), // (0x0 0) SlotDebugData { name: "", ty: Bool },
+                    lhs: StatePartIndex<SmallSlots>(2), // (0x0 0) SlotDebugData { name: "", ty: Bool },
+                    rhs: StatePartIndex<SmallSlots>(0), // (0x1 1) SlotDebugData { name: "", ty: Bool },
+                },
+                13: BranchIfSmallZero {
+                    target: 14,
+                    value: StatePartIndex<SmallSlots>(1), // (0x0 0) SlotDebugData { name: "", ty: Bool },
+                },
+                14: XorSmallImmediate {
+                    dest: StatePartIndex<SmallSlots>(0), // (0x1 1) SlotDebugData { name: "", ty: Bool },
+                    lhs: StatePartIndex<SmallSlots>(2), // (0x0 0) SlotDebugData { name: "", ty: Bool },
+                    rhs: 0x1,
+                },
+                // at: module-XXXXXXXXXX.rs:1:1
+                15: Return,
+            ],
+            ..
+        },
+        pc: 15,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [
+                MemoryData {
+                    array_type: Array<PhantomConst("mem_element"), 1>,
+                    data: [
+                        // len = 0x1
+                        [0x0]: 0x0,
+                    ],
+                },
+            ],
+        },
+        small_slots: StatePart {
+            value: [
+                1,
+                0,
+                0,
+                0,
+                0,
+            ],
+        },
+        big_slots: StatePart {
+            value: [
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::phantom_const,
+        instantiated: Module {
+            name: phantom_const,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::phantom_const,
+                instantiated: Module {
+                    name: phantom_const,
+                    ..
+                },
+            }.out,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::phantom_const,
+                instantiated: Module {
+                    name: phantom_const,
+                    ..
+                },
+            }.out,
+            Instance {
+                name: <simulator>::phantom_const,
+                instantiated: Module {
+                    name: phantom_const,
+                    ..
+                },
+            }.out[0],
+            Instance {
+                name: <simulator>::phantom_const,
+                instantiated: Module {
+                    name: phantom_const,
+                    ..
+                },
+            }.out[1],
+        },
+        did_initial_settle: true,
+    },
+    extern_modules: [],
+    trace_decls: TraceModule {
+        name: "phantom_const",
+        children: [
+            TraceModuleIO {
+                name: "out",
+                child: TraceArray {
+                    name: "out",
+                    elements: [
+                        TracePhantomConst {
+                            location: TraceScalarId(0),
+                            name: "[0]",
+                            ty: PhantomConst(
+                                ["a","b"],
+                            ),
+                            flow: Sink,
+                        },
+                        TracePhantomConst {
+                            location: TraceScalarId(1),
+                            name: "[1]",
+                            ty: PhantomConst(
+                                ["a","b"],
+                            ),
+                            flow: Sink,
+                        },
+                    ],
+                    ty: Array<PhantomConst(["a","b"]), 2>,
+                    flow: Sink,
+                },
+                ty: Array<PhantomConst(["a","b"]), 2>,
+                flow: Sink,
+            },
+            TraceMem {
+                id: TraceMemoryId(0),
+                name: "mem",
+                stride: 0,
+                element_type: TracePhantomConst {
+                    location: TraceMemoryLocation {
+                        id: TraceMemoryId(0),
+                        depth: 1,
+                        stride: 0,
+                        start: 0,
+                        len: 0,
+                    },
+                    name: "mem",
+                    ty: PhantomConst(
+                        "mem_element",
+                    ),
+                    flow: Duplex,
+                },
+                ports: [
+                    TraceMemPort {
+                        name: "r0",
+                        bundle: TraceBundle {
+                            name: "r0",
+                            fields: [
+                                TraceUInt {
+                                    location: TraceScalarId(2),
+                                    name: "addr",
+                                    ty: UInt<0>,
+                                    flow: Sink,
+                                },
+                                TraceBool {
+                                    location: TraceScalarId(3),
+                                    name: "en",
+                                    flow: Sink,
+                                },
+                                TraceClock {
+                                    location: TraceScalarId(4),
+                                    name: "clk",
+                                    flow: Sink,
+                                },
+                                TracePhantomConst {
+                                    location: TraceScalarId(5),
+                                    name: "data",
+                                    ty: PhantomConst(
+                                        "mem_element",
+                                    ),
+                                    flow: Source,
+                                },
+                            ],
+                            ty: Bundle {
+                                /* offset = 0 */
+                                addr: UInt<0>,
+                                /* offset = 0 */
+                                en: Bool,
+                                /* offset = 1 */
+                                clk: Clock,
+                                #[hdl(flip)] /* offset = 2 */
+                                data: PhantomConst(
+                                    "mem_element",
+                                ),
+                            },
+                            flow: Sink,
+                        },
+                        ty: Bundle {
+                            /* offset = 0 */
+                            addr: UInt<0>,
+                            /* offset = 0 */
+                            en: Bool,
+                            /* offset = 1 */
+                            clk: Clock,
+                            #[hdl(flip)] /* offset = 2 */
+                            data: PhantomConst(
+                                "mem_element",
+                            ),
+                        },
+                    },
+                ],
+                array_type: Array<PhantomConst("mem_element"), 1>,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: PhantomConst {
+                ty: PhantomConst(
+                    ["a","b"],
+                ),
+            },
+            state: PhantomConst,
+            last_state: PhantomConst,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: PhantomConst {
+                ty: PhantomConst(
+                    ["a","b"],
+                ),
+            },
+            state: PhantomConst,
+            last_state: PhantomConst,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(0),
+                ty: UInt<0>,
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(3),
+            kind: BigBool {
+                index: StatePartIndex<BigSlots>(1),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(4),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(2),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(5),
+            kind: PhantomConst {
+                ty: PhantomConst(
+                    "mem_element",
+                ),
+            },
+            state: PhantomConst,
+            last_state: PhantomConst,
+        },
+    ],
+    trace_memories: {
+        StatePartIndex<Memories>(0): TraceMem {
+            id: TraceMemoryId(0),
+            name: "mem",
+            stride: 0,
+            element_type: TracePhantomConst {
+                location: TraceMemoryLocation {
+                    id: TraceMemoryId(0),
+                    depth: 1,
+                    stride: 0,
+                    start: 0,
+                    len: 0,
+                },
+                name: "mem",
+                ty: PhantomConst(
+                    "mem_element",
+                ),
+                flow: Duplex,
+            },
+            ports: [
+                TraceMemPort {
+                    name: "r0",
+                    bundle: TraceBundle {
+                        name: "r0",
+                        fields: [
+                            TraceUInt {
+                                location: TraceScalarId(2),
+                                name: "addr",
+                                ty: UInt<0>,
+                                flow: Sink,
+                            },
+                            TraceBool {
+                                location: TraceScalarId(3),
+                                name: "en",
+                                flow: Sink,
+                            },
+                            TraceClock {
+                                location: TraceScalarId(4),
+                                name: "clk",
+                                flow: Sink,
+                            },
+                            TracePhantomConst {
+                                location: TraceScalarId(5),
+                                name: "data",
+                                ty: PhantomConst(
+                                    "mem_element",
+                                ),
+                                flow: Source,
+                            },
+                        ],
+                        ty: Bundle {
+                            /* offset = 0 */
+                            addr: UInt<0>,
+                            /* offset = 0 */
+                            en: Bool,
+                            /* offset = 1 */
+                            clk: Clock,
+                            #[hdl(flip)] /* offset = 2 */
+                            data: PhantomConst(
+                                "mem_element",
+                            ),
+                        },
+                        flow: Sink,
+                    },
+                    ty: Bundle {
+                        /* offset = 0 */
+                        addr: UInt<0>,
+                        /* offset = 0 */
+                        en: Bool,
+                        /* offset = 1 */
+                        clk: Clock,
+                        #[hdl(flip)] /* offset = 2 */
+                        data: PhantomConst(
+                            "mem_element",
+                        ),
+                    },
+                },
+            ],
+            array_type: Array<PhantomConst("mem_element"), 1>,
+        },
+    },
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [
+        StatePartIndex<SmallSlots>(1),
+    ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 1 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
+    ..
+}

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

@@ -0,0 +1,31 @@
+$timescale 1 ps $end
+$scope module phantom_const $end
+$scope struct out $end
+$var string 1 ! \[0] $end
+$var string 1 " \[1] $end
+$upscope $end
+$scope struct mem $end
+$scope struct contents $end
+$scope struct \[0] $end
+$var string 1 ' mem $end
+$upscope $end
+$upscope $end
+$scope struct r0 $end
+$var string 0 # addr $end
+$var wire 1 $ en $end
+$var wire 1 % clk $end
+$var string 1 & data $end
+$upscope $end
+$upscope $end
+$upscope $end
+$enddefinitions $end
+$dumpvars
+s0 '
+sPhantomConst([\"a\",\"b\"]) !
+sPhantomConst([\"a\",\"b\"]) "
+s0 #
+0$
+0%
+sPhantomConst(\"mem_element\") &
+$end
+#1000000

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

@@ -827,52 +827,6 @@ Simulation {
             running_generator: Some(
                 ...,
             ),
-            wait_targets: {
-                Change {
-                    key: CompiledValue {
-                        layout: CompiledTypeLayout {
-                            ty: Clock,
-                            layout: TypeLayout {
-                                small_slots: StatePartLayout<SmallSlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    ..
-                                },
-                                big_slots: StatePartLayout<BigSlots> {
-                                    len: 1,
-                                    debug_data: [
-                                        SlotDebugData {
-                                            name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::clk",
-                                            ty: Clock,
-                                        },
-                                    ],
-                                    ..
-                                },
-                                sim_only_slots: StatePartLayout<SimOnlySlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    layout_data: [],
-                                    ..
-                                },
-                            },
-                            body: Scalar,
-                        },
-                        range: TypeIndexRange {
-                            small_slots: StatePartIndexRange<SmallSlots> { start: 3, len: 0 },
-                            big_slots: StatePartIndexRange<BigSlots> { start: 33, len: 1 },
-                            sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
-                        },
-                        write: None,
-                    },
-                    value: SimValue {
-                        ty: Clock,
-                        value: OpaqueSimValue {
-                            bits: 0x0_u1,
-                            sim_only_values: [],
-                        },
-                    },
-                },
-            },
         },
         SimulationExternModuleState {
             module_state: SimulationModuleState {
@@ -956,52 +910,6 @@ Simulation {
             running_generator: Some(
                 ...,
             ),
-            wait_targets: {
-                Change {
-                    key: CompiledValue {
-                        layout: CompiledTypeLayout {
-                            ty: Clock,
-                            layout: TypeLayout {
-                                small_slots: StatePartLayout<SmallSlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    ..
-                                },
-                                big_slots: StatePartLayout<BigSlots> {
-                                    len: 1,
-                                    debug_data: [
-                                        SlotDebugData {
-                                            name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::clk",
-                                            ty: Clock,
-                                        },
-                                    ],
-                                    ..
-                                },
-                                sim_only_slots: StatePartLayout<SimOnlySlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    layout_data: [],
-                                    ..
-                                },
-                            },
-                            body: Scalar,
-                        },
-                        range: TypeIndexRange {
-                            small_slots: StatePartIndexRange<SmallSlots> { start: 6, len: 0 },
-                            big_slots: StatePartIndexRange<BigSlots> { start: 44, len: 1 },
-                            sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
-                        },
-                        write: None,
-                    },
-                    value: SimValue {
-                        ty: Clock,
-                        value: OpaqueSimValue {
-                            bits: 0x0_u1,
-                            sim_only_values: [],
-                        },
-                    },
-                },
-            },
         },
         SimulationExternModuleState {
             module_state: SimulationModuleState {
@@ -1085,55 +993,8 @@ Simulation {
             running_generator: Some(
                 ...,
             ),
-            wait_targets: {
-                Change {
-                    key: CompiledValue {
-                        layout: CompiledTypeLayout {
-                            ty: Clock,
-                            layout: TypeLayout {
-                                small_slots: StatePartLayout<SmallSlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    ..
-                                },
-                                big_slots: StatePartLayout<BigSlots> {
-                                    len: 1,
-                                    debug_data: [
-                                        SlotDebugData {
-                                            name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::clk",
-                                            ty: Clock,
-                                        },
-                                    ],
-                                    ..
-                                },
-                                sim_only_slots: StatePartLayout<SimOnlySlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    layout_data: [],
-                                    ..
-                                },
-                            },
-                            body: Scalar,
-                        },
-                        range: TypeIndexRange {
-                            small_slots: StatePartIndexRange<SmallSlots> { start: 9, len: 0 },
-                            big_slots: StatePartIndexRange<BigSlots> { start: 55, len: 1 },
-                            sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
-                        },
-                        write: None,
-                    },
-                    value: SimValue {
-                        ty: Clock,
-                        value: OpaqueSimValue {
-                            bits: 0x0_u1,
-                            sim_only_values: [],
-                        },
-                    },
-                },
-            },
         },
     ],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "ripple_counter",
         children: [
@@ -1593,11 +1454,315 @@ Simulation {
             },
         ),
     ],
-    instant: 256 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
         StatePartIndex<SmallSlots>(4),
         StatePartIndex<SmallSlots>(7),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 256 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 152,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::clk",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 9, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 55, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+        SensitivitySet {
+            id: 167,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::clk",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 6, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 44, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+        SensitivitySet {
+            id: 170,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::clk",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 3, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 33, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(ripple_counter.bit_reg_1: sw_reg).sw_reg::clk",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 3, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 33, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 170,
+                    ..
+                },
+            },
+        ),
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(ripple_counter.bit_reg_3: sw_reg).sw_reg::clk",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 6, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 44, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 167,
+                    ..
+                },
+            },
+        ),
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(ripple_counter.bit_reg_5: sw_reg).sw_reg::clk",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 9, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 55, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 152,
+                    ..
+                },
+            },
+        ),
+    },
     ..
 }

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

@@ -339,7 +339,6 @@ Simulation {
         did_initial_settle: true,
     },
     extern_modules: [],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "shift_register",
         children: [
@@ -440,7 +439,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
             },
             state: 0x1,
-            last_state: 0x1,
+            last_state: 0x0,
         },
         SimTrace {
             id: TraceScalarId(1),
@@ -509,9 +508,14 @@ Simulation {
             },
         ),
     ],
-    instant: 66 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 66 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {},
+    waiting_sensitivity_sets_by_compiled_value: {},
     ..
 }

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

@@ -52,9 +52,9 @@ $end
 0!
 #11000000
 1!
+1$
 0&
 1(
-1$
 #12000000
 0!
 1#
@@ -67,10 +67,10 @@ $end
 0#
 #15000000
 1!
+0$
 0%
 1&
 0(
-0$
 #16000000
 0!
 1#
@@ -83,23 +83,23 @@ $end
 0!
 #19000000
 1!
+1$
 1&
 0'
 1(
-1$
 #20000000
 0!
 #21000000
 1!
+0$
 1'
 0(
-0$
 #22000000
 0!
 #23000000
 1!
-1(
 1$
+1(
 #24000000
 0!
 0#
@@ -120,8 +120,8 @@ $end
 0!
 #31000000
 1!
-0(
 0$
+0(
 #32000000
 0!
 #33000000

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

@@ -0,0 +1,523 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 6,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join: sim_fork_join).sim_fork_join::clocks[0]",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join: sim_fork_join).sim_fork_join::clocks[1]",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join: sim_fork_join).sim_fork_join::clocks[2]",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join: sim_fork_join).sim_fork_join::outputs[0]",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join: sim_fork_join).sim_fork_join::outputs[1]",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join: sim_fork_join).sim_fork_join::outputs[2]",
+                                ty: UInt<8>,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 0,
+                    debug_data: [],
+                    layout_data: [],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Return,
+            ],
+            ..
+        },
+        pc: 0,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [],
+        },
+        small_slots: StatePart {
+            value: [],
+        },
+        big_slots: StatePart {
+            value: [
+                0,
+                0,
+                0,
+                49,
+                50,
+                50,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::sim_fork_join,
+        instantiated: Module {
+            name: sim_fork_join,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.clocks,
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.outputs,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.clocks,
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.clocks[0],
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.clocks[1],
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.clocks[2],
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.outputs,
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.outputs[0],
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.outputs[1],
+            Instance {
+                name: <simulator>::sim_fork_join,
+                instantiated: Module {
+                    name: sim_fork_join,
+                    ..
+                },
+            }.outputs[2],
+        },
+        did_initial_settle: true,
+    },
+    extern_modules: [
+        SimulationExternModuleState {
+            module_state: SimulationModuleState {
+                base_targets: [
+                    ModuleIO {
+                        name: sim_fork_join::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    },
+                ],
+                uninitialized_ios: {},
+                io_targets: {
+                    ModuleIO {
+                        name: sim_fork_join::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }[0],
+                    ModuleIO {
+                        name: sim_fork_join::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }[1],
+                    ModuleIO {
+                        name: sim_fork_join::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }[2],
+                    ModuleIO {
+                        name: sim_fork_join::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }[0],
+                    ModuleIO {
+                        name: sim_fork_join::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }[1],
+                    ModuleIO {
+                        name: sim_fork_join::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }[2],
+                },
+                did_initial_settle: true,
+            },
+            sim: ExternModuleSimulation {
+                generator: SimGeneratorFn {
+                    args: (
+                        ModuleIO {
+                            name: sim_fork_join::clocks,
+                            is_input: true,
+                            ty: Array<Clock, 3>,
+                            ..
+                        },
+                        ModuleIO {
+                            name: sim_fork_join::outputs,
+                            is_input: false,
+                            ty: Array<UInt<8>, 3>,
+                            ..
+                        },
+                    ),
+                    f: ...,
+                },
+                sim_io_to_generator_map: {
+                    ModuleIO {
+                        name: sim_fork_join::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_fork_join::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_fork_join::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    },
+                },
+                source_location: SourceLocation(
+                    module-XXXXXXXXXX.rs:4:1,
+                ),
+            },
+            running_generator: Some(
+                ...,
+            ),
+        },
+    ],
+    trace_decls: TraceModule {
+        name: "sim_fork_join",
+        children: [
+            TraceModuleIO {
+                name: "clocks",
+                child: TraceArray {
+                    name: "clocks",
+                    elements: [
+                        TraceClock {
+                            location: TraceScalarId(0),
+                            name: "[0]",
+                            flow: Source,
+                        },
+                        TraceClock {
+                            location: TraceScalarId(1),
+                            name: "[1]",
+                            flow: Source,
+                        },
+                        TraceClock {
+                            location: TraceScalarId(2),
+                            name: "[2]",
+                            flow: Source,
+                        },
+                    ],
+                    ty: Array<Clock, 3>,
+                    flow: Source,
+                },
+                ty: Array<Clock, 3>,
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "outputs",
+                child: TraceArray {
+                    name: "outputs",
+                    elements: [
+                        TraceUInt {
+                            location: TraceScalarId(3),
+                            name: "[0]",
+                            ty: UInt<8>,
+                            flow: Sink,
+                        },
+                        TraceUInt {
+                            location: TraceScalarId(4),
+                            name: "[1]",
+                            ty: UInt<8>,
+                            flow: Sink,
+                        },
+                        TraceUInt {
+                            location: TraceScalarId(5),
+                            name: "[2]",
+                            ty: UInt<8>,
+                            flow: Sink,
+                        },
+                    ],
+                    ty: Array<UInt<8>, 3>,
+                    flow: Sink,
+                },
+                ty: Array<UInt<8>, 3>,
+                flow: Sink,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(0),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(1),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(2),
+            },
+            state: 0x0,
+            last_state: 0x1,
+        },
+        SimTrace {
+            id: TraceScalarId(3),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(3),
+                ty: UInt<8>,
+            },
+            state: 0x31,
+            last_state: 0x31,
+        },
+        SimTrace {
+            id: TraceScalarId(4),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(4),
+                ty: UInt<8>,
+            },
+            state: 0x32,
+            last_state: 0x32,
+        },
+        SimTrace {
+            id: TraceScalarId(5),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(5),
+                ty: UInt<8>,
+            },
+            state: 0x32,
+            last_state: 0x32,
+        },
+    ],
+    trace_memories: {},
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 648 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 198,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 198,
+                    ..
+                },
+            },
+        ),
+    },
+    ..
+}

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

@@ -0,0 +1,523 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 6,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join_scope: sim_fork_join_scope).sim_fork_join_scope::clocks[0]",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join_scope: sim_fork_join_scope).sim_fork_join_scope::clocks[1]",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join_scope: sim_fork_join_scope).sim_fork_join_scope::clocks[2]",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join_scope: sim_fork_join_scope).sim_fork_join_scope::outputs[0]",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join_scope: sim_fork_join_scope).sim_fork_join_scope::outputs[1]",
+                                ty: UInt<8>,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_fork_join_scope: sim_fork_join_scope).sim_fork_join_scope::outputs[2]",
+                                ty: UInt<8>,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 0,
+                    debug_data: [],
+                    layout_data: [],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Return,
+            ],
+            ..
+        },
+        pc: 0,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [],
+        },
+        small_slots: StatePart {
+            value: [],
+        },
+        big_slots: StatePart {
+            value: [
+                0,
+                0,
+                0,
+                49,
+                50,
+                50,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::sim_fork_join_scope,
+        instantiated: Module {
+            name: sim_fork_join_scope,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.clocks,
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.outputs,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.clocks,
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.clocks[0],
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.clocks[1],
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.clocks[2],
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.outputs,
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.outputs[0],
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.outputs[1],
+            Instance {
+                name: <simulator>::sim_fork_join_scope,
+                instantiated: Module {
+                    name: sim_fork_join_scope,
+                    ..
+                },
+            }.outputs[2],
+        },
+        did_initial_settle: true,
+    },
+    extern_modules: [
+        SimulationExternModuleState {
+            module_state: SimulationModuleState {
+                base_targets: [
+                    ModuleIO {
+                        name: sim_fork_join_scope::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join_scope::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    },
+                ],
+                uninitialized_ios: {},
+                io_targets: {
+                    ModuleIO {
+                        name: sim_fork_join_scope::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join_scope::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }[0],
+                    ModuleIO {
+                        name: sim_fork_join_scope::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }[1],
+                    ModuleIO {
+                        name: sim_fork_join_scope::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }[2],
+                    ModuleIO {
+                        name: sim_fork_join_scope::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join_scope::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }[0],
+                    ModuleIO {
+                        name: sim_fork_join_scope::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }[1],
+                    ModuleIO {
+                        name: sim_fork_join_scope::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }[2],
+                },
+                did_initial_settle: true,
+            },
+            sim: ExternModuleSimulation {
+                generator: SimGeneratorFn {
+                    args: (
+                        ModuleIO {
+                            name: sim_fork_join_scope::clocks,
+                            is_input: true,
+                            ty: Array<Clock, 3>,
+                            ..
+                        },
+                        ModuleIO {
+                            name: sim_fork_join_scope::outputs,
+                            is_input: false,
+                            ty: Array<UInt<8>, 3>,
+                            ..
+                        },
+                    ),
+                    f: ...,
+                },
+                sim_io_to_generator_map: {
+                    ModuleIO {
+                        name: sim_fork_join_scope::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_fork_join_scope::clocks,
+                        is_input: true,
+                        ty: Array<Clock, 3>,
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_fork_join_scope::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_fork_join_scope::outputs,
+                        is_input: false,
+                        ty: Array<UInt<8>, 3>,
+                        ..
+                    },
+                },
+                source_location: SourceLocation(
+                    module-XXXXXXXXXX.rs:4:1,
+                ),
+            },
+            running_generator: Some(
+                ...,
+            ),
+        },
+    ],
+    trace_decls: TraceModule {
+        name: "sim_fork_join_scope",
+        children: [
+            TraceModuleIO {
+                name: "clocks",
+                child: TraceArray {
+                    name: "clocks",
+                    elements: [
+                        TraceClock {
+                            location: TraceScalarId(0),
+                            name: "[0]",
+                            flow: Source,
+                        },
+                        TraceClock {
+                            location: TraceScalarId(1),
+                            name: "[1]",
+                            flow: Source,
+                        },
+                        TraceClock {
+                            location: TraceScalarId(2),
+                            name: "[2]",
+                            flow: Source,
+                        },
+                    ],
+                    ty: Array<Clock, 3>,
+                    flow: Source,
+                },
+                ty: Array<Clock, 3>,
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "outputs",
+                child: TraceArray {
+                    name: "outputs",
+                    elements: [
+                        TraceUInt {
+                            location: TraceScalarId(3),
+                            name: "[0]",
+                            ty: UInt<8>,
+                            flow: Sink,
+                        },
+                        TraceUInt {
+                            location: TraceScalarId(4),
+                            name: "[1]",
+                            ty: UInt<8>,
+                            flow: Sink,
+                        },
+                        TraceUInt {
+                            location: TraceScalarId(5),
+                            name: "[2]",
+                            ty: UInt<8>,
+                            flow: Sink,
+                        },
+                    ],
+                    ty: Array<UInt<8>, 3>,
+                    flow: Sink,
+                },
+                ty: Array<UInt<8>, 3>,
+                flow: Sink,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(0),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(1),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(2),
+            },
+            state: 0x0,
+            last_state: 0x1,
+        },
+        SimTrace {
+            id: TraceScalarId(3),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(3),
+                ty: UInt<8>,
+            },
+            state: 0x31,
+            last_state: 0x31,
+        },
+        SimTrace {
+            id: TraceScalarId(4),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(4),
+                ty: UInt<8>,
+            },
+            state: 0x32,
+            last_state: 0x32,
+        },
+        SimTrace {
+            id: TraceScalarId(5),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(5),
+                ty: UInt<8>,
+            },
+            state: 0x32,
+            last_state: 0x32,
+        },
+    ],
+    trace_memories: {},
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 648 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 198,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 198,
+                    ..
+                },
+            },
+        ),
+    },
+    ..
+}

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

@@ -717,52 +717,6 @@ Simulation {
             running_generator: Some(
                 ...,
             ),
-            wait_targets: {
-                Change {
-                    key: CompiledValue {
-                        layout: CompiledTypeLayout {
-                            ty: Clock,
-                            layout: TypeLayout {
-                                small_slots: StatePartLayout<SmallSlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    ..
-                                },
-                                big_slots: StatePartLayout<BigSlots> {
-                                    len: 1,
-                                    debug_data: [
-                                        SlotDebugData {
-                                            name: "",
-                                            ty: Clock,
-                                        },
-                                    ],
-                                    ..
-                                },
-                                sim_only_slots: StatePartLayout<SimOnlySlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    layout_data: [],
-                                    ..
-                                },
-                            },
-                            body: Scalar,
-                        },
-                        range: TypeIndexRange {
-                            small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
-                            big_slots: StatePartIndexRange<BigSlots> { start: 4, len: 1 },
-                            sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 6, len: 0 },
-                        },
-                        write: None,
-                    },
-                    value: SimValue {
-                        ty: Clock,
-                        value: OpaqueSimValue {
-                            bits: 0x1_u1,
-                            sim_only_values: [],
-                        },
-                    },
-                },
-            },
         },
         SimulationExternModuleState {
             module_state: SimulationModuleState {
@@ -922,55 +876,8 @@ Simulation {
             running_generator: Some(
                 ...,
             ),
-            wait_targets: {
-                Change {
-                    key: CompiledValue {
-                        layout: CompiledTypeLayout {
-                            ty: Clock,
-                            layout: TypeLayout {
-                                small_slots: StatePartLayout<SmallSlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    ..
-                                },
-                                big_slots: StatePartLayout<BigSlots> {
-                                    len: 1,
-                                    debug_data: [
-                                        SlotDebugData {
-                                            name: "",
-                                            ty: Clock,
-                                        },
-                                    ],
-                                    ..
-                                },
-                                sim_only_slots: StatePartLayout<SimOnlySlots> {
-                                    len: 0,
-                                    debug_data: [],
-                                    layout_data: [],
-                                    ..
-                                },
-                            },
-                            body: Scalar,
-                        },
-                        range: TypeIndexRange {
-                            small_slots: StatePartIndexRange<SmallSlots> { start: 4, len: 0 },
-                            big_slots: StatePartIndexRange<BigSlots> { start: 12, len: 1 },
-                            sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 13, len: 0 },
-                        },
-                        write: None,
-                    },
-                    value: SimValue {
-                        ty: Clock,
-                        value: OpaqueSimValue {
-                            bits: 0x1_u1,
-                            sim_only_values: [],
-                        },
-                    },
-                },
-            },
         },
     ],
-    state_ready_to_run: false,
     trace_decls: TraceModule {
         name: "sim_only_connects",
         children: [
@@ -1628,9 +1535,214 @@ Simulation {
             },
         ),
     ],
-    instant: 16 μs,
     clocks_triggered: [
         StatePartIndex<SmallSlots>(1),
     ],
+    event_queue: EventQueue(EventQueueData {
+        instant: 16 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 30,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 4, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 6, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x1_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+        SensitivitySet {
+            id: 31,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 4, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 12, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 13, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x1_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 4, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 6, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x1_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 30,
+                    ..
+                },
+            },
+        ),
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 4, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 12, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 13, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x1_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 31,
+                    ..
+                },
+            },
+        ),
+    },
     ..
 }

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

@@ -72,22 +72,22 @@ s{} 8
 $end
 #1000000
 1!
+s{\"extra\":\x20\"value\"} $
 1'
+s{\"extra\":\x20\"value\"} )
 1+
+s{\"extra\":\x20\"value\"} -
 10
 11
 15
-s{\"extra\":\x20\"value\"} $
-s{\"extra\":\x20\"value\"} )
-s{\"extra\":\x20\"value\"} -
-s{\"bar\":\x20\"\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} *
-s{\"bar\":\x20\"\",\x20\"foo\":\x20\"baz\"} 4
 s{\"bar\":\x20\"\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} %
-s{\"bar\":\x20\"\",\x20\"foo\":\x20\"baz\"} &
+s{\"bar\":\x20\"\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} *
 s{\"bar\":\x20\"\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} .
 s{\"bar\":\x20\"\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} 3
 s{\"bar\":\x20\"\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} 7
-s{\"bar\":\x20\"\",\x20\"foo\":\x20\"baz\"} 8
+s{\"bar\":\x20\"baz\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} &
+s{\"bar\":\x20\"baz\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} 4
+s{\"bar\":\x20\"baz\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} 8
 #2000000
 0!
 0"
@@ -107,9 +107,6 @@ s{\"extra\":\x20\"value\"} /
 00
 11
 15
-s{\"bar\":\x20\"baz\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} 4
-s{\"bar\":\x20\"baz\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} &
-s{\"bar\":\x20\"baz\",\x20\"extra\":\x20\"value\",\x20\"foo\":\x20\"baz\"} 8
 #4000000
 0!
 0'

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

@@ -0,0 +1,550 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 3,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.clk",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.rst",
+                                ty: AsyncReset,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::out",
+                                ty: UInt<8>,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 0,
+                    debug_data: [],
+                    layout_data: [],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Return,
+            ],
+            ..
+        },
+        pc: 0,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [],
+        },
+        small_slots: StatePart {
+            value: [],
+        },
+        big_slots: StatePart {
+            value: [
+                0,
+                0,
+                3,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::sim_resettable_counter,
+        instantiated: Module {
+            name: sim_resettable_counter,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.clk,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.rst,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        },
+        did_initial_settle: true,
+    },
+    extern_modules: [
+        SimulationExternModuleState {
+            module_state: SimulationModuleState {
+                base_targets: [
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                ],
+                uninitialized_ios: {},
+                io_targets: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    }.clk,
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    }.rst,
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                did_initial_settle: true,
+            },
+            sim: ExternModuleSimulation {
+                generator: SimGeneratorFn {
+                    args: (
+                        ModuleIO {
+                            name: sim_resettable_counter::cd,
+                            is_input: true,
+                            ty: Bundle {
+                                /* offset = 0 */
+                                clk: Clock,
+                                /* offset = 1 */
+                                rst: AsyncReset,
+                            },
+                            ..
+                        },
+                        ModuleIO {
+                            name: sim_resettable_counter::out,
+                            is_input: false,
+                            ty: UInt<8>,
+                            ..
+                        },
+                    ),
+                    f: ...,
+                },
+                sim_io_to_generator_map: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                source_location: SourceLocation(
+                    module-XXXXXXXXXX.rs:4:1,
+                ),
+            },
+            running_generator: Some(
+                ...,
+            ),
+        },
+    ],
+    trace_decls: TraceModule {
+        name: "sim_resettable_counter",
+        children: [
+            TraceModuleIO {
+                name: "cd",
+                child: TraceBundle {
+                    name: "cd",
+                    fields: [
+                        TraceClock {
+                            location: TraceScalarId(0),
+                            name: "clk",
+                            flow: Source,
+                        },
+                        TraceAsyncReset {
+                            location: TraceScalarId(1),
+                            name: "rst",
+                            flow: Source,
+                        },
+                    ],
+                    ty: Bundle {
+                        /* offset = 0 */
+                        clk: Clock,
+                        /* offset = 1 */
+                        rst: AsyncReset,
+                    },
+                    flow: Source,
+                },
+                ty: Bundle {
+                    /* offset = 0 */
+                    clk: Clock,
+                    /* offset = 1 */
+                    rst: AsyncReset,
+                },
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "out",
+                child: TraceUInt {
+                    location: TraceScalarId(2),
+                    name: "out",
+                    ty: UInt<8>,
+                    flow: Sink,
+                },
+                ty: UInt<8>,
+                flow: Sink,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(0),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: BigAsyncReset {
+                index: StatePartIndex<BigSlots>(1),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(2),
+                ty: UInt<8>,
+            },
+            state: 0x03,
+            last_state: 0x03,
+        },
+    ],
+    trace_memories: {},
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 20 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 16,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: AsyncReset,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: AsyncReset,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 1, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: AsyncReset,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+        SensitivitySet {
+            id: 23,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: AsyncReset,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: AsyncReset,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 1, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: AsyncReset,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 16,
+                    ..
+                },
+            },
+        ),
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 23,
+                    ..
+                },
+            },
+        ),
+    },
+    ..
+}

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

@@ -0,0 +1,68 @@
+$timescale 1 ps $end
+$scope module sim_resettable_counter $end
+$scope struct cd $end
+$var wire 1 ! clk $end
+$var wire 1 " rst $end
+$upscope $end
+$var wire 8 # out $end
+$upscope $end
+$enddefinitions $end
+$dumpvars
+0!
+0"
+b0 #
+$end
+#1000000
+1!
+b1 #
+#2000000
+0!
+1"
+b0 #
+#3000000
+1!
+#4000000
+0!
+0"
+#5000000
+1!
+b1 #
+#6000000
+0!
+#7000000
+1!
+b10 #
+#8000000
+0!
+#9000000
+1!
+b11 #
+#10000000
+0!
+#11000000
+1!
+b100 #
+#12000000
+0!
+1"
+b0 #
+#13000000
+1!
+#14000000
+0!
+0"
+#15000000
+1!
+b1 #
+#16000000
+0!
+#17000000
+1!
+b10 #
+#18000000
+0!
+#19000000
+1!
+b11 #
+#20000000
+0!

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

@@ -0,0 +1,550 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 3,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.clk",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.rst",
+                                ty: AsyncReset,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::out",
+                                ty: UInt<8>,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 0,
+                    debug_data: [],
+                    layout_data: [],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Return,
+            ],
+            ..
+        },
+        pc: 0,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [],
+        },
+        small_slots: StatePart {
+            value: [],
+        },
+        big_slots: StatePart {
+            value: [
+                0,
+                0,
+                3,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::sim_resettable_counter,
+        instantiated: Module {
+            name: sim_resettable_counter,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.clk,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.rst,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        },
+        did_initial_settle: true,
+    },
+    extern_modules: [
+        SimulationExternModuleState {
+            module_state: SimulationModuleState {
+                base_targets: [
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                ],
+                uninitialized_ios: {},
+                io_targets: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    }.clk,
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    }.rst,
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                did_initial_settle: true,
+            },
+            sim: ExternModuleSimulation {
+                generator: SimGeneratorFn {
+                    args: (
+                        ModuleIO {
+                            name: sim_resettable_counter::cd,
+                            is_input: true,
+                            ty: Bundle {
+                                /* offset = 0 */
+                                clk: Clock,
+                                /* offset = 1 */
+                                rst: AsyncReset,
+                            },
+                            ..
+                        },
+                        ModuleIO {
+                            name: sim_resettable_counter::out,
+                            is_input: false,
+                            ty: UInt<8>,
+                            ..
+                        },
+                    ),
+                    f: ...,
+                },
+                sim_io_to_generator_map: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: AsyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                source_location: SourceLocation(
+                    module-XXXXXXXXXX.rs:4:1,
+                ),
+            },
+            running_generator: Some(
+                ...,
+            ),
+        },
+    ],
+    trace_decls: TraceModule {
+        name: "sim_resettable_counter",
+        children: [
+            TraceModuleIO {
+                name: "cd",
+                child: TraceBundle {
+                    name: "cd",
+                    fields: [
+                        TraceClock {
+                            location: TraceScalarId(0),
+                            name: "clk",
+                            flow: Source,
+                        },
+                        TraceAsyncReset {
+                            location: TraceScalarId(1),
+                            name: "rst",
+                            flow: Source,
+                        },
+                    ],
+                    ty: Bundle {
+                        /* offset = 0 */
+                        clk: Clock,
+                        /* offset = 1 */
+                        rst: AsyncReset,
+                    },
+                    flow: Source,
+                },
+                ty: Bundle {
+                    /* offset = 0 */
+                    clk: Clock,
+                    /* offset = 1 */
+                    rst: AsyncReset,
+                },
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "out",
+                child: TraceUInt {
+                    location: TraceScalarId(2),
+                    name: "out",
+                    ty: UInt<8>,
+                    flow: Sink,
+                },
+                ty: UInt<8>,
+                flow: Sink,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(0),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: BigAsyncReset {
+                index: StatePartIndex<BigSlots>(1),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(2),
+                ty: UInt<8>,
+            },
+            state: 0x03,
+            last_state: 0x03,
+        },
+    ],
+    trace_memories: {},
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 20 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 13,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: AsyncReset,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: AsyncReset,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 1, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: AsyncReset,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+        SensitivitySet {
+            id: 20,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: AsyncReset,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: AsyncReset,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 1, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: AsyncReset,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 13,
+                    ..
+                },
+            },
+        ),
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 20,
+                    ..
+                },
+            },
+        ),
+    },
+    ..
+}

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

@@ -0,0 +1,65 @@
+$timescale 1 ps $end
+$scope module sim_resettable_counter $end
+$scope struct cd $end
+$var wire 1 ! clk $end
+$var wire 1 " rst $end
+$upscope $end
+$var wire 8 # out $end
+$upscope $end
+$enddefinitions $end
+$dumpvars
+0!
+1"
+b0 #
+$end
+#1000000
+1!
+#2000000
+0!
+#3000000
+1!
+#4000000
+0!
+0"
+#5000000
+1!
+b1 #
+#6000000
+0!
+#7000000
+1!
+b10 #
+#8000000
+0!
+#9000000
+1!
+b11 #
+#10000000
+0!
+#11000000
+1!
+b100 #
+#12000000
+0!
+1"
+b0 #
+#13000000
+1!
+#14000000
+0!
+0"
+#15000000
+1!
+b1 #
+#16000000
+0!
+#17000000
+1!
+b10 #
+#18000000
+0!
+#19000000
+1!
+b11 #
+#20000000
+0!

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

@@ -0,0 +1,505 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 3,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.clk",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.rst",
+                                ty: SyncReset,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::out",
+                                ty: UInt<8>,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 0,
+                    debug_data: [],
+                    layout_data: [],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Return,
+            ],
+            ..
+        },
+        pc: 0,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [],
+        },
+        small_slots: StatePart {
+            value: [],
+        },
+        big_slots: StatePart {
+            value: [
+                0,
+                0,
+                3,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::sim_resettable_counter,
+        instantiated: Module {
+            name: sim_resettable_counter,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.clk,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.rst,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        },
+        did_initial_settle: true,
+    },
+    extern_modules: [
+        SimulationExternModuleState {
+            module_state: SimulationModuleState {
+                base_targets: [
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                ],
+                uninitialized_ios: {},
+                io_targets: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    }.clk,
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    }.rst,
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                did_initial_settle: true,
+            },
+            sim: ExternModuleSimulation {
+                generator: SimGeneratorFn {
+                    args: (
+                        ModuleIO {
+                            name: sim_resettable_counter::cd,
+                            is_input: true,
+                            ty: Bundle {
+                                /* offset = 0 */
+                                clk: Clock,
+                                /* offset = 1 */
+                                rst: SyncReset,
+                            },
+                            ..
+                        },
+                        ModuleIO {
+                            name: sim_resettable_counter::out,
+                            is_input: false,
+                            ty: UInt<8>,
+                            ..
+                        },
+                    ),
+                    f: ...,
+                },
+                sim_io_to_generator_map: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                source_location: SourceLocation(
+                    module-XXXXXXXXXX.rs:4:1,
+                ),
+            },
+            running_generator: Some(
+                ...,
+            ),
+        },
+    ],
+    trace_decls: TraceModule {
+        name: "sim_resettable_counter",
+        children: [
+            TraceModuleIO {
+                name: "cd",
+                child: TraceBundle {
+                    name: "cd",
+                    fields: [
+                        TraceClock {
+                            location: TraceScalarId(0),
+                            name: "clk",
+                            flow: Source,
+                        },
+                        TraceSyncReset {
+                            location: TraceScalarId(1),
+                            name: "rst",
+                            flow: Source,
+                        },
+                    ],
+                    ty: Bundle {
+                        /* offset = 0 */
+                        clk: Clock,
+                        /* offset = 1 */
+                        rst: SyncReset,
+                    },
+                    flow: Source,
+                },
+                ty: Bundle {
+                    /* offset = 0 */
+                    clk: Clock,
+                    /* offset = 1 */
+                    rst: SyncReset,
+                },
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "out",
+                child: TraceUInt {
+                    location: TraceScalarId(2),
+                    name: "out",
+                    ty: UInt<8>,
+                    flow: Sink,
+                },
+                ty: UInt<8>,
+                flow: Sink,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(0),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: BigSyncReset {
+                index: StatePartIndex<BigSlots>(1),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(2),
+                ty: UInt<8>,
+            },
+            state: 0x03,
+            last_state: 0x03,
+        },
+    ],
+    trace_memories: {},
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 20 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 42,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+        SensitivitySet {
+            id: 43,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 42,
+                    ..
+                },
+                SensitivitySet {
+                    id: 43,
+                    ..
+                },
+            },
+        ),
+    },
+    ..
+}

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

@@ -0,0 +1,70 @@
+$timescale 1 ps $end
+$scope module sim_resettable_counter $end
+$scope struct cd $end
+$var wire 1 ! clk $end
+$var wire 1 " rst $end
+$upscope $end
+$var wire 8 # out $end
+$upscope $end
+$enddefinitions $end
+$dumpvars
+0!
+0"
+b0 #
+$end
+#1000000
+1!
+b1 #
+#2000000
+0!
+1"
+#3000000
+1!
+b10 #
+b0 #
+#4000000
+0!
+0"
+#5000000
+1!
+b1 #
+#6000000
+0!
+#7000000
+1!
+b10 #
+#8000000
+0!
+#9000000
+1!
+b11 #
+#10000000
+0!
+#11000000
+1!
+b100 #
+#12000000
+0!
+1"
+#13000000
+1!
+b101 #
+b0 #
+#14000000
+0!
+0"
+#15000000
+1!
+b1 #
+#16000000
+0!
+#17000000
+1!
+b10 #
+#18000000
+0!
+#19000000
+1!
+b11 #
+#20000000
+0!

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

@@ -0,0 +1,505 @@
+Simulation {
+    state: State {
+        insns: Insns {
+            state_layout: StateLayout {
+                ty: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 3,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.clk",
+                                ty: Clock,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::cd.rst",
+                                ty: SyncReset,
+                            },
+                            SlotDebugData {
+                                name: "InstantiatedModule(sim_resettable_counter: sim_resettable_counter).sim_resettable_counter::out",
+                                ty: UInt<8>,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                memories: StatePartLayout<Memories> {
+                    len: 0,
+                    debug_data: [],
+                    layout_data: [],
+                    ..
+                },
+            },
+            insns: [
+                // at: module-XXXXXXXXXX.rs:1:1
+                0: Return,
+            ],
+            ..
+        },
+        pc: 0,
+        memory_write_log: [],
+        memories: StatePart {
+            value: [],
+        },
+        small_slots: StatePart {
+            value: [],
+        },
+        big_slots: StatePart {
+            value: [
+                0,
+                0,
+                3,
+            ],
+        },
+        sim_only_slots: StatePart {
+            value: [],
+        },
+    },
+    io: Instance {
+        name: <simulator>::sim_resettable_counter,
+        instantiated: Module {
+            name: sim_resettable_counter,
+            ..
+        },
+    },
+    main_module: SimulationModuleState {
+        base_targets: [
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        ],
+        uninitialized_ios: {},
+        io_targets: {
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.clk,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.cd.rst,
+            Instance {
+                name: <simulator>::sim_resettable_counter,
+                instantiated: Module {
+                    name: sim_resettable_counter,
+                    ..
+                },
+            }.out,
+        },
+        did_initial_settle: true,
+    },
+    extern_modules: [
+        SimulationExternModuleState {
+            module_state: SimulationModuleState {
+                base_targets: [
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                ],
+                uninitialized_ios: {},
+                io_targets: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    }.clk,
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    }.rst,
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                did_initial_settle: true,
+            },
+            sim: ExternModuleSimulation {
+                generator: SimGeneratorFn {
+                    args: (
+                        ModuleIO {
+                            name: sim_resettable_counter::cd,
+                            is_input: true,
+                            ty: Bundle {
+                                /* offset = 0 */
+                                clk: Clock,
+                                /* offset = 1 */
+                                rst: SyncReset,
+                            },
+                            ..
+                        },
+                        ModuleIO {
+                            name: sim_resettable_counter::out,
+                            is_input: false,
+                            ty: UInt<8>,
+                            ..
+                        },
+                    ),
+                    f: ...,
+                },
+                sim_io_to_generator_map: {
+                    ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::cd,
+                        is_input: true,
+                        ty: Bundle {
+                            /* offset = 0 */
+                            clk: Clock,
+                            /* offset = 1 */
+                            rst: SyncReset,
+                        },
+                        ..
+                    },
+                    ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    }: ModuleIO {
+                        name: sim_resettable_counter::out,
+                        is_input: false,
+                        ty: UInt<8>,
+                        ..
+                    },
+                },
+                source_location: SourceLocation(
+                    module-XXXXXXXXXX.rs:4:1,
+                ),
+            },
+            running_generator: Some(
+                ...,
+            ),
+        },
+    ],
+    trace_decls: TraceModule {
+        name: "sim_resettable_counter",
+        children: [
+            TraceModuleIO {
+                name: "cd",
+                child: TraceBundle {
+                    name: "cd",
+                    fields: [
+                        TraceClock {
+                            location: TraceScalarId(0),
+                            name: "clk",
+                            flow: Source,
+                        },
+                        TraceSyncReset {
+                            location: TraceScalarId(1),
+                            name: "rst",
+                            flow: Source,
+                        },
+                    ],
+                    ty: Bundle {
+                        /* offset = 0 */
+                        clk: Clock,
+                        /* offset = 1 */
+                        rst: SyncReset,
+                    },
+                    flow: Source,
+                },
+                ty: Bundle {
+                    /* offset = 0 */
+                    clk: Clock,
+                    /* offset = 1 */
+                    rst: SyncReset,
+                },
+                flow: Source,
+            },
+            TraceModuleIO {
+                name: "out",
+                child: TraceUInt {
+                    location: TraceScalarId(2),
+                    name: "out",
+                    ty: UInt<8>,
+                    flow: Sink,
+                },
+                ty: UInt<8>,
+                flow: Sink,
+            },
+        ],
+    },
+    traces: [
+        SimTrace {
+            id: TraceScalarId(0),
+            kind: BigClock {
+                index: StatePartIndex<BigSlots>(0),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(1),
+            kind: BigSyncReset {
+                index: StatePartIndex<BigSlots>(1),
+            },
+            state: 0x0,
+            last_state: 0x0,
+        },
+        SimTrace {
+            id: TraceScalarId(2),
+            kind: BigUInt {
+                index: StatePartIndex<BigSlots>(2),
+                ty: UInt<8>,
+            },
+            state: 0x03,
+            last_state: 0x03,
+        },
+    ],
+    trace_memories: {},
+    trace_writers: [
+        Running(
+            VcdWriter {
+                finished_init: true,
+                timescale: 1 ps,
+                ..
+            },
+        ),
+    ],
+    clocks_triggered: [],
+    event_queue: EventQueue(EventQueueData {
+        instant: 20 μs,
+        events: {},
+    }),
+    waiting_sensitivity_sets_by_address: {
+        SensitivitySet {
+            id: 43,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+        SensitivitySet {
+            id: 44,
+            values: {
+                CompiledValue {
+                    layout: CompiledTypeLayout {
+                        ty: Clock,
+                        layout: TypeLayout {
+                            small_slots: StatePartLayout<SmallSlots> {
+                                len: 0,
+                                debug_data: [],
+                                ..
+                            },
+                            big_slots: StatePartLayout<BigSlots> {
+                                len: 1,
+                                debug_data: [
+                                    SlotDebugData {
+                                        name: "",
+                                        ty: Clock,
+                                    },
+                                ],
+                                ..
+                            },
+                            sim_only_slots: StatePartLayout<SimOnlySlots> {
+                                len: 0,
+                                debug_data: [],
+                                layout_data: [],
+                                ..
+                            },
+                        },
+                        body: Scalar,
+                    },
+                    range: TypeIndexRange {
+                        small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                        big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                        sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+                    },
+                    write: None,
+                }: SimValue {
+                    ty: Clock,
+                    value: OpaqueSimValue {
+                        bits: 0x0_u1,
+                        sim_only_values: [],
+                    },
+                },
+            },
+            changed: Cell {
+                value: false,
+            },
+            ..
+        },
+    },
+    waiting_sensitivity_sets_by_compiled_value: {
+        CompiledValue {
+            layout: CompiledTypeLayout {
+                ty: Clock,
+                layout: TypeLayout {
+                    small_slots: StatePartLayout<SmallSlots> {
+                        len: 0,
+                        debug_data: [],
+                        ..
+                    },
+                    big_slots: StatePartLayout<BigSlots> {
+                        len: 1,
+                        debug_data: [
+                            SlotDebugData {
+                                name: "",
+                                ty: Clock,
+                            },
+                        ],
+                        ..
+                    },
+                    sim_only_slots: StatePartLayout<SimOnlySlots> {
+                        len: 0,
+                        debug_data: [],
+                        layout_data: [],
+                        ..
+                    },
+                },
+                body: Scalar,
+            },
+            range: TypeIndexRange {
+                small_slots: StatePartIndexRange<SmallSlots> { start: 0, len: 0 },
+                big_slots: StatePartIndexRange<BigSlots> { start: 0, len: 1 },
+                sim_only_slots: StatePartIndexRange<SimOnlySlots> { start: 0, len: 0 },
+            },
+            write: None,
+        }: (
+            SimValue {
+                ty: Clock,
+                value: OpaqueSimValue {
+                    bits: 0x0_u1,
+                    sim_only_values: [],
+                },
+            },
+            {
+                SensitivitySet {
+                    id: 43,
+                    ..
+                },
+                SensitivitySet {
+                    id: 44,
+                    ..
+                },
+            },
+        ),
+    },
+    ..
+}

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

@@ -0,0 +1,70 @@
+$timescale 1 ps $end
+$scope module sim_resettable_counter $end
+$scope struct cd $end
+$var wire 1 ! clk $end
+$var wire 1 " rst $end
+$upscope $end
+$var wire 8 # out $end
+$upscope $end
+$enddefinitions $end
+$dumpvars
+0!
+1"
+b0 #
+$end
+#1000000
+1!
+b1 #
+b0 #
+#2000000
+0!
+#3000000
+1!
+b1 #
+b0 #
+#4000000
+0!
+0"
+#5000000
+1!
+b1 #
+#6000000
+0!
+#7000000
+1!
+b10 #
+#8000000
+0!
+#9000000
+1!
+b11 #
+#10000000
+0!
+#11000000
+1!
+b100 #
+#12000000
+0!
+1"
+#13000000
+1!
+b101 #
+b0 #
+#14000000
+0!
+0"
+#15000000
+1!
+b1 #
+#16000000
+0!
+#17000000
+1!
+b10 #
+#18000000
+0!
+#19000000
+1!
+b11 #
+#20000000
+0!