trait_goals: Implement Fn-like goals

Author: compiler-errors

compiler/rustc_trait_selection/src/solve/assembly.rs

@@ -1,5 +1,7 @@
 //! Code shared by trait and projection goals for candidate assembly.
 
+use crate::traits::TupleArgumentsFlag;
+
 use super::infcx_ext::InferCtxtExt;
 use super::{
     fixme_instantiate_canonical_query_response, CanonicalGoal, CanonicalResponse, Certainty,
@@ -66,6 +68,13 @@ pub(super) trait GoalKind<'tcx>: TypeFoldable<'tcx> + Copy {
         acx: &mut AssemblyCtxt<'_, 'tcx, Self>,
         goal: Goal<'tcx, Self>,
     );
+
+    fn consider_fn_candidate(
+        acx: &mut AssemblyCtxt<'_, 'tcx, Self>,
+        goal: Goal<'tcx, Self>,
+        bound_sig: ty::PolyFnSig<'tcx>,
+        tuple_arguments: TupleArgumentsFlag,
+    );
 }
 
 /// An abstraction which correctly deals with the canonical results for candidates.
@@ -97,6 +106,8 @@ impl<'a, 'tcx, G: GoalKind<'tcx>> AssemblyCtxt<'a, 'tcx, G> {
 
         acx.assemble_auto_trait_candidates(goal);
 
+        acx.assemble_fn_like_candidates(goal);
+
         acx.candidates
     }
 
@@ -195,4 +206,27 @@ impl<'a, 'tcx, G: GoalKind<'tcx>> AssemblyCtxt<'a, 'tcx, G> {
             G::consider_auto_trait_candidate(self, goal);
         }
     }
+
+    fn assemble_fn_like_candidates(&mut self, goal: Goal<'tcx, G>) {
+        let tcx = self.cx.tcx;
+        let trait_def_id = goal.predicate.trait_def_id(tcx);
+        if let Some(goal_kind) = tcx.fn_trait_kind_from_def_id(trait_def_id) {
+            match *goal.predicate.self_ty().kind() {
+                ty::FnDef(def_id, substs) => {
+                    G::consider_fn_candidate(self, goal, tcx.bound_fn_sig(def_id).subst(tcx, substs), TupleArgumentsFlag::Yes)
+                }
+                ty::FnPtr(sig) => {
+                    G::consider_fn_candidate(self, goal, sig, TupleArgumentsFlag::Yes)
+                }
+                ty::Closure(_, substs) => {
+                    if let Some(kind) = self.infcx.closure_kind(substs)
+                        && kind.extends(goal_kind)
+                    {
+                        G::consider_fn_candidate(self, goal, substs.as_closure().sig(), TupleArgumentsFlag::No)
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
 }

compiler/rustc_trait_selection/src/solve/project_goals.rs

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

compiler/rustc_trait_selection/src/solve/trait_goals.rs

@@ -2,9 +2,12 @@
 
 use std::iter;
 
+use crate::traits::TupleArgumentsFlag;
+
 use super::assembly::{self, AssemblyCtxt};
 use super::{CanonicalGoal, Certainty, EvalCtxt, Goal, QueryResult};
 use rustc_hir::def_id::DefId;
+use rustc_hir::Unsafety;
 use rustc_infer::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime};
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::util::supertraits;
@@ -13,6 +16,7 @@ use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams};
 use rustc_middle::ty::TraitPredicate;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::DUMMY_SP;
+use rustc_target::spec::abi::Abi;
 
 #[allow(dead_code)] // FIXME: implement and use all variants.
 #[derive(Debug, Clone, Copy)]
@@ -53,6 +57,9 @@ pub(super) enum CandidateSource {
     /// at the constituent types of the `self_ty` to check whether the auto trait
     /// is implemented for those.
     AutoImpl,
+    /// An automatic impl for `Fn`/`FnMut`/`FnOnce` for fn pointers, fn items,
+    /// and closures.
+    Fn,
 }
 
 type Candidate<'tcx> = assembly::Candidate<'tcx, TraitPredicate<'tcx>>;
@@ -214,6 +221,39 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
             acx.try_insert_candidate(CandidateSource::AutoImpl, certainty);
         })
     }
+
+    fn consider_fn_candidate(
+        acx: &mut AssemblyCtxt<'_, 'tcx, Self>,
+        goal: Goal<'tcx, Self>,
+        bound_sig: ty::PolyFnSig<'tcx>,
+        tuple_args_flag: TupleArgumentsFlag,
+    ) {
+        if bound_sig.unsafety() != Unsafety::Normal || bound_sig.c_variadic() {
+            return;
+        }
+
+        // Binder skipped here (*)
+        let (arguments_tuple, expected_abi) = match tuple_args_flag {
+            TupleArgumentsFlag::No => (bound_sig.skip_binder().inputs()[0], Abi::RustCall),
+            TupleArgumentsFlag::Yes => {
+                (acx.cx.tcx.intern_tup(bound_sig.skip_binder().inputs()), Abi::Rust)
+            }
+        };
+        if expected_abi != bound_sig.abi() {
+            return;
+        }
+        // (*) Rebound here
+        let found_trait_ref = bound_sig.rebind(
+            acx.cx
+                .tcx
+                .mk_trait_ref(goal.predicate.def_id(), [goal.predicate.self_ty(), arguments_tuple]),
+        );
+
+        acx.infcx.probe(|_| {
+            // FIXME: This needs to validate that `fn() -> TY` has `TY: Sized`.
+            match_poly_trait_ref_against_goal(acx, goal, found_trait_ref, CandidateSource::Fn);
+        })
+    }
 }
 
 fn match_poly_trait_ref_against_goal<'tcx>(
@@ -379,7 +419,8 @@ impl<'tcx> EvalCtxt<'tcx> {
             | (CandidateSource::ObjectBound(_), _)
             | (CandidateSource::ObjectAutoBound, _)
             | (CandidateSource::Builtin, _)
-            | (CandidateSource::AutoImpl, _) => unimplemented!(),
+            | (CandidateSource::AutoImpl, _)
+            | (CandidateSource::Fn, _) => unimplemented!(),
         }
     }
 

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -60,6 +60,7 @@ pub use self::specialize::{specialization_graph, translate_substs, OverlapError}
 pub use self::structural_match::{
     search_for_adt_const_param_violation, search_for_structural_match_violation,
 };
+pub use self::util::TupleArgumentsFlag;
 pub use self::util::{
     elaborate_obligations, elaborate_predicates, elaborate_predicates_with_span,
     elaborate_trait_ref, elaborate_trait_refs,