format code after switching to edition 2024

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

@@ -1,21 +1,22 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
+    Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        common_derives, get_target, ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedField,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedField, ParsedFieldsNamed, ParsedGenerics,
-        ParsedFieldsNamed, ParsedGenerics, SplitForImpl, TypesParser, WrappedInConst,
+        SplitForImpl, TypesParser, WrappedInConst, common_derives, get_target,
     },
-    kw, Errors, HdlAttr, PairsIterExt,
+    kw,
 };
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote_spanned, ToTokens};
+use quote::{ToTokens, format_ident, quote_spanned};
 use syn::{
-    parse_quote, parse_quote_spanned,
+    AngleBracketedGenericArguments, Attribute, Field, FieldMutability, Fields, FieldsNamed,
+    GenericParam, Generics, Ident, ItemStruct, Path, Token, Type, Visibility, parse_quote,
+    parse_quote_spanned,
     punctuated::{Pair, Punctuated},
     spanned::Spanned,
     token::Brace,
-    AngleBracketedGenericArguments, Attribute, Field, FieldMutability, Fields, FieldsNamed,
-    GenericParam, Generics, Ident, ItemStruct, Path, Token, Type, Visibility,
 };
 
 #[derive(Clone, Debug)]

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

@@ -1,20 +1,20 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
+    Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        common_derives, get_target, ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType, SplitForImpl,
-        ParsedType, SplitForImpl, TypesParser, WrappedInConst,
+        TypesParser, WrappedInConst, common_derives, get_target,
     },
