WIP: use HdlOption[the_type_var] or UInt[123 + n] for creating types
All checks were successful
/ test (push) Successful in 13s
All checks were successful
/ test (push) Successful in 13s
This commit is contained in:
parent
cd99dbc849
commit
2c15472e11
SSH key fingerprint:
SHA256:B1iRVvUJkvd7upMIiMqn6OyxvD2SgJkAH3ZnUOj6z+c
|
|
@ -7,13 +7,14 @@ jobs:
|
||||||
- uses: https://code.forgejo.org/actions/checkout@v3
|
- uses: https://code.forgejo.org/actions/checkout@v3
|
||||||
with:
|
with:
|
||||||
fetch-depth: 0
|
fetch-depth: 0
|
||||||
- run: |
|
# FIXME: uncomment once the code works again
|
||||||
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain 1.79.0
|
# - run: |
|
||||||
source "$HOME/.cargo/env"
|
# curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain 1.79.0
|
||||||
echo "$PATH" >> "$GITHUB_PATH"
|
# source "$HOME/.cargo/env"
|
||||||
- uses: https://github.com/Swatinem/rust-cache@v2
|
# echo "$PATH" >> "$GITHUB_PATH"
|
||||||
with:
|
# - uses: https://github.com/Swatinem/rust-cache@v2
|
||||||
save-if: ${{ github.ref == 'refs/heads/master' }}
|
# with:
|
||||||
- run: cargo test
|
# save-if: ${{ github.ref == 'refs/heads/master' }}
|
||||||
- run: cargo test --features=unstable-doc
|
# - run: cargo test
|
||||||
- run: cargo doc --features=unstable-doc
|
# - run: cargo test --features=unstable-doc
|
||||||
|
# - run: cargo doc --features=unstable-doc
|
||||||
|
|
|
||||||
|
|
@ -1,671 +1,90 @@
|
||||||
// SPDX-License-Identifier: LGPL-3.0-or-later
|
// SPDX-License-Identifier: LGPL-3.0-or-later
|
||||||
// See Notices.txt for copyright information
|
// See Notices.txt for copyright information
|
||||||
|
|
||||||
use crate::{
|
use crate::{
|
||||||
bundle::{BundleType, BundleValue},
|
int::{KnownSize, UNKNOWN_SIZE},
|
||||||
expr::{
|
intern::{Intern, Interned},
|
||||||
ops::{ArrayIndex, ArrayLiteral, ExprIndex},
|
ty::{CanonicalType, StaticType, Type},
|
||||||
Expr, ToExpr,
|
|
||||||
},
|
|
||||||
intern::{Intern, Interned, InternedCompare, Memoize},
|
|
||||||
module::{
|
|
||||||
transform::visit::{Fold, Folder, Visit, Visitor},
|
|
||||||
ModuleBuilder, NormalModule,
|
|
||||||
},
|
|
||||||
source_location::SourceLocation,
|
|
||||||
ty::{
|
|
||||||
CanonicalType, CanonicalTypeKind, CanonicalValue, Connect, DynCanonicalType,
|
|
||||||
DynCanonicalValue, DynType, DynValueTrait, MatchVariantWithoutScope, StaticType,
|
|
||||||
StaticValue, Type, TypeEnum, Value, ValueEnum,
|
|
||||||
},
|
|
||||||
util::{ConstBool, GenericConstBool, MakeMutSlice},
|
|
||||||
};
|
|
||||||
use bitvec::{slice::BitSlice, vec::BitVec};
|
|
||||||
use std::{
|
|
||||||
any::Any,
|
|
||||||
borrow::{Borrow, BorrowMut},
|
|
||||||
fmt,
|
|
||||||
hash::Hash,
|
|
||||||
marker::PhantomData,
|
|
||||||
ops::IndexMut,
|
|
||||||
sync::Arc,
|
|
||||||
};
|
};
|
||||||
|
use std::ops::Index;
|
||||||
|
|
||||||
mod sealed {
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||||
pub trait Sealed {}
|
pub struct Array<T: Type, const LEN: usize = UNKNOWN_SIZE> {
|
||||||
|
element: T,
|
||||||
|
len: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait ValueArrayOrSlice:
|
#[allow(non_upper_case_globals)]
|
||||||
sealed::Sealed
|
pub const Array: ArrayWithoutGenerics = ArrayWithoutGenerics;
|
||||||
+ BorrowMut<[<Self as ValueArrayOrSlice>::Element]>
|
|
||||||
+ AsRef<[<Self as ValueArrayOrSlice>::Element]>
|
|
||||||
+ AsMut<[<Self as ValueArrayOrSlice>::Element]>
|
|
||||||
+ Hash
|
|
||||||
+ fmt::Debug
|
|
||||||
+ Eq
|
|
||||||
+ Send
|
|
||||||
+ Sync
|
|
||||||
+ 'static
|
|
||||||
+ IndexMut<usize, Output = <Self as ValueArrayOrSlice>::Element>
|
|
||||||
+ ToOwned
|
|
||||||
+ InternedCompare
|
|
||||||
{
|
|
||||||
type Element: Value<Type = <Self as ValueArrayOrSlice>::ElementType>;
|
|
||||||
type ElementType: Type<Value = <Self as ValueArrayOrSlice>::Element>;
|
|
||||||
type LenType: 'static + Copy + Ord + fmt::Debug + Hash + Send + Sync;
|
|
||||||
type Match: 'static
|
|
||||||
+ Clone
|
|
||||||
+ Eq
|
|
||||||
+ fmt::Debug
|
|
||||||
+ Hash
|
|
||||||
+ Send
|
|
||||||
+ Sync
|
|
||||||
+ BorrowMut<[Expr<Self::Element>]>;
|
|
||||||
type MaskVA: ValueArrayOrSlice<
|
|
||||||
Element = <Self::ElementType as Type>::MaskValue,
|
|
||||||
ElementType = <Self::ElementType as Type>::MaskType,
|
|
||||||
LenType = Self::LenType,
|
|
||||||
MaskVA = Self::MaskVA,
|
|
||||||
> + ?Sized;
|
|
||||||
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;
|
|
||||||
#[allow(clippy::result_unit_err)]
|
|
||||||
fn try_len_type_from_len(v: usize) -> Result<Self::LenType, ()>;
|
|
||||||
fn len_type(&self) -> Self::LenType;
|
|
||||||
fn len(&self) -> usize;
|
|
||||||
fn is_empty(&self) -> bool;
|
|
||||||
fn iter(&self) -> std::slice::Iter<Self::Element> {
|
|
||||||
Borrow::<[_]>::borrow(self).iter()
|
|
||||||
}
|
|
||||||
fn clone_to_arc(&self) -> Arc<Self>;
|
|
||||||
fn arc_make_mut(v: &mut Arc<Self>) -> &mut Self;
|
|
||||||
fn arc_to_arc_slice(self: Arc<Self>) -> Arc<[Self::Element]>;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T> sealed::Sealed for [T] {}
|
impl<T: Type, const LEN: usize> Array<T, LEN> {
|
||||||
|
pub const fn element(&self) -> &T {
|
||||||
impl<V: Value> ValueArrayOrSlice for [V]
|
|
||||||
where
|
|
||||||
V::Type: Type<Value = V>,
|
|
||||||
{
|
|
||||||
type Element = V;
|
|
||||||
type ElementType = V::Type;
|
|
||||||
type LenType = usize;
|
|
||||||
type Match = Box<[Expr<V>]>;
|
|
||||||
type MaskVA = [<Self::ElementType as Type>::MaskValue];
|
|
||||||
type IsStaticLen = ConstBool<false>;
|
|
||||||
const FIXED_LEN_TYPE: Option<Self::LenType> = None;
|
|
||||||
|
|
||||||
fn make_match(array: Expr<Array<Self>>) -> Self::Match {
|
|
||||||
(0..array.canonical_type().len())
|
|
||||||
.map(|index| ArrayIndex::<V::Type>::new_unchecked(array.canonical(), index).to_expr())
|
|
||||||
.collect()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn len_from_len_type(v: Self::LenType) -> usize {
|
|
||||||
v
|
|
||||||
}
|
|
||||||
|
|
||||||
fn try_len_type_from_len(v: usize) -> Result<Self::LenType, ()> {
|
|
||||||
Ok(v)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn len_type(&self) -> Self::LenType {
|
|
||||||
self.len()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn len(&self) -> usize {
|
|
||||||
<[_]>::len(self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn is_empty(&self) -> bool {
|
|
||||||
<[_]>::is_empty(self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn clone_to_arc(&self) -> Arc<Self> {
|
|
||||||
Arc::from(self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn arc_make_mut(v: &mut Arc<Self>) -> &mut Self {
|
|
||||||
MakeMutSlice::make_mut_slice(v)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn arc_to_arc_slice(self: Arc<Self>) -> Arc<[Self::Element]> {
|
|
||||||
self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T, const N: usize> sealed::Sealed for [T; N] {}
|
|
||||||
|
|
||||||
impl<V: Value, const N: usize> ValueArrayOrSlice for [V; N]
|
|
||||||
where
|
|
||||||
V::Type: Type<Value = V>,
|
|
||||||
{
|
|
||||||
type Element = V;
|
|
||||||
type ElementType = V::Type;
|
|
||||||
type LenType = ();
|
|
||||||
type Match = [Expr<V>; N];
|
|
||||||
type MaskVA = [<Self::ElementType as Type>::MaskValue; N];
|
|
||||||
type IsStaticLen = ConstBool<true>;
|
|
||||||
const FIXED_LEN_TYPE: Option<Self::LenType> = Some(());
|
|
||||||
|
|
||||||
fn make_match(array: Expr<Array<Self>>) -> Self::Match {
|
|
||||||
std::array::from_fn(|index| {
|
|
||||||
ArrayIndex::<V::Type>::new_unchecked(array.canonical(), index).to_expr()
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
fn len_from_len_type(_v: Self::LenType) -> usize {
|
|
||||||
N
|
|
||||||
}
|
|
||||||
|
|
||||||
fn try_len_type_from_len(v: usize) -> Result<Self::LenType, ()> {
|
|
||||||
if v == N {
|
|
||||||
Ok(())
|
|
||||||
} else {
|
|
||||||
Err(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn len_type(&self) -> Self::LenType {}
|
|
||||||
|
|
||||||
fn len(&self) -> usize {
|
|
||||||
N
|
|
||||||
}
|
|
||||||
|
|
||||||
fn is_empty(&self) -> bool {
|
|
||||||
N == 0
|
|
||||||
}
|
|
||||||
|
|
||||||
fn clone_to_arc(&self) -> Arc<Self> {
|
|
||||||
Arc::new(self.clone())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn arc_make_mut(v: &mut Arc<Self>) -> &mut Self {
|
|
||||||
Arc::make_mut(v)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn arc_to_arc_slice(self: Arc<Self>) -> Arc<[Self::Element]> {
|
|
||||||
self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, Eq, Hash)]
|
|
||||||
pub struct ArrayType<VA: ValueArrayOrSlice + ?Sized> {
|
|
||||||
element: VA::ElementType,
|
|
||||||
len: VA::LenType,
|
|
||||||
bit_width: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub trait ArrayTypeTrait:
|
|
||||||
Type<
|
|
||||||
CanonicalType = ArrayType<[DynCanonicalValue]>,
|
|
||||||
Value = Array<<Self as ArrayTypeTrait>::ValueArrayOrSlice>,
|
|
||||||
CanonicalValue = Array<[DynCanonicalValue]>,
|
|
||||||
MaskType = ArrayType<
|
|
||||||
<<Self as ArrayTypeTrait>::ValueArrayOrSlice as ValueArrayOrSlice>::MaskVA,
|
|
||||||
>,
|
|
||||||
> + From<ArrayType<<Self as ArrayTypeTrait>::ValueArrayOrSlice>>
|
|
||||||
+ Into<ArrayType<<Self as ArrayTypeTrait>::ValueArrayOrSlice>>
|
|
||||||
+ BorrowMut<ArrayType<<Self as ArrayTypeTrait>::ValueArrayOrSlice>>
|
|
||||||
+ sealed::Sealed
|
|
||||||
+ Connect<Self>
|
|
||||||
{
|
|
||||||
type ValueArrayOrSlice: ValueArrayOrSlice<Element = Self::Element, ElementType = Self::ElementType>
|
|
||||||
+ ?Sized;
|
|
||||||
type Element: Value<Type = Self::ElementType>;
|
|
||||||
type ElementType: Type<Value = Self::Element>;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> sealed::Sealed for ArrayType<VA> {}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> ArrayTypeTrait for ArrayType<VA> {
|
|
||||||
type ValueArrayOrSlice = VA;
|
|
||||||
type Element = VA::Element;
|
|
||||||
type ElementType = VA::ElementType;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Clone for ArrayType<VA> {
|
|
||||||
fn clone(&self) -> Self {
|
|
||||||
Self {
|
|
||||||
element: self.element.clone(),
|
|
||||||
len: self.len,
|
|
||||||
bit_width: self.bit_width,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Copy for ArrayType<VA> where VA::ElementType: Copy {}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> ArrayType<VA> {
|
|
||||||
pub fn element(&self) -> &VA::ElementType {
|
|
||||||
&self.element
|
&self.element
|
||||||
}
|
}
|
||||||
pub fn len(&self) -> usize {
|
pub const fn len(&self) -> usize {
|
||||||
VA::len_from_len_type(self.len)
|
if LEN != UNKNOWN_SIZE {
|
||||||
}
|
debug_assert!(self.len == LEN);
|
||||||
pub fn is_empty(&self) -> bool {
|
LEN
|
||||||
self.len() == 0
|
} else {
|
||||||
}
|
self.len
|
||||||
pub fn bit_width(&self) -> usize {
|
|
||||||
self.bit_width
|
|
||||||
}
|
|
||||||
pub fn into_slice_type(self) -> ArrayType<[VA::Element]> {
|
|
||||||
ArrayType {
|
|
||||||
len: self.len(),
|
|
||||||
element: self.element,
|
|
||||||
bit_width: self.bit_width,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[track_caller]
|
|
||||||
pub fn new_with_len(element: VA::ElementType, len: usize) -> Self {
|
|
||||||
Self::new_with_len_type(
|
|
||||||
element,
|
|
||||||
VA::try_len_type_from_len(len).expect("length should match"),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
#[track_caller]
|
|
||||||
pub fn new_with_len_type(element: VA::ElementType, len: VA::LenType) -> Self {
|
|
||||||
let Some(bit_width) = VA::len_from_len_type(len).checked_mul(element.bit_width()) else {
|
|
||||||
panic!("array is too big: bit-width overflowed");
|
|
||||||
};
|
|
||||||
ArrayType {
|
|
||||||
element,
|
|
||||||
len,
|
|
||||||
bit_width,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized, State: ?Sized + Folder> Fold<State> for ArrayType<VA>
|
impl<T: Type, const LEN: usize> Array<T, LEN>
|
||||||
where
|
where
|
||||||
VA::ElementType: Fold<State>,
|
(): KnownSize<LEN>,
|
||||||
{
|
{
|
||||||
fn fold(self, state: &mut State) -> Result<Self, State::Error> {
|
pub const fn new_static(element: T) -> Self {
|
||||||
state.fold_array_type(self)
|
Self { element, len: LEN }
|
||||||
}
|
|
||||||
fn default_fold(self, state: &mut State) -> Result<Self, State::Error> {
|
|
||||||
Ok(Self::new_with_len_type(self.element.fold(state)?, self.len))
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized, State: ?Sized + Visitor> Visit<State> for ArrayType<VA>
|
impl<T: StaticType, const LEN: usize> StaticType for Array<T, LEN>
|
||||||
where
|
where
|
||||||
VA::ElementType: Visit<State>,
|
(): KnownSize<LEN>,
|
||||||
{
|
{
|
||||||
fn visit(&self, state: &mut State) -> Result<(), State::Error> {
|
|
||||||
state.visit_array_type(self)
|
|
||||||
}
|
|
||||||
fn default_visit(&self, state: &mut State) -> Result<(), State::Error> {
|
|
||||||
self.element.visit(state)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<V: Value<Type: Type<Value = V>>, const N: usize> ArrayType<[V; N]> {
|
|
||||||
pub fn new_array(element: V::Type) -> Self {
|
|
||||||
ArrayType::new_with_len_type(element, ())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<V: StaticValue, const N: usize> StaticType for ArrayType<[V; N]> {
|
|
||||||
fn static_type() -> Self {
|
fn static_type() -> Self {
|
||||||
Self::new_array(StaticType::static_type())
|
Self::new_static(T::static_type())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<V: Value<Type: Type<Value = V>>> ArrayType<[V]> {
|
impl<T: Type> Array<T> {
|
||||||
pub fn new_slice(element: V::Type, len: usize) -> Self {
|
pub const fn new_dyn(element: T, len: usize) -> Self {
|
||||||
ArrayType::new_with_len_type(element, len)
|
assert!(len != UNKNOWN_SIZE);
|
||||||
|
Self { element, len }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Type for ArrayType<VA> {
|
impl<T: Type, const LEN: usize> Type for Array<T, LEN> {
|
||||||
type CanonicalType = ArrayType<[DynCanonicalValue]>;
|
fn canonical(&self) -> CanonicalType {
|
||||||
type Value = Array<VA>;
|
CanonicalType::Array(Intern::intern_sized(Array::new_dyn(
|
||||||
type CanonicalValue = Array<[DynCanonicalValue]>;
|
self.element().canonical(),
|
||||||
type MaskType = ArrayType<VA::MaskVA>;
|
self.len(),
|
||||||
type MaskValue = Array<VA::MaskVA>;
|
)))
|
||||||
type MatchVariant = VA::Match;
|
|
||||||
type MatchActiveScope = ();
|
|
||||||
type MatchVariantAndInactiveScope = MatchVariantWithoutScope<VA::Match>;
|
|
||||||
type MatchVariantsIter = std::iter::Once<Self::MatchVariantAndInactiveScope>;
|
|
||||||
|
|
||||||
fn match_variants<IO: BundleValue>(
|
|
||||||
this: Expr<Self::Value>,
|
|
||||||
module_builder: &mut ModuleBuilder<IO, NormalModule>,
|
|
||||||
source_location: SourceLocation,
|
|
||||||
) -> Self::MatchVariantsIter
|
|
||||||
where
|
|
||||||
IO::Type: BundleType<Value = IO>,
|
|
||||||
{
|
|
||||||
let _ = module_builder;
|
|
||||||
let _ = source_location;
|
|
||||||
std::iter::once(MatchVariantWithoutScope(VA::make_match(this)))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn mask_type(&self) -> Self::MaskType {
|
|
||||||
#[derive(Clone, Hash, Eq, PartialEq)]
|
|
||||||
struct ArrayMaskTypeMemoize<T: ArrayTypeTrait>(PhantomData<T>);
|
|
||||||
impl<T: ArrayTypeTrait> Copy for ArrayMaskTypeMemoize<T> {}
|
|
||||||
impl<T: ArrayTypeTrait> Memoize for ArrayMaskTypeMemoize<T> {
|
|
||||||
type Input = ArrayType<T::ValueArrayOrSlice>;
|
|
||||||
type InputOwned = ArrayType<T::ValueArrayOrSlice>;
|
|
||||||
type Output = <ArrayType<T::ValueArrayOrSlice> as Type>::MaskType;
|
|
||||||
|
|
||||||
fn inner(self, input: &Self::Input) -> Self::Output {
|
|
||||||
ArrayType::new_with_len_type(input.element.mask_type(), input.len)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
ArrayMaskTypeMemoize::<Self>(PhantomData).get(self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn canonical(&self) -> Self::CanonicalType {
|
|
||||||
ArrayType {
|
|
||||||
element: self.element.canonical_dyn(),
|
|
||||||
len: self.len(),
|
|
||||||
bit_width: self.bit_width,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn source_location(&self) -> SourceLocation {
|
|
||||||
SourceLocation::builtin()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn type_enum(&self) -> TypeEnum {
|
|
||||||
TypeEnum::ArrayType(self.canonical())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn from_canonical_type(t: Self::CanonicalType) -> Self {
|
|
||||||
Self {
|
|
||||||
element: VA::ElementType::from_dyn_canonical_type(t.element),
|
|
||||||
len: VA::try_len_type_from_len(t.len).expect("length should match"),
|
|
||||||
bit_width: t.bit_width,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn as_dyn_canonical_type_impl(this: &Self) -> Option<&dyn DynCanonicalType> {
|
|
||||||
Some(<dyn Any>::downcast_ref::<ArrayType<[DynCanonicalValue]>>(
|
|
||||||
this,
|
|
||||||
)?)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<Lhs: ValueArrayOrSlice + ?Sized, Rhs: ValueArrayOrSlice + ?Sized> Connect<ArrayType<Rhs>>
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
|
||||||
for ArrayType<Lhs>
|
pub struct ArrayWithoutGenerics;
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CanonicalType for ArrayType<[DynCanonicalValue]> {
|
impl<T: Type> Index<T> for ArrayWithoutGenerics {
|
||||||
const CANONICAL_TYPE_KIND: CanonicalTypeKind = CanonicalTypeKind::ArrayType;
|
type Output = ArrayWithoutLen<T>;
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, Eq, Hash)]
|
fn index(&self, element: T) -> &Self::Output {
|
||||||
pub struct Array<VA: ValueArrayOrSlice + ?Sized> {
|
Interned::<_>::into_inner(Intern::intern_sized(ArrayWithoutLen { element }))
|
||||||
element_ty: VA::ElementType,
|
|
||||||
value: Arc<VA>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Clone for Array<VA> {
|
|
||||||
fn clone(&self) -> Self {
|
|
||||||
Self {
|
|
||||||
element_ty: self.element_ty.clone(),
|
|
||||||
value: self.value.clone(),
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> ToExpr for Array<VA> {
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||||
type Type = ArrayType<VA>;
|
pub struct ArrayWithoutLen<T: Type> {
|
||||||
|
element: T,
|
||||||
fn ty(&self) -> Self::Type {
|
|
||||||
ArrayType::new_with_len_type(self.element_ty.clone(), self.value.len_type())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn to_expr(&self) -> Expr<<Self::Type as Type>::Value> {
|
|
||||||
Expr::from_value(self)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Value for Array<VA> {
|
impl<T: Type> Index<usize> for ArrayWithoutLen<T> {
|
||||||
fn to_canonical(&self) -> <Self::Type as Type>::CanonicalValue {
|
type Output = Array<T>;
|
||||||
Array {
|
|
||||||
element_ty: self.element_ty.canonical_dyn(),
|
|
||||||
value: AsRef::<[_]>::as_ref(&*self.value)
|
|
||||||
.iter()
|
|
||||||
.map(|v| v.to_canonical_dyn())
|
|
||||||
.collect(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fn to_bits_impl(this: &Self) -> Interned<BitSlice> {
|
|
||||||
#[derive(Hash, Eq, PartialEq)]
|
|
||||||
struct ArrayToBitsMemoize<VA: ValueArrayOrSlice + ?Sized>(PhantomData<VA>);
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Clone for ArrayToBitsMemoize<VA> {
|
|
||||||
fn clone(&self) -> Self {
|
|
||||||
*self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Copy for ArrayToBitsMemoize<VA> {}
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Memoize for ArrayToBitsMemoize<VA> {
|
|
||||||
type Input = Array<VA>;
|
|
||||||
type InputOwned = Array<VA>;
|
|
||||||
type Output = Interned<BitSlice>;
|
|
||||||
|
|
||||||
fn inner(self, input: &Self::Input) -> Self::Output {
|
fn index(&self, len: usize) -> &Self::Output {
|
||||||
let mut bits = BitVec::with_capacity(input.ty().bit_width());
|
Interned::<_>::into_inner(Intern::intern_sized(Array::new_dyn(self.element, len)))
|
||||||
for element in AsRef::<[_]>::as_ref(&*input.value).iter() {
|
|
||||||
bits.extend_from_bitslice(&element.to_bits());
|
|
||||||
}
|
|
||||||
Intern::intern_owned(bits)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
ArrayToBitsMemoize::<VA>(PhantomData).get(this)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CanonicalValue for Array<[DynCanonicalValue]> {
|
|
||||||
fn value_enum_impl(this: &Self) -> ValueEnum {
|
|
||||||
ValueEnum::Array(this.clone())
|
|
||||||
}
|
|
||||||
fn to_bits_impl(this: &Self) -> Interned<BitSlice> {
|
|
||||||
Value::to_bits_impl(this)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized> Array<VA> {
|
|
||||||
pub fn element_ty(&self) -> &VA::ElementType {
|
|
||||||
&self.element_ty
|
|
||||||
}
|
|
||||||
pub fn len(&self) -> usize {
|
|
||||||
VA::len_from_len_type(self.value.len_type())
|
|
||||||
}
|
|
||||||
pub fn is_empty(&self) -> bool {
|
|
||||||
self.len() == 0
|
|
||||||
}
|
|
||||||
pub fn value(&self) -> &Arc<VA> {
|
|
||||||
&self.value
|
|
||||||
}
|
|
||||||
pub fn set_element(&mut self, index: usize, element: VA::Element) {
|
|
||||||
assert_eq!(self.element_ty, element.ty());
|
|
||||||
VA::arc_make_mut(&mut self.value)[index] = element;
|
|
||||||
}
|
|
||||||
pub fn new(element_ty: VA::ElementType, value: Arc<VA>) -> Self {
|
|
||||||
for element in value.iter() {
|
|
||||||
assert_eq!(element_ty, element.ty());
|
|
||||||
}
|
|
||||||
Self { element_ty, value }
|
|
||||||
}
|
|
||||||
pub fn into_slice(self) -> Array<[VA::Element]> {
|
|
||||||
Array {
|
|
||||||
element_ty: self.element_ty,
|
|
||||||
value: self.value.arc_to_arc_slice(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice + ?Sized, T: Into<Arc<VA>>> From<T> for Array<VA>
|
|
||||||
where
|
|
||||||
VA::Element: StaticValue,
|
|
||||||
{
|
|
||||||
fn from(value: T) -> Self {
|
|
||||||
Self::new(StaticType::static_type(), value.into())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<E: ToExpr<Type = T>, T: StaticType<MaskType: StaticType>> ToExpr for [E] {
|
|
||||||
type Type = ArrayType<[T::Value]>;
|
|
||||||
|
|
||||||
fn ty(&self) -> Self::Type {
|
|
||||||
ArrayType::new_with_len_type(StaticType::static_type(), self.len())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn to_expr(&self) -> Expr<<Self::Type as Type>::Value> {
|
|
||||||
let elements = Intern::intern_owned(Vec::from_iter(
|
|
||||||
self.iter().map(|v| v.to_expr().to_canonical_dyn()),
|
|
||||||
));
|
|
||||||
ArrayLiteral::new_unchecked(elements, self.ty()).to_expr()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<E: ToExpr<Type = T>, T: StaticType<MaskType: StaticType>> ToExpr for Vec<E> {
|
|
||||||
type Type = ArrayType<[T::Value]>;
|
|
||||||
|
|
||||||
fn ty(&self) -> Self::Type {
|
|
||||||
<[E]>::ty(self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn to_expr(&self) -> Expr<<Self::Type as Type>::Value> {
|
|
||||||
<[E]>::to_expr(self)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<E: ToExpr<Type = T>, T: StaticType<MaskType: StaticType>, const N: usize> ToExpr for [E; N] {
|
|
||||||
type Type = ArrayType<[T::Value; N]>;
|
|
||||||
|
|
||||||
fn ty(&self) -> Self::Type {
|
|
||||||
ArrayType::new_with_len_type(StaticType::static_type(), ())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn to_expr(&self) -> Expr<<Self::Type as Type>::Value> {
|
|
||||||
let elements = Intern::intern_owned(Vec::from_iter(
|
|
||||||
self.iter().map(|v| v.to_expr().to_canonical_dyn()),
|
|
||||||
));
|
|
||||||
ArrayLiteral::new_unchecked(elements, self.ty()).to_expr()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct ArrayIntoIter<VA: ValueArrayOrSlice> {
|
|
||||||
array: Arc<VA>,
|
|
||||||
indexes: std::ops::Range<usize>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> Iterator for ArrayIntoIter<VA> {
|
|
||||||
type Item = VA::Element;
|
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
|
||||||
Some(self.array[self.indexes.next()?].clone())
|
|
||||||
}
|
|
||||||
|
|
||||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
||||||
self.indexes.size_hint()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> std::iter::FusedIterator for ArrayIntoIter<VA> {}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> ExactSizeIterator for ArrayIntoIter<VA> {}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> DoubleEndedIterator for ArrayIntoIter<VA> {
|
|
||||||
fn next_back(&mut self) -> Option<Self::Item> {
|
|
||||||
Some(self.array[self.indexes.next_back()?].clone())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> Array<VA> {
|
|
||||||
pub fn iter(&self) -> std::slice::Iter<'_, VA::Element> {
|
|
||||||
self.value.iter()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<'a, VA: ValueArrayOrSlice> IntoIterator for &'a Array<VA> {
|
|
||||||
type Item = &'a VA::Element;
|
|
||||||
type IntoIter = std::slice::Iter<'a, VA::Element>;
|
|
||||||
|
|
||||||
fn into_iter(self) -> Self::IntoIter {
|
|
||||||
self.value.iter()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> IntoIterator for Array<VA> {
|
|
||||||
type Item = VA::Element;
|
|
||||||
type IntoIter = ArrayIntoIter<VA>;
|
|
||||||
|
|
||||||
fn into_iter(self) -> Self::IntoIter {
|
|
||||||
ArrayIntoIter {
|
|
||||||
indexes: 0..self.len(),
|
|
||||||
array: self.value,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct ArrayExprIter<VA: ValueArrayOrSlice> {
|
|
||||||
array: Expr<Array<VA>>,
|
|
||||||
indexes: std::ops::Range<usize>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> Iterator for ArrayExprIter<VA> {
|
|
||||||
type Item = Expr<VA::Element>;
|
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
|
||||||
Some(ExprIndex::expr_index(self.array, self.indexes.next()?))
|
|
||||||
}
|
|
||||||
|
|
||||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
||||||
self.indexes.size_hint()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> std::iter::FusedIterator for ArrayExprIter<VA> {}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> ExactSizeIterator for ArrayExprIter<VA> {}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> DoubleEndedIterator for ArrayExprIter<VA> {
|
|
||||||
fn next_back(&mut self) -> Option<Self::Item> {
|
|
||||||
Some(ExprIndex::expr_index(self.array, self.indexes.next_back()?))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> IntoIterator for Expr<Array<VA>> {
|
|
||||||
type Item = Expr<VA::Element>;
|
|
||||||
type IntoIter = ArrayExprIter<VA>;
|
|
||||||
|
|
||||||
fn into_iter(self) -> Self::IntoIter {
|
|
||||||
self.iter()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> IntoIterator for &'_ Expr<Array<VA>> {
|
|
||||||
type Item = Expr<VA::Element>;
|
|
||||||
type IntoIter = ArrayExprIter<VA>;
|
|
||||||
|
|
||||||
fn into_iter(self) -> Self::IntoIter {
|
|
||||||
self.iter()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<VA: ValueArrayOrSlice> Expr<Array<VA>> {
|
|
||||||
pub fn len(self) -> usize {
|
|
||||||
self.canonical_type().len()
|
|
||||||
}
|
|
||||||
pub fn is_empty(self) -> bool {
|
|
||||||
self.canonical_type().is_empty()
|
|
||||||
}
|
|
||||||
pub fn iter(self) -> ArrayExprIter<VA> {
|
|
||||||
ArrayExprIter {
|
|
||||||
indexes: 0..self.len(),
|
|
||||||
array: self,
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,620 +1,91 @@
|
||||||
// SPDX-License-Identifier: LGPL-3.0-or-later
|
// SPDX-License-Identifier: LGPL-3.0-or-later
|
||||||
// See Notices.txt for copyright information
|
// See Notices.txt for copyright information
|
||||||
#![allow(clippy::type_complexity)]
|
|
||||||
use crate::{
|
use crate::{
|
||||||
bundle::{BundleValue, TypeHintTrait},
|
intern::{Intern, Interned},
|
||||||
expr::{ops::VariantAccess, Expr, ToExpr},
|
ty::{CanonicalType, StaticType, Type},
|
||||||
int::{UInt, UIntType},
|
|
||||||
intern::{Intern, Interned, MemoizeGeneric},
|
|
||||||
module::{
|
|
||||||
EnumMatchVariantAndInactiveScopeImpl, EnumMatchVariantsIterImpl, ModuleBuilder,
|
|
||||||
NormalModule, Scope,
|
|
||||||
},
|
|
||||||
source_location::SourceLocation,
|
|
||||||
ty::{
|
|
||||||
CanonicalType, CanonicalTypeKind, CanonicalValue, Connect, DynCanonicalType,
|
|
||||||
DynCanonicalValue, DynType, MatchVariantAndInactiveScope, Type, TypeEnum, Value, ValueEnum,
|
|
||||||
},
|
|
||||||
};
|
|
||||||
use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec, view::BitView};
|
|
||||||
use hashbrown::HashMap;
|
|
||||||
use std::{
|
|
||||||
borrow::Cow,
|
|
||||||
fmt,
|
|
||||||
hash::{Hash, Hasher},
|
|
||||||
iter::FusedIterator,
|
|
||||||
marker::PhantomData,
|
|
||||||
};
|
};
|
||||||
|
use hashbrown::HashSet;
|
||||||
|
use std::ops::Index;
|
||||||
|
|
||||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||||
pub struct VariantType<T> {
|
pub struct EnumVariant {
|
||||||
pub name: Interned<str>,
|
pub name: Interned<str>,
|
||||||
pub ty: Option<T>,
|
pub ty: Option<CanonicalType>,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct FmtDebugInEnum<'a, T>(&'a VariantType<T>);
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||||
|
pub struct Enum {
|
||||||
impl<T: fmt::Debug> fmt::Debug for FmtDebugInEnum<'_, T> {
|
variants: Interned<[EnumVariant]>,
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||||
let VariantType { name, ref ty } = *self.0;
|
|
||||||
if let Some(ty) = ty {
|
|
||||||
write!(f, "{name}({ty:?})")
|
|
||||||
} else {
|
|
||||||
write!(f, "{name}")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: fmt::Debug> fmt::Display for FmtDebugInEnum<'_, T> {
|
impl Enum {
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
#[track_caller]
|
||||||
fmt::Debug::fmt(self, f)
|
pub fn new(variants: &[EnumVariant]) -> Self {
|
||||||
}
|
let variants = variants.intern();
|
||||||
}
|
let mut names = HashSet::new();
|
||||||
|
for variant in variants {
|
||||||
impl<T> VariantType<T> {
|
|
||||||
pub fn map_opt_ty<U, F: FnOnce(Option<T>) -> Option<U>>(self, f: F) -> VariantType<U> {
|
|
||||||
let Self { name, ty } = self;
|
|
||||||
VariantType { name, ty: f(ty) }
|
|
||||||
}
|
|
||||||
pub fn map_ty<U, F: FnOnce(T) -> U>(self, f: F) -> VariantType<U> {
|
|
||||||
let Self { name, ty } = self;
|
|
||||||
VariantType {
|
|
||||||
name,
|
|
||||||
ty: ty.map(f),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn as_ref_ty(&self) -> VariantType<&T> {
|
|
||||||
VariantType {
|
|
||||||
name: self.name,
|
|
||||||
ty: self.ty.as_ref(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn fmt_debug_in_enum(&self) -> FmtDebugInEnum<T> {
|
|
||||||
FmtDebugInEnum(self)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: Type> VariantType<T> {
|
|
||||||
pub fn canonical(&self) -> VariantType<T::CanonicalType> {
|
|
||||||
self.as_ref_ty().map_ty(T::canonical)
|
|
||||||
}
|
|
||||||
pub fn to_dyn(&self) -> VariantType<Interned<dyn DynType>> {
|
|
||||||
self.as_ref_ty().map_ty(T::to_dyn)
|
|
||||||
}
|
|
||||||
pub fn canonical_dyn(&self) -> VariantType<Interned<dyn DynCanonicalType>> {
|
|
||||||
self.as_ref_ty().map_ty(T::canonical_dyn)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl VariantType<Interned<dyn DynCanonicalType>> {
|
|
||||||
pub fn from_canonical_type_helper_has_value<T: Type>(self, expected_name: &str) -> T {
|
|
||||||
assert_eq!(&*self.name, expected_name, "variant name doesn't match");
|
|
||||||
let Some(ty) = self.ty else {
|
|
||||||
panic!("variant {expected_name} has no value but a value is expected");
|
|
||||||
};
|
|
||||||
T::from_dyn_canonical_type(ty)
|
|
||||||
}
|
|
||||||
pub fn from_canonical_type_helper_no_value(self, expected_name: &str) {
|
|
||||||
assert_eq!(&*self.name, expected_name, "variant name doesn't match");
|
|
||||||
assert!(
|
assert!(
|
||||||
self.ty.is_none(),
|
names.insert(variant.name),
|
||||||
"variant {expected_name} has a value but is expected to have no value"
|
"duplicate variant name: {:?}",
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Eq)]
|
|
||||||
struct DynEnumTypeImpl {
|
|
||||||
variants: Interned<[VariantType<Interned<dyn DynCanonicalType>>]>,
|
|
||||||
name_indexes: HashMap<Interned<str>, usize>,
|
|
||||||
bit_width: usize,
|
|
||||||
is_storable: bool,
|
|
||||||
is_castable_from_bits: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl fmt::Debug for DynEnumTypeImpl {
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||||
write!(f, "DynEnumType ")?;
|
|
||||||
f.debug_set()
|
|
||||||
.entries(
|
|
||||||
self.variants
|
|
||||||
.iter()
|
|
||||||
.map(|variant| variant.fmt_debug_in_enum()),
|
|
||||||
)
|
|
||||||
.finish()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PartialEq for DynEnumTypeImpl {
|
|
||||||
fn eq(&self, other: &Self) -> bool {
|
|
||||||
self.variants == other.variants
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Hash for DynEnumTypeImpl {
|
|
||||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
||||||
self.variants.hash(state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Copy, Clone, Hash, PartialEq, Eq)]
|
|
||||||
pub struct DynEnumType(Interned<DynEnumTypeImpl>);
|
|
||||||
|
|
||||||
impl fmt::Debug for DynEnumType {
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||||
self.0.fmt(f)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn discriminant_bit_width_impl(variant_count: usize) -> usize {
|
|
||||||
variant_count
|
|
||||||
.next_power_of_two()
|
|
||||||
.checked_ilog2()
|
|
||||||
.unwrap_or(0) as usize
|
|
||||||
}
|
|
||||||
|
|
||||||
impl DynEnumType {
|
|
||||||
#[track_caller]
|
|
||||||
pub fn new(variants: Interned<[VariantType<Interned<dyn DynCanonicalType>>]>) -> Self {
|
|
||||||
assert!(!variants.is_empty(), "zero-variant enums aren't yet supported: https://github.com/chipsalliance/firrtl-spec/issues/208");
|
|
||||||
let mut name_indexes = HashMap::with_capacity(variants.len());
|
|
||||||
let mut body_bit_width = 0usize;
|
|
||||||
let mut is_storable = true;
|
|
||||||
let mut is_castable_from_bits = true;
|
|
||||||
for (index, &VariantType { name, ty }) in variants.iter().enumerate() {
|
|
||||||
if let Some(old_index) = name_indexes.insert(name, index) {
|
|
||||||
panic!("duplicate variant name {name:?}: at both index {old_index} and {index}");
|
|
||||||
}
|
|
||||||
if let Some(ty) = ty {
|
|
||||||
assert!(
|
|
||||||
ty.is_passive(),
|
|
||||||
"variant type must be a passive type: {ty:?}"
|
|
||||||
);
|
|
||||||
body_bit_width = body_bit_width.max(ty.bit_width());
|
|
||||||
is_storable &= ty.is_storable();
|
|
||||||
is_castable_from_bits &= ty.is_castable_from_bits();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let bit_width = body_bit_width
|
|
||||||
.checked_add(discriminant_bit_width_impl(variants.len()))
|
|
||||||
.unwrap_or_else(|| panic!("enum is too big: bit-width overflowed"));
|
|
||||||
Self(
|
|
||||||
DynEnumTypeImpl {
|
|
||||||
variants,
|
|
||||||
name_indexes,
|
|
||||||
bit_width,
|
|
||||||
is_storable,
|
|
||||||
is_castable_from_bits,
|
|
||||||
}
|
|
||||||
.intern_sized(),
|
|
||||||
)
|
|
||||||
}
|
|
||||||
pub fn discriminant_bit_width(self) -> usize {
|
|
||||||
discriminant_bit_width_impl(self.variants().len())
|
|
||||||
}
|
|
||||||
pub fn is_passive(self) -> bool {
|
|
||||||
true
|
|
||||||
}
|
|
||||||
pub fn is_storable(self) -> bool {
|
|
||||||
self.0.is_storable
|
|
||||||
}
|
|
||||||
pub fn is_castable_from_bits(self) -> bool {
|
|
||||||
self.0.is_castable_from_bits
|
|
||||||
}
|
|
||||||
pub fn bit_width(self) -> usize {
|
|
||||||
self.0.bit_width
|
|
||||||
}
|
|
||||||
pub fn name_indexes(&self) -> &HashMap<Interned<str>, usize> {
|
|
||||||
&self.0.name_indexes
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
|
|
||||||
pub struct DynEnum {
|
|
||||||
ty: DynEnumType,
|
|
||||||
variant_index: usize,
|
|
||||||
variant_value: Option<DynCanonicalValue>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl DynEnum {
|
|
||||||
#[track_caller]
|
|
||||||
pub fn new_by_index(
|
|
||||||
ty: DynEnumType,
|
|
||||||
variant_index: usize,
|
|
||||||
variant_value: Option<DynCanonicalValue>,
|
|
||||||
) -> Self {
|
|
||||||
let variant = ty.variants()[variant_index];
|
|
||||||
assert_eq!(
|
|
||||||
variant_value.as_ref().map(|v| v.ty()),
|
|
||||||
variant.ty,
|
|
||||||
"variant value doesn't match type"
|
|
||||||
);
|
|
||||||
Self {
|
|
||||||
ty,
|
|
||||||
variant_index,
|
|
||||||
variant_value,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[track_caller]
|
|
||||||
pub fn new_by_name(
|
|
||||||
ty: DynEnumType,
|
|
||||||
variant_name: Interned<str>,
|
|
||||||
variant_value: Option<DynCanonicalValue>,
|
|
||||||
) -> Self {
|
|
||||||
let variant_index = ty.name_indexes()[&variant_name];
|
|
||||||
Self::new_by_index(ty, variant_index, variant_value)
|
|
||||||
}
|
|
||||||
pub fn variant_index(&self) -> usize {
|
|
||||||
self.variant_index
|
|
||||||
}
|
|
||||||
pub fn variant_value(&self) -> &Option<DynCanonicalValue> {
|
|
||||||
&self.variant_value
|
|
||||||
}
|
|
||||||
pub fn variant_with_type(&self) -> VariantType<Interned<dyn DynCanonicalType>> {
|
|
||||||
self.ty.variants()[self.variant_index]
|
|
||||||
}
|
|
||||||
pub fn variant_name(&self) -> Interned<str> {
|
|
||||||
self.variant_with_type().name
|
|
||||||
}
|
|
||||||
pub fn variant_type(&self) -> Option<Interned<dyn DynCanonicalType>> {
|
|
||||||
self.variant_with_type().ty
|
|
||||||
}
|
|
||||||
pub fn variant_with_value(&self) -> VariantType<&DynCanonicalValue> {
|
|
||||||
self.variant_with_type()
|
|
||||||
.map_opt_ty(|_| self.variant_value.as_ref())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
|
|
||||||
pub struct VariantsHint {
|
|
||||||
pub known_variants: Interned<[VariantType<Interned<dyn TypeHintTrait>>]>,
|
|
||||||
pub more_variants: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl VariantsHint {
|
|
||||||
pub fn new(
|
|
||||||
known_variants: impl IntoIterator<Item = VariantType<Interned<dyn TypeHintTrait>>>,
|
|
||||||
more_variants: bool,
|
|
||||||
) -> Self {
|
|
||||||
let known_variants = Intern::intern_owned(Vec::from_iter(known_variants));
|
|
||||||
Self {
|
|
||||||
known_variants,
|
|
||||||
more_variants,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn check_variant(
|
|
||||||
self,
|
|
||||||
index: usize,
|
|
||||||
variant: VariantType<&dyn DynType>,
|
|
||||||
) -> Result<(), String> {
|
|
||||||
let Some(&known_variant) = self.known_variants.get(index) else {
|
|
||||||
return if self.more_variants {
|
|
||||||
Ok(())
|
|
||||||
} else {
|
|
||||||
Err(format!(
|
|
||||||
"too many variants: name={:?} index={index}",
|
|
||||||
variant.name
|
variant.name
|
||||||
))
|
|
||||||
};
|
|
||||||
};
|
|
||||||
let VariantType {
|
|
||||||
name: known_name,
|
|
||||||
ty: type_hint,
|
|
||||||
} = known_variant;
|
|
||||||
let VariantType { name, ty } = variant;
|
|
||||||
if name != known_name {
|
|
||||||
Err(format!(
|
|
||||||
"wrong variant name {name:?}, expected {known_name:?}"
|
|
||||||
))
|
|
||||||
} else {
|
|
||||||
match (ty, type_hint) {
|
|
||||||
(Some(ty), Some(type_hint)) => type_hint.matches(ty),
|
|
||||||
(None, None) => Ok(()),
|
|
||||||
(None, Some(_)) => Err(format!(
|
|
||||||
"expected variant {name:?} to have type, no type provided"
|
|
||||||
)),
|
|
||||||
(Some(_), None) => Err(format!(
|
|
||||||
"expected variant {name:?} to have no type, but a type was provided"
|
|
||||||
)),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub trait EnumType:
|
|
||||||
Type<
|
|
||||||
CanonicalType = DynEnumType,
|
|
||||||
CanonicalValue = DynEnum,
|
|
||||||
MaskType = UIntType<1>,
|
|
||||||
MaskValue = UInt<1>,
|
|
||||||
MatchActiveScope = Scope,
|
|
||||||
MatchVariantAndInactiveScope = EnumMatchVariantAndInactiveScope<Self>,
|
|
||||||
MatchVariantsIter = EnumMatchVariantsIter<Self>,
|
|
||||||
> + Connect<Self>
|
|
||||||
where
|
|
||||||
Self::Value: EnumValue + ToExpr<Type = Self>,
|
|
||||||
{
|
|
||||||
type Builder;
|
|
||||||
fn match_activate_scope(
|
|
||||||
v: Self::MatchVariantAndInactiveScope,
|
|
||||||
) -> (Self::MatchVariant, Self::MatchActiveScope);
|
|
||||||
fn builder() -> Self::Builder;
|
|
||||||
fn variants(&self) -> Interned<[VariantType<Interned<dyn DynCanonicalType>>]>;
|
|
||||||
fn variants_hint() -> VariantsHint;
|
|
||||||
#[allow(clippy::result_unit_err)]
|
|
||||||
fn variant_to_bits<VariantValue: ToExpr + Eq + Hash + Send + Sync + 'static + Clone>(
|
|
||||||
&self,
|
|
||||||
variant_index: usize,
|
|
||||||
variant_value: Option<&VariantValue>,
|
|
||||||
) -> Result<Interned<BitSlice>, ()> {
|
|
||||||
#[derive(Hash, Eq, PartialEq)]
|
|
||||||
struct VariantToBitsMemoize<E, V>(PhantomData<(E, V)>);
|
|
||||||
impl<E, V> Clone for VariantToBitsMemoize<E, V> {
|
|
||||||
fn clone(&self) -> Self {
|
|
||||||
*self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<E, V> Copy for VariantToBitsMemoize<E, V> {}
|
|
||||||
impl<
|
|
||||||
E: EnumType<Value: EnumValue<Type = E>>,
|
|
||||||
V: ToExpr + Eq + Hash + Send + Sync + 'static + Clone,
|
|
||||||
> MemoizeGeneric for VariantToBitsMemoize<E, V>
|
|
||||||
{
|
|
||||||
type InputRef<'a> = (&'a E, usize, Option<&'a V>);
|
|
||||||
type InputOwned = (E, usize, Option<V>);
|
|
||||||
type InputCow<'a> = (Cow<'a, E>, usize, Option<Cow<'a, V>>);
|
|
||||||
type Output = Result<Interned<BitSlice>, ()>;
|
|
||||||
|
|
||||||
fn input_borrow(input: &Self::InputOwned) -> Self::InputRef<'_> {
|
|
||||||
(&input.0, input.1, input.2.as_ref())
|
|
||||||
}
|
|
||||||
fn input_eq(a: Self::InputRef<'_>, b: Self::InputRef<'_>) -> bool {
|
|
||||||
a == b
|
|
||||||
}
|
|
||||||
fn input_cow_into_owned(input: Self::InputCow<'_>) -> Self::InputOwned {
|
|
||||||
(input.0.into_owned(), input.1, input.2.map(Cow::into_owned))
|
|
||||||
}
|
|
||||||
fn input_cow_borrow<'a>(input: &'a Self::InputCow<'_>) -> Self::InputRef<'a> {
|
|
||||||
(&input.0, input.1, input.2.as_deref())
|
|
||||||
}
|
|
||||||
fn input_cow_from_owned<'a>(input: Self::InputOwned) -> Self::InputCow<'a> {
|
|
||||||
(Cow::Owned(input.0), input.1, input.2.map(Cow::Owned))
|
|
||||||
}
|
|
||||||
fn input_cow_from_ref(input: Self::InputRef<'_>) -> Self::InputCow<'_> {
|
|
||||||
(Cow::Borrowed(input.0), input.1, input.2.map(Cow::Borrowed))
|
|
||||||
}
|
|
||||||
fn inner(self, input: Self::InputRef<'_>) -> Self::Output {
|
|
||||||
let (ty, variant_index, variant_value) = input;
|
|
||||||
let ty = ty.canonical();
|
|
||||||
let mut bits = BitVec::with_capacity(ty.bit_width());
|
|
||||||
bits.extend_from_bitslice(
|
|
||||||
&variant_index.view_bits::<Lsb0>()[..ty.discriminant_bit_width()],
|
|
||||||
);
|
);
|
||||||
if let Some(variant_value) = variant_value {
|
|
||||||
bits.extend_from_bitslice(&variant_value.to_expr().to_literal_bits()?);
|
|
||||||
}
|
}
|
||||||
bits.resize(ty.bit_width(), false);
|
Self { variants }
|
||||||
Ok(Intern::intern_owned(bits))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
VariantToBitsMemoize::<Self, VariantValue>(PhantomData).get((
|
|
||||||
self,
|
|
||||||
variant_index,
|
|
||||||
variant_value,
|
|
||||||
))
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait EnumValue: Value
|
impl Type for Enum {
|
||||||
where
|
fn canonical(&self) -> CanonicalType {
|
||||||
<Self as ToExpr>::Type: EnumType<Value = Self>,
|
CanonicalType::Enum(*self)
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct EnumMatchVariantAndInactiveScope<T: EnumType>(EnumMatchVariantAndInactiveScopeImpl<T>)
|
|
||||||
where
|
|
||||||
T::Value: EnumValue<Type = T>;
|
|
||||||
|
|
||||||
impl<T: EnumType> MatchVariantAndInactiveScope for EnumMatchVariantAndInactiveScope<T>
|
|
||||||
where
|
|
||||||
T::Value: EnumValue<Type = T>,
|
|
||||||
{
|
|
||||||
type MatchVariant = T::MatchVariant;
|
|
||||||
type MatchActiveScope = Scope;
|
|
||||||
|
|
||||||
fn match_activate_scope(self) -> (Self::MatchVariant, Self::MatchActiveScope) {
|
|
||||||
T::match_activate_scope(self)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: EnumType> EnumMatchVariantAndInactiveScope<T>
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||||
where
|
pub struct HdlOption<T: Type> {
|
||||||
T::Value: EnumValue<Type = T>,
|
some_ty: T,
|
||||||
{
|
}
|
||||||
pub fn variant_access(&self) -> Interned<VariantAccess<T, Interned<dyn DynCanonicalType>>> {
|
|
||||||
self.0.variant_access()
|
impl<T: Type> HdlOption<T> {
|
||||||
|
pub const fn new(some_ty: T) -> Self {
|
||||||
|
Self { some_ty }
|
||||||
}
|
}
|
||||||
pub fn activate(
|
pub const fn some_ty(&self) -> &T {
|
||||||
self,
|
&self.some_ty
|
||||||
) -> (
|
|
||||||
Interned<VariantAccess<T, Interned<dyn DynCanonicalType>>>,
|
|
||||||
Scope,
|
|
||||||
) {
|
|
||||||
self.0.activate()
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone)]
|
#[allow(non_upper_case_globals)]
|
||||||
pub struct EnumMatchVariantsIter<T: EnumType>
|
pub const HdlOption: HdlOptionWithoutGenerics = HdlOptionWithoutGenerics;
|
||||||
where
|
|
||||||
T::Value: EnumValue<Type = T>,
|
|
||||||
{
|
|
||||||
pub(crate) inner: EnumMatchVariantsIterImpl<T>,
|
|
||||||
pub(crate) variant_index: std::ops::Range<usize>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T: EnumType> Iterator for EnumMatchVariantsIter<T>
|
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Default)]
|
||||||
where
|
pub struct HdlOptionWithoutGenerics;
|
||||||
T::Value: EnumValue<Type = T>,
|
|
||||||
{
|
|
||||||
type Item = EnumMatchVariantAndInactiveScope<T>;
|
|
||||||
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
impl<T: Type> Index<T> for HdlOptionWithoutGenerics {
|
||||||
self.variant_index.next().map(|variant_index| {
|
type Output = HdlOption<T>;
|
||||||
EnumMatchVariantAndInactiveScope(self.inner.for_variant_index(variant_index))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
fn index(&self, some_ty: T) -> &Self::Output {
|
||||||
self.variant_index.size_hint()
|
Interned::<_>::into_inner(Intern::intern_sized(HdlOption::new(some_ty)))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: EnumType> ExactSizeIterator for EnumMatchVariantsIter<T>
|
impl<T: Type> Type for HdlOption<T> {
|
||||||
where
|
fn canonical(&self) -> CanonicalType {
|
||||||
T::Value: EnumValue<Type = T>,
|
CanonicalType::Enum(Enum::new(&[
|
||||||
{
|
EnumVariant {
|
||||||
fn len(&self) -> usize {
|
name: "None".intern(),
|
||||||
self.variant_index.len()
|
ty: None,
|
||||||
|
},
|
||||||
|
EnumVariant {
|
||||||
|
name: "Some".intern(),
|
||||||
|
ty: Some(self.some_ty().canonical()),
|
||||||
|
},
|
||||||
|
]))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: EnumType> FusedIterator for EnumMatchVariantsIter<T> where T::Value: EnumValue<Type = T> {}
|
impl<T: StaticType> StaticType for HdlOption<T> {
|
||||||
|
fn static_type() -> Self {
|
||||||
impl<T: EnumType> DoubleEndedIterator for EnumMatchVariantsIter<T>
|
HdlOption::new(T::static_type())
|
||||||
where
|
|
||||||
T::Value: EnumValue<Type = T>,
|
|
||||||
{
|
|
||||||
fn next_back(&mut self) -> Option<Self::Item> {
|
|
||||||
self.variant_index.next_back().map(|variant_index| {
|
|
||||||
EnumMatchVariantAndInactiveScope(self.inner.for_variant_index(variant_index))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Type for DynEnumType {
|
|
||||||
type CanonicalType = DynEnumType;
|
|
||||||
type Value = DynEnum;
|
|
||||||
type CanonicalValue = DynEnum;
|
|
||||||
type MaskType = UIntType<1>;
|
|
||||||
type MaskValue = UInt<1>;
|
|
||||||
type MatchVariant = Option<Expr<DynCanonicalValue>>;
|
|
||||||
type MatchActiveScope = Scope;
|
|
||||||
type MatchVariantAndInactiveScope = EnumMatchVariantAndInactiveScope<Self>;
|
|
||||||
type MatchVariantsIter = EnumMatchVariantsIter<Self>;
|
|
||||||
|
|
||||||
fn match_variants<IO: BundleValue>(
|
|
||||||
this: Expr<Self::Value>,
|
|
||||||
module_builder: &mut ModuleBuilder<IO, NormalModule>,
|
|
||||||
source_location: SourceLocation,
|
|
||||||
) -> Self::MatchVariantsIter
|
|
||||||
where
|
|
||||||
IO::Type: crate::bundle::BundleType<Value = IO>,
|
|
||||||
{
|
|
||||||
module_builder.enum_match_variants_helper(this, source_location)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn mask_type(&self) -> Self::MaskType {
|
|
||||||
UIntType::new()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn canonical(&self) -> Self::CanonicalType {
|
|
||||||
*self
|
|
||||||
}
|
|
||||||
|
|
||||||
fn source_location(&self) -> SourceLocation {
|
|
||||||
SourceLocation::builtin()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn type_enum(&self) -> TypeEnum {
|
|
||||||
TypeEnum::EnumType(*self)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn from_canonical_type(t: Self::CanonicalType) -> Self {
|
|
||||||
t
|
|
||||||
}
|
|
||||||
|
|
||||||
fn as_dyn_canonical_type_impl(this: &Self) -> Option<&dyn DynCanonicalType> {
|
|
||||||
Some(this)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Connect<Self> for DynEnumType {}
|
|
||||||
|
|
||||||
pub struct NoBuilder;
|
|
||||||
|
|
||||||
impl EnumType for DynEnumType {
|
|
||||||
type Builder = NoBuilder;
|
|
||||||
|
|
||||||
fn match_activate_scope(
|
|
||||||
v: Self::MatchVariantAndInactiveScope,
|
|
||||||
) -> (Self::MatchVariant, Self::MatchActiveScope) {
|
|
||||||
let (expr, scope) = v.0.activate();
|
|
||||||
(expr.variant_type().ty.map(|_| expr.to_expr()), scope)
|
|
||||||
}
|
|
||||||
|
|
||||||
fn builder() -> Self::Builder {
|
|
||||||
NoBuilder
|
|
||||||
}
|
|
||||||
|
|
||||||
fn variants(&self) -> Interned<[VariantType<Interned<dyn DynCanonicalType>>]> {
|
|
||||||
self.0.variants
|
|
||||||
}
|
|
||||||
|
|
||||||
fn variants_hint() -> VariantsHint {
|
|
||||||
VariantsHint {
|
|
||||||
known_variants: [][..].intern(),
|
|
||||||
more_variants: true,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl CanonicalType for DynEnumType {
|
|
||||||
const CANONICAL_TYPE_KIND: CanonicalTypeKind = CanonicalTypeKind::EnumType;
|
|
||||||
}
|
|
||||||
|
|
||||||
impl ToExpr for DynEnum {
|
|
||||||
type Type = DynEnumType;
|
|
||||||
|
|
||||||
fn ty(&self) -> Self::Type {
|
|
||||||
self.ty
|
|
||||||
}
|
|
||||||
|
|
||||||
fn to_expr(&self) -> Expr<<Self::Type as Type>::Value> {
|
|
||||||
Expr::from_value(self)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Value for DynEnum {
|
|
||||||
fn to_canonical(&self) -> <Self::Type as Type>::CanonicalValue {
|
|
||||||
self.clone()
|
|
||||||
}
|
|
||||||
fn to_bits_impl(this: &Self) -> Interned<BitSlice> {
|
|
||||||
this.ty
|
|
||||||
.variant_to_bits(this.variant_index, this.variant_value.as_ref())
|
|
||||||
.unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl EnumValue for DynEnum {}
|
|
||||||
|
|
||||||
impl CanonicalValue for DynEnum {
|
|
||||||
fn value_enum_impl(this: &Self) -> ValueEnum {
|
|
||||||
ValueEnum::Enum(this.clone())
|
|
||||||
}
|
|
||||||
fn to_bits_impl(this: &Self) -> Interned<BitSlice> {
|
|
||||||
this.ty
|
|
||||||
.variant_to_bits(this.variant_index, this.variant_value.as_ref())
|
|
||||||
.unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
mod impl_option {
|
|
||||||
#[allow(dead_code)]
|
|
||||||
#[derive(crate::ty::Value)]
|
|
||||||
#[hdl(target(std::option::Option), connect_inexact, outline_generated)]
|
|
||||||
pub enum Option<T> {
|
|
||||||
None,
|
|
||||||
Some(T),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -24,22 +24,23 @@ pub use fayalite_proc_macros::hdl_module;
|
||||||
#[cfg(feature = "unstable-doc")]
|
#[cfg(feature = "unstable-doc")]
|
||||||
pub mod _docs;
|
pub mod _docs;
|
||||||
|
|
||||||
pub mod annotations;
|
// FIXME: finish
|
||||||
|
//pub mod annotations;
|
||||||
pub mod array;
|
pub mod array;
|
||||||
pub mod bundle;
|
//pub mod bundle;
|
||||||
pub mod cli;
|
//pub mod cli;
|
||||||
pub mod clock;
|
//pub mod clock;
|
||||||
pub mod enum_;
|
pub mod enum_;
|
||||||
pub mod expr;
|
//pub mod expr;
|
||||||
pub mod firrtl;
|
//pub mod firrtl;
|
||||||
pub mod int;
|
pub mod int;
|
||||||
pub mod intern;
|
pub mod intern;
|
||||||
pub mod memory;
|
//pub mod memory;
|
||||||
pub mod module;
|
//pub mod module;
|
||||||
pub mod reg;
|
//pub mod reg;
|
||||||
pub mod reset;
|
//pub mod reset;
|
||||||
pub mod source_location;
|
pub mod source_location;
|
||||||
pub mod ty;
|
pub mod ty;
|
||||||
pub mod util;
|
pub mod util;
|
||||||
pub mod valueless;
|
//pub mod valueless;
|
||||||
pub mod wire;
|
//pub mod wire;
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue