463 lines
15 KiB
Rust
463 lines
15 KiB
Rust
// SPDX-License-Identifier: LGPL-3.0-or-later
|
|
// See Notices.txt for copyright information
|
|
#![allow(clippy::multiple_bound_locations)]
|
|
use crate::{
|
|
annotations::{Annotation, CustomFirrtlAnnotation, TargetedAnnotation},
|
|
array::{Array, ArrayType, ArrayTypeTrait, ValueArrayOrSlice},
|
|
bundle::{BundleType, BundleValue, DynBundle, DynBundleType, FieldType},
|
|
clock::{Clock, ClockType},
|
|
enum_::{DynEnum, DynEnumType, EnumType, EnumValue, VariantType},
|
|
expr::{
|
|
ops, Expr, ExprEnum, Literal, Target, TargetBase, TargetChild, TargetPathArrayElement,
|
|
TargetPathBundleField, TargetPathDynArrayElement, TargetPathElement, ToExpr,
|
|
},
|
|
int::{DynInt, DynIntType, FixedOrDynIntType, IntType, IntTypeTrait},
|
|
intern::{Intern, Interned},
|
|
memory::{Mem, MemPort, PortKind, PortName, PortType, ReadUnderWrite},
|
|
module::{
|
|
AnnotatedModuleIO, Block, BlockId, ExternModuleBody, ExternModuleParameter,
|
|
ExternModuleParameterValue, Instance, Module, ModuleBody, ModuleIO, NameId,
|
|
NormalModuleBody, ScopedNameId, Stmt, StmtConnect, StmtDeclaration, StmtIf, StmtInstance,
|
|
StmtMatch, StmtReg, StmtWire,
|
|
},
|
|
reg::Reg,
|
|
reset::{AsyncReset, AsyncResetType, Reset, ResetType, SyncReset, SyncResetType},
|
|
source_location::SourceLocation,
|
|
ty::{DynCanonicalType, DynCanonicalValue, DynType, Type, TypeEnum, Value, ValueEnum},
|
|
util::{ConstBool, GenericConstBool},
|
|
wire::Wire,
|
|
};
|
|
use num_bigint::{BigInt, BigUint};
|
|
use std::{rc::Rc, sync::Arc};
|
|
|
|
pub trait Fold<State: ?Sized + Folder>: Sized {
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error>;
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error>;
|
|
}
|
|
|
|
pub trait Visit<State: ?Sized + Visitor> {
|
|
fn visit(&self, state: &mut State) -> Result<(), State::Error>;
|
|
fn default_visit(&self, state: &mut State) -> Result<(), State::Error>;
|
|
}
|
|
|
|
macro_rules! impl_visit_fold {
|
|
(
|
|
impl<$T:ident, $State:ident $(, const $Const:ident: $const_ty:ty)*> _ for $ty:ty $(where ($($where_tt:tt)*))? {
|
|
fn fold($($fold_args:tt)*) -> $fold_ret_ty:ty $fold_block:block
|
|
fn default_fold($($default_fold_args:tt)*) -> $default_fold_ret_ty:ty $default_fold_block:block
|
|
fn visit($($visit_args:tt)*) -> $visit_ret_ty:ty $visit_block:block
|
|
fn default_visit($($default_visit_args:tt)*) -> $default_visit_ret_ty:ty $default_visit_block:block
|
|
}
|
|
) => {
|
|
impl<$T: Fold<$State>, $State: ?Sized + Folder $(, const $Const: $const_ty)*> Fold<$State> for $ty
|
|
$(where $($where_tt)*)?
|
|
{
|
|
fn fold($($fold_args)*) -> $fold_ret_ty $fold_block
|
|
fn default_fold($($default_fold_args)*) -> $default_fold_ret_ty $default_fold_block
|
|
}
|
|
impl<$T: Visit<$State>, $State: ?Sized + Visitor $(, const $Const: $const_ty)*> Visit<$State> for $ty
|
|
$(where $($where_tt)*)?
|
|
{
|
|
fn visit($($visit_args)*) -> $visit_ret_ty $visit_block
|
|
fn default_visit($($default_visit_args)*) -> $default_visit_ret_ty $default_visit_block
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! no_op_visit_fold {
|
|
($ty:ty) => {
|
|
impl<State: ?Sized + Folder> Fold<State> for $ty {
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
let _ = state;
|
|
Ok(self)
|
|
}
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
let _ = state;
|
|
Ok(self)
|
|
}
|
|
}
|
|
|
|
impl<State: ?Sized + Visitor> Visit<State> for $ty {
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
let _ = state;
|
|
Ok(())
|
|
}
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
let _ = state;
|
|
Ok(())
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
no_op_visit_fold!(());
|
|
no_op_visit_fold!(char);
|
|
no_op_visit_fold!(u8);
|
|
no_op_visit_fold!(u16);
|
|
no_op_visit_fold!(u32);
|
|
no_op_visit_fold!(u64);
|
|
no_op_visit_fold!(u128);
|
|
no_op_visit_fold!(usize);
|
|
no_op_visit_fold!(i8);
|
|
no_op_visit_fold!(i16);
|
|
no_op_visit_fold!(i32);
|
|
no_op_visit_fold!(i64);
|
|
no_op_visit_fold!(i128);
|
|
no_op_visit_fold!(isize);
|
|
no_op_visit_fold!(std::num::NonZeroU8);
|
|
no_op_visit_fold!(std::num::NonZeroU16);
|
|
no_op_visit_fold!(std::num::NonZeroU32);
|
|
no_op_visit_fold!(std::num::NonZeroU64);
|
|
no_op_visit_fold!(std::num::NonZeroU128);
|
|
no_op_visit_fold!(std::num::NonZeroUsize);
|
|
no_op_visit_fold!(std::num::NonZeroI8);
|
|
no_op_visit_fold!(std::num::NonZeroI16);
|
|
no_op_visit_fold!(std::num::NonZeroI32);
|
|
no_op_visit_fold!(std::num::NonZeroI64);
|
|
no_op_visit_fold!(std::num::NonZeroI128);
|
|
no_op_visit_fold!(std::num::NonZeroIsize);
|
|
no_op_visit_fold!(bool);
|
|
no_op_visit_fold!(String);
|
|
no_op_visit_fold!(Interned<str>);
|
|
no_op_visit_fold!(Box<str>);
|
|
no_op_visit_fold!(Arc<str>);
|
|
no_op_visit_fold!(Rc<str>);
|
|
no_op_visit_fold!(BigInt);
|
|
no_op_visit_fold!(BigUint);
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Box<T> {
|
|
fn fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
*self = T::fold(*self, state)?;
|
|
Ok(self)
|
|
}
|
|
|
|
fn default_fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
*self = T::default_fold(*self, state)?;
|
|
Ok(self)
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::visit(self, state)
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::default_visit(self, state)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Arc<T>
|
|
where (
|
|
T: Clone,
|
|
)
|
|
{
|
|
fn fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Arc::get_mut(&mut self) {
|
|
*v = T::fold(v.clone(), state)?;
|
|
Ok(self)
|
|
} else {
|
|
T::fold(T::clone(&*self), state).map(Arc::new)
|
|
}
|
|
}
|
|
|
|
fn default_fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Arc::get_mut(&mut self) {
|
|
*v = T::default_fold(v.clone(), state)?;
|
|
Ok(self)
|
|
} else {
|
|
T::default_fold(T::clone(&*self), state).map(Arc::new)
|
|
}
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::visit(self, state)
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::default_visit(self, state)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Rc<T>
|
|
where (
|
|
T: Clone,
|
|
)
|
|
{
|
|
fn fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Rc::get_mut(&mut self) {
|
|
*v = T::fold(v.clone(), state)?;
|
|
Ok(self)
|
|
} else {
|
|
T::fold(T::clone(&*self), state).map(Rc::new)
|
|
}
|
|
}
|
|
|
|
fn default_fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Rc::get_mut(&mut self) {
|
|
*v = T::default_fold(v.clone(), state)?;
|
|
Ok(self)
|
|
} else {
|
|
T::default_fold(T::clone(&*self), state).map(Rc::new)
|
|
}
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::visit(self, state)
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::default_visit(self, state)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Arc<[T]>
|
|
where (
|
|
T: Clone,
|
|
) {
|
|
fn fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Arc::get_mut(&mut self) {
|
|
v.iter_mut().try_for_each(|v| {
|
|
*v = v.clone().fold(state)?;
|
|
Ok(())
|
|
})?;
|
|
Ok(self)
|
|
} else {
|
|
FromIterator::from_iter(self.iter().map(|v| v.clone().fold(state)))
|
|
}
|
|
}
|
|
|
|
fn default_fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Arc::get_mut(&mut self) {
|
|
v.iter_mut().try_for_each(|v| {
|
|
*v = v.clone().default_fold(state)?;
|
|
Ok(())
|
|
})?;
|
|
Ok(self)
|
|
} else {
|
|
FromIterator::from_iter(self.iter().map(|v| v.clone().default_fold(state)))
|
|
}
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::visit(v, state))
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::default_visit(v, state))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Rc<[T]>
|
|
where (
|
|
T: Clone,
|
|
) {
|
|
fn fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Rc::get_mut(&mut self) {
|
|
v.iter_mut().try_for_each(|v| {
|
|
*v = v.clone().fold(state)?;
|
|
Ok(())
|
|
})?;
|
|
Ok(self)
|
|
} else {
|
|
FromIterator::from_iter(self.iter().map(|v| v.clone().fold(state)))
|
|
}
|
|
}
|
|
|
|
fn default_fold(mut self, state: &mut State) -> Result<Self, State::Error> {
|
|
if let Some(v) = Rc::get_mut(&mut self) {
|
|
v.iter_mut().try_for_each(|v| {
|
|
*v = v.clone().default_fold(state)?;
|
|
Ok(())
|
|
})?;
|
|
Ok(self)
|
|
} else {
|
|
FromIterator::from_iter(self.iter().map(|v| v.clone().default_fold(state)))
|
|
}
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::visit(v, state))
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::default_visit(v, state))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Interned<T>
|
|
where (
|
|
T: Clone + Intern
|
|
)
|
|
{
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
T::fold(T::clone(&self), state).map(Intern::intern_sized)
|
|
}
|
|
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
T::default_fold(T::clone(&self), state).map(Intern::intern_sized)
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::visit(self, state)
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::default_visit(self, state)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Interned<[T]>
|
|
where (
|
|
T: Clone + 'static + Send + Sync,
|
|
[T]: Intern,
|
|
)
|
|
{
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
FromIterator::from_iter(self.into_iter().map(|v| v.fold(state)))
|
|
}
|
|
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
FromIterator::from_iter(self.into_iter().map(|v| v.default_fold(state)))
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::visit(v, state))
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::default_visit(v, state))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Box<[T]> {
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
FromIterator::from_iter(self.into_vec().into_iter().map(|v| v.fold(state)))
|
|
}
|
|
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
FromIterator::from_iter(self.into_vec().into_iter().map(|v| v.default_fold(state)))
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::visit(v, state))
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::default_visit(v, state))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State, const N: usize> _ for [T; N] {
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
let mut retval = std::array::from_fn(|_| None);
|
|
for (retval, v) in retval.iter_mut().zip(self) {
|
|
*retval = Some(v.fold(state)?);
|
|
}
|
|
Ok(retval.map(Option::unwrap))
|
|
}
|
|
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
let mut retval = std::array::from_fn(|_| None);
|
|
for (retval, v) in retval.iter_mut().zip(self) {
|
|
*retval = Some(v.default_fold(state)?);
|
|
}
|
|
Ok(retval.map(Option::unwrap))
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::visit(v, state))
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::default_visit(v, state))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Vec<T> {
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
FromIterator::from_iter(self.into_iter().map(|v| v.fold(state)))
|
|
}
|
|
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
FromIterator::from_iter(self.into_iter().map(|v| v.default_fold(state)))
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::visit(v, state))
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
self.iter().try_for_each(|v| T::default_visit(v, state))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_visit_fold! {
|
|
impl<T, State> _ for Option<T> {
|
|
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
self.map(|v| v.fold(state)).transpose()
|
|
}
|
|
|
|
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
self.map(|v| v.default_fold(state)).transpose()
|
|
}
|
|
|
|
fn visit(&self, state: &mut State) -> Result<(), State::Error> {
|
|
let Some(v) = self else {
|
|
return Ok(());
|
|
};
|
|
T::visit(v, state)
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), State::Error> {
|
|
let Some(v) = self else {
|
|
return Ok(());
|
|
};
|
|
T::default_visit(v, state)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized + Visit<State>, State: ?Sized + Visitor> Visit<State> for &'_ T {
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::visit(self, state)
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::default_visit(self, state)
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized + Visit<State>, State: ?Sized + Visitor> Visit<State> for &'_ mut T {
|
|
fn visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::visit(self, state)
|
|
}
|
|
|
|
fn default_visit(&self, state: &mut State) -> Result<(), <State>::Error> {
|
|
T::default_visit(self, state)
|
|
}
|
|
}
|
|
|
|
type InternedDynType = Interned<dyn DynType>;
|
|
type InternedDynCanonicalType = Interned<dyn DynCanonicalType>;
|
|
|
|
include!(concat!(env!("OUT_DIR"), "/visit.rs"));
|