Add specialisation machinery for trivial traversal

[Auto-deref specialisation] is introduced to type library traversals,
the public API of which is via the `TriviallyTraverses` trait and the
`noop_if_trivially_traversable` macro.  Traversals invoked via the macro
will then be no-ops if the interner "trivially traverses" the type being
traversed *without requiring that type to implement the relevant
traversable trait*.

A further trait, `rustc_middle::ty::TriviallyTraversable`, is then
auto-implemented for types that do not contain anything that may be of
interest to traversers.  A generic implementation of the former trait is
then provided for the `TyCtxt` interner to indicate that it "trivially
traverses" all such `TriviallyTraversable` types.  This indirection is
necessary because auto-traits are unstable, whereas the type library is
intended to be stabilised.

Finally, the traversable derive macros are updated to utilise this
specialisation machinery, thereby avoiding any need for trivially
traversable fields (of types for which the traits are derived) to
implement the traversable traits.

[Auto-deref specialisation]: http://lukaskalbertodt.github.io/2019/12/05/generalized-autoref-based-specialization.html

Author: eggyal

compiler/rustc_middle/src/lib.rs

@@ -64,6 +64,7 @@
 #![feature(trait_alias)]
 #![feature(ptr_alignment_type)]
 #![feature(macro_metavar_expr)]
+#![feature(auto_traits)]
 #![recursion_limit = "512"]
 #![allow(rustc::potential_query_instability)]
 #![allow(internal_features)]

compiler/rustc_middle/src/ty/context.rs

@@ -67,7 +67,7 @@ use rustc_target::abi::{FieldIdx, Layout, LayoutS, TargetDataLayout, VariantIdx}
 use rustc_target::spec::abi;
 use rustc_type_ir::TyKind::*;
 use rustc_type_ir::WithCachedTypeInfo;
-use rustc_type_ir::{CollectAndApply, Interner, TypeFlags};
+use rustc_type_ir::{CollectAndApply, Interner, TriviallyTraverses, TypeFlags};
 
 use std::any::Any;
 use std::borrow::Borrow;
@@ -135,6 +135,22 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     }
 }
 
+/// Marker trait for types that do not need to be traversed by folders or visitors,
+/// because they do not contain anything that could be of interest.
+///
+/// Manually implementing this trait is DANGEROUS and should NEVER be done, as it
+/// can lead to miscompilation. Even if the type for which you wish to implement
+/// this trait does not today contain anything of interest to folders or visitors,
+/// a field added or changed in future may cause breakage.
+pub auto trait TriviallyTraversable {}
+impl<T: ?Sized + TriviallyTraversable> TriviallyTraverses<T> for TyCtxt<'_> {}
+
+impl<T> !TriviallyTraversable for Binder<'_, T> {}
+impl !TriviallyTraversable for Ty<'_> {}
+impl !TriviallyTraversable for ty::Const<'_> {}
+impl !TriviallyTraversable for Region<'_> {}
+impl !TriviallyTraversable for Predicate<'_> {}
+
 type InternedSet<'tcx, T> = ShardedHashMap<InternedInSet<'tcx, T>, ()>;
 
 pub struct CtxtInterners<'tcx> {

compiler/rustc_middle/src/ty/list.rs

@@ -45,6 +45,14 @@ extern "C" {
     type OpaqueListContents;
 }
 
+// Auto-traits are not automatically implemented for extern types[1], so
+// we manually implement it here to ensure that `List`s are automatically
+// skipped when appropriate (the `data` field will still ensure the auto
+// trait is not implemented for the `List` when it is not appropriate).
+//
+// [1]: https://github.com/rust-lang/rust/issues/43467#issuecomment-1207257995
+impl super::TriviallyTraversable for OpaqueListContents {}
+
 impl<T> List<T> {
     /// Returns a reference to the (unique, static) empty list.
     #[inline(always)]

compiler/rustc_middle/src/ty/mod.rs

@@ -88,7 +88,8 @@ pub use self::consts::{
     Const, ConstData, ConstInt, Expr, InferConst, ScalarInt, UnevaluatedConst, ValTree,
 };
 pub use self::context::{
-    tls, CtxtInterners, DeducedParamAttrs, FreeRegionInfo, GlobalCtxt, Lift, TyCtxt, TyCtxtFeed,
+    tls, CtxtInterners, DeducedParamAttrs, FreeRegionInfo, GlobalCtxt, Lift, TriviallyTraversable,
+    TyCtxt, TyCtxtFeed,
 };
 pub use self::instance::{Instance, InstanceDef, ShortInstance, UnusedGenericParams};
 pub use self::list::List;

compiler/rustc_type_ir/src/fold.rs

@@ -47,9 +47,10 @@
 
 use rustc_data_structures::sync::Lrc;
 use rustc_index::{Idx, IndexVec};
+use std::marker::PhantomData;
 use std::mem;
 
-use crate::{visit::TypeVisitable, Interner};
+use crate::{visit::TypeVisitable, Interner, TriviallyTraverses};
 
 /// This trait is implemented for every type that can be folded,
 /// providing the skeleton of the traversal.
@@ -248,6 +249,44 @@ where
     }
 }
 
