More comments, final tweaks

compiler/rustc_trait_selection/src/traits/project.rs

@@ -2491,6 +2491,9 @@ fn confirm_async_closure_candidate<'cx, 'tcx>(
     // since all this does is make the solver do more work.
     //
     // The code duplication due to the different length args is kind of weird, too.
+    //
+    // See the logic in `structural_traits` in the new solver to understand a bit
+    // more clearly how this *should* look.
     let poly_cache_entry = args.coroutine_closure_sig().map_bound(|sig| {
         let (projection_ty, term) = match tcx.item_name(obligation.predicate.def_id) {
             sym::CallOnceFuture => {

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -121,9 +121,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     self.assemble_async_fn_kind_helper_candidates(obligation, &mut candidates);
                 }
 
+                // FIXME: Put these into `else if` blocks above, since they're built-in.
                 self.assemble_closure_candidates(obligation, &mut candidates);
                 self.assemble_async_closure_candidates(obligation, &mut candidates);
                 self.assemble_fn_pointer_candidates(obligation, &mut candidates);
+
                 self.assemble_candidates_from_impls(obligation, &mut candidates);
                 self.assemble_candidates_from_object_ty(obligation, &mut candidates);
             }
@@ -382,6 +384,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             return;
         }
 
+        // Check that the self kind extends the goal kind. If it does,
+        // then there's nothing else to check.
         if let Some(closure_kind) = self_ty.to_opt_closure_kind()
             && let Some(goal_kind) = target_kind_ty.to_opt_closure_kind()
         {

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -88,6 +88,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 ImplSource::Builtin(BuiltinImplSource::Misc, vtable_closure)
             }
 
+            // No nested obligations or confirmation process. The checks that we do in
+            // candidate assembly are sufficient.
             AsyncFnKindHelperCandidate => ImplSource::Builtin(BuiltinImplSource::Misc, vec![]),
 
             CoroutineCandidate => {

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -728,7 +728,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
                 }
 
                 ty::CoroutineClosure(did, args) => {
-                    // See the above comments.
+                    // See the above comments. The same apply to coroutine-closures.
                     walker.skip_current_subtree();
                     self.compute(args.as_coroutine_closure().tupled_upvars_ty().into());
                     let obligations = self.nominal_obligations(did, args);