Auto merge of #78177 - benjaminp:cleanups, r=jyn514

A few miscellaneous comment fixes and a tiny code clarification.

compiler/rustc_infer/src/infer/higher_ranked/mod.rs

@@ -24,9 +24,9 @@ impl<'a, 'tcx> CombineFields<'a, 'tcx> {
         // as-is, we need to do some extra work here in order to make sure
         // that function subtyping works correctly with respect to regions
         //
-        // Note: this is a subtle algorithm.  For a full explanation,
+        // Note: this is a subtle algorithm.  For a full explanation, please see
-        // please see the large comment at the end of the file in the (inlined) module
+        // the rustc dev guide:
-        // `doc`.
+        // <https://rustc-dev-guide.rust-lang.org/borrow_check/region_inference/placeholders_and_universes.html>
 
         let span = self.trace.cause.span;
 

compiler/rustc_typeck/src/bounds.rs

@@ -67,22 +67,18 @@ impl<'tcx> Bounds<'tcx> {
 
         sized_predicate
             .into_iter()
+            .chain(self.region_bounds.iter().map(|&(region_bound, span)| {
+                let outlives = ty::OutlivesPredicate(param_ty, region_bound);
+                (ty::Binder::bind(outlives).to_predicate(tcx), span)
+            }))
+            .chain(self.trait_bounds.iter().map(|&(bound_trait_ref, span, constness)| {
+                let predicate = bound_trait_ref.with_constness(constness).to_predicate(tcx);
+                (predicate, span)
+            }))
             .chain(
-                self.region_bounds
+                self.projection_bounds
                     .iter()
-                    .map(|&(region_bound, span)| {
+                    .map(|&(projection, span)| (projection.to_predicate(tcx), span)),
-                        let outlives = ty::OutlivesPredicate(param_ty, region_bound);
-                        (ty::Binder::bind(outlives).to_predicate(tcx), span)
-                    })
-                    .chain(self.trait_bounds.iter().map(|&(bound_trait_ref, span, constness)| {
-                        let predicate = bound_trait_ref.with_constness(constness).to_predicate(tcx);
-                        (predicate, span)
-                    }))
-                    .chain(
-                        self.projection_bounds
-                            .iter()
-                            .map(|&(projection, span)| (projection.to_predicate(tcx), span)),
-                    ),
             )
             .collect()
     }

compiler/rustc_typeck/src/check/method/probe.rs

@@ -765,13 +765,12 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             )
         });
 
-        // It is illegal to invoke a method on a trait instance that
+        // It is illegal to invoke a method on a trait instance that refers to
-        // refers to the `Self` type. An error will be reported by
+        // the `Self` type. An [`ObjectSafetyViolation::SupertraitSelf`] error
-        // `enforce_object_limitations()` if the method refers to the
+        // will be reported by `object_safety.rs` if the method refers to the
-        // `Self` type anywhere other than the receiver. Here, we use
+        // `Self` type anywhere other than the receiver. Here, we use a
-        // a substitution that replaces `Self` with the object type
+        // substitution that replaces `Self` with the object type itself. Hence,
-        // itself. Hence, a `&self` method will wind up with an
+        // a `&self` method will wind up with an argument type like `&Trait`.
-        // argument type like `&Trait`.
         let trait_ref = principal.with_self_ty(self.tcx, self_ty);
         self.elaborate_bounds(iter::once(trait_ref), |this, new_trait_ref, item| {
             let new_trait_ref = this.erase_late_bound_regions(new_trait_ref);

compiler/rustc_typeck/src/check/writeback.rs

@@ -88,7 +88,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 ///////////////////////////////////////////////////////////////////////////
-// The Writeback context. This visitor walks the AST, checking the
+// The Writeback context. This visitor walks the HIR, checking the
 // fn-specific typeck results to find references to types or regions. It
 // resolves those regions to remove inference variables and writes the
 // final result back into the master typeck results in the tcx. Here and