it compiles :3

Author: lcnr

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -15,8 +15,10 @@ use rustc_index::{Idx, IndexVec};
 use rustc_middle::arena::ArenaAllocatable;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::ty::fold::TypeFoldable;
+use rustc_middle::ty::traverse::AlwaysTraversable;
 use rustc_middle::ty::{self, BoundVar, GenericArg, GenericArgKind, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
+use rustc_type_ir::traverse::OptTryFoldWith;
 use tracing::{debug, instrument};
 
 use crate::infer::canonical::instantiate::{CanonicalExt, instantiate_value};
@@ -60,7 +62,7 @@ impl<'tcx> InferCtxt<'tcx> {
         fulfill_cx: &mut dyn TraitEngine<'tcx, ScrubbedTraitError<'tcx>>,
     ) -> Result<CanonicalQueryResponse<'tcx, T>, NoSolution>
     where
-        T: Debug + TypeFoldable<TyCtxt<'tcx>>,
+        T: OptTryFoldWith<TyCtxt<'tcx>>,
         Canonical<'tcx, QueryResponse<'tcx, T>>: ArenaAllocatable<'tcx>,
     {
         let query_response = self.make_query_response(inference_vars, answer, fulfill_cx)?;
@@ -107,7 +109,7 @@ impl<'tcx> InferCtxt<'tcx> {
         fulfill_cx: &mut dyn TraitEngine<'tcx, ScrubbedTraitError<'tcx>>,
     ) -> Result<QueryResponse<'tcx, T>, NoSolution>
     where
-        T: Debug + TypeFoldable<TyCtxt<'tcx>>,
+        T: OptTryFoldWith<TyCtxt<'tcx>>,
     {
         let tcx = self.tcx;
 
@@ -243,7 +245,7 @@ impl<'tcx> InferCtxt<'tcx> {
         output_query_region_constraints: &mut QueryRegionConstraints<'tcx>,
     ) -> InferResult<'tcx, R>
     where
-        R: Debug + TypeFoldable<TyCtxt<'tcx>>,
+        R: OptTryFoldWith<TyCtxt<'tcx>>,
     {
         let InferOk { value: result_args, mut obligations } = self
             .query_response_instantiation_guess(
@@ -326,8 +328,11 @@ impl<'tcx> InferCtxt<'tcx> {
                 .map(|p_c| instantiate_value(self.tcx, &result_args, p_c.clone())),
         );
 
-        let user_result: R =
-            query_response.instantiate_projected(self.tcx, &result_args, |q_r| q_r.value.clone());
+        let user_result: R = query_response
+            .instantiate_projected(self.tcx, &result_args, |q_r| {
+                AlwaysTraversable(q_r.value.clone())
+            })
+            .0;
 
         Ok(InferOk { value: user_result, obligations })
     }
@@ -396,7 +401,7 @@ impl<'tcx> InferCtxt<'tcx> {
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
     ) -> InferResult<'tcx, CanonicalVarValues<'tcx>>
     where
-        R: Debug + TypeFoldable<TyCtxt<'tcx>>,
+        R: OptTryFoldWith<TyCtxt<'tcx>>,
     {
         // For each new universe created in the query result that did
         // not appear in the original query, create a local

compiler/rustc_infer/src/traits/structural_impls.rs

@@ -4,6 +4,7 @@ use rustc_ast_ir::try_visit;
 use rustc_middle::ty::fold::{FallibleTypeFolder, TypeFoldable};
 use rustc_middle::ty::visit::{TypeVisitable, TypeVisitor};
 use rustc_middle::ty::{self, TyCtxt};
+use rustc_type_ir::traverse::{ImportantTypeTraversal, TypeTraversable};
 
 use crate::traits;
 use crate::traits::project::Normalized;
@@ -55,6 +56,11 @@ impl<'tcx, O: TypeFoldable<TyCtxt<'tcx>>> TypeFoldable<TyCtxt<'tcx>>
     }
 }
 
+impl<'tcx, O: TypeVisitable<TyCtxt<'tcx>>> TypeTraversable<TyCtxt<'tcx>>
+    for traits::Obligation<'tcx, O>
+{
+    type Kind = ImportantTypeTraversal;
+}
 impl<'tcx, O: TypeVisitable<TyCtxt<'tcx>>> TypeVisitable<TyCtxt<'tcx>>
     for traits::Obligation<'tcx, O>
 {

compiler/rustc_middle/src/thir.rs

@@ -17,7 +17,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{BindingMode, ByRef, HirId, MatchSource, RangeEnd};
 use rustc_index::{IndexVec, newtype_index};
-use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeVisitable};
+use rustc_macros::{HashStable, NoopTypeTraversable, TyDecodable, TyEncodable, TypeVisitable};
 use rustc_middle::middle::region;
 use rustc_middle::mir::interpret::AllocId;
 use rustc_middle::mir::{self, BinOp, BorrowKind, FakeReadCause, UnOp};
@@ -234,7 +234,8 @@ pub enum StmtKind<'tcx> {
     },
 }
 
-#[derive(Clone, Debug, Copy, PartialEq, Eq, Hash, HashStable, TyEncodable, TyDecodable)]
+#[derive(Clone, Debug, Copy, PartialEq, Eq, Hash, HashStable)]
+#[derive(NoopTypeTraversable, TyEncodable, TyDecodable)]
 pub struct LocalVarId(pub HirId);
 
 /// A THIR expression.

compiler/rustc_middle/src/ty/adt.rs

@@ -13,7 +13,7 @@ use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, LangItem};
 use rustc_index::{IndexSlice, IndexVec};