-    kw, Errors, HdlAttr, PairsIterExt,
+    kw,
 };
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote_spanned, ToTokens};
+use quote::{ToTokens, format_ident, quote_spanned};
 use syn::{
-    parse_quote_spanned,
+    Attribute, Field, FieldMutability, Fields, FieldsNamed, FieldsUnnamed, Generics, Ident,
+    ItemEnum, ItemStruct, Token, Type, Variant, Visibility, parse_quote_spanned,
     punctuated::{Pair, Punctuated},
     token::{Brace, Paren},
-    Attribute, Field, FieldMutability, Fields, FieldsNamed, FieldsUnnamed, Generics, Ident,
-    ItemEnum, ItemStruct, Token, Type, Variant, Visibility,
 };
 
 crate::options! {

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

@@ -1,15 +1,16 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
+    Errors, HdlAttr,
     hdl_type_common::{
-        get_target, ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType, TypesParser,
-        TypesParser,
+        get_target,
     },
-    kw, Errors, HdlAttr,
+    kw,
 };
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn::{parse_quote_spanned, Attribute, Generics, Ident, ItemType, Token, Type, Visibility};
+use syn::{Attribute, Generics, Ident, ItemType, Token, Type, Visibility, parse_quote_spanned};
 
 #[derive(Clone, Debug)]
 pub(crate) struct ParsedTypeAlias {

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

@@ -1,21 +1,21 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
-use crate::{fold::impl_fold, kw, Errors, HdlAttr, PairsIterExt};
+use crate::{Errors, HdlAttr, PairsIterExt, fold::impl_fold, kw};
 use proc_macro2::{Span, TokenStream};
-use quote::{format_ident, quote_spanned, ToTokens};
+use quote::{ToTokens, format_ident, quote_spanned};
 use std::{collections::HashMap, fmt, mem};
 use syn::{
-    parse::{Parse, ParseStream},
-    parse_quote, parse_quote_spanned,
-    punctuated::{Pair, Punctuated},
-    spanned::Spanned,
-    token::{Brace, Bracket, Paren},
     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,
+    parse::{Parse, ParseStream},
+    parse_quote, parse_quote_spanned,
+    punctuated::{Pair, Punctuated},
+    spanned::Spanned,
+    token::{Brace, Bracket, Paren},
 };
 
 crate::options! {
@@ -299,7 +299,7 @@ impl ParseTypes<Expr> for ParsedExpr {
                 return Ok(ParsedExpr::Delimited(ParsedExprDelimited {
                     delim: ExprDelimiter::Group(*group_token),
                     expr: parser.parse(expr)?,
-                }))
+                }));
             }
             Expr::Paren(ExprParen {
                 attrs,
@@ -309,7 +309,7 @@ impl ParseTypes<Expr> for ParsedExpr {
                 return Ok(ParsedExpr::Delimited(ParsedExprDelimited {
                     delim: ExprDelimiter::Paren(*paren_token),
                     expr: parser.parse(expr)?,
-                }))
+                }));
             }
             Expr::Path(ExprPath {
                 attrs,
@@ -1902,8 +1902,8 @@ pub(crate) mod known_items {
     use proc_macro2::{Ident, Span, TokenStream};
     use quote::ToTokens;
     use syn::{
-        parse::{Parse, ParseStream},
         Path, PathArguments, PathSegment, Token,
+        parse::{Parse, ParseStream},
     };
 
     macro_rules! impl_known_item_body {

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

@@ -2,13 +2,13 @@
 // See Notices.txt for copyright information
 #![cfg_attr(test, recursion_limit = "512")]
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 use std::{
-    collections::{hash_map::Entry, HashMap},
+    collections::{HashMap, hash_map::Entry},
     io::{ErrorKind, Write},
 };
 use syn::{
-    bracketed,
+    AttrStyle, Attribute, Error, Ident, Item, ItemFn, LitBool, LitStr, Meta, Token, bracketed,
     ext::IdentExt,
     parenthesized,
     parse::{Parse, ParseStream, Parser},
@@ -16,7 +16,6 @@ use syn::{
     punctuated::{Pair, Punctuated},
     spanned::Spanned,
     token::{Bracket, Paren},
-    AttrStyle, Attribute, Error, Ident, Item, ItemFn, LitBool, LitStr, Meta, Token,
 };
 
 mod fold;

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

@@ -1,19 +1,20 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
+    Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{ParsedGenerics, SplitForImpl},
     kw,
     module::transform_body::{HdlLet, HdlLetKindIO},
-    options, Errors, HdlAttr, PairsIterExt,
+    options,
 };
 use proc_macro2::TokenStream;
-use quote::{format_ident, quote, quote_spanned, ToTokens};
+use quote::{ToTokens, format_ident, quote, quote_spanned};
 use std::collections::HashSet;
 use syn::{
-    parse_quote,
-    visit::{visit_pat, Visit},
     Attribute, Block, ConstParam, Error, FnArg, GenericParam, Generics, Ident, ItemFn, ItemStruct,
     LifetimeParam, ReturnType, Signature, TypeParam, Visibility, WhereClause, WherePredicate,
+    parse_quote,
+    visit::{Visit, visit_pat},
 };
 
 mod transform_body;

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

@@ -1,27 +1,28 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
-    fold::{impl_fold, DoFold},
+    Errors, HdlAttr,
+    fold::{DoFold, impl_fold},
     hdl_type_common::{
-        known_items, ParseFailed, ParseTypes, ParsedGenerics, ParsedType, TypesParser,
+        ParseFailed, ParseTypes, ParsedGenerics, ParsedType, TypesParser, known_items,
     },
     is_hdl_attr, kw,
-    module::{check_name_conflicts_with_module_builder, ModuleIO, ModuleIOKind, ModuleKind},
+    module::{ModuleIO, ModuleIOKind, ModuleKind, check_name_conflicts_with_module_builder},
-    options, Errors, HdlAttr,
+    options,
 };
 use num_bigint::BigInt;
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, quote_spanned, ToTokens};
+use quote::{ToTokens, quote, quote_spanned};
 use std::{borrow::Borrow, convert::Infallible};
 use syn::{
-    fold::{fold_expr, fold_expr_lit, fold_expr_unary, fold_local, fold_stmt, Fold},
+    Attribute, Block, Error, Expr, ExprIf, ExprLet, ExprLit, ExprRepeat, ExprUnary,
+    GenericArgument, Ident, Item, Lit, LitStr, Local, LocalInit, Pat, Token, Type, UnOp,
+    fold::{Fold, fold_expr, fold_expr_lit, fold_expr_unary, fold_local, fold_stmt},
     parenthesized,
     parse::{Parse, ParseStream},
     parse_quote, parse_quote_spanned,
     spanned::Spanned,
     token::Paren,
-    Attribute, Block, Error, Expr, ExprIf, ExprLet, ExprLit, ExprRepeat, ExprUnary,
-    GenericArgument, Ident, Item, Lit, LitStr, Local, LocalInit, Pat, Token, Type, UnOp,
 };
 
 mod expand_aggregate_literals;

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

@@ -2,19 +2,18 @@
 // See Notices.txt for copyright information
 
 use crate::{
-    kw,
+    HdlAttr, kw,
     module::transform_body::{
-        expand_match::{parse_enum_path, EnumPath},
         ExprOptions, Visitor,
+        expand_match::{EnumPath, parse_enum_path},
     },
-    HdlAttr,
 };
 use quote::{format_ident, quote_spanned};
 use std::mem;
 use syn::{
-    parse_quote_spanned, punctuated::Punctuated, spanned::Spanned, token::Paren, Expr, ExprArray,
+    Expr, ExprArray, ExprCall, ExprGroup, ExprMethodCall, ExprParen, ExprPath, ExprRepeat,
-    ExprCall, ExprGroup, ExprMethodCall, ExprParen, ExprPath, ExprRepeat, ExprStruct, ExprTuple,
+    ExprStruct, ExprTuple, FieldValue, Token, TypePath, parse_quote_spanned,
-    FieldValue, Token, TypePath,
+    punctuated::Punctuated, spanned::Spanned, token::Paren,
 };
 
 impl Visitor<'_> {

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

@@ -1,25 +1,25 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
-    fold::{impl_fold, DoFold},
+    Errors, HdlAttr, PairsIterExt,
+    fold::{DoFold, impl_fold},
     kw,
     module::transform_body::{
-        empty_let, with_debug_clone_and_fold, wrap_ty_with_expr, ExprOptions, Visitor,
+        ExprOptions, Visitor, empty_let, with_debug_clone_and_fold, wrap_ty_with_expr,
     },
-    Errors, HdlAttr, PairsIterExt,
 };
 use proc_macro2::{Span, TokenStream};
-use quote::{format_ident, quote_spanned, ToTokens, TokenStreamExt};
+use quote::{ToTokens, TokenStreamExt, format_ident, quote_spanned};
 use std::collections::BTreeSet;
 use syn::{
-    fold::{fold_arm, fold_expr_match, fold_local, fold_pat, Fold},
+    Arm, Attribute, Expr, ExprMatch, FieldPat, Ident, Local, Member, Pat, PatIdent, PatOr,
+    PatParen, PatPath, PatRest, PatStruct, PatTuple, PatTupleStruct, PatWild, Path, PathSegment,
+    Token, TypePath,
+    fold::{Fold, fold_arm, fold_expr_match, fold_local, fold_pat},
     parse_quote_spanned,
     punctuated::Punctuated,
     spanned::Spanned,
     token::{Brace, Paren},
-    Arm, Attribute, Expr, ExprMatch, FieldPat, Ident, Local, Member, Pat, PatIdent, PatOr,
-    PatParen, PatPath, PatRest, PatStruct, PatTuple, PatTupleStruct, PatWild, Path, PathSegment,
-    Token, TypePath,
 };
 
 macro_rules! visit_trait {
@@ -444,7 +444,7 @@ trait ParseMatchPat: Sized {
     fn struct_(state: &mut HdlMatchParseState<'_>, v: MatchPatStruct) -> Result<Self, ()>;
     fn tuple(state: &mut HdlMatchParseState<'_>, v: MatchPatTuple) -> Result<Self, ()>;
     fn enum_variant(state: &mut HdlMatchParseState<'_>, v: MatchPatEnumVariant)
-        -> Result<Self, ()>;
+    -> Result<Self, ()>;
     fn parse(state: &mut HdlMatchParseState<'_>, pat: Pat) -> Result<Self, ()> {
         match pat {
             Pat::Ident(PatIdent {

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

@@ -5,8 +5,8 @@ use crate::{Cfg, CfgAttr, Cfgs, Errors};
 use proc_macro2::Ident;
 use std::{collections::VecDeque, marker::PhantomData};
 use syn::{
-    punctuated::{Pair, Punctuated},
     Token,
+    punctuated::{Pair, Punctuated},
 };
 
 struct State<P: Phase> {
@@ -131,9 +131,9 @@ trait PhaseDispatch {
     type Args<P: Phase>;
     type Output<P: Phase>;
     fn dispatch_collect(self, args: Self::Args<CollectCfgsPhase>)
-        -> Self::Output<CollectCfgsPhase>;
+    -> Self::Output<CollectCfgsPhase>;
     fn dispatch_process(self, args: Self::Args<ProcessCfgsPhase>)
-        -> Self::Output<ProcessCfgsPhase>;
+    -> Self::Output<ProcessCfgsPhase>;
 }
 
 trait Phase: Sized + 'static {
@@ -2510,7 +2510,7 @@ pub(crate) fn process_cfgs(item: syn::Item, cfgs: Cfgs<bool>) -> syn::Result<Opt
         errors: Errors::new(),
         _phantom: PhantomData,
     };
-    let retval = TopItem(item).process(&mut state).map(|v| v.0 .0);
+    let retval = TopItem(item).process(&mut state).map(|v| v.0.0);
     state.errors.finish()?;
     Ok(retval)
 }

crates/fayalite-visit-gen/src/lib.rs

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use proc_macro2::{Span, TokenStream};
-use quote::{format_ident, quote, ToTokens};
+use quote::{ToTokens, format_ident, quote};
 use std::{collections::BTreeMap, fs};
 use syn::{fold::Fold, parse_quote};
 

crates/fayalite/src/annotations.rs

@@ -314,10 +314,8 @@ impl<T: Iterator<Item: IntoAnnotations>> Iterator for IterIntoAnnotations<T> {
 }
 
 impl<
-        T: FusedIterator<
+    T: FusedIterator<Item: IntoAnnotations<IntoAnnotations: IntoIterator<IntoIter: FusedIterator>>>,
-            Item: IntoAnnotations<IntoAnnotations: IntoIterator<IntoIter: FusedIterator>>,
+> FusedIterator for IterIntoAnnotations<T>
-        >,
-    > FusedIterator for IterIntoAnnotations<T>
 {
 }
 

crates/fayalite/src/array.rs

@@ -3,22 +3,22 @@
 
 use crate::{
     expr::{
-        ops::{ArrayLiteral, ExprFromIterator, ExprIntoIterator, ExprPartialEq},
         CastToBits, Expr, HdlPartialEq, ReduceBits, ToExpr,
+        ops::{ArrayLiteral, ExprFromIterator, ExprIntoIterator, ExprPartialEq},
     },
-    int::{Bool, DynSize, KnownSize, Size, SizeType, DYN_SIZE},
+    int::{Bool, DYN_SIZE, DynSize, KnownSize, Size, SizeType},
     intern::{Intern, Interned, LazyInterned},
     module::transform::visit::{Fold, Folder, Visit, Visitor},
     sim::value::{SimValue, SimValuePartialEq},
     source_location::SourceLocation,
     ty::{
-        serde_impls::SerdeCanonicalType, CanonicalType, MatchVariantWithoutScope, StaticType, Type,
+        CanonicalType, MatchVariantWithoutScope, StaticType, Type, TypeProperties, TypeWithDeref,
-        TypeProperties, TypeWithDeref,
+        serde_impls::SerdeCanonicalType,
     },
     util::ConstUsize,
 };
 use bitvec::slice::BitSlice;
-use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error};
 use std::{iter::FusedIterator, ops::Index};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]

crates/fayalite/src/bundle.rs

@@ -3,16 +3,16 @@
 
 use crate::{
     expr::{
-        ops::{ArrayLiteral, BundleLiteral, ExprPartialEq},
         CastToBits, Expr, ReduceBits, ToExpr,
+        ops::{ArrayLiteral, BundleLiteral, ExprPartialEq},
     },
     int::{Bool, DynSize},
     intern::{Intern, Interned},
     sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType},
     source_location::SourceLocation,
     ty::{
-        impl_match_variant_as_self, CanonicalType, MatchVariantWithoutScope, OpaqueSimValue,
+        CanonicalType, MatchVariantWithoutScope, OpaqueSimValue, StaticType, Type, TypeProperties,
-        StaticType, Type, TypeProperties, TypeWithDeref,
+        TypeWithDeref, impl_match_variant_as_self,
     },
     util::HashMap,
 };

crates/fayalite/src/cli.rs

@@ -8,10 +8,10 @@ use crate::{
     util::{job_server::AcquiredJob, streaming_read_utf8::streaming_read_utf8},
 };
 use clap::{
-    builder::{OsStringValueParser, TypedValueParser},
     Parser, Subcommand, ValueEnum, ValueHint,
+    builder::{OsStringValueParser, TypedValueParser},
 };
-use eyre::{eyre, Report};
+use eyre::{Report, eyre};
 use serde::{Deserialize, Serialize};
 use std::{
     error,
@@ -301,7 +301,9 @@ impl VerilogArgs {
                 input.split_once(file_separator_prefix)
             {
                 let Some((next_file_name, rest)) = rest.split_once(file_separator_suffix) else {
-                    return Err(CliError(eyre!("parsing firtool's output failed: found {file_separator_prefix:?} but no {file_separator_suffix:?}")));
+                    return Err(CliError(eyre!(
+                        "parsing firtool's output failed: found {file_separator_prefix:?} but no {file_separator_suffix:?}"
+                    )));
                 };
                 input = rest;
                 (chunk, Some(next_file_name.as_ref()))

crates/fayalite/src/clock.rs

@@ -6,7 +6,7 @@ use crate::{
     int::Bool,
     reset::{Reset, ResetType},
     source_location::SourceLocation,
-    ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties},
+    ty::{CanonicalType, StaticType, Type, TypeProperties, impl_match_variant_as_self},
 };
 use bitvec::slice::BitSlice;
 

crates/fayalite/src/enum_.rs

@@ -3,15 +3,15 @@
 
 use crate::{
     expr::{
-        ops::{ExprPartialEq, VariantAccess},
         Expr, ToExpr,
+        ops::{ExprPartialEq, VariantAccess},
     },
     hdl,
     int::{Bool, UIntValue},
     intern::{Intern, Interned},
     module::{
-        connect, enum_match_variants_helper, incomplete_wire, wire,
+        EnumMatchVariantAndInactiveScopeImpl, EnumMatchVariantsIterImpl, Scope, connect,
-        EnumMatchVariantAndInactiveScopeImpl, EnumMatchVariantsIterImpl, Scope,
+        enum_match_variants_helper, incomplete_wire, wire,
     },
     sim::value::{SimValue, SimValuePartialEq},
     source_location::SourceLocation,
@@ -254,12 +254,12 @@ impl Enum {
 
 pub trait EnumType:
     Type<
-    BaseType = Enum,
+        BaseType = Enum,
-    MaskType = Bool,
+        MaskType = Bool,
-    MatchActiveScope = Scope,
+        MatchActiveScope = Scope,
-    MatchVariantAndInactiveScope = EnumMatchVariantAndInactiveScope<Self>,
+        MatchVariantAndInactiveScope = EnumMatchVariantAndInactiveScope<Self>,
-    MatchVariantsIter = EnumMatchVariantsIter<Self>,
+        MatchVariantsIter = EnumMatchVariantsIter<Self>,
->
+    >
 {
     type SimBuilder: From<Self>;
     fn variants(&self) -> Interned<[EnumVariant]>;

crates/fayalite/src/expr.rs

@@ -13,8 +13,8 @@ use crate::{
     intern::{Intern, Interned},
     memory::{DynPortType, MemPort, PortType},
     module::{
-        transform::visit::{Fold, Folder, Visit, Visitor},
         Instance, ModuleIO,
+        transform::visit::{Fold, Folder, Visit, Visitor},
     },
     phantom_const::PhantomConst,
     reg::Reg,
@@ -283,7 +283,10 @@ impl<T: Type + fmt::Debug> fmt::Debug for Expr<T> {
             } = self;
             let expr_ty = __ty.canonical();
             let enum_ty = __enum.to_expr().__ty;
-            assert_eq!(expr_ty, enum_ty, "expr ty mismatch:\nExpr {{\n__enum: {__enum:?},\n__ty: {__ty:?},\n__flow: {__flow:?}\n}}");
+            assert_eq!(
+                expr_ty, enum_ty,
+                "expr ty mismatch:\nExpr {{\n__enum: {__enum:?},\n__ty: {__ty:?},\n__flow: {__flow:?}\n}}"
+            );
         }
         self.__enum.fmt(f)
     }
@@ -529,11 +532,7 @@ impl Flow {
         }
     }
     pub const fn flip_if(self, flipped: bool) -> Flow {
-        if flipped {
+        if flipped { self.flip() } else { self }
-            self.flip()
-        } else {
-            self
-        }
     }
 }
 

crates/fayalite/src/expr/ops.rs

@@ -7,12 +7,12 @@ use crate::{
     clock::{Clock, ToClock},
     enum_::{Enum, EnumType, EnumVariant},
     expr::{
+        CastBitsTo as _, CastTo, CastToBits as _, Expr, ExprEnum, Flow, HdlPartialEq,
+        HdlPartialOrd, NotALiteralExpr, ReduceBits, ToExpr, ToLiteralBits,
         target::{
             GetTarget, Target, TargetPathArrayElement, TargetPathBundleField,
             TargetPathDynArrayElement, TargetPathElement,
         },
-        CastBitsTo as _, CastTo, CastToBits as _, Expr, ExprEnum, Flow, HdlPartialEq,
-        HdlPartialOrd, NotALiteralExpr, ReduceBits, ToExpr, ToLiteralBits,
     },
     int::{
         Bool, BoolOrIntType, DynSize, IntType, KnownSize, SInt, SIntType, SIntValue, Size, UInt,

crates/fayalite/src/firrtl.rs

@@ -11,32 +11,32 @@ use crate::{
     clock::Clock,
     enum_::{Enum, EnumType, EnumVariant},
     expr::{
+        CastBitsTo, Expr, ExprEnum,
         ops::{self, VariantAccess},
         target::{
             Target, TargetBase, TargetPathArrayElement, TargetPathBundleField, TargetPathElement,
         },
-        CastBitsTo, Expr, ExprEnum,
     },
     formal::FormalKind,
     int::{Bool, DynSize, IntType, SIntValue, UInt, UIntValue},
     intern::{Intern, Interned},
     memory::{Mem, PortKind, PortName, ReadUnderWrite},
     module::{
-        transform::{
-            simplify_enums::{simplify_enums, SimplifyEnumsError, SimplifyEnumsKind},
-            simplify_memories::simplify_memories,
-        },
         AnnotatedModuleIO, Block, ExternModuleBody, ExternModuleParameter,
         ExternModuleParameterValue, Module, ModuleBody, NameOptId, NormalModuleBody, Stmt,
         StmtConnect, StmtDeclaration, StmtFormal, StmtIf, StmtInstance, StmtMatch, StmtReg,
         StmtWire,
+        transform::{
+            simplify_enums::{SimplifyEnumsError, SimplifyEnumsKind, simplify_enums},
+            simplify_memories::simplify_memories,
+        },
     },
     reset::{AsyncReset, Reset, ResetType, SyncReset},
     source_location::SourceLocation,
     ty::{CanonicalType, Type},
     util::{
-        const_str_array_is_strictly_ascending, BitSliceWriteWithBase, DebugAsRawString,
+        BitSliceWriteWithBase, DebugAsRawString, GenericConstBool, HashMap, HashSet,
-        GenericConstBool, HashMap, HashSet,
+        const_str_array_is_strictly_ascending,
     },
 };
 use bitvec::slice::BitSlice;
@@ -925,7 +925,10 @@ impl<'a> Exporter<'a> {
             },
         ) in expr.field_values().into_iter().zip(ty.fields())
         {
-            debug_assert!(!flipped, "can't have bundle literal with flipped field -- this should have been caught in BundleLiteral::new_unchecked");
+            debug_assert!(
+                !flipped,
+                "can't have bundle literal with flipped field -- this should have been caught in BundleLiteral::new_unchecked"
+            );
             let name = bundle_ns.borrow_mut().get(name);
             let field_value = self.expr(Expr::canonical(field_value), definitions, const_ty);
             definitions.add_definition_line(format_args!("connect {ident}.{name}, {field_value}"));
@@ -1261,7 +1264,9 @@ impl<'a> Exporter<'a> {
             "UInt<0>(0)".into()
         };
         for (variant_index, variant) in ty.variants().into_iter().enumerate() {
-            let when_cond = format!("eq(UInt<{discriminant_bit_width}>({variant_index}), tail({value_str}, {body_bit_width}))");
+            let when_cond = format!(
+                "eq(UInt<{discriminant_bit_width}>({variant_index}), tail({value_str}, {body_bit_width}))"
+            );
             if variant_index == ty.variants().len() - 1 {
                 definitions.add_definition_line(format_args!("{extra_indent}else:"));
             } else if variant_index == 0 {

crates/fayalite/src/int.rs

@@ -4,22 +4,22 @@
 use crate::{
     array::ArrayType,
     expr::{
-        target::{GetTarget, Target},
         Expr, NotALiteralExpr, ToExpr, ToLiteralBits,
+        target::{GetTarget, Target},
     },
     hdl,
     intern::{Intern, Interned, Memoize},
     sim::value::{SimValue, ToSimValueWithType},
     source_location::SourceLocation,
-    ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties},
+    ty::{CanonicalType, StaticType, Type, TypeProperties, impl_match_variant_as_self},
-    util::{interned_bit, ConstBool, ConstUsize, GenericConstBool, GenericConstUsize},
+    util::{ConstBool, ConstUsize, GenericConstBool, GenericConstUsize, interned_bit},
 };
 use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec, view::BitView};
 use num_bigint::{BigInt, BigUint, Sign};
 use num_traits::{One, Signed, Zero};
 use serde::{
-    de::{DeserializeOwned, Error, Visitor},
     Deserialize, Deserializer, Serialize, Serializer,
+    de::{DeserializeOwned, Error, Visitor},
 };
 use std::{
     borrow::{BorrowMut, Cow},
@@ -224,11 +224,7 @@ impl<T: KnownSize> Size for T {
     }
 
     fn try_from_usize(v: usize) -> Option<Self::SizeType> {
-        if v == T::VALUE {
+        if v == T::VALUE { Some(T::SIZE) } else { None }
-            Some(T::SIZE)
-        } else {
-            None
-        }
     }
 }
 

crates/fayalite/src/int/uint_in_range.rs

@@ -4,20 +4,20 @@
 use crate::{
     bundle::{Bundle, BundleField, BundleType, BundleTypePropertiesBuilder, NoBuilder},
     expr::{
-        ops::{ExprCastTo, ExprPartialEq, ExprPartialOrd},
         CastBitsTo, CastTo, CastToBits, Expr, HdlPartialEq, HdlPartialOrd,
+        ops::{ExprCastTo, ExprPartialEq, ExprPartialOrd},
     },
     int::{Bool, DynSize, KnownSize, Size, SizeType, UInt, UIntType},
     intern::{Intern, Interned},
     phantom_const::PhantomConst,
     sim::value::{SimValue, SimValuePartialEq, ToSimValueWithType},
     source_location::SourceLocation,
-    ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties},
+    ty::{CanonicalType, StaticType, Type, TypeProperties, impl_match_variant_as_self},
 };
 use bitvec::{order::Lsb0, slice::BitSlice, view::BitView};
 use serde::{
-    de::{value::UsizeDeserializer, Error, Visitor},
     Deserialize, Deserializer, Serialize, Serializer,
+    de::{Error, Visitor, value::UsizeDeserializer},
 };
 use std::{fmt, marker::PhantomData, ops::Index};
 
@@ -45,15 +45,18 @@ impl Type for UIntInRangeMaskType {
 
     fn from_canonical(canonical_type: CanonicalType) -> Self {
         let fields = Bundle::from_canonical(canonical_type).fields();
-        let [BundleField {
+        let [
-            name: value_name,
+            BundleField {
-            flipped: false,
+                name: value_name,
-            ty: value,
+                flipped: false,
-        }, BundleField {
+                ty: value,
-            name: range_name,
+            },
-            flipped: false,
+            BundleField {
-            ty: range,
+                name: range_name,
-        }] = *fields
+                flipped: false,
+                ty: range,
+            },
+        ] = *fields
         else {
             panic!("expected UIntInRangeMaskType");
         };
@@ -323,15 +326,18 @@ macro_rules! define_uint_in_range_type {
 
             fn from_canonical(canonical_type: CanonicalType) -> Self {
                 let fields = Bundle::from_canonical(canonical_type).fields();
-                let [BundleField {
+                let [
-                    name: value_name,
+                    BundleField {
-                    flipped: false,
+                        name: value_name,
-                    ty: value,
+                        flipped: false,
-                }, BundleField {
+                        ty: value,
-                    name: range_name,
+                    },
-                    flipped: false,
+                    BundleField {
-                    ty: range,
+                        name: range_name,
-                }] = *fields
+                        flipped: false,
+                        ty: range,
+                    },
+                ] = *fields
                 else {
                     panic!("expected {}", stringify!($UIntInRange));
                 };

crates/fayalite/src/memory.rs

@@ -7,7 +7,7 @@ use crate::{
     array::{Array, ArrayType},
     bundle::{Bundle, BundleType},
     clock::Clock,
-    expr::{ops::BundleLiteral, repeat, Expr, Flow, ToExpr, ToLiteralBits},
+    expr::{Expr, Flow, ToExpr, ToLiteralBits, ops::BundleLiteral, repeat},
     hdl,
     int::{Bool, DynSize, Size, UInt, UIntType},
     intern::{Intern, Interned},

crates/fayalite/src/module.rs

@@ -8,12 +8,12 @@ use crate::{
     clock::{Clock, ClockDomain},
     enum_::{Enum, EnumMatchVariantsIter, EnumType},
     expr::{
+        Expr, Flow, ToExpr,
         ops::VariantAccess,
         target::{
             GetTarget, Target, TargetBase, TargetPathArrayElement, TargetPathBundleField,
             TargetPathElement,
         },
-        Expr, Flow, ToExpr,
     },
     formal::FormalKind,
     int::{Bool, DynSize, Size},
@@ -1459,7 +1459,9 @@ impl TargetState {
                     })
                     .reduce(TargetWritten::conditional_merge_written)
                 else {
-                    unreachable!("merge_conditional_sub_blocks_into_block must be called with at least one sub-block");
+                    unreachable!(
+                        "merge_conditional_sub_blocks_into_block must be called with at least one sub-block"
+                    );
                 };
                 let mut written_in_blocks = written_in_blocks.borrow_mut();
                 if target_block >= written_in_blocks.len() {
@@ -2290,14 +2292,12 @@ pub fn annotate<T: Type>(target: Expr<T>, annotations: impl IntoAnnotations) {
         }
         TargetBase::MemPort(v) => {
             ModuleBuilder::with(|m| {
-                RefCell::borrow_mut(unwrap!(unwrap!(m
+                RefCell::borrow_mut(unwrap!(
-                    .impl_
+                    unwrap!(m.impl_.borrow_mut().body.builder_normal_body_opt())
-                    .borrow_mut()
+                        .body
-                    .body
+                        .memory_map
-                    .builder_normal_body_opt())
+                        .get_mut(&v.mem_name())
-                .body
+                ))
-                .memory_map
-                .get_mut(&v.mem_name())))
                 .port_annotations
                 .extend(annotations)
             });

crates/fayalite/src/module/transform/deduce_resets.rs

@@ -6,12 +6,12 @@ use crate::{
     bundle::{BundleField, BundleType},
     enum_::{EnumType, EnumVariant},
     expr::{
+        ExprEnum,
         ops::{self, ArrayLiteral},
         target::{
             Target, TargetBase, TargetChild, TargetPathArrayElement, TargetPathBundleField,
             TargetPathDynArrayElement, TargetPathElement,
         },
-        ExprEnum,
     },
     formal::FormalKind,
     int::{SIntValue, UIntValue},
@@ -41,10 +41,16 @@ impl fmt::Display for DeduceResetsError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             DeduceResetsError::ResetIsNotDrivenByAsyncOrSync { source_location } => {
-                write!(f, "deduce_reset failed: Reset signal is not driven by any AsyncReset or SyncReset signals: {source_location}")
+                write!(
+                    f,
+                    "deduce_reset failed: Reset signal is not driven by any AsyncReset or SyncReset signals: {source_location}"
+                )
             }
             DeduceResetsError::ResetIsDrivenByBothAsyncAndSync { source_location } => {
-                write!(f, "deduce_reset failed: Reset signal is driven by both AsyncReset and SyncReset signals: {source_location}")
+                write!(
+                    f,
+                    "deduce_reset failed: Reset signal is driven by both AsyncReset and SyncReset signals: {source_location}"
+                )
             }
         }
     }
@@ -2099,7 +2105,7 @@ impl<P: Pass> RunPass<P> for StmtDeclaration {
     ) -> Result<PassOutput<Self, P>, DeduceResetsError> {
         let (annotations, reg) = match self {
             StmtDeclaration::Wire(v) => {
-                return Ok(v.run_pass(pass_args)?.map(StmtDeclaration::Wire))
+                return Ok(v.run_pass(pass_args)?.map(StmtDeclaration::Wire));
             }
             &StmtDeclaration::Reg(StmtReg { annotations, reg }) => (annotations, AnyReg::from(reg)),
             &StmtDeclaration::RegSync(StmtReg { annotations, reg }) => {
@@ -2109,7 +2115,7 @@ impl<P: Pass> RunPass<P> for StmtDeclaration {
                 (annotations, AnyReg::from(reg))
             }
             StmtDeclaration::Instance(v) => {
-                return Ok(v.run_pass(pass_args)?.map(StmtDeclaration::Instance))
+                return Ok(v.run_pass(pass_args)?.map(StmtDeclaration::Instance));
             }
         };
         let annotations = annotations.run_pass(pass_args.as_mut())?;

crates/fayalite/src/module/transform/simplify_enums.rs

@@ -5,16 +5,16 @@ use crate::{
     bundle::{Bundle, BundleField, BundleType},
     enum_::{Enum, EnumType, EnumVariant},
     expr::{
-        ops::{self, EnumLiteral},
         CastBitsTo, CastTo, CastToBits, Expr, ExprEnum, HdlPartialEq, ToExpr,
+        ops::{self, EnumLiteral},
     },
     hdl,
     int::UInt,
     intern::{Intern, Interned, Memoize},
     memory::{DynPortType, Mem, MemPort},
     module::{
-        transform::visit::{Fold, Folder},
         Block, Id, Module, NameId, ScopedNameId, Stmt, StmtConnect, StmtIf, StmtMatch, StmtWire,
+        transform::visit::{Fold, Folder},
     },
     source_location::SourceLocation,
     ty::{CanonicalType, Type},
@@ -810,7 +810,7 @@ impl Folder for State {
                             .unwrap()
                             .gen_name(&format!(
                                 "{}_{}",
-                                memory.scoped_name().1 .0,
+                                memory.scoped_name().1.0,
                                 port.port_name()
                             )),
                         port.source_location(),

crates/fayalite/src/module/transform/simplify_memories.rs

@@ -9,8 +9,8 @@ use crate::{
     intern::{Intern, Interned},
     memory::{Mem, MemPort, PortType},
     module::{
-        transform::visit::{Fold, Folder},
         Block, Id, Module, NameId, ScopedNameId, Stmt, StmtConnect, StmtWire,
+        transform::visit::{Fold, Folder},
     },
     source_location::SourceLocation,
     ty::{CanonicalType, Type},
@@ -634,7 +634,7 @@ impl ModuleState {
         split_state: &SplitState<'_>,
     ) -> Mem {
         let mem_name = NameId(
-            Intern::intern_owned(format!("{}{mem_name_path}", input_mem.scoped_name().1 .0)),
+            Intern::intern_owned(format!("{}{mem_name_path}", input_mem.scoped_name().1.0)),
             Id::new(),
         );
         let mem_name = ScopedNameId(input_mem.scoped_name().0, mem_name);

crates/fayalite/src/module/transform/visit.rs

@@ -11,12 +11,11 @@ use crate::{
     clock::Clock,
     enum_::{Enum, EnumType, EnumVariant},
     expr::{
-        ops,
+        Expr, ExprEnum, ops,
         target::{
             Target, TargetBase, TargetChild, TargetPathArrayElement, TargetPathBundleField,
             TargetPathDynArrayElement, TargetPathElement,
         },
-        Expr, ExprEnum,
     },
     formal::FormalKind,
     int::{Bool, SIntType, SIntValue, Size, UIntType, UIntValue},

crates/fayalite/src/phantom_const.rs

@@ -3,23 +3,22 @@
 
 use crate::{
     expr::{
-        ops::{ExprPartialEq, ExprPartialOrd},
         Expr, ToExpr,
+        ops::{ExprPartialEq, ExprPartialOrd},
     },
     int::Bool,
     intern::{Intern, Interned, InternedCompare, LazyInterned, LazyInternedTrait, Memoize},
     sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType},
     source_location::SourceLocation,
     ty::{
-        impl_match_variant_as_self,
+        CanonicalType, StaticType, Type, TypeProperties, impl_match_variant_as_self,
         serde_impls::{SerdeCanonicalType, SerdePhantomConst},
-        CanonicalType, StaticType, Type, TypeProperties,
     },
 };
 use bitvec::slice::BitSlice;
 use serde::{
-    de::{DeserializeOwned, Error},
     Deserialize, Deserializer, Serialize, Serializer,
+    de::{DeserializeOwned, Error},
 };
 use std::{
     any::Any,

crates/fayalite/src/prelude.rs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 pub use crate::{
+    __,
     annotations::{
         BlackBoxInlineAnnotation, BlackBoxPathAnnotation, CustomFirrtlAnnotation,
         DocStringAnnotation, DontTouchAnnotation, SVAttributeAnnotation,
@@ -11,33 +12,32 @@ pub use crate::{
     clock::{Clock, ClockDomain, ToClock},
     enum_::{Enum, HdlNone, HdlOption, HdlSome},
     expr::{
-        repeat, CastBitsTo, CastTo, CastToBits, Expr, HdlPartialEq, HdlPartialOrd, MakeUninitExpr,
+        CastBitsTo, CastTo, CastToBits, Expr, HdlPartialEq, HdlPartialOrd, MakeUninitExpr,
-        ReduceBits, ToExpr,
+        ReduceBits, ToExpr, repeat,
     },
     formal::{
-        all_const, all_seq, any_const, any_seq, formal_global_clock, formal_reset, hdl_assert,
+        MakeFormalExpr, all_const, all_seq, any_const, any_seq, formal_global_clock, formal_reset,
-        hdl_assert_with_enable, hdl_assume, hdl_assume_with_enable, hdl_cover,
+        hdl_assert, hdl_assert_with_enable, hdl_assume, hdl_assume_with_enable, hdl_cover,
-        hdl_cover_with_enable, MakeFormalExpr,
+        hdl_cover_with_enable,
     },
     hdl, hdl_module,
     int::{Bool, DynSize, KnownSize, SInt, SIntType, SIntValue, Size, UInt, UIntType, UIntValue},
     memory::{Mem, MemBuilder, ReadUnderWrite},
     module::{
-        annotate, connect, connect_any, incomplete_wire, instance, memory, memory_array,
+        Instance, Module, ModuleBuilder, annotate, connect, connect_any, incomplete_wire, instance,
-        memory_with_init, reg_builder, wire, Instance, Module, ModuleBuilder,
+        memory, memory_array, memory_with_init, reg_builder, wire,
     },
     phantom_const::PhantomConst,
     reg::Reg,
     reset::{AsyncReset, Reset, SyncReset, ToAsyncReset, ToReset, ToSyncReset},
     sim::{
+        ExternModuleSimulationState, Simulation,
         time::{SimDuration, SimInstant},
         value::{SimValue, ToSimValue, ToSimValueWithType},
-        ExternModuleSimulationState, Simulation,
     },
     source_location::SourceLocation,
     ty::{AsMask, CanonicalType, Type},
     util::{ConstUsize, GenericConstUsize},
     wire::Wire,
-    __,
 };
 pub use bitvec::{slice::BitSlice, vec::BitVec};

crates/fayalite/src/reset.rs

@@ -2,10 +2,10 @@
 // See Notices.txt for copyright information
 use crate::{
     clock::Clock,
-    expr::{ops, Expr, ToExpr},
+    expr::{Expr, ToExpr, ops},
     int::{Bool, SInt, UInt},
     source_location::SourceLocation,
-    ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties},
+    ty::{CanonicalType, StaticType, Type, TypeProperties, impl_match_variant_as_self},
 };
 use bitvec::slice::BitSlice;
 

crates/fayalite/src/sim.rs

@@ -7,12 +7,11 @@ use crate::{
     bundle::{BundleField, BundleType},
     enum_::{EnumType, EnumVariant},
     expr::{
-        ops,
+        ExprEnum, Flow, ToLiteralBits, ops,
         target::{
             GetTarget, Target, TargetBase, TargetPathArrayElement, TargetPathBundleField,
             TargetPathElement,
         },
-        ExprEnum, Flow, ToLiteralBits,
     },
     int::{BoolOrIntType, UIntValue},
     intern::{
@@ -20,10 +19,10 @@ use crate::{
     },
     memory::PortKind,
     module::{
-        transform::deduce_resets::deduce_resets, AnnotatedModuleIO, Block, ExternModuleBody, Id,
+        AnnotatedModuleIO, Block, ExternModuleBody, Id, InstantiatedModule, ModuleBody, NameId,
-        InstantiatedModule, ModuleBody, NameId, NormalModuleBody, ScopedNameId, Stmt, StmtConnect,
+        NormalModuleBody, ScopedNameId, Stmt, StmtConnect, StmtDeclaration, StmtFormal, StmtIf,
-        StmtDeclaration, StmtFormal, StmtIf, StmtInstance, StmtMatch, StmtReg, StmtWire,
+        StmtInstance, StmtMatch, StmtReg, StmtWire, TargetInInstantiatedModule,
-        TargetInInstantiatedModule,
+        transform::deduce_resets::deduce_resets,
     },
     prelude::*,
     reset::{ResetType, ResetTypeDispatch},
@@ -4569,7 +4568,7 @@ impl Compiler {
                 )
             })
             .unzip();
-        let name = mem.scoped_name().1 .0;
+        let name = mem.scoped_name().1.0;
         let id = TraceMemoryId(self.memories.len());
         let stride = mem.array_type().element().bit_width();
         let trace = TraceMem {
@@ -5597,7 +5596,7 @@ trait TraceWriterDynTrait: fmt::Debug + 'static {
     fn set_signal_clock_dyn(&mut self, id: TraceScalarId, value: bool) -> std::io::Result<()>;
     fn set_signal_sync_reset_dyn(&mut self, id: TraceScalarId, value: bool) -> std::io::Result<()>;
     fn set_signal_async_reset_dyn(&mut self, id: TraceScalarId, value: bool)
-        -> std::io::Result<()>;
+    -> std::io::Result<()>;
     fn set_signal_enum_discriminant_dyn(
         &mut self,
         id: TraceScalarId,
@@ -6284,8 +6283,8 @@ impl EarliestWaitTargets {
     fn iter<'a>(
         &'a self,
     ) -> impl Clone
-           + Iterator<Item = WaitTarget<CompiledValue<CanonicalType>, &'a SimValue<CanonicalType>>>
+    + Iterator<Item = WaitTarget<CompiledValue<CanonicalType>, &'a SimValue<CanonicalType>>>
-           + 'a {
+    + 'a {
         self.settle
             .then_some(WaitTarget::Settle)
             .into_iter()
@@ -6728,7 +6727,10 @@ impl SimulationImpl {
                 let this = &mut *self;
                 let mut sim = this.sim.borrow_mut();
                 let sim = &mut *sim;
-                assert!(cx.waker().will_wake(&sim.generator_waker), "can't use ExternModuleSimulationState's methods outside of ExternModuleSimulation");
+                assert!(
+                    cx.waker().will_wake(&sim.generator_waker),
+                    "can't use ExternModuleSimulationState's methods outside of ExternModuleSimulation"
+                );
                 this.targets.convert_earlier_instants_to_settle(sim.instant);
                 if this.targets.is_empty() {
                     this.targets.settle = true;
@@ -7753,9 +7755,9 @@ impl<Args: Clone, Fut> Clone for SimGeneratorFn<Args, Fut> {
 impl<Args: Copy, Fut> Copy for SimGeneratorFn<Args, Fut> {}
 
 impl<
-        T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static,
+    T: fmt::Debug + Clone + Eq + Hash + Send + Sync + 'static,
-        Fut: IntoFuture<Output = ()> + 'static,
+    Fut: IntoFuture<Output = ()> + 'static,
-    > ExternModuleSimGenerator for SimGeneratorFn<T, Fut>
+> ExternModuleSimGenerator for SimGeneratorFn<T, Fut>
 {
     fn run<'a>(&'a self, sim: ExternModuleSimulationState) -> impl IntoFuture<Output = ()> + 'a {
         (self.f)(self.args.clone(), sim)
@@ -7764,7 +7766,7 @@ impl<
 
 trait DynExternModuleSimGenerator: Any + Send + Sync + SupportsPtrEqWithTypeId + fmt::Debug {
     fn dyn_run<'a>(&'a self, sim: ExternModuleSimulationState)
-        -> Box<dyn Future<Output = ()> + 'a>;
+    -> Box<dyn Future<Output = ()> + 'a>;
 }
 
 impl<T: ExternModuleSimGenerator> DynExternModuleSimGenerator for T {

crates/fayalite/src/sim/value.rs

@@ -11,8 +11,8 @@ use crate::{
     reset::{AsyncReset, Reset, SyncReset},
     ty::{CanonicalType, StaticType, Type},
     util::{
-        alternating_cell::{AlternatingCell, AlternatingCellMethods},
         ConstUsize,
+        alternating_cell::{AlternatingCell, AlternatingCellMethods},
     },
 };
 use bitvec::{slice::BitSlice, vec::BitVec};

crates/fayalite/src/sim/vcd.rs

@@ -7,12 +7,12 @@ use crate::{
     int::UInt,
     intern::{Intern, Interned},
     sim::{
-        time::{SimDuration, SimInstant},
         TraceArray, TraceAsyncReset, TraceBool, TraceBundle, TraceClock, TraceDecl,
         TraceEnumDiscriminant, TraceEnumWithFields, TraceFieldlessEnum, TraceInstance,
         TraceLocation, TraceMem, TraceMemPort, TraceMemoryId, TraceMemoryLocation, TraceModule,
         TraceModuleIO, TraceReg, TraceSInt, TraceScalar, TraceScalarId, TraceScope, TraceSyncReset,
         TraceUInt, TraceWire, TraceWriter, TraceWriterDecls,
+        time::{SimDuration, SimInstant},
     },
     util::HashMap,
 };

crates/fayalite/src/ty.rs

@@ -16,7 +16,7 @@ use crate::{
     util::ConstUsize,
 };
 use bitvec::slice::BitSlice;
-use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Deserializer, Serialize, Serializer, de::DeserializeOwned};
 use std::{fmt, hash::Hash, iter::FusedIterator, ops::Index, sync::Arc};
 
 pub(crate) mod serde_impls;
@@ -334,16 +334,16 @@ pub trait Type:
     type MatchVariant: 'static + Send + Sync;
     type MatchActiveScope;
     type MatchVariantAndInactiveScope: MatchVariantAndInactiveScope<
-        MatchVariant = Self::MatchVariant,
+            MatchVariant = Self::MatchVariant,
-        MatchActiveScope = Self::MatchActiveScope,
+            MatchActiveScope = Self::MatchActiveScope,
-    >;
+        >;
     type MatchVariantsIter: Iterator<Item = Self::MatchVariantAndInactiveScope>
         + ExactSizeIterator
         + FusedIterator
         + DoubleEndedIterator;
     #[track_caller]
     fn match_variants(this: Expr<Self>, source_location: SourceLocation)
-        -> Self::MatchVariantsIter;
+    -> Self::MatchVariantsIter;
     fn mask_type(&self) -> Self::MaskType;
     fn canonical(&self) -> CanonicalType;
     fn from_canonical(canonical_type: CanonicalType) -> Self;

crates/fayalite/src/util/const_bool.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use serde::{
-    de::{DeserializeOwned, Error, Unexpected},
     Deserialize, Deserializer, Serialize, Serializer,
+    de::{DeserializeOwned, Error, Unexpected},
 };
 use std::{fmt::Debug, hash::Hash, mem::ManuallyDrop, ptr};
 

crates/fayalite/src/util/const_usize.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use serde::{
-    de::{DeserializeOwned, Error, Unexpected},
     Deserialize, Deserializer, Serialize, Serializer,
+    de::{DeserializeOwned, Error, Unexpected},
 };
 use std::{fmt::Debug, hash::Hash};