3 () => ( $crate::bug!("impossible case reached") );
4 ($msg:expr) => ({ $crate::util::bug::bug_fmt(::std::format_args!($msg)) });
5 ($msg:expr,) => ({ $crate::bug!($msg) });
6 ($fmt:expr, $($arg:tt)+) => ({
7 $crate::util::bug::bug_fmt(::std::format_args!($fmt, $($arg)+))
12 macro_rules! span_bug {
13 ($span:expr, $msg:expr) => ({ $crate::util::bug::span_bug_fmt($span, ::std::format_args!($msg)) });
14 ($span:expr, $msg:expr,) => ({ $crate::span_bug!($span, $msg) });
15 ($span:expr, $fmt:expr, $($arg:tt)+) => ({
16 $crate::util::bug::span_bug_fmt($span, ::std::format_args!($fmt, $($arg)+))
20 ///////////////////////////////////////////////////////////////////////////
21 // Lift and TypeFoldable/TypeVisitable macros
23 // When possible, use one of these (relatively) convenient macros to write
27 macro_rules! CloneLiftImpls {
28 (for <$tcx:lifetime> { $($ty:ty,)+ }) => {
30 impl<$tcx> $crate::ty::Lift<$tcx> for $ty {
32 fn lift_to_tcx(self, _: $crate::ty::TyCtxt<$tcx>) -> Option<Self> {
48 /// Used for types that are `Copy` and which **do not care arena
49 /// allocated data** (i.e., don't need to be folded).
51 macro_rules! TrivialTypeTraversalImpls {
52 (for <$tcx:lifetime> { $($ty:ty,)+ }) => {
54 impl<$tcx> $crate::ty::fold::TypeFoldable<$tcx> for $ty {
55 fn try_fold_with<F: $crate::ty::fold::FallibleTypeFolder<$tcx>>(
58 ) -> ::std::result::Result<$ty, F::Error> {
63 impl<$tcx> $crate::ty::visit::TypeVisitable<$tcx> for $ty {
64 fn visit_with<F: $crate::ty::visit::TypeVisitor<$tcx>>(
67 -> ::std::ops::ControlFlow<F::BreakTy>
69 ::std::ops::ControlFlow::CONTINUE
76 TrivialTypeTraversalImpls! {
85 macro_rules! TrivialTypeTraversalAndLiftImpls {
87 TrivialTypeTraversalImpls! { $($t)* }
88 CloneLiftImpls! { $($t)* }
93 macro_rules! EnumTypeTraversalImpl {
94 (impl<$($p:tt),*> TypeFoldable<$tcx:tt> for $s:path {
96 } $(where $($wc:tt)*)*) => {
97 impl<$($p),*> $crate::ty::fold::TypeFoldable<$tcx> for $s
100 fn try_fold_with<V: $crate::ty::fold::FallibleTypeFolder<$tcx>>(
103 ) -> ::std::result::Result<Self, V::Error> {
104 EnumTypeTraversalImpl!(@FoldVariants(self, folder) input($($variants)*) output())
109 (impl<$($p:tt),*> TypeVisitable<$tcx:tt> for $s:path {
111 } $(where $($wc:tt)*)*) => {
112 impl<$($p),*> $crate::ty::visit::TypeVisitable<$tcx> for $s
115 fn visit_with<V: $crate::ty::visit::TypeVisitor<$tcx>>(
118 ) -> ::std::ops::ControlFlow<V::BreakTy> {
119 EnumTypeTraversalImpl!(@VisitVariants(self, visitor) input($($variants)*) output())
124 (@FoldVariants($this:expr, $folder:expr) input() output($($output:tt)*)) => {
130 (@FoldVariants($this:expr, $folder:expr)
131 input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
132 output( $($output:tt)*) ) => {
133 EnumTypeTraversalImpl!(
134 @FoldVariants($this, $folder)
137 $variant ( $($variant_arg),* ) => {
139 $($crate::ty::fold::TypeFoldable::try_fold_with($variant_arg, $folder)?),*
147 (@FoldVariants($this:expr, $folder:expr)
148 input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
149 output( $($output:tt)*) ) => {
150 EnumTypeTraversalImpl!(
151 @FoldVariants($this, $folder)
154 $variant { $($variant_arg),* } => {
156 $($variant_arg: $crate::ty::fold::TypeFoldable::fold_with(
157 $variant_arg, $folder
165 (@FoldVariants($this:expr, $folder:expr)
166 input( ($variant:path), $($input:tt)*)
167 output( $($output:tt)*) ) => {
168 EnumTypeTraversalImpl!(
169 @FoldVariants($this, $folder)
172 $variant => { $variant }
178 (@VisitVariants($this:expr, $visitor:expr) input() output($($output:tt)*)) => {
184 (@VisitVariants($this:expr, $visitor:expr)
185 input( ($variant:path) ( $($variant_arg:ident),* ) , $($input:tt)*)
186 output( $($output:tt)*) ) => {
187 EnumTypeTraversalImpl!(
188 @VisitVariants($this, $visitor)
191 $variant ( $($variant_arg),* ) => {
192 $($crate::ty::visit::TypeVisitable::visit_with(
193 $variant_arg, $visitor
195 ::std::ops::ControlFlow::CONTINUE
202 (@VisitVariants($this:expr, $visitor:expr)
203 input( ($variant:path) { $($variant_arg:ident),* $(,)? } , $($input:tt)*)
204 output( $($output:tt)*) ) => {
205 EnumTypeTraversalImpl!(
206 @VisitVariants($this, $visitor)
209 $variant { $($variant_arg),* } => {
210 $($crate::ty::visit::TypeVisitable::visit_with(
211 $variant_arg, $visitor
213 ::std::ops::ControlFlow::CONTINUE
220 (@VisitVariants($this:expr, $visitor:expr)
221 input( ($variant:path), $($input:tt)*)
222 output( $($output:tt)*) ) => {
223 EnumTypeTraversalImpl!(
224 @VisitVariants($this, $visitor)
227 $variant => { ::std::ops::ControlFlow::CONTINUE }