-use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+use rustc_macros::{HashStable, NoopTypeTraversable, TyDecodable, TyEncodable};
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::DataTypeKind;
 use rustc_span::symbol::sym;
@@ -168,7 +168,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for AdtDefData {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable, NoopTypeTraversable)]
 #[rustc_pass_by_value]
 pub struct AdtDef<'tcx>(pub Interned<'tcx, AdtDefData>);
 

compiler/rustc_middle/src/ty/generic_args.rs

@@ -14,7 +14,7 @@ use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable, extension};
 use rustc_serialize::{Decodable, Encodable};
 use rustc_type_ir::WithCachedTypeInfo;
-use rustc_type_ir::traverse::{ImportantTypeTraversal, NoopTypeTraversal, TypeTraversable};
+use rustc_type_ir::traverse::{ImportantTypeTraversal, TypeTraversable};
 use smallvec::SmallVec;
 
 use crate::ty::codec::{TyDecoder, TyEncoder};
@@ -646,8 +646,8 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
     }
 }
 
-impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeTraversable<TyCtxt<'tcx>> for &'tcx ty::List<T> {
-    type Kind = ImportantTypeTraversal;
+impl<'tcx, T: TypeTraversable<TyCtxt<'tcx>>> TypeTraversable<TyCtxt<'tcx>> for &'tcx ty::List<T> {
+    type Kind = T::Kind;
 }
 impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeVisitable<TyCtxt<'tcx>> for &'tcx ty::List<T> {
     #[inline]

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -209,55 +209,56 @@ impl<'tcx> fmt::Debug for Region<'tcx> {
 // For things for which the type library provides traversal implementations
 // for all Interners, we only need to provide a Lift implementation:
 TrivialLiftImpls! {
-     (),
-     bool,
-     usize,
-     u64,
+    (),
+    bool,
+    usize,
+    u64,
+    crate::ty::ParamConst,
 }
 
 // For some things about which the type library does not know, or does not
 // provide any traversal implementations, we need to provide a traversal
 // implementation (only for TyCtxt<'_> interners).
 TrivialTypeTraversalImpls! {
-    ::rustc_target::abi::FieldIdx,
-    ::rustc_target::abi::VariantIdx,
-    crate::middle::region::Scope,
-    ::rustc_ast::InlineAsmOptions,
-    ::rustc_ast::InlineAsmTemplatePiece,
-    ::rustc_ast::NodeId,
-    ::rustc_span::symbol::Symbol,
-    ::rustc_hir::def::Res,
-    ::rustc_hir::def_id::LocalDefId,
-    ::rustc_hir::ByRef,
-    ::rustc_hir::HirId,
-    ::rustc_hir::RangeEnd,
-    ::rustc_hir::MatchSource,
-    ::rustc_target::asm::InlineAsmRegOrRegClass,
-    crate::mir::coverage::BlockMarkerId,
-    crate::mir::coverage::CounterId,
-    crate::mir::coverage::ExpressionId,
-    crate::mir::coverage::ConditionId,
-    crate::mir::Local,
-    crate::mir::Promoted,
-    crate::traits::Reveal,
-    crate::ty::adjustment::AutoBorrowMutability,
-    crate::ty::AdtKind,
-    crate::ty::BoundRegion,
-    // Including `BoundRegionKind` is a *bit* dubious, but direct
-    // references to bound region appear in `ty::Error`, and aren't
-    // really meant to be folded. In general, we can only fold a fully
-    // general `Region`.
-    crate::ty::BoundRegionKind,
-    crate::ty::AssocItem,
-    crate::ty::AssocKind,
-    crate::ty::Placeholder<crate::ty::BoundRegion>,
-    crate::ty::Placeholder<crate::ty::BoundTy>,
-    crate::ty::Placeholder<ty::BoundVar>,
+::rustc_target::abi::FieldIdx,
+::rustc_target::abi::VariantIdx,
+crate::middle::region::Scope,
+::rustc_ast::InlineAsmOptions,
+::rustc_ast::InlineAsmTemplatePiece,
+::rustc_ast::NodeId,
+::rustc_ast::ast::BindingMode,
+::rustc_span::symbol::Symbol,
+::rustc_hir::def::Res,
+::rustc_hir::def_id::LocalDefId,
+::rustc_hir::ByRef,
+::rustc_hir::HirId,
+::rustc_hir::RangeEnd,
+::rustc_hir::MatchSource,
+::rustc_target::asm::InlineAsmRegOrRegClass,
+crate::mir::coverage::BlockMarkerId,
+crate::mir::coverage::CounterId,
+crate::mir::coverage::ExpressionId,
+crate::mir::coverage::ConditionId,
+crate::mir::Local,
+crate::mir::Promoted,
+crate::ty::adjustment::AutoBorrowMutability,
+crate::ty::AdtKind,
+crate::ty::BoundRegion,
+// Including `BoundRegionKind` is a *bit* dubious, but direct
+// references to bound region appear in `ty::Error`, and aren't
+// really meant to be folded. In general, we can only fold a fully
+// general `Region`.
+crate::ty::BoundRegionKind,
+crate::ty::AssocItem,
+crate::ty::AssocKind,
+crate::ty::Placeholder<crate::ty::BoundRegion>,
+crate::ty::Placeholder<crate::ty::BoundTy>,
+crate::ty::Placeholder<ty::BoundVar>,}
+TrivialTypeTraversalImpls! {
     crate::ty::LateParamRegion,
     crate::ty::adjustment::PointerCoercion,
     ::rustc_span::Span,
     ::rustc_span::symbol::Ident,
-    ty::BoundVar,
 }
 // For some things about which the type library does not know, or does not
 // provide any traversal implementations, we need to provide a traversal
@@ -268,7 +269,6 @@ TrivialTypeTraversalAndLiftImpls! {
     ::rustc_hir::Safety,
     ::rustc_target::spec::abi::Abi,
     crate::ty::ClosureKind,
-    crate::ty::ParamConst,
     crate::ty::ParamTy,
     crate::ty::instance::ReifyReason,
     interpret::AllocId,
@@ -578,12 +578,12 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Const<'tcx> {
         folder: &mut F,
     ) -> Result<Self, F::Error> {
         let kind = match self.kind() {
-            ConstKind::Param(p) => ConstKind::Param(p.try_fold_with(folder)?),
-            ConstKind::Infer(i) => ConstKind::Infer(i.try_fold_with(folder)?),
+            ConstKind::Param(p) => ConstKind::Param(p.noop_try_fold_with(folder)?),
+            ConstKind::Infer(i) => ConstKind::Infer(i.noop_try_fold_with(folder)?),
             ConstKind::Bound(d, b) => {
-                ConstKind::Bound(d.try_fold_with(folder)?, b.try_fold_with(folder)?)
+                ConstKind::Bound(d.noop_try_fold_with(folder)?, b.noop_try_fold_with(folder)?)
             }
-            ConstKind::Placeholder(p) => ConstKind::Placeholder(p.try_fold_with(folder)?),
+            ConstKind::Placeholder(p) => ConstKind::Placeholder(p.noop_try_fold_with(folder)?),
             ConstKind::Unevaluated(uv) => ConstKind::Unevaluated(uv.try_fold_with(folder)?),
             ConstKind::Value(t, v) => {
                 ConstKind::Value(t.try_fold_with(folder)?, v.noop_try_fold_with(folder)?)
@@ -598,17 +598,17 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Const<'tcx> {
 impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for ty::Const<'tcx> {
     fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
         match self.kind() {
-            ConstKind::Param(p) => p.visit_with(visitor),
-            ConstKind::Infer(i) => i.visit_with(visitor),
+            ConstKind::Param(p) => p.noop_visit_with(visitor),
+            ConstKind::Infer(i) => i.noop_visit_with(visitor),
             ConstKind::Bound(d, b) => {
-                try_visit!(d.visit_with(visitor));
-                b.visit_with(visitor)
+                try_visit!(d.noop_visit_with(visitor));
+                b.noop_visit_with(visitor)
             }
-            ConstKind::Placeholder(p) => p.visit_with(visitor),
+            ConstKind::Placeholder(p) => p.noop_visit_with(visitor),
             ConstKind::Unevaluated(uv) => uv.visit_with(visitor),
             ConstKind::Value(t, v) => {
                 try_visit!(t.visit_with(visitor));
-                v.visit_with(visitor)
+                v.noop_visit_with(visitor)
             }
             ConstKind::Error(e) => e.visit_with(visitor),
             ConstKind::Expr(e) => e.visit_with(visitor),

compiler/rustc_middle/src/ty/sty.rs

@@ -13,7 +13,9 @@ use rustc_errors::{ErrorGuaranteed, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::LangItem;
 use rustc_hir::def_id::DefId;
-use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, extension};
+use rustc_macros::{
+    HashStable, NoopTypeTraversable, TyDecodable, TyEncodable, TypeFoldable, extension,
+};
 use rustc_span::symbol::{Symbol, sym};
 use rustc_span::{DUMMY_SP, Span};
 use rustc_target::abi::{FIRST_VARIANT, FieldIdx, VariantIdx};
@@ -323,7 +325,7 @@ impl<'tcx> ParamTy {
 }
 
 #[derive(Copy, Clone, Hash, TyEncodable, TyDecodable, Eq, PartialEq, Ord, PartialOrd)]
-#[derive(HashStable)]
+#[derive(HashStable, NoopTypeTraversable)]
 pub struct ParamConst {
     pub index: u32,
     pub name: Symbol,

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs

@@ -442,7 +442,7 @@ where
 
 // FIXME: needs to be pub to be accessed by downstream
 // `rustc_trait_selection::solve::inspect::analyse`.
-pub fn instantiate_canonical_state<D, I, T: TypeFoldable<I>>(
+pub fn instantiate_canonical_state<D, I, T: OptTryFoldWith<I>>(
     delegate: &D,
     span: D::Span,
     param_env: I::ParamEnv,

compiler/rustc_trait_selection/src/infer.rs

@@ -1,5 +1,3 @@
-use std::fmt::Debug;
-
 use rustc_hir::def_id::DefId;
 use rustc_hir::lang_items::LangItem;
 pub use rustc_infer::infer::*;
@@ -11,6 +9,7 @@ use rustc_middle::infer::canonical::{
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::{self, GenericArg, Ty, TyCtxt, TypeFoldable, TypeVisitableExt, Upcast};
 use rustc_span::DUMMY_SP;
+use rustc_type_ir::traverse::OptTryFoldWith;
 use tracing::instrument;
 
 use crate::infer::at::ToTrace;
@@ -139,7 +138,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
     ) -> Result<CanonicalQueryResponse<'tcx, R>, NoSolution>
     where
         K: TypeFoldable<TyCtxt<'tcx>>,
-        R: Debug + TypeFoldable<TyCtxt<'tcx>>,
+        R: OptTryFoldWith<TyCtxt<'tcx>>,
         Canonical<'tcx, QueryResponse<'tcx, R>>: ArenaAllocatable<'tcx>,
     {
         let (infcx, key, canonical_inference_vars) =

compiler/rustc_trait_selection/src/traits/engine.rs

@@ -1,5 +1,4 @@
 use std::cell::RefCell;
-use std::fmt::Debug;
 
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::ErrorGuaranteed;
@@ -15,6 +14,7 @@ use rustc_macros::extension;
 use rustc_middle::arena::ArenaAllocatable;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::error::TypeError;
+use rustc_middle::ty::traverse::OptTryFoldWith;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable, Upcast, Variance};
 use rustc_type_ir::relate::Relate;
 
@@ -259,7 +259,7 @@ impl<'tcx> ObligationCtxt<'_, 'tcx, ScrubbedTraitError<'tcx>> {
         answer: T,
     ) -> Result<CanonicalQueryResponse<'tcx, T>, NoSolution>
     where
-        T: Debug + TypeFoldable<TyCtxt<'tcx>>,
+        T: OptTryFoldWith<TyCtxt<'tcx>>,
         Canonical<'tcx, QueryResponse<'tcx, T>>: ArenaAllocatable<'tcx>,
     {
         self.infcx.make_canonicalized_query_response(

compiler/rustc_trait_selection/src/traits/query/type_op/custom.rs

@@ -3,8 +3,10 @@ use std::fmt;
 use rustc_errors::ErrorGuaranteed;
 use rustc_infer::infer::region_constraints::RegionConstraintData;
 use rustc_middle::traits::query::NoSolution;
-use rustc_middle::ty::{TyCtxt, TypeFoldable};
+use rustc_middle::ty::TyCtxt;
+use rustc_middle::ty::traverse::AlwaysTraversable;
 use rustc_span::Span;
+use rustc_type_ir::traverse::OptTryFoldWith;
 use tracing::info;
 
 use crate::infer::InferCtxt;
@@ -29,7 +31,7 @@ impl<F> CustomTypeOp<F> {
 impl<'tcx, F, R> super::TypeOp<'tcx> for CustomTypeOp<F>
 where
     F: FnOnce(&ObligationCtxt<'_, 'tcx>) -> Result<R, NoSolution>,
-    R: fmt::Debug + TypeFoldable<TyCtxt<'tcx>>,
+    R: fmt::Debug + OptTryFoldWith<TyCtxt<'tcx>>,
 {
     type Output = R;
     /// We can't do any custom error reporting for `CustomTypeOp`, so
@@ -67,7 +69,7 @@ pub fn scrape_region_constraints<'tcx, Op, R>(
     span: Span,
 ) -> Result<(TypeOpOutput<'tcx, Op>, RegionConstraintData<'tcx>), ErrorGuaranteed>
 where
-    R: TypeFoldable<TyCtxt<'tcx>>,
+    R: OptTryFoldWith<TyCtxt<'tcx>>,
     Op: super::TypeOp<'tcx, Output = R>,
 {
     // During NLL, we expect that nobody will register region
@@ -97,7 +99,7 @@ where
     })?;
 
     // Next trait solver performs operations locally, and normalize goals should resolve vars.
-    let value = infcx.resolve_vars_if_possible(value);
+    let value = infcx.resolve_vars_if_possible(AlwaysTraversable(value)).0;
 
     let region_obligations = infcx.take_registered_region_obligations();
     let region_constraint_data = infcx.take_and_reset_region_constraints();