+pub trait SpecTypeFoldable {
+    type Interner: Interner;
+    type Item;
+    fn spec_try_fold_with<F: FallibleTypeFolder<Self::Interner>>(
+        self,
+        value: Self::Item,
+        folder: &mut F,
+    ) -> Result<Self::Item, F::Error>;
+}
+
+impl<I: Interner, T: TypeFoldable<I>> SpecTypeFoldable for PhantomData<(I, T)> {
+    type Interner = I;
+    type Item = T;
+
+    #[inline(always)]
+    fn spec_try_fold_with<F: FallibleTypeFolder<I>>(
+        self,
+        value: T,
+        folder: &mut F,
+    ) -> Result<T, F::Error> {
+        value.try_fold_with(folder)
+    }
+}
+
+impl<I: TriviallyTraverses<T>, T> SpecTypeFoldable for &PhantomData<(I, T)> {
+    type Interner = I;
+    type Item = T;
+
+    #[inline(always)]
+    fn spec_try_fold_with<F: FallibleTypeFolder<I>>(
+        self,
+        value: T,
+        _: &mut F,
+    ) -> Result<T, F::Error> {
+        Ok(value)
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Traversal implementations.
 

compiler/rustc_type_ir/src/interner.rs

@@ -66,6 +66,25 @@ pub trait Interner: Sized {
     fn ty_and_mut_to_parts(ty_and_mut: Self::TypeAndMut) -> (Self::Ty, Mutability);
 }
 
+/// Marker to signify that the interner type `Self` trivially traverses type `T`,
+/// which is to say that traversing (folding or visiting) values of type `T` is
+/// *guaranteed* to be a no-op because `T` does not contain anything that could be
+/// of interest to a traverser (folder or visitor). Per the traverser traits'
+/// methods, traversers are only capable of taking an interest in the following
+/// five types:
+///
+/// * `Self::Binder<B>` for any type `B`
+/// * `Self::Ty`
+/// * `Self::Region`
+/// * `Self::Const`
+/// * `Self::Predicate`
+//
+// If and when implementations of the super-traverser traits are uplifted to
+// this library, the `B` above will likely be restricted to types of interest.
+// For now, that is an implementation detail of `rustc_middle` and is therefore
+// omitted from this library's documentation.
+pub trait TriviallyTraverses<T: ?Sized>: Interner {}
+
 /// Imagine you have a function `F: FnOnce(&[T]) -> R`, plus an iterator `iter`
 /// that produces `T` items. You could combine them with
 /// `f(&iter.collect::<Vec<_>>())`, but this requires allocating memory for the

compiler/rustc_type_ir/src/macros.rs

@@ -52,3 +52,32 @@ TrivialTypeTraversalImpls! {
     crate::AliasRelationDirection,
     crate::UniverseIndex,
 }
+
+#[macro_export]
+macro_rules! noop_if_trivially_traversable {
+    ($val:tt.try_fold_with::<$interner:ty>($folder:expr)) => {{
+        use $crate::fold::SpecTypeFoldable as _;
+        $crate::noop_if_trivially_traversable!($val.spec_try_fold_with::<$interner>($folder))
+    }};
+    ($val:tt.visit_with::<$interner:ty>($visitor:expr)) => {{
+        use $crate::visit::SpecTypeVisitable as _;
+        $crate::noop_if_trivially_traversable!($val.spec_visit_with::<$interner>($visitor))
+    }};
+    ($val:tt.$method:ident::<$interner:ty>($traverser:expr)) => {{
+        let val = $val;
+
+        #[allow(unreachable_code)]
+        let p = 'p: {
+            use ::core::marker::PhantomData;
+
+            fn unreachable_phantom_constraint<I, T>(_: T) -> PhantomData<(I, T)> {
+                unreachable!()
+            }
+
+            break 'p PhantomData;
+            unreachable_phantom_constraint::<$interner, _>(val)
+        };
+
+        (&&p).$method(val, $traverser)
+    }};
+}

compiler/rustc_type_ir/src/visit.rs

@@ -44,9 +44,10 @@
 use rustc_data_structures::sync::Lrc;
 use rustc_index::{Idx, IndexVec};
 use std::fmt;
+use std::marker::PhantomData;
 use std::ops::ControlFlow;
 
-use crate::Interner;
+use crate::{Interner, TriviallyTraverses};
 
 /// This trait is implemented for every type that can be visited,
 /// providing the skeleton of the traversal.
@@ -120,6 +121,40 @@ pub trait TypeVisitor<I: Interner>: Sized {
     }
 }
 
+pub trait SpecTypeVisitable {
+    type Interner: Interner;
+    type Item: ?Sized;
+    fn spec_visit_with<V: TypeVisitor<Self::Interner>>(
+        self,
+        value: &Self::Item,
+        visitor: &mut V,
+    ) -> ControlFlow<V::BreakTy>;
+}
+
+impl<I: Interner, T: ?Sized + TypeVisitable<I>> SpecTypeVisitable for PhantomData<(I, &T)> {
+    type Interner = I;
+    type Item = T;
+
+    #[inline(always)]
+    fn spec_visit_with<V: TypeVisitor<I>>(
+        self,
+        value: &T,
+        visitor: &mut V,
+    ) -> ControlFlow<V::BreakTy> {
+        value.visit_with(visitor)
+    }
+}
+
+impl<I: TriviallyTraverses<T>, T: ?Sized> SpecTypeVisitable for &PhantomData<(I, &T)> {
+    type Interner = I;
+    type Item = T;
+
+    #[inline(always)]
+    fn spec_visit_with<V: TypeVisitor<I>>(self, _: &T, _: &mut V) -> ControlFlow<V::BreakTy> {
+        ControlFlow::Continue(())
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Traversal implementations.