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.

[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.