From a40eaaa2da1731eb7af535dbd6b910408f3874dc Mon Sep 17 00:00:00 2001 From: Jacob Lifshay Date: Sun, 30 Mar 2025 00:55:38 -0700 Subject: [PATCH] expand SimValue support --- .../src/hdl_bundle.rs | 96 ++++ .../fayalite-proc-macros-impl/src/hdl_enum.rs | 46 ++ crates/fayalite-proc-macros-impl/src/lib.rs | 1 + .../src/module/transform_body.rs | 46 +- .../expand_aggregate_literals.rs | 111 ++++- .../src/module/transform_body/expand_match.rs | 113 +++-- crates/fayalite/src/bundle.rs | 85 ++-- crates/fayalite/src/int.rs | 9 +- crates/fayalite/src/phantom_const.rs | 32 +- crates/fayalite/src/sim.rs | 4 +- crates/fayalite/src/sim/value.rs | 455 +++++++++++++----- crates/fayalite/src/ty.rs | 12 +- crates/fayalite/tests/sim.rs | 196 ++++---- 13 files changed, 864 insertions(+), 342 deletions(-) diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs index a083def..8e49ac4 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs @@ -692,6 +692,12 @@ impl ToTokens for ParsedBundle { v.field_to_bits(&value.#ident); } })); + let to_sim_value_fields = Vec::from_iter(fields.named().into_iter().map(|field| { + let ident: &Ident = field.ident().as_ref().unwrap(); + quote_spanned! {span=> + #ident: ::fayalite::sim::value::SimValue::ty(&self.#ident), + } + })); let fields_len = fields.named().into_iter().len(); quote_spanned! {span=> #[automatically_derived] @@ -797,6 +803,51 @@ impl ToTokens for ParsedBundle { } } #[automatically_derived] + impl #impl_generics ::fayalite::sim::value::ToSimValue for #mask_type_sim_value_ident #type_generics + #where_clause + { + type Type = #mask_type_ident #type_generics; + + fn to_sim_value( + &self, + ) -> ::fayalite::sim::value::SimValue< + ::Type, + > { + let ty = #mask_type_ident { + #(#to_sim_value_fields)* + }; + ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) + } + fn into_sim_value( + self, + ) -> ::fayalite::sim::value::SimValue< + ::Type, + > { + let ty = #mask_type_ident { + #(#to_sim_value_fields)* + }; + ::fayalite::sim::value::SimValue::from_value(ty, self) + } + } + #[automatically_derived] + impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#mask_type_ident #type_generics> + for #mask_type_sim_value_ident #type_generics + #where_clause + { + fn to_sim_value_with_type( + &self, + ty: #mask_type_ident #type_generics, + ) -> ::fayalite::sim::value::SimValue<#mask_type_ident #type_generics> { + ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) + } + fn into_sim_value_with_type( + self, + ty: #mask_type_ident #type_generics, + ) -> ::fayalite::sim::value::SimValue<#mask_type_ident #type_generics> { + ::fayalite::sim::value::SimValue::from_value(ty, self) + } + } + #[automatically_derived] impl #impl_generics ::fayalite::ty::Type for #target #type_generics #where_clause { @@ -900,6 +951,51 @@ impl ToTokens for ParsedBundle { ::fayalite::intern::Interned::into_inner(::fayalite::intern::Intern::intern_sized(__retval)) } } + #[automatically_derived] + impl #impl_generics ::fayalite::sim::value::ToSimValue for #sim_value_ident #type_generics + #where_clause + { + type Type = #target #type_generics; + + fn to_sim_value( + &self, + ) -> ::fayalite::sim::value::SimValue< + ::Type, + > { + let ty = #target { + #(#to_sim_value_fields)* + }; + ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) + } + fn into_sim_value( + self, + ) -> ::fayalite::sim::value::SimValue< + ::Type, + > { + let ty = #target { + #(#to_sim_value_fields)* + }; + ::fayalite::sim::value::SimValue::from_value(ty, self) + } + } + #[automatically_derived] + impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#target #type_generics> + for #sim_value_ident #type_generics + #where_clause + { + fn to_sim_value_with_type( + &self, + ty: #target #type_generics, + ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { + ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) + } + fn into_sim_value_with_type( + self, + ty: #target #type_generics, + ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { + ::fayalite::sim::value::SimValue::from_value(ty, self) + } + } } .to_tokens(tokens); if let Some((cmp_eq,)) = cmp_eq { diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs index 0cdf85c..dd09a73 100644 --- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs +++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs @@ -866,6 +866,24 @@ impl ToTokens for ParsedEnum { ][..]) } } + #[automatically_derived] + impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#target #type_generics> + for #sim_value_ident #type_generics + #where_clause + { + fn to_sim_value_with_type( + &self, + ty: #target #type_generics, + ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { + ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self)) + } + fn into_sim_value_with_type( + self, + ty: #target #type_generics, + ) -> ::fayalite::sim::value::SimValue<#target #type_generics> { + ::fayalite::sim::value::SimValue::from_value(ty, self) + } + } } .to_tokens(tokens); if let (None, MaybeParsed::Parsed(generics)) = (no_static, &self.generics) { @@ -921,6 +939,34 @@ impl ToTokens for ParsedEnum { const MASK_TYPE_PROPERTIES: ::fayalite::ty::TypeProperties = <::fayalite::int::Bool as ::fayalite::ty::StaticType>::TYPE_PROPERTIES; } + #[automatically_derived] + impl #static_impl_generics ::fayalite::sim::value::ToSimValue + for #sim_value_ident #static_type_generics + #static_where_clause + { + type Type = #target #static_type_generics; + + fn to_sim_value( + &self, + ) -> ::fayalite::sim::value::SimValue< + ::Type, + > { + ::fayalite::sim::value::SimValue::from_value( + ::fayalite::ty::StaticType::TYPE, + ::fayalite::__std::clone::Clone::clone(self), + ) + } + fn into_sim_value( + self, + ) -> ::fayalite::sim::value::SimValue< + ::Type, + > { + ::fayalite::sim::value::SimValue::from_value( + ::fayalite::ty::StaticType::TYPE, + self, + ) + } + } } .to_tokens(tokens); } diff --git a/crates/fayalite-proc-macros-impl/src/lib.rs b/crates/fayalite-proc-macros-impl/src/lib.rs index 5fe3ae8..4f7c4f0 100644 --- a/crates/fayalite-proc-macros-impl/src/lib.rs +++ b/crates/fayalite-proc-macros-impl/src/lib.rs @@ -93,6 +93,7 @@ mod kw { custom_keyword!(output); custom_keyword!(reg_builder); custom_keyword!(reset); + custom_keyword!(sim); custom_keyword!(skip); custom_keyword!(target); custom_keyword!(wire); 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 c67f8dc..8f427a9 100644 --- a/crates/fayalite-proc-macros-impl/src/module/transform_body.rs +++ b/crates/fayalite-proc-macros-impl/src/module/transform_body.rs @@ -16,7 +16,7 @@ use std::{borrow::Borrow, convert::Infallible}; use syn::{ fold::{fold_expr, fold_expr_lit, fold_expr_unary, fold_local, fold_stmt, Fold}, parenthesized, - parse::{Nothing, Parse, ParseStream}, + parse::{Parse, ParseStream}, parse_quote, parse_quote_spanned, spanned::Spanned, token::Paren, @@ -27,6 +27,13 @@ use syn::{ mod expand_aggregate_literals; mod expand_match; +options! { + #[options = ExprOptions] + pub(crate) enum ExprOption { + Sim(sim), + } +} + options! { pub(crate) enum LetFnKind { Input(input), @@ -952,7 +959,7 @@ with_debug_clone_and_fold! { #[allow(dead_code)] pub(crate) struct HdlLet { pub(crate) attrs: Vec, - pub(crate) hdl_attr: HdlAttr, + pub(crate) hdl_attr: HdlAttr, pub(crate) let_token: Token![let], pub(crate) mut_token: Option, pub(crate) name: Ident, @@ -1173,7 +1180,7 @@ impl Visitor<'_> { Some(_) => {} } } - fn process_hdl_if(&mut self, hdl_attr: HdlAttr, expr_if: ExprIf) -> Expr { + fn process_hdl_if(&mut self, hdl_attr: HdlAttr, expr_if: ExprIf) -> Expr { let ExprIf { attrs, if_token, @@ -1181,10 +1188,10 @@ impl Visitor<'_> { then_branch, else_branch, } = expr_if; - self.require_normal_module_or_fn(if_token); - let else_expr = else_branch.unzip().1.map(|else_expr| match *else_expr { - Expr::If(expr_if) => self.process_hdl_if(hdl_attr.clone(), expr_if), - expr => expr, + let (else_token, else_expr) = else_branch.unzip(); + let else_expr = else_expr.map(|else_expr| match *else_expr { + Expr::If(expr_if) => Box::new(self.process_hdl_if(hdl_attr.clone(), expr_if)), + _ => else_expr, }); if let Expr::Let(ExprLet { attrs: let_attrs, @@ -1206,7 +1213,19 @@ impl Visitor<'_> { }, ); } - if let Some(else_expr) = else_expr { + let ExprOptions { sim } = hdl_attr.body; + if sim.is_some() { + ExprIf { + attrs, + if_token, + cond: parse_quote_spanned! {if_token.span=> + *::fayalite::sim::value::SimValue::<::fayalite::int::Bool>::value(&::fayalite::sim::value::ToSimValue::into_sim_value(#cond)) + }, + then_branch, + else_branch: else_token.zip(else_expr), + } + .into() + } else if let Some(else_expr) = else_expr { parse_quote_spanned! {if_token.span=> #(#attrs)* { @@ -1675,7 +1694,7 @@ impl Fold for Visitor<'_> { fn fold_local(&mut self, mut let_stmt: Local) -> Local { match self .errors - .ok(HdlAttr::::parse_and_leave_attr( + .ok(HdlAttr::::parse_and_leave_attr( &let_stmt.attrs, )) { None => return empty_let(), @@ -1694,10 +1713,11 @@ impl Fold for Visitor<'_> { subpat: None, }) = pat else { - let hdl_attr = HdlAttr::::parse_and_take_attr(&mut let_stmt.attrs) - .ok() - .flatten() - .expect("already checked above"); + let hdl_attr = + HdlAttr::::parse_and_take_attr(&mut let_stmt.attrs) + .ok() + .flatten() + .expect("already checked above"); let let_stmt = fold_local(self, let_stmt); return self.process_hdl_let_pat(hdl_attr, let_stmt); }; diff --git a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs index b5a0ad3..8892bd5 100644 --- a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs +++ b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_aggregate_literals.rs @@ -1,45 +1,97 @@ // SPDX-License-Identifier: LGPL-3.0-or-later // See Notices.txt for copyright information -use crate::{kw, module::transform_body::Visitor, HdlAttr}; +use crate::{ + kw, + module::transform_body::{ExprOptions, Visitor}, + HdlAttr, +}; use quote::{format_ident, quote_spanned}; use syn::{ - parse::Nothing, parse_quote, parse_quote_spanned, spanned::Spanned, Expr, ExprArray, ExprPath, - ExprRepeat, ExprStruct, ExprTuple, FieldValue, TypePath, + parse_quote_spanned, spanned::Spanned, Expr, ExprArray, ExprPath, ExprRepeat, ExprStruct, + ExprTuple, FieldValue, TypePath, }; impl Visitor<'_> { pub(crate) fn process_hdl_array( &mut self, - hdl_attr: HdlAttr, + hdl_attr: HdlAttr, mut expr_array: ExprArray, ) -> Expr { - self.require_normal_module_or_fn(hdl_attr); - for elem in &mut expr_array.elems { - *elem = parse_quote_spanned! {elem.span()=> - ::fayalite::expr::ToExpr::to_expr(&(#elem)) - }; + let ExprOptions { sim } = hdl_attr.body; + let span = hdl_attr.kw.span; + if sim.is_some() { + for elem in &mut expr_array.elems { + *elem = parse_quote_spanned! {elem.span()=> + ::fayalite::sim::value::ToSimValue::to_sim_value(&(#elem)) + }; + } + parse_quote_spanned! {span=> + ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_array) + } + } else { + for elem in &mut expr_array.elems { + *elem = parse_quote_spanned! {elem.span()=> + ::fayalite::expr::ToExpr::to_expr(&(#elem)) + }; + } + parse_quote_spanned! {span=> + ::fayalite::expr::ToExpr::to_expr(&#expr_array) + } } - parse_quote! {::fayalite::expr::ToExpr::to_expr(&#expr_array)} } pub(crate) fn process_hdl_repeat( &mut self, - hdl_attr: HdlAttr, + hdl_attr: HdlAttr, mut expr_repeat: ExprRepeat, ) -> Expr { - self.require_normal_module_or_fn(hdl_attr); let repeated_value = &expr_repeat.expr; - *expr_repeat.expr = parse_quote_spanned! {repeated_value.span()=> - ::fayalite::expr::ToExpr::to_expr(&(#repeated_value)) - }; - parse_quote! {::fayalite::expr::ToExpr::to_expr(&#expr_repeat)} + let ExprOptions { sim } = hdl_attr.body; + let span = hdl_attr.kw.span; + if sim.is_some() { + *expr_repeat.expr = parse_quote_spanned! {repeated_value.span()=> + ::fayalite::sim::value::ToSimValue::to_sim_value(&(#repeated_value)) + }; + parse_quote_spanned! {span=> + ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_repeat) + } + } else { + *expr_repeat.expr = parse_quote_spanned! {repeated_value.span()=> + ::fayalite::expr::ToExpr::to_expr(&(#repeated_value)) + }; + parse_quote_spanned! {span=> + ::fayalite::expr::ToExpr::to_expr(&#expr_repeat) + } + } } pub(crate) fn process_hdl_struct( &mut self, - hdl_attr: HdlAttr, - expr_struct: ExprStruct, + hdl_attr: HdlAttr, + mut expr_struct: ExprStruct, ) -> Expr { - self.require_normal_module_or_fn(&hdl_attr); let name_span = expr_struct.path.segments.last().unwrap().ident.span(); + let ExprOptions { sim } = hdl_attr.body; + if sim.is_some() { + let ty_path = TypePath { + qself: expr_struct.qself.take(), + path: expr_struct.path, + }; + expr_struct.path = parse_quote_spanned! {name_span=> + __SimValue::<#ty_path> + }; + for field in &mut expr_struct.fields { + let expr = &field.expr; + field.expr = parse_quote_spanned! {field.member.span()=> + ::fayalite::sim::value::ToSimValue::to_sim_value(&(#expr)) + }; + } + return parse_quote_spanned! {name_span=> + { + type __SimValue = ::SimValue; + let value: ::fayalite::sim::value::SimValue<#ty_path> = ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_struct); + value + } + }; + } let builder_ident = format_ident!("__builder", span = name_span); let empty_builder = if expr_struct.qself.is_some() || expr_struct @@ -91,12 +143,23 @@ impl Visitor<'_> { } pub(crate) fn process_hdl_tuple( &mut self, - hdl_attr: HdlAttr, - expr_tuple: ExprTuple, + hdl_attr: HdlAttr, + mut expr_tuple: ExprTuple, ) -> Expr { - self.require_normal_module_or_fn(hdl_attr); - parse_quote_spanned! {expr_tuple.span()=> - ::fayalite::expr::ToExpr::to_expr(&#expr_tuple) + let ExprOptions { sim } = hdl_attr.body; + if sim.is_some() { + for element in &mut expr_tuple.elems { + *element = parse_quote_spanned! {element.span()=> + &(#element) + }; + } + parse_quote_spanned! {expr_tuple.span()=> + ::fayalite::sim::value::ToSimValue::into_sim_value(#expr_tuple) + } + } else { + parse_quote_spanned! {expr_tuple.span()=> + ::fayalite::expr::ToExpr::to_expr(&#expr_tuple) + } } } } diff --git a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs index f1ff2c2..57e919a 100644 --- a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs +++ b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs @@ -3,7 +3,9 @@ use crate::{ fold::{impl_fold, DoFold}, kw, - module::transform_body::{empty_let, with_debug_clone_and_fold, wrap_ty_with_expr, Visitor}, + module::transform_body::{ + empty_let, with_debug_clone_and_fold, wrap_ty_with_expr, ExprOptions, Visitor, + }, Errors, HdlAttr, PairsIterExt, }; use proc_macro2::{Span, TokenStream}; @@ -11,7 +13,6 @@ use quote::{format_ident, quote_spanned, ToTokens, TokenStreamExt}; use std::collections::BTreeSet; use syn::{ fold::{fold_arm, fold_expr_match, fold_local, fold_pat, Fold}, - parse::Nothing, parse_quote_spanned, punctuated::Punctuated, spanned::Spanned, @@ -981,7 +982,7 @@ impl<'a> VisitMatchPat<'a> for HdlLetPatVisitState<'a> { impl Visitor<'_> { pub(crate) fn process_hdl_let_pat( &mut self, - _hdl_attr: HdlAttr, + hdl_attr: HdlAttr, mut let_stmt: Local, ) -> Local { let span = let_stmt.let_token.span(); @@ -996,7 +997,6 @@ impl Visitor<'_> { init, semi_token, } = let_stmt; - self.require_normal_module_or_fn(let_token); let Some(syn::LocalInit { eq_token, expr, @@ -1031,29 +1031,48 @@ impl Visitor<'_> { errors: _, bindings, } = state; - let retval = parse_quote_spanned! {span=> - let (#(#bindings,)* __scope,) = { - type __MatchTy = ::MatchVariant; - let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); - ::fayalite::expr::check_match_expr(__match_expr, |__match_value, __infallible| { - #[allow(unused_variables)] - #check_let_stmt - match __infallible {} - }); - let mut __match_iter = ::fayalite::module::match_(__match_expr); - let ::fayalite::__std::option::Option::Some(__match_variant) = ::fayalite::__std::iter::Iterator::next(&mut __match_iter) else { - ::fayalite::__std::unreachable!("#[hdl] let with uninhabited type"); + let ExprOptions { sim } = hdl_attr.body; + let retval = if sim.is_some() { + parse_quote_spanned! {span=> + let (#(#bindings,)*) = { + type __MatchTy = ::SimValue; + let __match_value = ::fayalite::sim::value::ToSimValue::to_sim_value(&(#expr)); + #let_token #pat #eq_token ::fayalite::sim::value::SimValue::into_value(__match_value) #semi_token + (#(#bindings,)*) }; - let ::fayalite::__std::option::Option::None = ::fayalite::__std::iter::Iterator::next(&mut __match_iter) else { - ::fayalite::__std::unreachable!("#[hdl] let with refutable pattern"); - }; - let (__match_variant, __scope) = - ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( - __match_variant, + } + } else { + parse_quote_spanned! {span=> + let (#(#bindings,)* __scope,) = { + type __MatchTy = ::MatchVariant; + let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); + ::fayalite::expr::check_match_expr( + __match_expr, + |__match_value, __infallible| { + #[allow(unused_variables)] + #check_let_stmt + match __infallible {} + }, ); - #let_token #pat #eq_token __match_variant #semi_token - (#(#bindings,)* __scope,) - }; + let mut __match_iter = ::fayalite::module::match_(__match_expr); + let ::fayalite::__std::option::Option::Some(__match_variant) = + ::fayalite::__std::iter::Iterator::next(&mut __match_iter) + else { + ::fayalite::__std::unreachable!("#[hdl] let with uninhabited type"); + }; + let ::fayalite::__std::option::Option::None = + ::fayalite::__std::iter::Iterator::next(&mut __match_iter) + else { + ::fayalite::__std::unreachable!("#[hdl] let with refutable pattern"); + }; + let (__match_variant, __scope) = + ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( + __match_variant, + ); + #let_token #pat #eq_token __match_variant #semi_token + (#(#bindings,)* __scope,) + }; + } }; match retval { syn::Stmt::Local(retval) => retval, @@ -1062,7 +1081,7 @@ impl Visitor<'_> { } pub(crate) fn process_hdl_match( &mut self, - _hdl_attr: HdlAttr, + hdl_attr: HdlAttr, expr_match: ExprMatch, ) -> Expr { let span = expr_match.match_token.span(); @@ -1074,7 +1093,6 @@ impl Visitor<'_> { brace_token: _, arms, } = expr_match; - self.require_normal_module_or_fn(match_token); let mut state = HdlMatchParseState { match_span: span, errors: &mut self.errors, @@ -1083,24 +1101,37 @@ impl Visitor<'_> { arms.into_iter() .filter_map(|arm| MatchArm::parse(&mut state, arm).ok()), ); - let expr = quote_spanned! {span=> - { - type __MatchTy = ::MatchVariant; - let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); - ::fayalite::expr::check_match_expr(__match_expr, |__match_value, __infallible| { - #[allow(unused_variables)] - #check_match - }); - for __match_variant in ::fayalite::module::match_(__match_expr) { - let (__match_variant, __scope) = - ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( - __match_variant, - ); - #match_token __match_variant { + let ExprOptions { sim } = hdl_attr.body; + let expr = if sim.is_some() { + quote_spanned! {span=> + { + type __MatchTy = ::SimValue; + let __match_expr = ::fayalite::sim::value::ToSimValue::to_sim_value(&(#expr)); + #match_token *__match_expr { #(#arms)* } } } + } else { + quote_spanned! {span=> + { + type __MatchTy = ::MatchVariant; + let __match_expr = ::fayalite::expr::ToExpr::to_expr(&(#expr)); + ::fayalite::expr::check_match_expr(__match_expr, |__match_value, __infallible| { + #[allow(unused_variables)] + #check_match + }); + for __match_variant in ::fayalite::module::match_(__match_expr) { + let (__match_variant, __scope) = + ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope( + __match_variant, + ); + #match_token __match_variant { + #(#arms)* + } + } + } + } }; syn::parse2(expr).unwrap() } diff --git a/crates/fayalite/src/bundle.rs b/crates/fayalite/src/bundle.rs index 06e0411..9279b57 100644 --- a/crates/fayalite/src/bundle.rs +++ b/crates/fayalite/src/bundle.rs @@ -8,7 +8,7 @@ use crate::{ }, int::{Bool, DynSize}, intern::{Intern, Interned}, - sim::value::{SimValue, SimValuePartialEq, ToSimValue}, + sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType}, source_location::SourceLocation, ty::{ impl_match_variant_as_self, CanonicalType, MatchVariantWithoutScope, OpaqueSimValue, @@ -562,29 +562,29 @@ macro_rules! impl_tuples { BundleLiteral::new(ty, field_values[..].intern()).to_expr() } } - impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { + impl<$($T: ToSimValueWithType,)*> ToSimValueWithType for ($($T,)*) { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(ToSimValue::::to_sim_value(self, Bundle::from_canonical(ty))) + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(ToSimValueWithType::::to_sim_value_with_type(self, Bundle::from_canonical(ty))) } #[track_caller] - fn into_sim_value(self, ty: CanonicalType) -> SimValue + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(ToSimValue::::into_sim_value(self, Bundle::from_canonical(ty))) + SimValue::into_canonical(ToSimValueWithType::::into_sim_value_with_type(self, Bundle::from_canonical(ty))) } } - impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { + impl<$($T: ToSimValueWithType,)*> ToSimValueWithType for ($($T,)*) { #[track_caller] - fn to_sim_value(&self, ty: Bundle) -> SimValue { + fn to_sim_value_with_type(&self, ty: Bundle) -> SimValue { let ($($var,)*) = self; let [$($ty_var,)*] = *ty.fields() else { panic!("bundle has wrong number of fields"); }; - $(let $var = $var.to_sim_value($ty_var.ty);)* - ToSimValue::into_sim_value(($($var,)*), ty) + $(let $var = $var.to_sim_value_with_type($ty_var.ty);)* + ToSimValueWithType::into_sim_value_with_type(($($var,)*), ty) } #[track_caller] - fn into_sim_value(self, ty: Bundle) -> SimValue { + fn into_sim_value_with_type(self, ty: Bundle) -> SimValue { #![allow(unused_mut)] #![allow(clippy::unused_unit)] let ($($var,)*) = self; @@ -592,29 +592,44 @@ macro_rules! impl_tuples { panic!("bundle has wrong number of fields"); }; let mut bits = BitVec::new(); - $(let $var = $var.into_sim_value($ty_var.ty); + $(let $var = $var.into_sim_value_with_type($ty_var.ty); assert_eq!(SimValue::ty(&$var), $ty_var.ty); bits.extend_from_bitslice(SimValue::bits(&$var).bits()); )* - bits.into_sim_value(ty) + bits.into_sim_value_with_type(ty) } } - impl<$($T: ToSimValue<$Ty>, $Ty: Type,)*> ToSimValue<($($Ty,)*)> for ($($T,)*) { + impl<$($T: ToSimValueWithType<$Ty>, $Ty: Type,)*> ToSimValueWithType<($($Ty,)*)> for ($($T,)*) { #[track_caller] - fn to_sim_value(&self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { + fn to_sim_value_with_type(&self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.to_sim_value($ty_var);)* + $(let $var = $var.to_sim_value_with_type($ty_var);)* SimValue::from_value(ty, ($($var,)*)) } #[track_caller] - fn into_sim_value(self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { + fn into_sim_value_with_type(self, ty: ($($Ty,)*)) -> SimValue<($($Ty,)*)> { let ($($var,)*) = self; let ($($ty_var,)*) = ty; - $(let $var = $var.into_sim_value($ty_var);)* + $(let $var = $var.into_sim_value_with_type($ty_var);)* SimValue::from_value(ty, ($($var,)*)) } } + impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) { + type Type = ($($T::Type,)*); + #[track_caller] + fn to_sim_value(&self) -> SimValue { + let ($($var,)*) = self; + $(let $var = $var.to_sim_value();)* + SimValue::from_value(($(SimValue::ty(&$var),)*), ($($var,)*)) + } + #[track_caller] + fn into_sim_value(self) -> SimValue { + let ($($var,)*) = self; + $(let $var = $var.to_sim_value();)* + SimValue::from_value(($(SimValue::ty(&$var),)*), ($($var,)*)) + } + } impl<$($Lhs: Type + ExprPartialEq<$Rhs>, $Rhs: Type,)*> ExprPartialEq<($($Rhs,)*)> for ($($Lhs,)*) { fn cmp_eq(lhs: Expr, rhs: Expr<($($Rhs,)*)>) -> Expr { let ($($lhs_var,)*) = *lhs; @@ -674,7 +689,7 @@ impl_tuples! { impl Type for PhantomData { type BaseType = Bundle; type MaskType = (); - type SimValue = (); + type SimValue = PhantomData; type MatchVariant = PhantomData; type MatchActiveScope = (); type MatchVariantAndInactiveScope = MatchVariantWithoutScope; @@ -709,7 +724,7 @@ impl Type for PhantomData { } fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { assert!(bits.is_empty()); - () + *self } fn sim_value_clone_from_bits(&self, _value: &mut Self::SimValue, bits: &BitSlice) { assert!(bits.is_empty()); @@ -764,26 +779,38 @@ impl ToExpr for PhantomData { } } -impl ToSimValue for PhantomData { +impl ToSimValue for PhantomData { + type Type = PhantomData; + #[track_caller] - fn to_sim_value(&self, ty: Self) -> SimValue { - ToSimValue::into_sim_value(BitVec::new(), ty) + fn to_sim_value(&self) -> SimValue { + SimValue::from_value(*self, *self) } } -impl ToSimValue for PhantomData { +impl ToSimValueWithType for PhantomData { #[track_caller] - fn to_sim_value(&self, ty: Bundle) -> SimValue { + fn to_sim_value_with_type(&self, ty: Self) -> SimValue { + SimValue::from_value(ty, *self) + } +} + +impl ToSimValueWithType for PhantomData { + #[track_caller] + fn to_sim_value_with_type(&self, ty: Bundle) -> SimValue { assert!(ty.fields().is_empty()); - ToSimValue::into_sim_value(BitVec::new(), ty) + ToSimValueWithType::into_sim_value_with_type(BitVec::new(), ty) } } -impl ToSimValue for PhantomData { +impl ToSimValueWithType for PhantomData { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { let ty = Bundle::from_canonical(ty); assert!(ty.fields().is_empty()); - SimValue::into_canonical(ToSimValue::into_sim_value(BitVec::new(), ty)) + SimValue::into_canonical(ToSimValueWithType::into_sim_value_with_type( + BitVec::new(), + ty, + )) } } diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs index a956dd5..373e150 100644 --- a/crates/fayalite/src/int.rs +++ b/crates/fayalite/src/int.rs @@ -2,12 +2,13 @@ // See Notices.txt for copyright information use crate::{ + array::ArrayType, expr::{ target::{GetTarget, Target}, Expr, NotALiteralExpr, ToExpr, ToLiteralBits, }, intern::{Intern, Interned, Memoize}, - sim::value::SimValue, + sim::value::{SimValue, ToSimValueWithType}, source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, util::{interned_bit, ConstBool, ConstUsize, GenericConstBool, GenericConstUsize}, @@ -58,7 +59,8 @@ pub trait KnownSize: + std::fmt::Debug + IntoIterator> + TryFrom>> - + Into>>; + + Into>> + + ToSimValueWithType>; } macro_rules! known_widths { @@ -120,7 +122,8 @@ pub trait Size: + std::fmt::Debug + IntoIterator> + TryFrom>> - + Into>>; + + Into>> + + ToSimValueWithType>; const KNOWN_VALUE: Option; type SizeType: SizeType + Copy diff --git a/crates/fayalite/src/phantom_const.rs b/crates/fayalite/src/phantom_const.rs index 27bb04e..8422ae0 100644 --- a/crates/fayalite/src/phantom_const.rs +++ b/crates/fayalite/src/phantom_const.rs @@ -11,7 +11,7 @@ use crate::{ }, int::Bool, intern::{Intern, Interned, InternedCompare, LazyInterned, Memoize}, - sim::value::{SimValue, SimValuePartialEq}, + sim::value::{SimValue, SimValuePartialEq, ToSimValue, ToSimValueWithType}, source_location::SourceLocation, ty::{impl_match_variant_as_self, CanonicalType, StaticType, Type, TypeProperties}, }; @@ -248,7 +248,7 @@ impl PhantomConst { impl Type for PhantomConst { type BaseType = PhantomConst; type MaskType = (); - type SimValue = (); + type SimValue = PhantomConst; impl_match_variant_as_self!(); fn mask_type(&self) -> Self::MaskType { @@ -272,15 +272,17 @@ impl Type for PhantomConst { fn sim_value_from_bits(&self, bits: &BitSlice) -> Self::SimValue { assert!(bits.is_empty()); - () + *self } - fn sim_value_clone_from_bits(&self, _value: &mut Self::SimValue, bits: &BitSlice) { + fn sim_value_clone_from_bits(&self, value: &mut Self::SimValue, bits: &BitSlice) { assert!(bits.is_empty()); + assert_eq!(*value, *self); } - fn sim_value_to_bits(&self, _value: &Self::SimValue, bits: &mut BitSlice) { + fn sim_value_to_bits(&self, value: &Self::SimValue, bits: &mut BitSlice) { assert!(bits.is_empty()); + assert_eq!(*value, *self); } } @@ -334,3 +336,23 @@ impl SimValuePartialEq for PhantomConst true } } + +impl ToSimValue for PhantomConst { + type Type = PhantomConst; + + fn to_sim_value(&self) -> SimValue { + SimValue::from_value(*self, *self) + } +} + +impl ToSimValueWithType> for PhantomConst { + fn to_sim_value_with_type(&self, ty: PhantomConst) -> SimValue> { + SimValue::from_value(ty, *self) + } +} + +impl ToSimValueWithType for PhantomConst { + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_value(Self::from_canonical(ty), *self)) + } +} diff --git a/crates/fayalite/src/sim.rs b/crates/fayalite/src/sim.rs index 9be4889..563cd37 100644 --- a/crates/fayalite/src/sim.rs +++ b/crates/fayalite/src/sim.rs @@ -7531,10 +7531,10 @@ macro_rules! impl_simulation_methods { SimValue::from_canonical($self.settle_if_needed(retval)$(.$await)?) } $(#[$track_caller])? - pub $($async)? fn write>(&mut $self, io: Expr, value: V) { + pub $($async)? fn write>(&mut $self, io: Expr, value: V) { $self.sim_impl.borrow_mut().write( Expr::canonical(io), - &SimValue::into_canonical(value.into_sim_value(Expr::ty(io))), + &SimValue::into_canonical(value.into_sim_value_with_type(Expr::ty(io))), $which_module, ); } diff --git a/crates/fayalite/src/sim/value.rs b/crates/fayalite/src/sim/value.rs index 3e45016..d415af4 100644 --- a/crates/fayalite/src/sim/value.rs +++ b/crates/fayalite/src/sim/value.rs @@ -9,7 +9,7 @@ use crate::{ expr::{CastBitsTo, Expr, ToExpr}, int::{Bool, IntType, KnownSize, SInt, SIntType, SIntValue, Size, UInt, UIntType, UIntValue}, reset::{AsyncReset, Reset, SyncReset}, - ty::{CanonicalType, Type}, + ty::{CanonicalType, StaticType, Type}, util::{ alternating_cell::{AlternatingCell, AlternatingCellMethods}, ConstUsize, @@ -307,122 +307,223 @@ impl SimValuePartialEq for Bool { } } -pub trait ToSimValue { +pub trait ToSimValue: ToSimValueWithType<::Type> { + type Type: Type; + #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue; + fn to_sim_value(&self) -> SimValue; #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue + fn into_sim_value(self) -> SimValue where Self: Sized, { - self.to_sim_value(ty) + self.to_sim_value() } #[track_caller] - fn arc_into_sim_value(self: Arc, ty: T) -> SimValue { - self.to_sim_value(ty) + fn arc_into_sim_value(self: Arc) -> SimValue { + self.to_sim_value() } #[track_caller] - fn arc_to_sim_value(self: &Arc, ty: T) -> SimValue { - self.to_sim_value(ty) + fn arc_to_sim_value(self: &Arc) -> SimValue { + self.to_sim_value() } } -impl ToSimValue for SimValue { +pub trait ToSimValueWithType { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - assert_eq!(SimValue::ty(self), ty); + fn to_sim_value_with_type(&self, ty: T) -> SimValue; + #[track_caller] + fn into_sim_value_with_type(self, ty: T) -> SimValue + where + Self: Sized, + { + self.to_sim_value_with_type(ty) + } + #[track_caller] + fn arc_into_sim_value_with_type(self: Arc, ty: T) -> SimValue { + self.to_sim_value_with_type(ty) + } + #[track_caller] + fn arc_to_sim_value_with_type(self: &Arc, ty: T) -> SimValue { + self.to_sim_value_with_type(ty) + } +} + +macro_rules! forward_to_sim_value_with_type { + ([$($generics:tt)*] $ty:ty) => { + impl<$($generics)*> ToSimValueWithType<::Type> for $ty { + fn to_sim_value_with_type(&self, ty: ::Type) -> SimValue<::Type> { + let retval = Self::to_sim_value(self); + assert_eq!(SimValue::ty(&retval), ty); + retval + } + #[track_caller] + fn into_sim_value_with_type(self, ty: ::Type) -> SimValue<::Type> + where + Self: Sized, + { + let retval = Self::into_sim_value(self); + assert_eq!(SimValue::ty(&retval), ty); + retval + } + #[track_caller] + fn arc_into_sim_value_with_type(self: Arc, ty: ::Type) -> SimValue<::Type> { + let retval = Self::arc_into_sim_value(self); + assert_eq!(SimValue::ty(&retval), ty); + retval + } + #[track_caller] + fn arc_to_sim_value_with_type(self: &Arc, ty: ::Type) -> SimValue<::Type> { + let retval = Self::arc_to_sim_value(self); + assert_eq!(SimValue::ty(&retval), ty); + retval + } + } + }; +} + +impl ToSimValue for SimValue { + type Type = T; + fn to_sim_value(&self) -> SimValue { self.clone() } - #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue { - assert_eq!(SimValue::ty(&self), ty); + fn into_sim_value(self) -> SimValue { self } } -impl ToSimValue for BitVec { +forward_to_sim_value_with_type!([T: Type] SimValue); + +impl ToSimValueWithType for BitVec { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - self.clone().into_sim_value(ty) + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + self.clone().into_sim_value_with_type(ty) } #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue { - Arc::new(self).arc_into_sim_value(ty) + fn into_sim_value_with_type(self, ty: T) -> SimValue { + Arc::new(self).arc_into_sim_value_with_type(ty) } #[track_caller] - fn arc_into_sim_value(self: Arc, ty: T) -> SimValue { + fn arc_into_sim_value_with_type(self: Arc, ty: T) -> SimValue { SimValue::from_bits(ty, UIntValue::new_dyn(self)) } #[track_caller] - fn arc_to_sim_value(self: &Arc, ty: T) -> SimValue { + fn arc_to_sim_value_with_type(self: &Arc, ty: T) -> SimValue { SimValue::from_bits(ty, UIntValue::new_dyn(self.clone())) } } -impl ToSimValue for bitvec::boxed::BitBox { +impl ToSimValueWithType for bitvec::boxed::BitBox { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - self.clone().into_sim_value(ty) + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + self.clone().into_sim_value_with_type(ty) } #[track_caller] - fn into_sim_value(self, ty: T) -> SimValue { - self.into_bitvec().into_sim_value(ty) + fn into_sim_value_with_type(self, ty: T) -> SimValue { + self.into_bitvec().into_sim_value_with_type(ty) } } -impl ToSimValue for BitSlice { +impl ToSimValueWithType for BitSlice { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - self.to_bitvec().into_sim_value(ty) + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + self.to_bitvec().into_sim_value_with_type(ty) } } -impl, T: Type> ToSimValue for &'_ This { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) +impl ToSimValue for &'_ This { + type Type = This::Type; + + fn to_sim_value(&self) -> SimValue { + This::to_sim_value(self) } } -impl, T: Type> ToSimValue for &'_ mut This { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) +impl, T: Type> ToSimValueWithType for &'_ This { + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + This::to_sim_value_with_type(self, ty) } } -impl, T: Type> ToSimValue for Arc { - fn to_sim_value(&self, ty: T) -> SimValue { - This::arc_to_sim_value(self, ty) - } - fn into_sim_value(self, ty: T) -> SimValue { - This::arc_into_sim_value(self, ty) +impl ToSimValue for &'_ mut This { + type Type = This::Type; + + fn to_sim_value(&self) -> SimValue { + This::to_sim_value(self) } } -impl + Send + Sync + 'static, T: Type> ToSimValue +impl, T: Type> ToSimValueWithType for &'_ mut This { + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + This::to_sim_value_with_type(self, ty) + } +} + +impl ToSimValue for Arc { + type Type = This::Type; + + fn to_sim_value(&self) -> SimValue { + This::arc_to_sim_value(self) + } + fn into_sim_value(self) -> SimValue { + This::arc_into_sim_value(self) + } +} + +impl, T: Type> ToSimValueWithType for Arc { + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + This::arc_to_sim_value_with_type(self, ty) + } + fn into_sim_value_with_type(self, ty: T) -> SimValue { + This::arc_into_sim_value_with_type(self, ty) + } +} + +impl ToSimValue for crate::intern::Interned { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) + type Type = This::Type; + fn to_sim_value(&self) -> SimValue { + This::to_sim_value(self) } } -impl, T: Type> ToSimValue for Box { - fn to_sim_value(&self, ty: T) -> SimValue { - This::to_sim_value(self, ty) +impl + Send + Sync + 'static, T: Type> ToSimValueWithType + for crate::intern::Interned +{ + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + This::to_sim_value_with_type(self, ty) } - fn into_sim_value(self, ty: T) -> SimValue { - This::into_sim_value(*self, ty) +} + +impl ToSimValue for Box { + type Type = This::Type; + + fn to_sim_value(&self) -> SimValue { + This::to_sim_value(self) + } + fn into_sim_value(self) -> SimValue { + This::into_sim_value(*self) + } +} + +impl, T: Type> ToSimValueWithType for Box { + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + This::to_sim_value_with_type(self, ty) + } + fn into_sim_value_with_type(self, ty: T) -> SimValue { + This::into_sim_value_with_type(*self, ty) } } impl SimValue> { #[track_caller] - pub fn from_array_elements>>( + pub fn from_array_elements>>( ty: ArrayType, elements: I, ) -> Self { @@ -430,23 +531,32 @@ impl SimValue> { let elements = Vec::from_iter( elements .into_iter() - .map(|element| element.into_sim_value(element_ty)), + .map(|element| element.into_sim_value_with_type(element_ty)), ); assert_eq!(elements.len(), ty.len()); SimValue::from_value(ty, elements.try_into().ok().expect("already checked len")) } } -impl, T: Type> ToSimValue> for [Element] { +impl, T: Type> ToSimValueWithType> for [Element] { #[track_caller] - fn to_sim_value(&self, ty: Array) -> SimValue> { + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } } -impl> ToSimValue for [Element] { +impl> ToSimValue for [Element] { + type Type = Array; + #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value(&self) -> SimValue { + SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) + } +} + +impl> ToSimValueWithType for [Element] { + #[track_caller] + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { SimValue::into_canonical(SimValue::from_array_elements( ::from_canonical(ty), self, @@ -454,71 +564,61 @@ impl> ToSimValue for [Element] } } -impl, T: Type, const N: usize> ToSimValue> for [Element; N] +impl, T: Type, const N: usize> ToSimValueWithType> + for [Element; N] where ConstUsize: KnownSize, { #[track_caller] - fn to_sim_value(&self, ty: Array) -> SimValue> { + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } #[track_caller] - fn into_sim_value(self, ty: Array) -> SimValue> { + fn into_sim_value_with_type(self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } } -impl, T: Type, const N: usize> ToSimValue> for [Element; N] { - #[track_caller] - fn to_sim_value(&self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) +impl, const N: usize> ToSimValue for [Element; N] +where + ConstUsize: KnownSize, +{ + type Type = Array; + + fn to_sim_value(&self) -> SimValue { + SimValue::from_array_elements(StaticType::TYPE, self) } - #[track_caller] - fn into_sim_value(self, ty: Array) -> SimValue> { - SimValue::from_array_elements(ty, self) + + fn into_sim_value(self) -> SimValue { + SimValue::from_array_elements(StaticType::TYPE, self) } } -impl, const N: usize> ToSimValue +impl, T: Type, const N: usize> ToSimValueWithType> for [Element; N] { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } - #[track_caller] - fn into_sim_value(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(SimValue::from_array_elements( - ::from_canonical(ty), - self, - )) - } -} - -impl, T: Type> ToSimValue> for Vec { - #[track_caller] - fn to_sim_value(&self, ty: Array) -> SimValue> { + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } #[track_caller] - fn into_sim_value(self, ty: Array) -> SimValue> { + fn into_sim_value_with_type(self, ty: Array) -> SimValue> { SimValue::from_array_elements(ty, self) } } -impl> ToSimValue for Vec { +impl, const N: usize> ToSimValueWithType + for [Element; N] +{ #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { SimValue::into_canonical(SimValue::from_array_elements( ::from_canonical(ty), self, )) } #[track_caller] - fn into_sim_value(self, ty: CanonicalType) -> SimValue { + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { SimValue::into_canonical(SimValue::from_array_elements( ::from_canonical(ty), self, @@ -526,37 +626,131 @@ impl> ToSimValue for Vec ToSimValue for Expr { +impl, T: Type> ToSimValueWithType> for Vec { #[track_caller] - fn to_sim_value(&self, ty: T) -> SimValue { - assert_eq!(Expr::ty(*self), ty); + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } + #[track_caller] + fn into_sim_value_with_type(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } +} + +impl> ToSimValue for Vec { + type Type = Array; + + fn to_sim_value(&self) -> SimValue { + SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) + } + + fn into_sim_value(self) -> SimValue { + SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) + } +} + +impl> ToSimValueWithType + for Vec +{ + #[track_caller] + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } + #[track_caller] + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } +} + +impl, T: Type> ToSimValueWithType> for Box<[Element]> { + #[track_caller] + fn to_sim_value_with_type(&self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } + #[track_caller] + fn into_sim_value_with_type(self, ty: Array) -> SimValue> { + SimValue::from_array_elements(ty, self) + } +} + +impl> ToSimValue for Box<[Element]> { + type Type = Array; + + fn to_sim_value(&self) -> SimValue { + SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) + } + + fn into_sim_value(self) -> SimValue { + SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self) + } +} + +impl> ToSimValueWithType + for Box<[Element]> +{ + #[track_caller] + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } + #[track_caller] + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical(SimValue::from_array_elements( + ::from_canonical(ty), + self, + )) + } +} + +impl ToSimValue for Expr { + type Type = T; + #[track_caller] + fn to_sim_value(&self) -> SimValue { SimValue::from_bitslice( - ty, + Expr::ty(*self), &crate::expr::ToLiteralBits::to_literal_bits(self) .expect("must be a literal expression"), ) } } +forward_to_sim_value_with_type!([T: Type] Expr); + macro_rules! impl_to_sim_value_for_bool_like { ($ty:ident) => { - impl ToSimValue<$ty> for bool { - fn to_sim_value(&self, ty: $ty) -> SimValue<$ty> { + impl ToSimValueWithType<$ty> for bool { + fn to_sim_value_with_type(&self, ty: $ty) -> SimValue<$ty> { SimValue::from_value(ty, *self) } } }; } +impl ToSimValue for bool { + type Type = Bool; + + fn to_sim_value(&self) -> SimValue { + SimValue::from_value(Bool, *self) + } +} + impl_to_sim_value_for_bool_like!(Bool); impl_to_sim_value_for_bool_like!(AsyncReset); impl_to_sim_value_for_bool_like!(SyncReset); impl_to_sim_value_for_bool_like!(Reset); impl_to_sim_value_for_bool_like!(Clock); -impl ToSimValue for bool { +impl ToSimValueWithType for bool { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { match ty { CanonicalType::UInt(_) | CanonicalType::SInt(_) @@ -579,19 +773,22 @@ impl ToSimValue for bool { macro_rules! impl_to_sim_value_for_primitive_int { ($prim:ident) => { - impl ToSimValue<<$prim as ToExpr>::Type> for $prim { + impl ToSimValue for $prim { + type Type = <$prim as ToExpr>::Type; + #[track_caller] fn to_sim_value( &self, - ty: <$prim as ToExpr>::Type, - ) -> SimValue<<$prim as ToExpr>::Type> { - SimValue::from_value(ty, (*self).into()) + ) -> SimValue { + SimValue::from_value(StaticType::TYPE, (*self).into()) } } - impl ToSimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> for $prim { + forward_to_sim_value_with_type!([] $prim); + + impl ToSimValueWithType<<<$prim as ToExpr>::Type as IntType>::Dyn> for $prim { #[track_caller] - fn to_sim_value( + fn to_sim_value_with_type( &self, ty: <<$prim as ToExpr>::Type as IntType>::Dyn, ) -> SimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> { @@ -602,11 +799,11 @@ macro_rules! impl_to_sim_value_for_primitive_int { } } - impl ToSimValue for $prim { + impl ToSimValueWithType for $prim { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { let ty: <<$prim as ToExpr>::Type as IntType>::Dyn = Type::from_canonical(ty); - SimValue::into_canonical(self.to_sim_value(ty)) + SimValue::into_canonical(self.to_sim_value_with_type(ty)) } } }; @@ -627,35 +824,51 @@ impl_to_sim_value_for_primitive_int!(isize); macro_rules! impl_to_sim_value_for_int_value { ($IntValue:ident, $Int:ident, $IntType:ident) => { - impl ToSimValue<$IntType> for $IntValue { - fn to_sim_value(&self, ty: $IntType) -> SimValue<$IntType> { - self.bits().to_sim_value(ty) + impl ToSimValue for $IntValue { + type Type = $IntType; + + fn to_sim_value(&self) -> SimValue { + SimValue::from_value(self.ty(), self.clone()) } - fn into_sim_value(self, ty: $IntType) -> SimValue<$IntType> { - self.into_bits().into_sim_value(ty) + fn into_sim_value(self) -> SimValue { + SimValue::from_value(self.ty(), self) } } - impl ToSimValue<$Int> for $IntValue { - fn to_sim_value(&self, ty: $Int) -> SimValue<$Int> { - self.bits().to_sim_value(ty) + impl ToSimValueWithType<$IntType> for $IntValue { + fn to_sim_value_with_type(&self, ty: $IntType) -> SimValue<$IntType> { + SimValue::from_value(ty, self.clone()) } - fn into_sim_value(self, ty: $Int) -> SimValue<$Int> { - self.into_bits().into_sim_value(ty) + fn into_sim_value_with_type(self, ty: $IntType) -> SimValue<$IntType> { + SimValue::from_value(ty, self) } } - impl ToSimValue for $IntValue { + impl ToSimValueWithType<$Int> for $IntValue { + fn to_sim_value_with_type(&self, ty: $Int) -> SimValue<$Int> { + self.bits().to_sim_value_with_type(ty) + } + + fn into_sim_value_with_type(self, ty: $Int) -> SimValue<$Int> { + self.into_bits().into_sim_value_with_type(ty) + } + } + + impl ToSimValueWithType for $IntValue { #[track_caller] - fn to_sim_value(&self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(self.to_sim_value($Int::from_canonical(ty))) + fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical( + self.to_sim_value_with_type($IntType::::from_canonical(ty)), + ) } #[track_caller] - fn into_sim_value(self, ty: CanonicalType) -> SimValue { - SimValue::into_canonical(self.into_sim_value($Int::from_canonical(ty))) + fn into_sim_value_with_type(self, ty: CanonicalType) -> SimValue { + SimValue::into_canonical( + self.into_sim_value_with_type($IntType::::from_canonical(ty)), + ) } } }; diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs index cd26c9b..23680f7 100644 --- a/crates/fayalite/src/ty.rs +++ b/crates/fayalite/src/ty.rs @@ -11,6 +11,7 @@ use crate::{ intern::{Intern, Interned}, phantom_const::PhantomConst, reset::{AsyncReset, Reset, SyncReset}, + sim::value::{SimValue, ToSimValueWithType}, source_location::SourceLocation, util::ConstUsize, }; @@ -269,7 +270,7 @@ pub trait Type: { type BaseType: BaseType; type MaskType: Type; - type SimValue: fmt::Debug + Clone + 'static; + type SimValue: fmt::Debug + Clone + 'static + ToSimValueWithType; type MatchVariant: 'static + Send + Sync; type MatchActiveScope; type MatchVariantAndInactiveScope: MatchVariantAndInactiveScope< @@ -389,6 +390,15 @@ impl OpaqueSimValue { } } +impl> ToSimValueWithType for OpaqueSimValue { + fn to_sim_value_with_type(&self, ty: T) -> SimValue { + SimValue::from_value(ty, self.clone()) + } + fn into_sim_value_with_type(self, ty: T) -> SimValue { + SimValue::from_value(ty, self) + } +} + pub trait StaticType: Type { const TYPE: Self; const MASK_TYPE: Self::MaskType; diff --git a/crates/fayalite/tests/sim.rs b/crates/fayalite/tests/sim.rs index eb5c79e..398fe18 100644 --- a/crates/fayalite/tests/sim.rs +++ b/crates/fayalite/tests/sim.rs @@ -7,13 +7,7 @@ use fayalite::{ module::{instance_with_loc, reg_builder_with_loc}, prelude::*, reset::ResetType, - sim::{ - time::SimDuration, - value::{SimValue, ToSimValue}, - vcd::VcdWriterDecls, - Simulation, - }, - ty::StaticType, + sim::{time::SimDuration, vcd::VcdWriterDecls, Simulation}, util::RcWriter, }; use std::num::NonZeroUsize; @@ -391,113 +385,110 @@ fn test_enums() { let mut sim = Simulation::new(enums()); let mut writer = RcWriter::default(); sim.add_trace_writer(VcdWriterDecls::new(writer.clone())); - sim.write_clock(sim.io().cd.clk, false); - sim.write_reset(sim.io().cd.rst, true); - sim.write_bool(sim.io().en, false); - sim.write_bool_or_int(sim.io().which_in, 0_hdl_u2); - sim.write_bool_or_int(sim.io().data_in, 0_hdl_u4); + sim.write(sim.io().cd.clk, false); + sim.write(sim.io().cd.rst, true); + sim.write(sim.io().en, false); + sim.write(sim.io().which_in, 0_hdl_u2); + sim.write(sim.io().data_in, 0_hdl_u4); sim.advance_time(SimDuration::from_micros(1)); - sim.write_clock(sim.io().cd.clk, true); + sim.write(sim.io().cd.clk, true); sim.advance_time(SimDuration::from_nanos(100)); - sim.write_reset(sim.io().cd.rst, false); + sim.write(sim.io().cd.rst, false); sim.advance_time(SimDuration::from_nanos(900)); - type BOutTy = HdlOption<(UInt<1>, Bool)>; - #[derive(Debug, PartialEq)] + #[hdl(cmp_eq)] struct IO { - en: bool, - which_in: u8, - data_in: u8, - which_out: u8, - data_out: u8, - b_out: SimValue, + en: Bool, + which_in: UInt<2>, + data_in: UInt<4>, + which_out: UInt<2>, + data_out: UInt<4>, + b_out: HdlOption<(UInt<1>, Bool)>, } let io_cycles = [ + #[hdl(sim)] IO { en: false, - which_in: 0, - data_in: 0, - which_out: 0, - data_out: 0, - b_out: HdlNone().to_sim_value(StaticType::TYPE), + which_in: 0_hdl_u2, + data_in: 0_hdl_u4, + which_out: 0_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlNone(), }, + #[hdl(sim)] IO { en: true, - which_in: 1, - data_in: 0, - which_out: 0, - data_out: 0, - b_out: HdlNone().to_sim_value(StaticType::TYPE), + which_in: 1_hdl_u2, + data_in: 0_hdl_u4, + which_out: 0_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlNone(), }, + #[hdl(sim)] IO { en: false, - which_in: 0, - data_in: 0, - which_out: 1, - data_out: 0, - b_out: HdlSome((0_hdl_u1, false)).to_sim_value(StaticType::TYPE), + which_in: 0_hdl_u2, + data_in: 0_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlSome((0_hdl_u1, false)), }, + #[hdl(sim)] IO { en: true, - which_in: 1, - data_in: 0xF, - which_out: 1, - data_out: 0, - b_out: HdlSome((0_hdl_u1, false)).to_sim_value(StaticType::TYPE), + which_in: 1_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0_hdl_u4, + b_out: HdlSome((0_hdl_u1, false)), }, + #[hdl(sim)] IO { en: true, - which_in: 1, - data_in: 0xF, - which_out: 1, - data_out: 0x3, - b_out: HdlSome((1_hdl_u1, true)).to_sim_value(StaticType::TYPE), + which_in: 1_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0x3_hdl_u4, + b_out: HdlSome((1_hdl_u1, true)), }, + #[hdl(sim)] IO { en: true, - which_in: 2, - data_in: 0xF, - which_out: 1, - data_out: 0x3, - b_out: HdlSome((1_hdl_u1, true)).to_sim_value(StaticType::TYPE), + which_in: 2_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 1_hdl_u2, + data_out: 0x3_hdl_u4, + b_out: HdlSome((1_hdl_u1, true)), }, + #[hdl(sim)] IO { en: true, - which_in: 2, - data_in: 0xF, - which_out: 2, - data_out: 0xF, - b_out: HdlNone().to_sim_value(StaticType::TYPE), + which_in: 2_hdl_u2, + data_in: 0xF_hdl_u4, + which_out: 2_hdl_u2, + data_out: 0xF_hdl_u4, + b_out: HdlNone(), }, ]; - for ( - cycle, - expected @ IO { + for (cycle, expected) in io_cycles.into_iter().enumerate() { + #[hdl(sim)] + let IO { en, which_in, data_in, which_out: _, data_out: _, b_out: _, - }, - ) in io_cycles.into_iter().enumerate() - { - sim.write_bool(sim.io().en, en); - sim.write_bool_or_int(sim.io().which_in, which_in.cast_to_static()); - sim.write_bool_or_int(sim.io().data_in, data_in.cast_to_static()); - let io = IO { + } = expected; + sim.write(sim.io().en, &en); + sim.write(sim.io().which_in, &which_in); + sim.write(sim.io().data_in, &data_in); + let io = #[hdl(sim)] + IO { en, which_in, data_in, - which_out: sim - .read_bool_or_int(sim.io().which_out) - .to_bigint() - .try_into() - .expect("known to be in range"), - data_out: sim - .read_bool_or_int(sim.io().data_out) - .to_bigint() - .try_into() - .expect("known to be in range"), + which_out: sim.read(sim.io().which_out), + data_out: sim.read(sim.io().data_out), b_out: sim.read(sim.io().b_out), }; assert_eq!( @@ -559,7 +550,7 @@ fn test_memories() { w_mask: (Bool, Bool), } let io_cycles = [ - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: false, @@ -569,7 +560,7 @@ fn test_memories() { w_data: (0u8, 0i8), w_mask: (false, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -579,7 +570,7 @@ fn test_memories() { w_data: (0x10u8, 0x20i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -589,7 +580,7 @@ fn test_memories() { w_data: (0x30u8, 0x40i8), w_mask: (false, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -599,7 +590,7 @@ fn test_memories() { w_data: (0x50u8, 0x60i8), w_mask: (true, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -609,7 +600,7 @@ fn test_memories() { w_data: (0x70u8, -0x80i8), w_mask: (false, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -619,7 +610,7 @@ fn test_memories() { w_data: (0x90u8, 0xA0u8 as i8), w_mask: (false, false), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -629,7 +620,7 @@ fn test_memories() { w_data: (0x90u8, 0xA0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -639,7 +630,7 @@ fn test_memories() { w_data: (0xB0u8, 0xC0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 0_hdl_u4, r_en: true, @@ -649,7 +640,7 @@ fn test_memories() { w_data: (0xD0u8, 0xE0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 1_hdl_u4, r_en: true, @@ -659,7 +650,7 @@ fn test_memories() { w_data: (0xD0u8, 0xE0u8 as i8), w_mask: (true, true), }, - #[hdl] + #[hdl(sim)] IO { r_addr: 2_hdl_u4, r_en: true, @@ -671,7 +662,7 @@ fn test_memories() { }, ]; for (cycle, expected) in io_cycles.into_iter().enumerate() { - #[hdl] + #[hdl(sim)] let IO { r_addr, r_en, @@ -681,13 +672,13 @@ fn test_memories() { w_data, w_mask, } = expected; - sim.write(sim.io().r.addr, r_addr); - sim.write(sim.io().r.en, r_en); - sim.write(sim.io().w.addr, w_addr); - sim.write(sim.io().w.en, w_en); - sim.write(sim.io().w.data, w_data); - sim.write(sim.io().w.mask, w_mask); - let io = (#[hdl] + sim.write(sim.io().r.addr, &r_addr); + sim.write(sim.io().r.en, &r_en); + sim.write(sim.io().w.addr, &w_addr); + sim.write(sim.io().w.en, &w_en); + sim.write(sim.io().w.data, &w_data); + sim.write(sim.io().w.mask, &w_mask); + let io = #[hdl(sim)] IO { r_addr, r_en, @@ -696,20 +687,19 @@ fn test_memories() { w_en, w_data, w_mask, - }) - .to_sim_value(StaticType::TYPE); + }; assert_eq!( - expected.to_sim_value(StaticType::TYPE), + expected, io, "vcd:\n{}\ncycle: {cycle}", String::from_utf8(writer.take()).unwrap(), ); sim.advance_time(SimDuration::from_micros(1)); - sim.write_clock(sim.io().r.clk, true); - sim.write_clock(sim.io().w.clk, true); + sim.write(sim.io().r.clk, true); + sim.write(sim.io().w.clk, true); sim.advance_time(SimDuration::from_micros(1)); - sim.write_clock(sim.io().r.clk, false); - sim.write_clock(sim.io().w.clk, false); + sim.write(sim.io().r.clk, false); + sim.write(sim.io().w.clk, false); } sim.flush_traces().unwrap(); let vcd = String::from_utf8(writer.take()).unwrap();