mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

impl TypeVisitable in type traversal macros

Browse Source
This commit is contained in:
Alan Egerton 2022-06-17 11:05:17 +01:00
parent e4b9625b87
commit 9ffdc2de8c
No known key found for this signature in database
GPG Key ID: 07CAC3CCA7E0643F
14 changed files with 57 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_middle/src/infer/canonical.rs
View File

@ -293,7 +293,7 @@ impl<'tcx, V> Canonical<'tcx, V> {
pub type QueryOutlivesConstraint<'tcx> =
ty::Binder<'tcx, ty::OutlivesPredicate<GenericArg<'tcx>, Region<'tcx>>>;
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
for <'tcx> {
crate::infer::canonical::Certainty,
crate::infer::canonical::CanonicalVarInfo<'tcx>,
@ -301,7 +301,7 @@ TrivialTypeFoldableAndLiftImpls! {
}
}
TrivialTypeFoldableImpls! {
TrivialTypeTraversalImpls! {
for <'tcx> {
crate::infer::canonical::CanonicalVarInfos<'tcx>,
}

46
compiler/rustc_middle/src/macros.rs
View File

@ -18,7 +18,7 @@ macro_rules! span_bug {
}
///////////////////////////////////////////////////////////////////////////
// Lift and TypeFoldable macros
// Lift and TypeFoldable/TypeVisitable macros
//
// When possible, use one of these (relatively) convenient macros to write
// the impls for you.
@ -48,7 +48,7 @@ macro_rules! CloneLiftImpls {
/// Used for types that are `Copy` and which **do not care arena
/// allocated data** (i.e., don't need to be folded).
#[macro_export]
macro_rules! TrivialTypeFoldableImpls {
macro_rules! TrivialTypeTraversalImpls {
(for <$tcx:lifetime> { $($ty:ty,)+ }) => {
$(
impl<$tcx> $crate::ty::fold::TypeFoldable<$tcx> for $ty {
@ -58,8 +58,10 @@ macro_rules! TrivialTypeFoldableImpls {
) -> ::std::result::Result<$ty, F::Error> {
Ok(self)
}
}
fn visit_with<F: $crate::ty::fold::TypeVisitor<$tcx>>(
impl<$tcx> $crate::ty::visit::TypeVisitable<$tcx> for $ty {
fn visit_with<F: $crate::ty::visit::TypeVisitor<$tcx>>(
&self,
_: &mut F)
-> ::std::ops::ControlFlow<F::BreakTy>
@ -71,7 +73,7 @@ macro_rules! TrivialTypeFoldableImpls {
};
($($ty:ty,)+) => {
TrivialTypeFoldableImpls! {
TrivialTypeTraversalImpls! {
for <'tcx> {
$($ty,)+
}
@ -80,15 +82,15 @@ macro_rules! TrivialTypeFoldableImpls {
}
#[macro_export]
macro_rules! TrivialTypeFoldableAndLiftImpls {
macro_rules! TrivialTypeTraversalAndLiftImpls {
($($t:tt)*) => {
TrivialTypeFoldableImpls! { $($t)* }
TrivialTypeTraversalImpls! { $($t)* }
CloneLiftImpls! { $($t)* }
}
}
#[macro_export]
macro_rules! EnumTypeFoldableImpl {
macro_rules! EnumTypeTraversalImpl {
(impl<$($p:tt),*> TypeFoldable<$tcx:tt> for $s:path {
$($variants:tt)*
} $(where $($wc:tt)*)*) => {
@ -99,14 +101,22 @@ macro_rules! EnumTypeFoldableImpl {
self,
folder: &mut V,
) -> ::std::result::Result<Self, V::Error> {
EnumTypeFoldableImpl!(@FoldVariants(self, folder) input($($variants)*) output())
EnumTypeTraversalImpl!(@FoldVariants(self, folder) input($($variants)*) output())
}
}
};
fn visit_with<V: $crate::ty::fold::TypeVisitor<$tcx>>(
(impl<$($p:tt),*> TypeVisitable<$tcx:tt> for $s:path {
$($variants:tt)*
} $(where $($wc:tt)*)*) => {
impl<$($p),*> $crate::ty::visit::TypeVisitable<$tcx> for $s
$(where $($wc)*)*
{
fn visit_with<V: $crate::ty::visit::TypeVisitor<$tcx>>(
&self,
visitor: &mut V,
) -> ::std::ops::ControlFlow<V::BreakTy> {
EnumTypeFoldableImpl!(@VisitVariants(self, visitor) input($($variants)*) output())
EnumTypeTraversalImpl!(@VisitVariants(self, visitor) input($($variants)*) output())
}
}
};
@ -120,7 +130,7 @@ macro_rules! EnumTypeFoldableImpl {
(@FoldVariants($this:expr, $folder:expr)
input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeFoldableImpl!(
EnumTypeTraversalImpl!(
@FoldVariants($this, $folder)
input($($input)*)
output(
@ -137,7 +147,7 @@ macro_rules! EnumTypeFoldableImpl {
(@FoldVariants($this:expr, $folder:expr)
input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeFoldableImpl!(
EnumTypeTraversalImpl!(
@FoldVariants($this, $folder)
input($($input)*)
output(
@ -155,7 +165,7 @@ macro_rules! EnumTypeFoldableImpl {
(@FoldVariants($this:expr, $folder:expr)
input( ($variant:path), $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeFoldableImpl!(
EnumTypeTraversalImpl!(
@FoldVariants($this, $folder)
input($($input)*)
output(
@ -174,12 +184,12 @@ macro_rules! EnumTypeFoldableImpl {
(@VisitVariants($this:expr, $visitor:expr)
input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeFoldableImpl!(
EnumTypeTraversalImpl!(
@VisitVariants($this, $visitor)
input($($input)*)
output(
$variant ( $($variant_arg),* ) => {
$($crate::ty::fold::TypeFoldable::visit_with(
$($crate::ty::visit::TypeVisitable::visit_with(
$variant_arg, $visitor
)?;)*
::std::ops::ControlFlow::CONTINUE
@ -192,12 +202,12 @@ macro_rules! EnumTypeFoldableImpl {
(@VisitVariants($this:expr, $visitor:expr)
input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeFoldableImpl!(
EnumTypeTraversalImpl!(
@VisitVariants($this, $visitor)
input($($input)*)
output(
$variant { $($variant_arg),* } => {
$($crate::ty::fold::TypeFoldable::visit_with(
$($crate::ty::visit::TypeVisitable::visit_with(
$variant_arg, $visitor
)?;)*
::std::ops::ControlFlow::CONTINUE
@ -210,7 +220,7 @@ macro_rules! EnumTypeFoldableImpl {
(@VisitVariants($this:expr, $visitor:expr)
input( ($variant:path), $($input:tt)*)
output( $($output:tt)*) ) => {
EnumTypeFoldableImpl!(
EnumTypeTraversalImpl!(
@VisitVariants($this, $visitor)
input($($input)*)
output(

2
compiler/rustc_middle/src/mir/graph_cyclic_cache.rs
View File

@ -58,6 +58,6 @@ impl<CTX> HashStable<CTX> for GraphIsCyclicCache {
}
}
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
GraphIsCyclicCache,
}

2
compiler/rustc_middle/src/mir/interpret/error.rs
View File

@ -29,7 +29,7 @@ impl From<ErrorGuaranteed> for ErrorHandled {
}
}
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
ErrorHandled,
}

4
compiler/rustc_middle/src/mir/mod.rs
View File

@ -762,7 +762,7 @@ pub enum ImplicitSelfKind {
None,
}
TrivialTypeFoldableAndLiftImpls! { BindingForm<'tcx>, }
TrivialTypeTraversalAndLiftImpls! { BindingForm<'tcx>, }
mod binding_form_impl {
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@ -2641,7 +2641,7 @@ impl UserTypeProjection {
}
}
TrivialTypeFoldableAndLiftImpls! { ProjectionKind, }
TrivialTypeTraversalAndLiftImpls! { ProjectionKind, }
impl<'tcx> TypeFoldable<'tcx> for UserTypeProjection {
fn try_fold_with<F: FallibleTypeFolder<'tcx>>(self, folder: &mut F) -> Result<Self, F::Error> {

2
compiler/rustc_middle/src/mir/predecessors.rs
View File

@ -73,6 +73,6 @@ impl<CTX> HashStable<CTX> for PredecessorCache {
}
}
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
PredecessorCache,
}

2
compiler/rustc_middle/src/mir/switch_sources.rs
View File

@ -73,6 +73,6 @@ impl<CTX> HashStable<CTX> for SwitchSourceCache {
}
}
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
SwitchSourceCache,
}

2
compiler/rustc_middle/src/mir/traversal.rs
View File

@ -384,6 +384,6 @@ impl<CTX> HashStable<CTX> for PostorderCache {
}
}
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
PostorderCache,
}

2
compiler/rustc_middle/src/mir/type_foldable.rs
View File

@ -4,7 +4,7 @@ use super::*;
use crate::ty;
use rustc_data_structures::functor::IdFunctor;
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
BlockTailInfo,
MirPhase,
SourceInfo,

2
compiler/rustc_middle/src/thir/abstract_const.rs
View File

@ -42,7 +42,7 @@ impl From<ErrorGuaranteed> for NotConstEvaluatable {
}
}
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
NotConstEvaluatable,
}

2
compiler/rustc_middle/src/traits/select.rs
View File

@ -283,7 +283,7 @@ impl From<ErrorGuaranteed> for OverflowError {
}
}
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
OverflowError,
}

2
compiler/rustc_middle/src/traits/structural_impls.rs
View File

@ -129,7 +129,7 @@ impl<N: fmt::Debug> fmt::Debug for traits::ImplSourceConstDestructData<N> {
///////////////////////////////////////////////////////////////////////////
// Lift implementations
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
super::IfExpressionCause,
super::ImplSourceDiscriminantKindData,
super::ImplSourcePointeeData,

2
compiler/rustc_middle/src/ty/binding.rs
View File

@ -8,7 +8,7 @@ pub enum BindingMode {
BindByValue(Mutability),
}
TrivialTypeFoldableAndLiftImpls! { BindingMode, }
TrivialTypeTraversalAndLiftImpls! { BindingMode, }
impl BindingMode {
pub fn convert(ba: BindingAnnotation) -> BindingMode {

18
compiler/rustc_middle/src/ty/structural_impls.rs
View File

@ -183,7 +183,7 @@ impl<'tcx> fmt::Debug for ty::PredicateKind<'tcx> {
// For things that don't carry any arena-allocated data (and are
// copy...), just add them to this list.
TrivialTypeFoldableAndLiftImpls! {
TrivialTypeTraversalAndLiftImpls! {
(),
bool,
usize,
@ -692,19 +692,31 @@ impl<'tcx, A: TypeFoldable<'tcx>, B: TypeFoldable<'tcx>, C: TypeFoldable<'tcx>>
}
}
EnumTypeFoldableImpl! {
EnumTypeTraversalImpl! {
impl<'tcx, T> TypeFoldable<'tcx> for Option<T> {
(Some)(a),
(None),
} where T: TypeFoldable<'tcx>
}
EnumTypeTraversalImpl! {
impl<'tcx, T> TypeVisitable<'tcx> for Option<T> {
(Some)(a),
(None),
} where T: TypeVisitable<'tcx>
}
EnumTypeFoldableImpl! {
EnumTypeTraversalImpl! {
impl<'tcx, T, E> TypeFoldable<'tcx> for Result<T, E> {
(Ok)(a),
(Err)(a),
} where T: TypeFoldable<'tcx>, E: TypeFoldable<'tcx>,
}
EnumTypeTraversalImpl! {
impl<'tcx, T, E> TypeVisitable<'tcx> for Result<T, E> {
(Ok)(a),
(Err)(a),
} where T: TypeVisitable<'tcx>, E: TypeVisitable<'tcx>,
}
impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Rc<T> {
fn try_fold_with<F: FallibleTypeFolder<'tcx>>(