Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit a6c1fa5

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of rust-lang#110386 - nnethercote:clean-up-traversal-macros, r=lcnr
Clean up traversal macros The declarative macros relating to type folding and visiting can be simplified. r? ``@lcnr``
2 parents a785328 + d2b5a64 commit a6c1fa5

File tree

8 files changed

+54
-206
lines changed

8 files changed

+54
-206
lines changed

‎compiler/rustc_middle/src/infer/canonical.rs‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -392,10 +392,8 @@ pub type QueryOutlivesConstraint<'tcx> =
392392
(ty::OutlivesPredicate<GenericArg<'tcx>, Region<'tcx>>, ConstraintCategory<'tcx>);
393393

394394
TrivialTypeTraversalAndLiftImpls! {
395-
for <'tcx> {
396-
crate::infer::canonical::Certainty,
397-
crate::infer::canonical::CanonicalTyVarKind,
398-
}
395+
crate::infer::canonical::Certainty,
396+
crate::infer::canonical::CanonicalTyVarKind,
399397
}
400398

401399
impl<'tcx> CanonicalVarValues<'tcx> {

‎compiler/rustc_middle/src/macros.rs‎

Lines changed: 9 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -43,52 +43,44 @@ macro_rules! span_bug {
4343

4444
#[macro_export]
4545
macro_rules! CloneLiftImpls {
46-
(for <$tcx:lifetime> { $($ty:ty,)+ }) => {
46+
($($ty:ty,)+) => {
4747
$(
48-
impl<$tcx> $crate::ty::Lift<$tcx> for $ty {
48+
impl<'tcx> $crate::ty::Lift<'tcx> for $ty {
4949
type Lifted = Self;
50-
fn lift_to_tcx(self, _: $crate::ty::TyCtxt<$tcx>) -> Option<Self> {
50+
fn lift_to_tcx(self, _: $crate::ty::TyCtxt<'tcx>) -> Option<Self> {
5151
Some(self)
5252
}
5353
}
5454
)+
5555
};
56-
57-
($($ty:ty,)+) => {
58-
CloneLiftImpls! {
59-
for <'tcx> {
60-
$($ty,)+
61-
}
62-
}
63-
};
6456
}
6557

6658
/// Used for types that are `Copy` and which **do not care arena
6759
/// allocated data** (i.e., don't need to be folded).
6860
#[macro_export]
6961
macro_rules! TrivialTypeTraversalImpls {
70-
(for <$tcx:lifetime> { $($ty:ty,)+ }) => {
62+
($($ty:ty,)+) => {
7163
$(
72-
impl<$tcx> $crate::ty::fold::TypeFoldable<$crate::ty::TyCtxt<$tcx>> for $ty {
73-
fn try_fold_with<F: $crate::ty::fold::FallibleTypeFolder<$crate::ty::TyCtxt<$tcx>>>(
64+
impl<'tcx> $crate::ty::fold::TypeFoldable<$crate::ty::TyCtxt<'tcx>> for $ty {
65+
fn try_fold_with<F: $crate::ty::fold::FallibleTypeFolder<$crate::ty::TyCtxt<'tcx>>>(
7466
self,
7567
_: &mut F,
7668
) -> ::std::result::Result<Self, F::Error> {
7769
Ok(self)
7870
}
7971

8072
#[inline]
81-
fn fold_with<F: $crate::ty::fold::TypeFolder<$crate::ty::TyCtxt<$tcx>>>(
73+
fn fold_with<F: $crate::ty::fold::TypeFolder<$crate::ty::TyCtxt<'tcx>>>(
8274
self,
8375
_: &mut F,
8476
) -> Self {
8577
self
8678
}
8779
}
8880

89-
impl<$tcx> $crate::ty::visit::TypeVisitable<$crate::ty::TyCtxt<$tcx>> for $ty {
81+
impl<'tcx> $crate::ty::visit::TypeVisitable<$crate::ty::TyCtxt<'tcx>> for $ty {
9082
#[inline]
91-
fn visit_with<F: $crate::ty::visit::TypeVisitor<$crate::ty::TyCtxt<$tcx>>>(
83+
fn visit_with<F: $crate::ty::visit::TypeVisitor<$crate::ty::TyCtxt<'tcx>>>(
9284
&self,
9385
_: &mut F)
9486
-> ::std::ops::ControlFlow<F::BreakTy>
@@ -98,14 +90,6 @@ macro_rules! TrivialTypeTraversalImpls {
9890
}
9991
)+
10092
};
101-
102-
($($ty:ty,)+) => {
103-
TrivialTypeTraversalImpls! {
104-
for<'tcx> {
105-
$($ty,)+
106-
}
107-
}
108-
};
10993
}
11094

11195
#[macro_export]

‎compiler/rustc_middle/src/mir/mod.rs‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -714,9 +714,7 @@ pub enum BindingForm<'tcx> {
714714
}
715715

716716
TrivialTypeTraversalAndLiftImpls! {
717-
for<'tcx> {
718-
BindingForm<'tcx>,
719-
}
717+
BindingForm<'tcx>,
720718
}
721719

722720
mod binding_form_impl {

‎compiler/rustc_middle/src/mir/type_foldable.rs‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,9 +25,7 @@ TrivialTypeTraversalAndLiftImpls! {
2525
}
2626

2727
TrivialTypeTraversalImpls! {
28-
for <'tcx> {
29-
ConstValue<'tcx>,
30-
}
28+
ConstValue<'tcx>,
3129
}
3230

3331
impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [InlineAsmTemplatePiece] {

‎compiler/rustc_middle/src/ty/context.rs‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1329,9 +1329,12 @@ nop_list_lift! {bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariable
13291329
// This is the impl for `&'a InternalSubsts<'a>`.
13301330
nop_list_lift! {substs; GenericArg<'a> => GenericArg<'tcx>}
13311331

1332-
CloneLiftImpls! { for<'tcx> {
1333-
Constness, traits::WellFormedLoc, ImplPolarity, crate::mir::ReturnConstraint,
1334-
} }
1332+
CloneLiftImpls! {
1333+
Constness,
1334+
traits::WellFormedLoc,
1335+
ImplPolarity,
1336+
crate::mir::ReturnConstraint,
1337+
}
13351338

13361339
macro_rules! sty_debug_print {
13371340
($fmt: expr, $ctxt: expr, $($variant: ident),*) => {{

‎compiler/rustc_middle/src/ty/structural_impls.rs‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -276,9 +276,7 @@ TrivialTypeTraversalAndLiftImpls! {
276276
}
277277

278278
TrivialTypeTraversalAndLiftImpls! {
279-
for<'tcx> {
280-
ty::ValTree<'tcx>,
281-
}
279+
ty::ValTree<'tcx>,
282280
}
283281

284282
///////////////////////////////////////////////////////////////////////////

‎compiler/rustc_type_ir/src/macros.rs‎

Lines changed: 0 additions & 141 deletions
Original file line numberDiff line numberDiff line change
@@ -33,144 +33,3 @@ macro_rules! TrivialTypeTraversalImpls {
3333
)+
3434
};
3535
}
36-
37-
macro_rules! EnumTypeTraversalImpl {
38-
(impl<$($p:tt),*> TypeFoldable<$tcx:tt> for $s:path {
39-
$($variants:tt)*
40-
} $(where $($wc:tt)*)*) => {
41-
impl<$($p),*> $crate::fold::TypeFoldable<$tcx> for $s
42-
$(where $($wc)*)*
43-
{
44-
fn try_fold_with<V: $crate::fold::FallibleTypeFolder<$tcx>>(
45-
self,
46-
folder: &mut V,
47-
) -> ::std::result::Result<Self, V::Error> {
48-
EnumTypeTraversalImpl!(@FoldVariants(self, folder) input($($variants)*) output())
49-
}
50-
}
51-
};
52-
53-
(impl<$($p:tt),*> TypeVisitable<$tcx:tt> for $s:path {
54-
$($variants:tt)*
55-
} $(where $($wc:tt)*)*) => {
56-
impl<$($p),*> $crate::visit::TypeVisitable<$tcx> for $s
57-
$(where $($wc)*)*
58-
{
59-
fn visit_with<V: $crate::visit::TypeVisitor<$tcx>>(
60-
&self,
61-
visitor: &mut V,
62-
) -> ::std::ops::ControlFlow<V::BreakTy> {
63-
EnumTypeTraversalImpl!(@VisitVariants(self, visitor) input($($variants)*) output())
64-
}
65-
}
66-
};
67-
68-
(@FoldVariants($this:expr, $folder:expr) input() output($($output:tt)*)) => {
69-
Ok(match $this {
70-
$($output)*
71-
})
72-
};
73-
74-
(@FoldVariants($this:expr, $folder:expr)
75-
input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
76-
output( $($output:tt)*) ) => {
77-
EnumTypeTraversalImpl!(
78-
@FoldVariants($this, $folder)
79-
input($($input)*)
80-
output(
81-
$variant ( $($variant_arg),* ) => {
82-
$variant (
83-
$($crate::fold::TypeFoldable::try_fold_with($variant_arg, $folder)?),*
84-
)
85-
}
86-
$($output)*
87-
)
88-
)
89-
};
90-
91-
(@FoldVariants($this:expr, $folder:expr)
92-
input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
93-
output( $($output:tt)*) ) => {
94-
EnumTypeTraversalImpl!(
95-
@FoldVariants($this, $folder)
96-
input($($input)*)
97-
output(
98-
$variant { $($variant_arg),* } => {
99-
$variant {
100-
$($variant_arg: $crate::fold::TypeFoldable::fold_with(
101-
$variant_arg, $folder
102-
)?),* }
103-
}
104-
$($output)*
105-
)
106-
)
107-
};
108-
109-
(@FoldVariants($this:expr, $folder:expr)
110-
input( ($variant:path), $($input:tt)*)
111-
output( $($output:tt)*) ) => {
112-
EnumTypeTraversalImpl!(
113-
@FoldVariants($this, $folder)
114-
input($($input)*)
115-
output(
116-
$variant => { $variant }
117-
$($output)*
118-
)
119-
)
120-
};
121-
122-
(@VisitVariants($this:expr, $visitor:expr) input() output($($output:tt)*)) => {
123-
match $this {
124-
$($output)*
125-
}
126-
};
127-
128-
(@VisitVariants($this:expr, $visitor:expr)
129-
input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
130-
output( $($output:tt)*) ) => {
131-
EnumTypeTraversalImpl!(
132-
@VisitVariants($this, $visitor)
133-
input($($input)*)
134-
output(
135-
$variant ( $($variant_arg),* ) => {
136-
$($crate::visit::TypeVisitable::visit_with(
137-
$variant_arg, $visitor
138-
)?;)*
139-
::std::ops::ControlFlow::Continue(())
140-
}
141-
$($output)*
142-
)
143-
)
144-
};
145-
146-
(@VisitVariants($this:expr, $visitor:expr)
147-
input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
148-
output( $($output:tt)*) ) => {
149-
EnumTypeTraversalImpl!(
150-
@VisitVariants($this, $visitor)
151-
input($($input)*)
152-
output(
153-
$variant { $($variant_arg),* } => {
154-
$($crate::visit::TypeVisitable::visit_with(
155-
$variant_arg, $visitor
156-
)?;)*
157-
::std::ops::ControlFlow::Continue(())
158-
}
159-
$($output)*
160-
)
161-
)
162-
};
163-
164-
(@VisitVariants($this:expr, $visitor:expr)
165-
input( ($variant:path), $($input:tt)*)
166-
output( $($output:tt)*) ) => {
167-
EnumTypeTraversalImpl!(
168-
@VisitVariants($this, $visitor)
169-
input($($input)*)
170-
output(
171-
$variant => { ::std::ops::ControlFlow::Continue(()) }
172-
$($output)*
173-
)
174-
)
175-
};
176-
}

‎compiler/rustc_type_ir/src/structural_impls.rs‎

Lines changed: 34 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -70,30 +70,40 @@ impl<I: Interner, A: TypeVisitable<I>, B: TypeVisitable<I>, C: TypeVisitable<I>>
7070
}
7171
}
7272

73-
EnumTypeTraversalImpl! {
74-
impl<I, T> TypeFoldable<I> for Option<T> {
75-
(Some)(a),
76-
(None),
77-
} where I: Interner, T: TypeFoldable<I>
78-
}
79-
EnumTypeTraversalImpl! {
80-
impl<I, T> TypeVisitable<I> for Option<T> {
81-
(Some)(a),
82-
(None),
83-
} where I: Interner, T: TypeVisitable<I>
84-
}
85-
86-
EnumTypeTraversalImpl! {
87-
impl<I, T, E> TypeFoldable<I> for Result<T, E> {
88-
(Ok)(a),
89-
(Err)(a),
90-
} where I: Interner, T: TypeFoldable<I>, E: TypeFoldable<I>,
91-
}
92-
EnumTypeTraversalImpl! {
93-
impl<I, T, E> TypeVisitable<I> for Result<T, E> {
94-
(Ok)(a),
95-
(Err)(a),
96-
} where I: Interner, T: TypeVisitable<I>, E: TypeVisitable<I>,
73+
impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Option<T> {
74+
fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
75+
Ok(match self {
76+
Some(v) => Some(v.try_fold_with(folder)?),
77+
None => None,
78+
})
79+
}
80+
}
81+
82+
impl<I: Interner, T: TypeVisitable<I>> TypeVisitable<I> for Option<T> {
83+
fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
84+
match self {
85+
Some(v) => v.visit_with(visitor),
86+
None => ControlFlow::Continue(()),
87+
}
88+
}
89+
}
90+
91+
impl<I: Interner, T: TypeFoldable<I>, E: TypeFoldable<I>> TypeFoldable<I> for Result<T, E> {
92+
fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
93+
Ok(match self {
94+
Ok(v) => Ok(v.try_fold_with(folder)?),
95+
Err(e) => Err(e.try_fold_with(folder)?),
96+
})
97+
}
98+
}
99+
100+
impl<I: Interner, T: TypeVisitable<I>, E: TypeVisitable<I>> TypeVisitable<I> for Result<T, E> {
101+
fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
102+
match self {
103+
Ok(v) => v.visit_with(visitor),
104+
Err(e) => e.visit_with(visitor),
105+
}
106+
}
97107
}
98108

99109
impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Rc<T> {

0 commit comments

Comments
 (0)