trait_goals: Auto traits

Author: compiler-errors

compiler/rustc_trait_selection/src/solve/assembly.rs

@@ -61,6 +61,11 @@ pub(super) trait GoalKind<'tcx>: TypeFoldable<'tcx> + Copy {
         acx: &mut AssemblyCtxt<'_, 'tcx, Self>,
         goal: Goal<'tcx, Self>,
     );
+
+    fn consider_auto_trait_candidate(
+        acx: &mut AssemblyCtxt<'_, 'tcx, Self>,
+        goal: Goal<'tcx, Self>,
+    );
 }
 
 /// An abstraction which correctly deals with the canonical results for candidates.
@@ -90,6 +95,8 @@ impl<'a, 'tcx, G: GoalKind<'tcx>> AssemblyCtxt<'a, 'tcx, G> {
 
         acx.assemble_param_env_candidates(goal);
 
+        acx.assemble_auto_trait_candidates(goal);
+
         acx.candidates
     }
 
@@ -182,4 +189,10 @@ impl<'a, 'tcx, G: GoalKind<'tcx>> AssemblyCtxt<'a, 'tcx, G> {
     fn assemble_param_env_candidates(&mut self, goal: Goal<'tcx, G>) {
         G::consider_param_env_candidates(self, goal);
     }
+
+    fn assemble_auto_trait_candidates(&mut self, goal: Goal<'tcx, G>) {
+        if self.cx.tcx.trait_is_auto(goal.predicate.trait_def_id(self.cx.tcx)) {
+            G::consider_auto_trait_candidate(self, goal);
+        }
+    }
 }

compiler/rustc_trait_selection/src/solve/project_goals.rs

@@ -234,6 +234,13 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> {
     ) {
         todo!()
     }
+
+    fn consider_auto_trait_candidate(
+        _acx: &mut AssemblyCtxt<'_, 'tcx, Self>,
+        _goal: Goal<'tcx, Self>,
+    ) {
+        // Auto traits never have associated types
+    }
 }
 
 /// This behavior is also implemented in `rustc_ty_utils` and in the old `project` code.

compiler/rustc_trait_selection/src/solve/trait_goals.rs

@@ -5,7 +5,7 @@ use std::iter;
 use super::assembly::{self, AssemblyCtxt};
 use super::{CanonicalGoal, Certainty, EvalCtxt, Goal, QueryResult};
 use rustc_hir::def_id::DefId;
-use rustc_infer::infer::{InferOk, LateBoundRegionConversionTime};
+use rustc_infer::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime};
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::util::supertraits;
 use rustc_infer::traits::ObligationCause;
@@ -191,6 +191,29 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
             );
         }
     }
+
+    fn consider_auto_trait_candidate(
+        acx: &mut AssemblyCtxt<'_, 'tcx, Self>,
+        goal: Goal<'tcx, Self>,
+    ) {
+        // FIXME: We need to give auto trait candidates less precedence than impl candidates?
+        acx.infcx.probe(|_| {
+            let Ok(constituent_tys) =
+                instantiate_constituent_tys_for_auto_trait(acx.infcx, goal.predicate.self_ty()) else { return };
+            let nested_goals = constituent_tys
+                .into_iter()
+                .map(|ty| {
+                    Goal::new(
+                        acx.cx.tcx,
+                        goal.param_env,
+                        ty::Binder::dummy(goal.predicate.with_self_ty(acx.cx.tcx, ty)),
+                    )
+                })
+                .collect();
+            let Ok(certainty) = acx.cx.evaluate_all(acx.infcx, nested_goals) else { return };
+            acx.try_insert_candidate(CandidateSource::AutoImpl, certainty);
+        })
+    }
 }
 
 fn match_poly_trait_ref_against_goal<'tcx>(
@@ -223,6 +246,77 @@ fn match_poly_trait_ref_against_goal<'tcx>(
     })
 }
 
+// Calculates the constituent types of a type for `auto trait` purposes.
+//
+// For types with an "existential" binder, i.e. generator witnesses, we also
+// instantiate the binder with placeholders eagerly.
+fn instantiate_constituent_tys_for_auto_trait<'tcx>(
+    infcx: &InferCtxt<'tcx>,
+    ty: Ty<'tcx>,
+) -> Result<Vec<Ty<'tcx>>, ()> {
+    let tcx = infcx.tcx;
+    match *ty.kind() {
+        ty::Uint(_)
+        | ty::Int(_)
+        | ty::Bool
+        | ty::Float(_)
+        | ty::FnDef(..)
+        | ty::FnPtr(_)
+        | ty::Str
+        | ty::Error(_)
+        | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
+        | ty::Never
+        | ty::Char => Ok(vec![]),
+
+        ty::Placeholder(..)
+        | ty::Dynamic(..)
+        | ty::Param(..)
+        | ty::Foreign(..)
+        | ty::Alias(ty::Projection, ..)
+        | ty::Bound(..)
+        | ty::Infer(ty::TyVar(_)) => {
+            // FIXME: Do we need to mark anything as ambiguous here? Yeah?
+            Err(())
+        }
+
+        ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => bug!(),
+
+        ty::RawPtr(ty::TypeAndMut { ty: element_ty, .. }) | ty::Ref(_, element_ty, _) => {
+            Ok(vec![element_ty])
+        }
+
+        ty::Array(element_ty, _) | ty::Slice(element_ty) => Ok(vec![element_ty]),
+
+        ty::Tuple(ref tys) => {
+            // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
+            Ok(tys.iter().collect())
+        }
+
+        ty::Closure(_, ref substs) => Ok(vec![substs.as_closure().tupled_upvars_ty()]),
+
+        ty::Generator(_, ref substs, _) => {
+            let generator_substs = substs.as_generator();
+            Ok(vec![generator_substs.tupled_upvars_ty(), generator_substs.witness()])
+        }
+
+        ty::GeneratorWitness(types) => {
+            Ok(infcx.replace_bound_vars_with_placeholders(types).to_vec())
+        }
+
+        // For `PhantomData<T>`, we pass `T`.
+        ty::Adt(def, substs) if def.is_phantom_data() => Ok(vec![substs.type_at(0)]),
+
+        ty::Adt(def, substs) => Ok(def.all_fields().map(|f| f.ty(tcx, substs)).collect()),
+
+        ty::Alias(ty::Opaque, ty::AliasTy { def_id, substs, .. }) => {
+            // We can resolve the `impl Trait` to its concrete type,
+            // which enforces a DAG between the functions requiring
+            // the auto trait bounds in question.
+            Ok(vec![tcx.bound_type_of(def_id).subst(tcx, substs)])
+        }
+    }
+}
+
 impl<'tcx> EvalCtxt<'tcx> {
     pub(super) fn compute_trait_goal(
         &mut self,