nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-06-06 04:08:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove EnumTypeTraversalImpl.

Browse Source 
I suspect this macro was around before `TypeFoldable`/`TypeVisitable`
were derivable. But now it's only used for two types, `Result` and
`Option`. Removing the macro and implementing the traits for those types
by hand makes the code much simpler.
This commit is contained in:
Nicholas Nethercote 2023-04-16 13:47:27 +10:00
parent d558796beb
commit 32f6e7a38e
2 changed files with 31 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
compiler/rustc_type_ir/src/macros.rs
View File

@ -33,144 +33,3 @@ macro_rules! TrivialTypeTraversalImpls {
)+ )+
}; };
} }
macro_rules! EnumTypeTraversalImpl {
(impl<$($p:tt),*> TypeFoldable<$tcx:tt> for $s:path {
$($variants:tt)*
} $(where $($wc:tt)*)*) => {
impl<$($p),*> $crate::fold::TypeFoldable<$tcx> for $s
$(where $($wc)*)*
{
fn try_fold_with<V: $crate::fold::FallibleTypeFolder<$tcx>>(
self,
folder: &mut V,
) -> ::std::result::Result<Self, V::Error> {
EnumTypeTraversalImpl!(@FoldVariants(self, folder) input($($variants)*) output())
}
}
};
(impl<$($p:tt),*> TypeVisitable<$tcx:tt> for $s:path {
$($variants:tt)*
} $(where $($wc:tt)*)*) => {
impl<$($p),*> $crate::visit::TypeVisitable<$tcx> for $s
$(where $($wc)*)*
{
fn visit_with<V: $crate::visit::TypeVisitor<$tcx>>(
&self,
visitor: &mut V,
) -> ::std::ops::ControlFlow<V::BreakTy> {
EnumTypeTraversalImpl!(@VisitVariants(self, visitor) input($($variants)*) output())
}
}
};
(@FoldVariants($this:expr, $folder:expr) input() output($($output:tt)*)) => {
Ok(match $this {
$($output)*
})
};
(@FoldVariants($this:expr, $folder:expr)
input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeTraversalImpl!(
@FoldVariants($this, $folder)
input($($input)*)
output(
$variant ( $($variant_arg),* ) => {
$variant (
$($crate::fold::TypeFoldable::try_fold_with($variant_arg, $folder)?),*
)
}
$($output)*
)
)
};
(@FoldVariants($this:expr, $folder:expr)
input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeTraversalImpl!(
@FoldVariants($this, $folder)
input($($input)*)
output(
$variant { $($variant_arg),* } => {
$variant {
$($variant_arg: $crate::fold::TypeFoldable::fold_with(
$variant_arg, $folder
)?),* }
}
$($output)*
)
)
};
(@FoldVariants($this:expr, $folder:expr)
input( ($variant:path), $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeTraversalImpl!(
@FoldVariants($this, $folder)
input($($input)*)
output(
$variant => { $variant }
$($output)*
)
)
};
(@VisitVariants($this:expr, $visitor:expr) input() output($($output:tt)*)) => {
match $this {
$($output)*
}
};
(@VisitVariants($this:expr, $visitor:expr)
input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeTraversalImpl!(
@VisitVariants($this, $visitor)
input($($input)*)
output(
$variant ( $($variant_arg),* ) => {
$($crate::visit::TypeVisitable::visit_with(
$variant_arg, $visitor
)?;)*
::std::ops::ControlFlow::Continue(())
}
$($output)*
)
)
};
(@VisitVariants($this:expr, $visitor:expr)
input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeTraversalImpl!(
@VisitVariants($this, $visitor)
input($($input)*)
output(
$variant { $($variant_arg),* } => {
$($crate::visit::TypeVisitable::visit_with(
$variant_arg, $visitor
)?;)*
::std::ops::ControlFlow::Continue(())
}
$($output)*
)
)
};
(@VisitVariants($this:expr, $visitor:expr)
input( ($variant:path), $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeTraversalImpl!(
@VisitVariants($this, $visitor)
input($($input)*)
output(
$variant => { ::std::ops::ControlFlow::Continue(()) }
$($output)*
)
)
};
}

52
compiler/rustc_type_ir/src/structural_impls.rs
View File

@ -70,30 +70,40 @@ impl<I: Interner, A: TypeVisitable<I>, B: TypeVisitable<I>, C: TypeVisitable<I>>
} }
} }
EnumTypeTraversalImpl! { impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Option<T> {
impl<I, T> TypeFoldable<I> for Option<T> { fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
(Some)(a), Ok(match self {
(None), Some(v) => Some(v.try_fold_with(folder)?),
} where I: Interner, T: TypeFoldable<I> None => None,
} })
EnumTypeTraversalImpl! { }
impl<I, T> TypeVisitable<I> for Option<T> {
(Some)(a),
(None),
} where I: Interner, T: TypeVisitable<I>
} }
EnumTypeTraversalImpl! { impl<I: Interner, T: TypeVisitable<I>> TypeVisitable<I> for Option<T> {
impl<I, T, E> TypeFoldable<I> for Result<T, E> { fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
(Ok)(a), match self {
(Err)(a), Some(v) => v.visit_with(visitor),
} where I: Interner, T: TypeFoldable<I>, E: TypeFoldable<I>, None => ControlFlow::Continue(()),
}
}
} }
EnumTypeTraversalImpl! {
impl<I, T, E> TypeVisitable<I> for Result<T, E> { impl<I: Interner, T: TypeFoldable<I>, E: TypeFoldable<I>> TypeFoldable<I> for Result<T, E> {
(Ok)(a), fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
(Err)(a), Ok(match self {
} where I: Interner, T: TypeVisitable<I>, E: TypeVisitable<I>, Ok(v) => Ok(v.try_fold_with(folder)?),
Err(e) => Err(e.try_fold_with(folder)?),
})
}
}
impl<I: Interner, T: TypeVisitable<I>, E: TypeVisitable<I>> TypeVisitable<I> for Result<T, E> {
fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
match self {
Ok(v) => v.visit_with(visitor),
Err(e) => e.visit_with(visitor),
}
}
} }
impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Rc<T> { impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Rc<T> {