yikes

Author: lcnr

compiler/rustc_macros/src/lib.rs

@@ -17,6 +17,7 @@ mod diagnostics;
 mod extension;
 mod hash_stable;
 mod lift;
+mod noop_type_traversable;
 mod query;
 mod serialize;
 mod symbols;
@@ -81,27 +82,9 @@ decl_derive!([TyDecodable] => serialize::type_decodable_derive);
 decl_derive!([TyEncodable] => serialize::type_encodable_derive);
 decl_derive!([MetadataDecodable] => serialize::meta_decodable_derive);
 decl_derive!([MetadataEncodable] => serialize::meta_encodable_derive);
-decl_derive!(
-    [TypeFoldable, attributes(type_foldable)] =>
-    /// Derives `TypeFoldable` for the annotated `struct` or `enum` (`union` is not supported).
-    ///
-    /// The fold will produce a value of the same struct or enum variant as the input, with
-    /// each field respectively folded using the `TypeFoldable` implementation for its type.
-    /// However, if a field of a struct or an enum variant is annotated with
-    /// `#[type_foldable(identity)]` then that field will retain its incumbent value (and its
-    /// type is not required to implement `TypeFoldable`).
-    type_foldable::type_foldable_derive
-);
-decl_derive!(
-    [TypeVisitable, attributes(type_visitable)] =>
-    /// Derives `TypeVisitable` for the annotated `struct` or `enum` (`union` is not supported).
-    ///
-    /// Each field of the struct or enum variant will be visited in definition order, using the
-    /// `TypeVisitable` implementation for its type. However, if a field of a struct or an enum
-    /// variant is annotated with `#[type_visitable(ignore)]` then that field will not be
-    /// visited (and its type is not required to implement `TypeVisitable`).
-    type_visitable::type_visitable_derive
-);
+decl_derive!([NoopTypeTraversable] => noop_type_traversable::noop_type_traversable_derive);
+decl_derive!([TypeVisitable] => type_visitable::type_visitable_derive);
+decl_derive!([TypeFoldable] => type_foldable::type_foldable_derive);
 decl_derive!([Lift, attributes(lift)] => lift::lift_derive);
 decl_derive!(
     [Diagnostic, attributes(

compiler/rustc_macros/src/noop_type_traversable.rs

@@ -0,0 +1,39 @@
+use quote::quote;
+use syn::parse_quote;
+
+pub(super) fn noop_type_traversable_derive(
+    mut s: synstructure::Structure<'_>,
+) -> proc_macro2::TokenStream {
+    if let syn::Data::Union(_) = s.ast().data {
+        panic!("cannot derive on union")
+    }
+
+    s.underscore_const(true);
+
+    if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
+        s.add_impl_generic(parse_quote! { 'tcx });
+    }
+
+    s.add_bounds(synstructure::AddBounds::None);
+    let mut where_clauses = None;
+    s.add_trait_bounds(
+        &parse_quote!(
+            ::rustc_middle::ty::traverse::TypeTraversable<
+                ::rustc_middle::ty::TyCtxt<'tcx>,
+                Kind = ::rustc_middle::ty::traverse::NoopTypeTraversal,
+            >
+        ),
+        &mut where_clauses,
+        synstructure::AddBounds::Fields,
+    );
+    for pred in where_clauses.into_iter().flat_map(|c| c.predicates) {
+        s.add_where_predicate(pred);
+    }
+
+    s.bound_impl(
+        quote!(::rustc_middle::ty::traverse::TypeTraversable<::rustc_middle::ty::TyCtxt<'tcx>>),
+        quote! {
+            type Kind = ::rustc_middle::ty::traverse::NoopTypeTraversal;
+        },
+    )
+}

compiler/rustc_macros/src/type_foldable.rs

@@ -1,4 +1,4 @@
-use quote::{ToTokens, quote};
+use quote::quote;
 use syn::parse_quote;
 
 pub(super) fn type_foldable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
@@ -12,34 +12,24 @@ pub(super) fn type_foldable_derive(mut s: synstructure::Structure<'_>) -> proc_m
         s.add_impl_generic(parse_quote! { 'tcx });
     }
 
-    s.add_bounds(synstructure::AddBounds::Generics);
+    s.add_bounds(synstructure::AddBounds::None);
+    let mut where_clauses = None;
+    s.add_trait_bounds(
+        &parse_quote!(::rustc_type_ir::traverse::OptTryFoldWith<::rustc_middle::ty::TyCtxt<'tcx>>),
+        &mut where_clauses,
+        synstructure::AddBounds::Fields,
+    );
+    for pred in where_clauses.into_iter().flat_map(|c| c.predicates) {
+        s.add_where_predicate(pred);
+    }
+
     s.bind_with(|_| synstructure::BindStyle::Move);
     let body_fold = s.each_variant(|vi| {
         let bindings = vi.bindings();
         vi.construct(|_, index| {
             let bind = &bindings[index];
-
-            let mut fixed = false;
-
-            // retain value of fields with #[type_foldable(identity)]
-            bind.ast().attrs.iter().for_each(|x| {
-                if !x.path().is_ident("type_foldable") {
-                    return;
-                }
-                let _ = x.parse_nested_meta(|nested| {
-                    if nested.path.is_ident("identity") {
-                        fixed = true;
-                    }
-                    Ok(())
-                });
-            });
-
-            if fixed {
-                bind.to_token_stream()
-            } else {
-                quote! {
-                    ::rustc_middle::ty::fold::TypeFoldable::try_fold_with(#bind, __folder)?
-                }
+            quote! {
+                ::rustc_middle::ty::traverse::OptTryFoldWith::mk_try_fold_with()(#bind, __folder)?
             }
         })
     });

compiler/rustc_macros/src/type_visitable.rs

@@ -10,34 +10,27 @@ pub(super) fn type_visitable_derive(
 
     s.underscore_const(true);
 
-    // ignore fields with #[type_visitable(ignore)]
-    s.filter(|bi| {
-        let mut ignored = false;
-
-        bi.ast().attrs.iter().for_each(|attr| {
-            if !attr.path().is_ident("type_visitable") {
-                return;
-            }
-            let _ = attr.parse_nested_meta(|nested| {
-                if nested.path.is_ident("ignore") {
-                    ignored = true;
-                }
-                Ok(())
-            });
-        });
-
-        !ignored
-    });
-
     if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
         s.add_impl_generic(parse_quote! { 'tcx });
     }
 
-    s.add_bounds(synstructure::AddBounds::Generics);
+    s.add_bounds(synstructure::AddBounds::None);
+    let mut where_clauses = None;
+    s.add_trait_bounds(
+        &parse_quote!(
+            ::rustc_middle::ty::traverse::OptVisitWith::<::rustc_middle::ty::TyCtxt<'tcx>>
+        ),
+        &mut where_clauses,
+        synstructure::AddBounds::Fields,
+    );
+    for pred in where_clauses.into_iter().flat_map(|c| c.predicates) {
+        s.add_where_predicate(pred);
+    }
+
     let body_visit = s.each(|bind| {
         quote! {
             match ::rustc_ast_ir::visit::VisitorResult::branch(
-                ::rustc_middle::ty::visit::TypeVisitable::visit_with(#bind, __visitor)
+                ::rustc_middle::ty::traverse::OptVisitWith::mk_visit_with()(#bind, __visitor)
             ) {
                 ::core::ops::ControlFlow::Continue(()) => {},
                 ::core::ops::ControlFlow::Break(r) => {

compiler/rustc_middle/src/macros.rs

@@ -73,32 +73,8 @@ macro_rules! TrivialLiftImpls {
 macro_rules! TrivialTypeTraversalImpls {
     ($($ty:ty),+ $(,)?) => {
         $(
-            impl<'tcx> $crate::ty::fold::TypeFoldable<$crate::ty::TyCtxt<'tcx>> for $ty {
-                fn try_fold_with<F: $crate::ty::fold::FallibleTypeFolder<$crate::ty::TyCtxt<'tcx>>>(
-                    self,
-                    _: &mut F,
-                ) -> ::std::result::Result<Self, F::Error> {
-                    Ok(self)
-                }
-
-                #[inline]
-                fn fold_with<F: $crate::ty::fold::TypeFolder<$crate::ty::TyCtxt<'tcx>>>(
-                    self,
-                    _: &mut F,
-                ) -> Self {
-                    self
-                }
-            }
-
-            impl<'tcx> $crate::ty::visit::TypeVisitable<$crate::ty::TyCtxt<'tcx>> for $ty {
-                #[inline]
-                fn visit_with<F: $crate::ty::visit::TypeVisitor<$crate::ty::TyCtxt<'tcx>>>(
-                    &self,
-                    _: &mut F)
-                    -> F::Result
-                {
-                    <F::Result as ::rustc_ast_ir::visit::VisitorResult>::output()
-                }
+            impl<'tcx> $crate::ty::traverse::TypeTraversable<$crate::ty::TyCtxt<'tcx>> for $ty {
+                type Kind = $crate::ty::traverse::NoopTypeTraversal;
             }
         )+
     };

compiler/rustc_middle/src/mir/query.rs

@@ -57,8 +57,6 @@ pub struct CoroutineLayout<'tcx> {
     /// Which saved locals are storage-live at the same time. Locals that do not
     /// have conflicts with each other are allowed to overlap in the computed
     /// layout.
-    #[type_foldable(identity)]
-    #[type_visitable(ignore)]
     pub storage_conflicts: BitMatrix<CoroutineSavedLocal, CoroutineSavedLocal>,
 }
 

compiler/rustc_middle/src/mir/type_foldable.rs

@@ -1,7 +1,5 @@
 //! `TypeFoldable` implementations for MIR types
-
-use rustc_ast::InlineAsmTemplatePiece;
-use rustc_hir::def_id::LocalDefId;
+use rustc_index::bit_set::BitMatrix;
 
 use super::*;
 
@@ -20,40 +18,14 @@ TrivialTypeTraversalImpls! {
     SwitchTargets,
     CoroutineKind,
     CoroutineSavedLocal,
+    BitMatrix<CoroutineSavedLocal, CoroutineSavedLocal>,
 }
 
 TrivialTypeTraversalImpls! {
     ConstValue<'tcx>,
     NullOp<'tcx>,
 }
 
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [InlineAsmTemplatePiece] {
-    fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        _folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        Ok(self)
-    }
-}
-
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx [Span] {
-    fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        _folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        Ok(self)
-    }
-}
-
-impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<LocalDefId> {
-    fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
-        self,
-        _folder: &mut F,
-    ) -> Result<Self, F::Error> {
-        Ok(self)
-    }
-}
-
 impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<PlaceElem<'tcx>> {
     fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
         self,

compiler/rustc_middle/src/thir.rs

@@ -739,9 +739,7 @@ pub enum PatKind<'tcx> {
     /// `x`, `ref x`, `x @ P`, etc.
     Binding {
         name: Symbol,
-        #[type_visitable(ignore)]
         mode: BindingMode,
-        #[type_visitable(ignore)]
         var: LocalVarId,
         ty: Ty<'tcx>,
         subpattern: Option<Box<Pat<'tcx>>>,
@@ -844,7 +842,6 @@ pub struct PatRange<'tcx> {
     pub lo: PatRangeBoundary<'tcx>,
     /// Must not be `NegInfinity`.
     pub hi: PatRangeBoundary<'tcx>,
-    #[type_visitable(ignore)]
     pub end: RangeEnd,
     pub ty: Ty<'tcx>,
 }

compiler/rustc_middle/src/ty/consts/valtree.rs

@@ -1,11 +1,11 @@
-use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+use rustc_macros::{HashStable, NoopTypeTraversable, TyDecodable, TyEncodable};
 
 use super::ScalarInt;
 use crate::mir::interpret::Scalar;
 use crate::ty::{self, Ty, TyCtxt};
 
 #[derive(Copy, Clone, Debug, Hash, TyEncodable, TyDecodable, Eq, PartialEq)]
-#[derive(HashStable)]
+#[derive(HashStable, NoopTypeTraversable)]
 /// This datastructure is used to represent the value of constants used in the type system.
 ///
 /// We explicitly choose a different datastructure from the way values are processed within

compiler/rustc_middle/src/ty/mod.rs

@@ -55,6 +55,7 @@ pub use rustc_type_ir::ConstKind::{
     Placeholder as PlaceholderCt, Unevaluated, Value,
 };
 pub use rustc_type_ir::relate::VarianceDiagInfo;
+use rustc_type_ir::traverse::TypeTraversable;
 pub use rustc_type_ir::*;
 use tracing::{debug, instrument};
 pub use vtable::*;
@@ -1031,15 +1032,15 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ParamEnv<'tcx> {
     ) -> Result<Self, F::Error> {
         Ok(ParamEnv::new(
             self.caller_bounds().try_fold_with(folder)?,
-            self.reveal().try_fold_with(folder)?,
+            self.reveal().noop_try_fold_with(folder)?,
         ))
     }
 }
 
 impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for ParamEnv<'tcx> {
     fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
         try_visit!(self.caller_bounds().visit_with(visitor));
-        self.reveal().visit_with(visitor)
+        self.reveal().noop_visit_with(visitor)
     }
 }