diff --git a/crates/fayalite-proc-macros-impl/src/fold.rs b/crates/fayalite-proc-macros-impl/src/fold.rs
index 6175914..1e1ff42 100644
--- a/crates/fayalite-proc-macros-impl/src/fold.rs
+++ b/crates/fayalite-proc-macros-impl/src/fold.rs
@@ -248,5 +248,6 @@ no_op_fold!(syn::Token![enum]);
 no_op_fold!(syn::Token![extern]);
 no_op_fold!(syn::Token![let]);
 no_op_fold!(syn::Token![mut]);
+no_op_fold!(syn::Token![static]);
 no_op_fold!(syn::Token![struct]);
 no_op_fold!(syn::Token![where]);
diff --git a/crates/fayalite-proc-macros-impl/src/lib.rs b/crates/fayalite-proc-macros-impl/src/lib.rs
index 3a4a326..920a27b 100644
--- a/crates/fayalite-proc-macros-impl/src/lib.rs
+++ b/crates/fayalite-proc-macros-impl/src/lib.rs
@@ -20,7 +20,7 @@ mod value_derive_struct;
 
 mod kw {
     pub(crate) use syn::token::{
-        Enum as enum_, Extern as extern_, Struct as struct_, Where as where_,
+        Enum as enum_, Extern as extern_, Static as static_, Struct as struct_, Where as where_,
     };
 
     macro_rules! custom_keyword {
@@ -43,7 +43,6 @@ mod kw {
 
     custom_keyword!(clock_domain);
     custom_keyword!(connect_inexact);
-    custom_keyword!(fixed_type);
     custom_keyword!(flip);
     custom_keyword!(hdl);
     custom_keyword!(input);
diff --git a/crates/fayalite-proc-macros-impl/src/module.rs b/crates/fayalite-proc-macros-impl/src/module.rs
index b490096..ff5c1e5 100644
--- a/crates/fayalite-proc-macros-impl/src/module.rs
+++ b/crates/fayalite-proc-macros-impl/src/module.rs
@@ -312,9 +312,9 @@ impl ModuleFn {
             #body_fn
             ::fayalite::module::ModuleBuilder::run(#fn_name_str, |m| __body #body_turbofish_type_generics(m, #(#param_names,)*))
         }};
-        let fixed_type = io.iter().all(|io| io.kind.ty_expr.is_none());
-        let struct_options = if fixed_type {
-            quote! { #[hdl(fixed_type)] }
+        let static_type = io.iter().all(|io| io.kind.ty_expr.is_none());
+        let struct_options = if static_type {
+            quote! { #[hdl(static)] }
         } else {
             quote! {}
         };
diff --git a/crates/fayalite-proc-macros-impl/src/module/transform_body.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body.rs
index 13a7362..d2b3e77 100644
--- a/crates/fayalite-proc-macros-impl/src/module/transform_body.rs
+++ b/crates/fayalite-proc-macros-impl/src/module/transform_body.rs
@@ -1003,10 +1003,10 @@ fn wrap_ty_with_expr(ty: impl ToTokens) -> Type {
     }
 }
 
-fn unwrap_or_fixed_type(expr: Option<impl ToTokens>, span: Span) -> TokenStream {
+fn unwrap_or_static_type(expr: Option<impl ToTokens>, span: Span) -> TokenStream {
     expr.map(ToTokens::into_token_stream).unwrap_or_else(|| {
         quote_spanned! {span=>
-            ::fayalite::ty::FixedType::fixed_type()
+            ::fayalite::ty::StaticType::static_type()
         }
     })
 }
@@ -1109,7 +1109,7 @@ impl Visitor {
         let m = hdl_let.kind.m;
         let dot = hdl_let.kind.dot_token;
         let kind = hdl_let.kind.kind;
-        let ty_expr = unwrap_or_fixed_type(hdl_let.kind.ty_expr.as_ref(), kind.span());
+        let ty_expr = unwrap_or_static_type(hdl_let.kind.ty_expr.as_ref(), kind.span());
         let mut expr = quote! {#m #dot #kind};
         hdl_let.kind.paren.surround(&mut expr, |expr| {
             let name_str = ImplicitName {
@@ -1214,7 +1214,7 @@ impl Visitor {
                 paren,
                 ty_expr,
             } => {
-                let ty_expr = unwrap_or_fixed_type(ty_expr.as_ref(), reg_builder.span());
+                let ty_expr = unwrap_or_static_type(ty_expr.as_ref(), reg_builder.span());
                 dot_token.to_tokens(&mut expr);
                 no_reset.to_tokens(&mut expr);
                 paren.surround(&mut expr, |expr| ty_expr.to_tokens(expr));
@@ -1248,7 +1248,7 @@ impl Visitor {
         let dot = hdl_let.kind.dot_token;
         let wire = hdl_let.kind.wire;
         self.require_normal_module(wire);
-        let ty_expr = unwrap_or_fixed_type(hdl_let.kind.ty_expr.as_ref(), wire.span());
+        let ty_expr = unwrap_or_static_type(hdl_let.kind.ty_expr.as_ref(), wire.span());
         let mut expr = quote! {#m #dot #wire};
         hdl_let.kind.paren.surround(&mut expr, |expr| {
             let name_str = ImplicitName {
@@ -1290,14 +1290,14 @@ impl Visitor {
                 memory,
                 paren,
                 ty_expr,
-            } => (paren, unwrap_or_fixed_type(ty_expr.as_ref(), memory.span())),
+            } => (paren, unwrap_or_static_type(ty_expr.as_ref(), memory.span())),
             MemoryFn::MemoryArray {
                 memory_array,
                 paren,
                 ty_expr,
             } => (
                 paren,
-                unwrap_or_fixed_type(ty_expr.as_ref(), memory_array.span()),
+                unwrap_or_static_type(ty_expr.as_ref(), memory_array.span()),
             ),
             MemoryFn::MemoryWithInit {
                 memory_with_init: _,
diff --git a/crates/fayalite-proc-macros-impl/src/value_derive_common.rs b/crates/fayalite-proc-macros-impl/src/value_derive_common.rs
index 0ceac12..68532e7 100644
--- a/crates/fayalite-proc-macros-impl/src/value_derive_common.rs
+++ b/crates/fayalite-proc-macros-impl/src/value_derive_common.rs
@@ -167,46 +167,46 @@ pub(crate) fn get_target(target: &Option<(kw::target, Paren, Path)>, item_ident:
 
 pub(crate) struct ValueDeriveGenerics {
     pub(crate) generics: Generics,
-    pub(crate) fixed_type_generics: Generics,
+    pub(crate) static_type_generics: Generics,
 }
 
 impl ValueDeriveGenerics {
     pub(crate) fn get(mut generics: Generics, where_: &Option<(Where, Paren, Bounds)>) -> Self {
-        let mut fixed_type_generics = generics.clone();
+        let mut static_type_generics = generics.clone();
         if let Some((_, _, bounds)) = where_ {
             generics
                 .make_where_clause()
                 .predicates
                 .extend(bounds.0.iter().cloned());
-            fixed_type_generics
+            static_type_generics
                 .where_clause
                 .clone_from(&generics.where_clause);
         } else {
             let type_params = Vec::from_iter(generics.type_params().map(|v| v.ident.clone()));
             let predicates = &mut generics.make_where_clause().predicates;
-            let fixed_type_predicates = &mut fixed_type_generics.make_where_clause().predicates;
+            let static_type_predicates = &mut static_type_generics.make_where_clause().predicates;
             for type_param in type_params {
                 predicates.push(parse_quote! {#type_param: ::fayalite::ty::Value});
                 predicates.push(parse_quote! {
                     <#type_param as ::fayalite::expr::ToExpr>::Type:
                         ::fayalite::ty::Type<Value = #type_param>
                 });
-                fixed_type_predicates.push(parse_quote! {#type_param: ::fayalite::ty::Value});
-                fixed_type_predicates.push(parse_quote! {
+                static_type_predicates.push(parse_quote! {#type_param: ::fayalite::ty::Value});
+                static_type_predicates.push(parse_quote! {
                     <#type_param as ::fayalite::expr::ToExpr>::Type:
-                        ::fayalite::ty::FixedType<Value = #type_param>
+                        ::fayalite::ty::StaticType<Value = #type_param>
                 });
-                fixed_type_predicates.push(parse_quote! {
+                static_type_predicates.push(parse_quote! {
                     <
                         <#type_param as ::fayalite::expr::ToExpr>::Type
                         as ::fayalite::ty::Type
-                    >::MaskType: ::fayalite::ty::FixedType
+                    >::MaskType: ::fayalite::ty::StaticType
                 });
             }
         }
         Self {
             generics,
-            fixed_type_generics,
+            static_type_generics,
         }
     }
 }
diff --git a/crates/fayalite-proc-macros-impl/src/value_derive_enum.rs b/crates/fayalite-proc-macros-impl/src/value_derive_enum.rs
index 27a2974..87f53c1 100644
--- a/crates/fayalite-proc-macros-impl/src/value_derive_enum.rs
+++ b/crates/fayalite-proc-macros-impl/src/value_derive_enum.rs
@@ -152,7 +152,7 @@ impl ParsedVariant {
                     parsed_struct: ParsedStruct {
                         options: StructOptions {
                             outline_generated: None,
-                            fixed_type: Some(Default::default()),
+                            static_: Some(Default::default()),
                             where_: Some((
                                 Default::default(),
                                 Default::default(),
@@ -160,7 +160,7 @@ impl ParsedVariant {
                                     enum_generics.clone(),
                                     &enum_options.where_,
                                 )
-                                .fixed_type_generics
+                                .static_type_generics
                                 .where_clause
                                 .into(),
                             )),
@@ -275,10 +275,10 @@ impl ToTokens for ParsedEnum {
         let target = get_target(target, enum_ident);
         let ValueDeriveGenerics {
             generics: _,
-            fixed_type_generics,
+            static_type_generics,
         } = ValueDeriveGenerics::get(enum_generics.clone(), where_);
-        let (fixed_type_impl_generics, fixed_type_type_generics, fixed_type_where_clause) =
-            fixed_type_generics.split_for_impl();
+        let (static_type_impl_generics, static_type_type_generics, static_type_where_clause) =
+            static_type_generics.split_for_impl();
         let type_struct_ident = format_ident!("__{}__Type", enum_ident);
         let mut field_checks = vec![];
         let mut make_type_struct_variant_type = |variant: &ParsedVariant| {
@@ -303,7 +303,7 @@ impl ToTokens for ParsedEnum {
             let mut field_names = Vec::from_iter(get_field_names(&value_struct.fields));
             derive_clone_hash_eq_partialeq_for_struct(
                 &value_struct.ident,
-                &fixed_type_generics,
+                &static_type_generics,
                 &field_names,
             )
             .to_tokens(tokens);
@@ -334,9 +334,9 @@ impl ToTokens for ParsedEnum {
             let value_struct_ident = &value_struct.ident;
             quote! {
                 #[automatically_derived]
-                impl #fixed_type_impl_generics ::fayalite::__std::fmt::Debug
-                    for #value_struct_ident #fixed_type_type_generics
-                #fixed_type_where_clause
+                impl #static_type_impl_generics ::fayalite::__std::fmt::Debug
+                    for #value_struct_ident #static_type_type_generics
+                #static_type_where_clause
                 {
                     fn fmt(
                         &self,
@@ -349,7 +349,7 @@ impl ToTokens for ParsedEnum {
             .to_tokens(tokens);
             Some(parse_quote! {
                 <
-                    #value_struct_ident #fixed_type_type_generics
+                    #value_struct_ident #static_type_type_generics
                     as ::fayalite::expr::ToExpr
                 >::Type
             })
@@ -373,7 +373,7 @@ impl ToTokens for ParsedEnum {
             vis: vis.clone(),
             struct_token: Token![struct](enum_token.span),
             ident: type_struct_ident,
-            generics: fixed_type_generics.clone(),
+            generics: static_type_generics.clone(),
             fields: Fields::Named(FieldsNamed {
                 brace_token: *brace_token,
                 named: type_struct_variants,
@@ -398,7 +398,7 @@ impl ToTokens for ParsedEnum {
         };
         derive_clone_hash_eq_partialeq_for_struct(
             type_struct_ident,
-            &fixed_type_generics,
+            &static_type_generics,
             &non_empty_variant_names,
         )
         .to_tokens(tokens);
@@ -432,7 +432,7 @@ impl ToTokens for ParsedEnum {
                             .last()
                             .expect("missing phantom field")
                             .name;
-                        let type_generics = fixed_type_type_generics.as_turbofish();
+                        let type_generics = static_type_type_generics.as_turbofish();
                         quote! {
                             ::fayalite::__std::option::Option::Some(
                                 ::fayalite::ty::DynValueTrait::to_canonical_dyn(
@@ -628,7 +628,7 @@ impl ToTokens for ParsedEnum {
                     #variant_index => {
                         let __variant_access = ::fayalite::expr::ToExpr::to_expr(
                             &__variant_access.downcast_unchecked::<<
-                                #ident #fixed_type_type_generics
+                                #ident #static_type_type_generics
                                 as ::fayalite::expr::ToExpr
                             >::Type>(),
                         );
@@ -660,11 +660,11 @@ impl ToTokens for ParsedEnum {
                     {
                         ::fayalite::expr::ToExpr::to_expr(
                             &::fayalite::expr::ops::EnumLiteral::<
-                                #type_struct_ident #fixed_type_type_generics
+                                #type_struct_ident #static_type_type_generics
                             >::new_unchecked(
                                 ::fayalite::__std::option::Option::None,
                                 #variant_index,
-                                ::fayalite::ty::FixedType::fixed_type(),
+                                ::fayalite::ty::StaticType::static_type(),
                             ),
                         )
                     }
@@ -673,13 +673,13 @@ impl ToTokens for ParsedEnum {
                     {
                         ::fayalite::expr::ToExpr::to_expr(
                             &::fayalite::expr::ops::EnumLiteral::<
-                                #type_struct_ident #fixed_type_type_generics
+                                #type_struct_ident #static_type_type_generics
                             >::new_unchecked(
                                 ::fayalite::__std::option::Option::Some(
                                     #(#builder_field_vars)*.to_canonical_dyn(),
                                 ),
                                 #variant_index,
-                                ::fayalite::ty::FixedType::fixed_type(),
+                                ::fayalite::ty::StaticType::static_type(),
                             ),
                         )
                     }
@@ -698,19 +698,19 @@ impl ToTokens for ParsedEnum {
                 } => parse_quote! {
                     {
                         let __builder = <
-                            #field_type_struct_ident #fixed_type_type_generics
+                            #field_type_struct_ident #static_type_type_generics
                             as ::fayalite::bundle::BundleType
                         >::builder();
                         #(let __builder = __builder.#builder_field_vars(#builder_field_vars);)*
                         ::fayalite::expr::ToExpr::to_expr(
                             &::fayalite::expr::ops::EnumLiteral::<
-                                #type_struct_ident #fixed_type_type_generics
+                                #type_struct_ident #static_type_type_generics
                             >::new_unchecked(
                                 ::fayalite::__std::option::Option::Some(
                                     __builder.build().to_canonical_dyn(),
                                 ),
                                 #variant_index,
-                                ::fayalite::ty::FixedType::fixed_type(),
+                                ::fayalite::ty::StaticType::static_type(),
                             ),
                         )
                     }
@@ -730,9 +730,9 @@ impl ToTokens for ParsedEnum {
                             (name.clone(), parse_quote! { ::fayalite::expr::Expr<#ty> })
                         },
                     ),
-                    &fixed_type_generics,
-                    &parse_quote! {#type_struct_ident #fixed_type_type_generics},
-                    &parse_quote! { ::fayalite::expr::Expr<#target #fixed_type_type_generics> },
+                    &static_type_generics,
+                    &parse_quote! {#type_struct_ident #static_type_type_generics},
+                    &parse_quote! { ::fayalite::expr::Expr<#target #static_type_type_generics> },
                     build_body,
                 )
                 .to_tokens(tokens);
@@ -742,7 +742,7 @@ impl ToTokens for ParsedEnum {
             vis: vis.clone(),
             enum_token: *enum_token,
             ident: match_enum_ident,
-            generics: fixed_type_generics.clone(),
+            generics: static_type_generics.clone(),
             brace_token: *brace_token,
             variants: match_enum_variants,
         };
@@ -750,7 +750,7 @@ impl ToTokens for ParsedEnum {
         match_enum.to_tokens(tokens);
         make_connect_impl(
             *connect_inexact,
-            &fixed_type_generics,
+            &static_type_generics,
             type_struct_ident,
             variants.iter().flat_map(|variant| {
                 variant.fields.iter().map(|field| {
@@ -766,9 +766,9 @@ impl ToTokens for ParsedEnum {
         let empty_builder_ty = builder.ty([], Some(&parse_quote! { Self }), false);
         quote! {
             #[automatically_derived]
-            impl #fixed_type_impl_generics ::fayalite::__std::fmt::Debug
-                for #match_enum_ident #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::__std::fmt::Debug
+                for #match_enum_ident #static_type_type_generics
+            #static_type_where_clause
             {
                 fn fmt(
                     &self,
@@ -781,13 +781,13 @@ impl ToTokens for ParsedEnum {
             }
 
             #[automatically_derived]
-            impl #fixed_type_impl_generics ::fayalite::ty::FixedType
-                for #type_struct_ident #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::ty::StaticType
+                for #type_struct_ident #static_type_type_generics
+            #static_type_where_clause
             {
-                fn fixed_type() -> Self {
+                fn static_type() -> Self {
                     Self {
-                        #(#non_empty_variant_names: ::fayalite::ty::FixedType::fixed_type(),)*
+                        #(#non_empty_variant_names: ::fayalite::ty::StaticType::static_type(),)*
                     }
                 }
             }
@@ -796,16 +796,16 @@ impl ToTokens for ParsedEnum {
             where
                 <T as ::fayalite::expr::ToExpr>::Type: ::fayalite::ty::Type<Value = T>,
             {}
-            fn __check_fields #fixed_type_impl_generics(_: #target #fixed_type_type_generics)
-            #fixed_type_where_clause
+            fn __check_fields #static_type_impl_generics(_: #target #static_type_type_generics)
+            #static_type_where_clause
             {
                 #(#field_checks)*
             }
 
             #[automatically_derived]
-            impl #fixed_type_impl_generics ::fayalite::__std::fmt::Debug
-                for #type_struct_ident #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::__std::fmt::Debug
+                for #type_struct_ident #static_type_type_generics
+            #static_type_where_clause
             {
                 fn fmt(
                     &self,
@@ -816,16 +816,16 @@ impl ToTokens for ParsedEnum {
             }
 
             #[automatically_derived]
-            impl #fixed_type_impl_generics ::fayalite::ty::Type
-                for #type_struct_ident #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::ty::Type
+                for #type_struct_ident #static_type_type_generics
+            #static_type_where_clause
             {
                 type CanonicalType = ::fayalite::enum_::DynEnumType;
-                type Value = #target #fixed_type_type_generics;
+                type Value = #target #static_type_type_generics;
                 type CanonicalValue = ::fayalite::enum_::DynEnum;
                 type MaskType = ::fayalite::int::UIntType<1>;
                 type MaskValue = ::fayalite::int::UInt<1>;
-                type MatchVariant = #match_enum_ident #fixed_type_type_generics;
+                type MatchVariant = #match_enum_ident #static_type_type_generics;
                 type MatchActiveScope = ::fayalite::module::Scope;
                 type MatchVariantAndInactiveScope =
                     ::fayalite::enum_::EnumMatchVariantAndInactiveScope<Self>;
@@ -871,9 +871,9 @@ impl ToTokens for ParsedEnum {
 
             #[automatically_derived]
             #[allow(clippy::init_numbered_fields)]
-            impl #fixed_type_impl_generics ::fayalite::enum_::EnumType
-                for #type_struct_ident #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::enum_::EnumType
+                for #type_struct_ident #static_type_type_generics
+            #static_type_where_clause
             {
                 type Builder = #empty_builder_ty;
                 fn match_activate_scope(
@@ -907,13 +907,13 @@ impl ToTokens for ParsedEnum {
             }
 
             #[automatically_derived]
-            impl #fixed_type_impl_generics ::fayalite::expr::ToExpr
-                for #target #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::expr::ToExpr
+                for #target #static_type_type_generics
+            #static_type_where_clause
             {
-                type Type = #type_struct_ident #fixed_type_type_generics;
+                type Type = #type_struct_ident #static_type_type_generics;
                 fn ty(&self) -> <Self as ::fayalite::expr::ToExpr>::Type {
-                    ::fayalite::ty::FixedType::fixed_type()
+                    ::fayalite::ty::StaticType::static_type()
                 }
                 fn to_expr(&self) -> ::fayalite::expr::Expr<Self> {
                     ::fayalite::expr::Expr::from_value(self)
@@ -921,9 +921,9 @@ impl ToTokens for ParsedEnum {
             }
 
             #[automatically_derived]
-            impl #fixed_type_impl_generics ::fayalite::ty::Value
-                for #target #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::ty::Value
+                for #target #static_type_type_generics
+            #static_type_where_clause
             {
                 fn to_canonical(&self) -> <
                         <Self as ::fayalite::expr::ToExpr>::Type
@@ -944,9 +944,9 @@ impl ToTokens for ParsedEnum {
             }
 
             #[automatically_derived]
-            impl #fixed_type_impl_generics ::fayalite::enum_::EnumValue
-                for #target #fixed_type_type_generics
-            #fixed_type_where_clause
+            impl #static_type_impl_generics ::fayalite::enum_::EnumValue
+                for #target #static_type_type_generics
+            #static_type_where_clause
             {
             }
         }
diff --git a/crates/fayalite-proc-macros-impl/src/value_derive_struct.rs b/crates/fayalite-proc-macros-impl/src/value_derive_struct.rs
index 6363b55..a0b303a 100644
--- a/crates/fayalite-proc-macros-impl/src/value_derive_struct.rs
+++ b/crates/fayalite-proc-macros-impl/src/value_derive_struct.rs
@@ -18,7 +18,7 @@ crate::options! {
     #[options = StructOptions]
     pub(crate) enum StructOption {
         OutlineGenerated(outline_generated),
-        FixedType(fixed_type),
+        Static(static_),
         ConnectInexact(connect_inexact),
         Bounds(where_, Bounds),
         Target(target, Path),
@@ -136,12 +136,12 @@ impl ParsedStruct {
             outline_generated: _,
             where_,
             target: _,
-            fixed_type,
+            static_,
             connect_inexact,
         } = &options.body;
         let ValueDeriveGenerics {
             generics,
-            fixed_type_generics,
+            static_type_generics,
         } = ValueDeriveGenerics::get(generics.clone(), where_);
         let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
         let unskipped_fields = fields
@@ -373,16 +373,17 @@ impl ParsedStruct {
                 __check_field(#check_v.#name);
             }
         }));
-        if fixed_type.is_some() {
-            let (impl_generics, type_generics, where_clause) = fixed_type_generics.split_for_impl();
+        if static_.is_some() {
+            let (impl_generics, type_generics, where_clause) =
+                static_type_generics.split_for_impl();
             quote! {
                 #[automatically_derived]
-                impl #impl_generics ::fayalite::ty::FixedType for #type_struct_ident #type_generics
+                impl #impl_generics ::fayalite::ty::StaticType for #type_struct_ident #type_generics
                 #where_clause
                 {
-                    fn fixed_type() -> Self {
+                    fn static_type() -> Self {
                         Self {
-                            #(#unskipped_field_names: ::fayalite::ty::FixedType::fixed_type(),)*
+                            #(#unskipped_field_names: ::fayalite::ty::StaticType::static_type(),)*
                             #(#phantom_data_field_name_slice:
                                 ::fayalite::__std::marker::PhantomData,)*
                         }
diff --git a/crates/fayalite/src/_docs/modules/module_bodies/hdl_struct_variant_expressions.rs b/crates/fayalite/src/_docs/modules/module_bodies/hdl_struct_variant_expressions.rs
index 1013447..314e283 100644
--- a/crates/fayalite/src/_docs/modules/module_bodies/hdl_struct_variant_expressions.rs
+++ b/crates/fayalite/src/_docs/modules/module_bodies/hdl_struct_variant_expressions.rs
@@ -11,7 +11,7 @@
 //! ```
 //! # use fayalite::{hdl_module, int::UInt, array::Array, ty::Value};
 //! #[derive(Value, Clone, PartialEq, Eq, Hash, Debug)]
-//! #[hdl(fixed_type)]
+//! #[hdl(static)]
 //! pub struct MyStruct {
 //!     pub a: UInt<8>,
 //!     pub b: UInt<16>,
diff --git a/crates/fayalite/src/array.rs b/crates/fayalite/src/array.rs
index d25987c..a430738 100644
--- a/crates/fayalite/src/array.rs
+++ b/crates/fayalite/src/array.rs
@@ -14,7 +14,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, CanonicalTypeKind, CanonicalValue, Connect, DynCanonicalType,
-        DynCanonicalValue, DynType, DynValueTrait, FixedType, MatchVariantWithoutScope, Type,
+        DynCanonicalValue, DynType, DynValueTrait, MatchVariantWithoutScope, StaticType, Type,
         TypeEnum, Value, ValueEnum,
     },
     util::{ConstBool, GenericConstBool, MakeMutSlice},
@@ -66,7 +66,7 @@ pub trait ValueArrayOrSlice:
             LenType = Self::LenType,
             MaskVA = Self::MaskVA,
         > + ?Sized;
-    type IsFixedLen: GenericConstBool;
+    type IsStaticLen: GenericConstBool;
     const FIXED_LEN_TYPE: Option<Self::LenType>;
     fn make_match(array: Expr<Array<Self>>) -> Self::Match;
     fn len_from_len_type(v: Self::LenType) -> usize;
@@ -94,7 +94,7 @@ where
     type LenType = usize;
     type Match = Box<[Expr<V>]>;
     type MaskVA = [<Self::ElementType as Type>::MaskValue];
-    type IsFixedLen = ConstBool<false>;
+    type IsStaticLen = ConstBool<false>;
     const FIXED_LEN_TYPE: Option<Self::LenType> = None;
 
     fn make_match(array: Expr<Array<Self>>) -> Self::Match {
@@ -147,7 +147,7 @@ where
     type LenType = ();
     type Match = [Expr<V>; N];
     type MaskVA = [<Self::ElementType as Type>::MaskValue; N];
-    type IsFixedLen = ConstBool<true>;
+    type IsStaticLen = ConstBool<true>;
     const FIXED_LEN_TYPE: Option<Self::LenType> = Some(());
 
     fn make_match(array: Expr<Array<Self>>) -> Self::Match {
@@ -311,12 +311,12 @@ where
     }
 }
 
-impl<V: Value, const N: usize> FixedType for ArrayType<[V; N]>
+impl<V: Value, const N: usize> StaticType for ArrayType<[V; N]>
 where
-    V::Type: FixedType<Value = V>,
+    V::Type: StaticType<Value = V>,
 {
-    fn fixed_type() -> Self {
-        Self::new_array(FixedType::fixed_type())
+    fn static_type() -> Self {
+        Self::new_array(StaticType::static_type())
     }
 }
 
@@ -514,18 +514,18 @@ impl<VA: ValueArrayOrSlice + ?Sized> Array<VA> {
 
 impl<VA: ValueArrayOrSlice + ?Sized, T: Into<Arc<VA>>> From<T> for Array<VA>
 where
-    VA::ElementType: FixedType,
+    VA::ElementType: StaticType,
 {
     fn from(value: T) -> Self {
-        Self::new(FixedType::fixed_type(), value.into())
+        Self::new(StaticType::static_type(), value.into())
     }
 }
 
-impl<E: ToExpr<Type = T>, T: FixedType> ToExpr for [E] {
+impl<E: ToExpr<Type = T>, T: StaticType> ToExpr for [E] {
     type Type = ArrayType<[T::Value]>;
 
     fn ty(&self) -> Self::Type {
-        ArrayType::new_with_len_type(FixedType::fixed_type(), self.len())
+        ArrayType::new_with_len_type(StaticType::static_type(), self.len())
     }
 
     fn to_expr(&self) -> Expr<<Self::Type as Type>::Value> {
@@ -536,7 +536,7 @@ impl<E: ToExpr<Type = T>, T: FixedType> ToExpr for [E] {
     }
 }
 
-impl<E: ToExpr<Type = T>, T: FixedType> ToExpr for Vec<E> {
+impl<E: ToExpr<Type = T>, T: StaticType> ToExpr for Vec<E> {
     type Type = ArrayType<[T::Value]>;
 
     fn ty(&self) -> Self::Type {
@@ -548,11 +548,11 @@ impl<E: ToExpr<Type = T>, T: FixedType> ToExpr for Vec<E> {
     }
 }
 
-impl<E: ToExpr<Type = T>, T: FixedType, const N: usize> ToExpr for [E; N] {
+impl<E: ToExpr<Type = T>, T: StaticType, const N: usize> ToExpr for [E; N] {
     type Type = ArrayType<[T::Value; N]>;
 
     fn ty(&self) -> Self::Type {
-        ArrayType::new_with_len_type(FixedType::fixed_type(), ())
+        ArrayType::new_with_len_type(StaticType::static_type(), ())
     }
 
     fn to_expr(&self) -> Expr<<Self::Type as Type>::Value> {
diff --git a/crates/fayalite/src/bundle.rs b/crates/fayalite/src/bundle.rs
index 7777493..39b0d8e 100644
--- a/crates/fayalite/src/bundle.rs
+++ b/crates/fayalite/src/bundle.rs
@@ -9,7 +9,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, CanonicalTypeKind, CanonicalValue, Connect, DynCanonicalType,
-        DynCanonicalValue, DynType, FixedType, MatchVariantWithoutScope, Type, TypeEnum,
+        DynCanonicalValue, DynType, MatchVariantWithoutScope, StaticType, Type, TypeEnum,
         TypeWithDeref, Value, ValueEnum,
     },
 };
@@ -755,13 +755,13 @@ macro_rules! impl_tuple {
             }
         }
 
-        impl<$($T: FixedType,)*> FixedType for ($($T,)*)
+        impl<$($T: StaticType,)*> StaticType for ($($T,)*)
         where
             $($T::Value: Value<Type = $T>,)*
         {
             #[allow(clippy::unused_unit)]
-            fn fixed_type() -> Self {
-                ($($T::fixed_type(),)*)
+            fn static_type() -> Self {
+                ($($T::static_type(),)*)
             }
         }
 
diff --git a/crates/fayalite/src/clock.rs b/crates/fayalite/src/clock.rs
index 34676f0..415d7b6 100644
--- a/crates/fayalite/src/clock.rs
+++ b/crates/fayalite/src/clock.rs
@@ -8,7 +8,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         impl_match_values_as_self, CanonicalType, CanonicalTypeKind, CanonicalValue, Connect,
-        DynCanonicalType, FixedType, Type, TypeEnum, Value, ValueEnum,
+        DynCanonicalType, StaticType, Type, TypeEnum, Value, ValueEnum,
     },
     util::interned_bit,
 };
@@ -63,8 +63,8 @@ impl CanonicalType for ClockType {
     const CANONICAL_TYPE_KIND: CanonicalTypeKind = CanonicalTypeKind::Clock;
 }
 
-impl FixedType for ClockType {
-    fn fixed_type() -> Self {
+impl StaticType for ClockType {
+    fn static_type() -> Self {
         Self
     }
 }
@@ -103,7 +103,7 @@ impl CanonicalValue for Clock {
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Value)]
-#[hdl(fixed_type, outline_generated)]
+#[hdl(static, outline_generated)]
 pub struct ClockDomain {
     pub clk: Clock,
     pub rst: Reset,
diff --git a/crates/fayalite/src/expr.rs b/crates/fayalite/src/expr.rs
index 43d2a51..2b8f2b2 100644
--- a/crates/fayalite/src/expr.rs
+++ b/crates/fayalite/src/expr.rs
@@ -4,7 +4,7 @@ use crate::{
     array::ArrayType,
     bundle::{BundleType, BundleValue, DynBundle, DynBundleType, FieldType},
     enum_::{DynEnumType, EnumType, EnumValue},
-    int::{DynSIntType, DynUInt, DynUIntType, FixedOrDynIntType, IntValue, UInt, UIntType},
+    int::{DynSIntType, DynUInt, DynUIntType, IntValue, StaticOrDynIntType, UInt, UIntType},
     intern::{Intern, Interned, InternedCompare, PtrEqWithTypeId, SupportsPtrEqWithTypeId},
     memory::{DynPortType, MemPort, PortType},
     module::{
@@ -288,7 +288,7 @@ impl<T> Hash for Expr<T> {
 
 impl<T> Expr<IntValue<T>>
 where
-    T: FixedOrDynIntType<
+    T: StaticOrDynIntType<
         1,
         Signed = ConstBool<false>,
         CanonicalType = DynUIntType,
diff --git a/crates/fayalite/src/expr/ops.rs b/crates/fayalite/src/expr/ops.rs
index e932ff5..c1a16f1 100644
--- a/crates/fayalite/src/expr/ops.rs
+++ b/crates/fayalite/src/expr/ops.rs
@@ -10,7 +10,7 @@ use crate::{
         TargetPathDynArrayElement, TargetPathElement, ToExpr,
     },
     int::{
-        DynInt, DynIntType, DynSInt, DynSIntType, DynUInt, DynUIntType, FixedOrDynIntType, Int,
+        DynInt, DynIntType, DynSInt, DynSIntType, DynUInt, DynUIntType, StaticOrDynIntType, Int,
         IntCmp, IntType, IntTypeTrait, IntValue, UInt, UIntType,
     },
     intern::{Intern, Interned},
@@ -726,7 +726,7 @@ macro_rules! cmp_op {
                     CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>,
                     CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>,
                 >,
-                Output: FixedOrDynIntType<
+                Output: StaticOrDynIntType<
                     1,
                     Signed = ConstBool<false>,
                     CanonicalType = DynUIntType,
@@ -737,7 +737,7 @@ macro_rules! cmp_op {
                 pub lhs: Expr<LhsType::CanonicalValue>,
                 pub rhs: Expr<RhsType::CanonicalValue>,
                 #[type]
-                ty: Output = FixedOrDynIntType::new(),
+                ty: Output = StaticOrDynIntType::new(),
                 #[cache]
                 literal_bits: Result<Interned<BitSlice>, ()> = {
                     lhs.to_literal_bits()
@@ -1098,7 +1098,7 @@ macro_rules! reduce_bit_op {
         fixed_ary_op! {
             pub struct $name<Output,>
             where (
-                Output: FixedOrDynIntType<
+                Output: StaticOrDynIntType<
                     1,
                     Signed = ConstBool<false>,
                     CanonicalType = DynUIntType,
@@ -1108,7 +1108,7 @@ macro_rules! reduce_bit_op {
             {
                 pub arg: Expr<DynUInt>,
                 #[type]
-                ty: Output = FixedOrDynIntType::new(),
+                ty: Output = StaticOrDynIntType::new(),
                 #[cache]
                 literal_bits: Result<Interned<BitSlice>, ()> = {
                     arg.to_literal_bits().map(|$bits| interned_bit($literal_bits_bool))
@@ -1503,7 +1503,7 @@ where
     }
 }
 
-cast_bit_to_typed_bit!(pub struct CastClockToBit<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; ClockType => ToType);
+cast_bit_to_typed_bit!(pub struct CastClockToBit<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; ClockType => ToType);
 
 impl ToBit for Clock {
     fn to_bit(v: Expr<Self>) -> Expr<UInt<1>> {
@@ -1511,7 +1511,7 @@ impl ToBit for Clock {
     }
 }
 
-cast_bit_to_typed_bit!(pub struct CastSyncResetToBit<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; SyncResetType => ToType);
+cast_bit_to_typed_bit!(pub struct CastSyncResetToBit<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; SyncResetType => ToType);
 
 impl ToBit for SyncReset {
     fn to_bit(v: Expr<Self>) -> Expr<UInt<1>> {
@@ -1519,7 +1519,7 @@ impl ToBit for SyncReset {
     }
 }
 
-cast_bit_to_typed_bit!(pub struct CastAsyncResetToBit<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; AsyncResetType => ToType);
+cast_bit_to_typed_bit!(pub struct CastAsyncResetToBit<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; AsyncResetType => ToType);
 
 impl ToBit for AsyncReset {
     fn to_bit(v: Expr<Self>) -> Expr<UInt<1>> {
@@ -1527,7 +1527,7 @@ impl ToBit for AsyncReset {
     }
 }
 
-cast_bit_to_typed_bit!(pub struct CastResetToBit<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; ResetType => ToType);
+cast_bit_to_typed_bit!(pub struct CastResetToBit<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>; ResetType => ToType);
 
 impl ToBit for Reset {
     fn to_bit(v: Expr<Self>) -> Expr<UInt<1>> {
diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs
index b1b796e..ce7d96f 100644
--- a/crates/fayalite/src/int.rs
+++ b/crates/fayalite/src/int.rs
@@ -6,7 +6,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         impl_match_values_as_self, CanonicalType, CanonicalTypeKind, CanonicalValue, Connect,
-        DynCanonicalType, FixedType, Type, TypeEnum, Value, ValueEnum,
+        DynCanonicalType, StaticType, Type, TypeEnum, Value, ValueEnum,
     },
     util::{ConstBool, GenericConstBool},
     valueless::Valueless,
@@ -825,7 +825,7 @@ impl_int!(i64, true);
 impl_int!(i128, true);
 
 impl<
-        T: FixedOrDynIntType<
+        T: StaticOrDynIntType<
             1,
             Signed = ConstBool<false>,
             CanonicalType = DynUIntType,
@@ -1000,7 +1000,7 @@ pub trait IntTypeTrait:
     }
 }
 
-pub trait FixedOrDynIntType<const WIDTH: usize>: IntTypeTrait {
+pub trait StaticOrDynIntType<const WIDTH: usize>: IntTypeTrait {
     fn new() -> Self;
 }
 
@@ -1203,7 +1203,7 @@ impl<Signed: GenericConstBool> IntTypeTrait for DynIntType<Signed> {
     }
 }
 
-impl<Signed: GenericConstBool, const WIDTH: usize> FixedOrDynIntType<WIDTH> for DynIntType<Signed> {
+impl<Signed: GenericConstBool, const WIDTH: usize> StaticOrDynIntType<WIDTH> for DynIntType<Signed> {
     fn new() -> Self {
         DynIntType::new(WIDTH)
     }
@@ -1264,8 +1264,8 @@ impl<Signed: GenericConstBool, const WIDTH: usize> Type for IntType<Signed, WIDT
     }
 }
 
-impl<Signed: GenericConstBool, const WIDTH: usize> FixedType for IntType<Signed, WIDTH> {
-    fn fixed_type() -> Self {
+impl<Signed: GenericConstBool, const WIDTH: usize> StaticType for IntType<Signed, WIDTH> {
+    fn static_type() -> Self {
         Self::new()
     }
 }
@@ -1292,7 +1292,7 @@ impl<Signed: GenericConstBool, const WIDTH: usize> IntTypeTrait for IntType<Sign
     }
 }
 
-impl<Signed: GenericConstBool, const WIDTH: usize> FixedOrDynIntType<WIDTH>
+impl<Signed: GenericConstBool, const WIDTH: usize> StaticOrDynIntType<WIDTH>
     for IntType<Signed, WIDTH>
 {
     fn new() -> Self {
diff --git a/crates/fayalite/src/module.rs b/crates/fayalite/src/module.rs
index 144ca96..81706ef 100644
--- a/crates/fayalite/src/module.rs
+++ b/crates/fayalite/src/module.rs
@@ -11,13 +11,13 @@ use crate::{
         ops::VariantAccess, Expr, Flow, Target, TargetBase, TargetPathArrayElement,
         TargetPathBundleField, TargetPathElement, ToExpr,
     },
-    int::{DynUInt, DynUIntType, FixedOrDynIntType, IntValue, UInt},
+    int::{DynUInt, DynUIntType, IntValue, StaticOrDynIntType, UInt},
     intern::{Intern, Interned},
     memory::{Mem, MemBuilder, MemBuilderTarget, PortName},
     reg::Reg,
     source_location::SourceLocation,
     ty::{
-        CanonicalType, Connect, DynCanonicalType, DynCanonicalValue, DynType, FixedType, Type,
+        CanonicalType, Connect, DynCanonicalType, DynCanonicalValue, DynType, StaticType, Type,
         TypeEnum, Value,
     },
     util::ConstBool,
@@ -1829,7 +1829,7 @@ impl<'a, CD> RegBuilder<'a, CD, (), ()> {
     }
     pub fn reset_default<V: Value + Default>(self) -> RegBuilder<'a, CD, Option<Expr<V>>, V>
     where
-        V::Type: FixedType<Value = V>,
+        V::Type: StaticType<Value = V>,
     {
         self.reset(V::default().to_expr())
     }
@@ -2264,7 +2264,7 @@ where
     #[track_caller]
     pub fn if_<Ty>(&mut self, cond: Expr<IntValue<Ty>>) -> IfScope
     where
-        Ty: FixedOrDynIntType<
+        Ty: StaticOrDynIntType<
             1,
             Signed = ConstBool<false>,
             CanonicalType = DynUIntType,
@@ -2279,7 +2279,7 @@ where
         source_location: SourceLocation,
     ) -> IfScope
     where
-        Ty: FixedOrDynIntType<
+        Ty: StaticOrDynIntType<
             1,
             Signed = ConstBool<false>,
             CanonicalType = DynUIntType,
diff --git a/crates/fayalite/src/module/transform/visit.rs b/crates/fayalite/src/module/transform/visit.rs
index 3e2ee03..fcac723 100644
--- a/crates/fayalite/src/module/transform/visit.rs
+++ b/crates/fayalite/src/module/transform/visit.rs
@@ -12,7 +12,7 @@ use crate::{
         TargetPathBundleField, TargetPathDynArrayElement, TargetPathElement, ToExpr,
     },
     int::{
-        DynInt, DynIntType, DynSInt, DynSIntType, DynUInt, DynUIntType, FixedOrDynIntType, IntType,
+        DynInt, DynIntType, DynSInt, DynSIntType, DynUInt, DynUIntType, StaticOrDynIntType, IntType,
         IntTypeTrait,
     },
     intern::{Intern, Interned},
diff --git a/crates/fayalite/src/reset.rs b/crates/fayalite/src/reset.rs
index 9402db3..ee422a3 100644
--- a/crates/fayalite/src/reset.rs
+++ b/crates/fayalite/src/reset.rs
@@ -7,13 +7,13 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         impl_match_values_as_self, CanonicalType, CanonicalTypeKind, CanonicalValue, Connect,
-        DynCanonicalType, FixedType, Type, TypeEnum, Value, ValueEnum,
+        DynCanonicalType, StaticType, Type, TypeEnum, Value, ValueEnum,
     },
     util::interned_bit,
 };
 use bitvec::slice::BitSlice;
 
-pub trait ResetTypeTrait: CanonicalType + FixedType {}
+pub trait ResetTypeTrait: CanonicalType + StaticType {}
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
 pub struct AsyncResetType;
@@ -64,8 +64,8 @@ impl CanonicalType for AsyncResetType {
     const CANONICAL_TYPE_KIND: CanonicalTypeKind = CanonicalTypeKind::AsyncReset;
 }
 
-impl FixedType for AsyncResetType {
-    fn fixed_type() -> Self {
+impl StaticType for AsyncResetType {
+    fn static_type() -> Self {
         Self
     }
 }
@@ -154,8 +154,8 @@ impl CanonicalType for SyncResetType {
     const CANONICAL_TYPE_KIND: CanonicalTypeKind = CanonicalTypeKind::SyncReset;
 }
 
-impl FixedType for SyncResetType {
-    fn fixed_type() -> Self {
+impl StaticType for SyncResetType {
+    fn static_type() -> Self {
         Self
     }
 }
@@ -244,8 +244,8 @@ impl CanonicalType for ResetType {
     const CANONICAL_TYPE_KIND: CanonicalTypeKind = CanonicalTypeKind::Reset;
 }
 
-impl FixedType for ResetType {
-    fn fixed_type() -> Self {
+impl StaticType for ResetType {
+    fn static_type() -> Self {
         Self
     }
 }
diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs
index 22ae1c3..e45afdf 100644
--- a/crates/fayalite/src/ty.rs
+++ b/crates/fayalite/src/ty.rs
@@ -625,8 +625,8 @@ pub trait CanonicalType:
 
 impl<T: CanonicalType> DynCanonicalType for T {}
 
-pub trait FixedType: Type {
-    fn fixed_type() -> Self;
+pub trait StaticType: Type {
+    fn static_type() -> Self;
 }
 
 pub trait DynValueTrait: fmt::Debug + Send + Sync + Any {
diff --git a/crates/fayalite/tests/module.rs b/crates/fayalite/tests/module.rs
index 9a83c59..96001e3 100644
--- a/crates/fayalite/tests/module.rs
+++ b/crates/fayalite/tests/module.rs
@@ -13,7 +13,7 @@ use fayalite::{
     module::transform::simplify_enums::{simplify_enums, SimplifyEnumsKind},
     reset::{SyncReset, ToReset},
     source_location::SourceLocation,
-    ty::{FixedType, Value},
+    ty::{StaticType, Value},
 };
 use serde_json::json;
 
@@ -195,7 +195,7 @@ circuit check_array_repeat_1:
 #[hdl_module(outline_generated)]
 pub fn check_skipped_generics<T, #[hdl(skip)] U, const N: usize, #[hdl(skip)] const M: usize>(v: U)
 where
-    T: Value<Type: FixedType<Value = T>>,
+    T: Value<Type: StaticType<Value = T>>,
     U: std::fmt::Display,
 {
     dbg!(M);
@@ -377,18 +377,18 @@ circuit check_written_inside_both_if_else:
 }
 
 #[derive(Value, Clone, PartialEq, Eq, Hash, Debug)]
-#[hdl(fixed_type, outline_generated)]
+#[hdl(static, outline_generated)]
 pub struct TestStruct<T> {
     pub a: T,
     pub b: UInt<8>,
 }
 
 #[derive(Value, Clone, PartialEq, Eq, Hash, Debug)]
-#[hdl(fixed_type, outline_generated)]
+#[hdl(static, outline_generated)]
 pub struct TestStruct2(pub UInt<8>);
 
 #[derive(Value, Clone, PartialEq, Eq, Hash, Debug)]
-#[hdl(fixed_type, outline_generated)]
+#[hdl(static, outline_generated)]
 pub struct TestStruct3;
 
 #[hdl_module(outline_generated)]
diff --git a/crates/fayalite/visit_types.json b/crates/fayalite/visit_types.json
index 0304e06..5401097 100644
--- a/crates/fayalite/visit_types.json
+++ b/crates/fayalite/visit_types.json
@@ -501,7 +501,7 @@
                 "lhs": "Visible",
                 "rhs": "Visible"
             },
-            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::CmpLe": {
             "data": {
@@ -510,7 +510,7 @@
                 "lhs": "Visible",
                 "rhs": "Visible"
             },
-            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::CmpGt": {
             "data": {
@@ -519,7 +519,7 @@
                 "lhs": "Visible",
                 "rhs": "Visible"
             },
-            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::CmpGe": {
             "data": {
@@ -528,7 +528,7 @@
                 "lhs": "Visible",
                 "rhs": "Visible"
             },
-            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::CmpEq": {
             "data": {
@@ -537,7 +537,7 @@
                 "lhs": "Visible",
                 "rhs": "Visible"
             },
-            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::CmpNe": {
             "data": {
@@ -546,7 +546,7 @@
                 "lhs": "Visible",
                 "rhs": "Visible"
             },
-            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<LhsType: IntTypeTrait<CanonicalType = DynIntType<<LhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<LhsType as IntTypeTrait>::Signed>>, RhsType: IntTypeTrait<Signed = LhsType::Signed, CanonicalType = DynIntType<<RhsType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<RhsType as IntTypeTrait>::Signed>>, Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::CastInt": {
             "data": {
@@ -574,7 +574,7 @@
                 "$constructor": "ops::ReduceBitAnd::new_unchecked",
                 "arg": "Visible"
             },
-            "generics": "<Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::ReduceBitOr": {
             "data": {
@@ -582,7 +582,7 @@
                 "$constructor": "ops::ReduceBitOr::new_unchecked",
                 "arg": "Visible"
             },
-            "generics": "<Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::ReduceBitXor": {
             "data": {
@@ -590,7 +590,7 @@
                 "$constructor": "ops::ReduceBitXor::new_unchecked",
                 "arg": "Visible"
             },
-            "generics": "<Output: FixedOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
+            "generics": "<Output: StaticOrDynIntType<1, Signed = ConstBool<false>, CanonicalType = DynUIntType, CanonicalValue = DynUInt>>"
         },
         "ops::FieldAccess": {
             "data": {
@@ -696,7 +696,7 @@
                 "$constructor": "ops::CastClockToBit::new_unchecked",
                 "value": "Visible"
             },
-            "generics": "<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
+            "generics": "<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
         },
         "ops::CastSyncResetToBit": {
             "data": {
@@ -704,7 +704,7 @@
                 "$constructor": "ops::CastSyncResetToBit::new_unchecked",
                 "value": "Visible"
             },
-            "generics": "<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
+            "generics": "<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
         },
         "ops::CastAsyncResetToBit": {
             "data": {
@@ -712,7 +712,7 @@
                 "$constructor": "ops::CastAsyncResetToBit::new_unchecked",
                 "value": "Visible"
             },
-            "generics": "<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
+            "generics": "<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
         },
         "ops::CastResetToBit": {
             "data": {
@@ -720,7 +720,7 @@
                 "$constructor": "ops::CastResetToBit::new_unchecked",
                 "value": "Visible"
             },
-            "generics": "<ToType: FixedOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
+            "generics": "<ToType: StaticOrDynIntType<1, CanonicalType = DynIntType<<ToType as IntTypeTrait>::Signed>, CanonicalValue = DynInt<<ToType as IntTypeTrait>::Signed>>>"
         },
         "BlockId": {
             "data": {