Clean up comments and formatting.

Mostly by reflowing overly long comment lines.

Author: nnethercote

Diff for: compiler/rustc_hir_analysis/src/bounds.rs

@@ -75,7 +75,8 @@ impl<'tcx> Bounds<'tcx> {
     pub(crate) fn push_sized(&mut self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) {
         let sized_def_id = tcx.require_lang_item(LangItem::Sized, Some(span));
         let trait_ref = ty::TraitRef::new(tcx, sized_def_id, [ty]);
-        // Preferable to put this obligation first, since we report better errors for sized ambiguity.
+        // Preferable to put this obligation first, since we report better errors for sized
+        // ambiguity.
         self.clauses.insert(0, (trait_ref.upcast(tcx), span));
     }
 

Diff for: compiler/rustc_hir_analysis/src/check/check.rs

@@ -233,8 +233,8 @@ fn check_opaque(tcx: TyCtxt<'_>, def_id: LocalDefId) {
 
     // HACK(jynelson): trying to infer the type of `impl trait` breaks documenting
     // `async-std` (and `pub async fn` in general).
-    // Since rustdoc doesn't care about the concrete type behind `impl Trait`, just don't look at it!
-    // See https://github.com/rust-lang/rust/issues/75100
+    // Since rustdoc doesn't care about the concrete type behind `impl Trait`, just don't look at
+    // it! See https://github.com/rust-lang/rust/issues/75100
     if tcx.sess.opts.actually_rustdoc {
         return;
     }
@@ -322,7 +322,8 @@ fn check_opaque_meets_bounds<'tcx>(
     };
     let param_env = tcx.param_env(defining_use_anchor);
 
-    // FIXME(#132279): Once `PostBorrowckAnalysis` is supported in the old solver, this branch should be removed.
+    // FIXME(#132279): Once `PostBorrowckAnalysis` is supported in the old solver, this branch
+    // should be removed.
     let infcx = tcx.infer_ctxt().build(if tcx.next_trait_solver_globally() {
         TypingMode::post_borrowck_analysis(tcx, defining_use_anchor)
     } else {
@@ -401,9 +402,9 @@ fn check_opaque_meets_bounds<'tcx>(
         }
     }
 
-    // Additionally require the hidden type to be well-formed with only the generics of the opaque type.
-    // Defining use functions may have more bounds than the opaque type, which is ok, as long as the
-    // hidden type is well formed even without those bounds.
+    // Additionally require the hidden type to be well-formed with only the generics of the opaque
+    // type. Defining use functions may have more bounds than the opaque type, which is ok, as long
+    // as the hidden type is well formed even without those bounds.
     let predicate =
         ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(hidden_ty.into())));
     ocx.register_obligation(Obligation::new(tcx, misc_cause.clone(), param_env, predicate));
@@ -434,7 +435,8 @@ fn check_opaque_meets_bounds<'tcx>(
         let _ = infcx.take_opaque_types();
         Ok(())
     } else {
-        // Check that any hidden types found during wf checking match the hidden types that `type_of` sees.
+        // Check that any hidden types found during wf checking match the hidden types that
+        // `type_of` sees.
         for (mut key, mut ty) in infcx.take_opaque_types() {
             ty.ty = infcx.resolve_vars_if_possible(ty.ty);
             key = infcx.resolve_vars_if_possible(key);
@@ -686,7 +688,8 @@ fn check_opaque_precise_captures<'tcx>(tcx: TyCtxt<'tcx>, opaque_def_id: LocalDe
                 ty::GenericParamDefKind::Lifetime => {
                     let use_span = tcx.def_span(param.def_id);
                     let opaque_span = tcx.def_span(opaque_def_id);
-                    // Check if the lifetime param was captured but isn't named in the precise captures list.
+                    // Check if the lifetime param was captured but isn't named in the precise
+                    // captures list.
                     if variances[param.index as usize] == ty::Invariant {
                         if let DefKind::OpaqueTy = tcx.def_kind(tcx.parent(param.def_id))
                             && let Some(def_id) = tcx
@@ -1519,15 +1522,17 @@ fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     check_unsafe_fields(tcx, def_id);
 }
 
-/// Part of enum check. Given the discriminants of an enum, errors if two or more discriminants are equal
+/// Part of enum check. Given the discriminants of an enum, errors if two or more discriminants are
+/// equal.
 fn detect_discriminant_duplicate<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>) {
     // Helper closure to reduce duplicate code. This gets called everytime we detect a duplicate.
     // Here `idx` refers to the order of which the discriminant appears, and its index in `vs`
     let report = |dis: Discr<'tcx>, idx, err: &mut Diag<'_>| {
         let var = adt.variant(idx); // HIR for the duplicate discriminant
         let (span, display_discr) = match var.discr {
             ty::VariantDiscr::Explicit(discr_def_id) => {
-                // In the case the discriminant is both a duplicate and overflowed, let the user know
+                // In the case the discriminant is both a duplicate and overflowed, let the user
+                // know.
                 if let hir::Node::AnonConst(expr) =
                     tcx.hir_node_by_def_id(discr_def_id.expect_local())
                     && let hir::ExprKind::Lit(lit) = &tcx.hir().body(expr.body).value.kind
@@ -1546,7 +1551,7 @@ fn detect_discriminant_duplicate<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
                 // At this point we know this discriminant is a duplicate, and was not explicitly
                 // assigned by the user. Here we iterate backwards to fetch the HIR for the last
                 // explicitly assigned discriminant, and letting the user know that this was the
-                // increment startpoint, and how many steps from there leading to the duplicate
+                // increment startpoint, and how many steps from there leading to the duplicate.
                 if let Some(explicit_idx) =
                     idx.as_u32().checked_sub(distance_to_explicit).map(VariantIdx::from_u32)
                 {
@@ -1657,11 +1662,12 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
                     None
                 }
             })
-            // FIXME: This assumes that elaborated `Sized` bounds come first (which does hold at the
-            // time of writing). This is a bit fragile since we later use the span to detect elaborated
-            // `Sized` bounds. If they came last for example, this would break `Trait + /*elab*/Sized`
-            // since it would overwrite the span of the user-written bound. This could be fixed by
-            // folding the spans with `Span::to` which requires a bit of effort I think.
+            // FIXME: This assumes that elaborated `Sized` bounds come first (which does hold at
+            // the time of writing). This is a bit fragile since we later use the span to detect
+            // elaborated `Sized` bounds. If they came last for example, this would break `Trait +
+            // /*elab*/Sized` since it would overwrite the span of the user-written bound. This
+            // could be fixed by folding the spans with `Span::to` which requires a bit of effort I
+            // think.
             .collect::<FxIndexMap<_, _>>()
     });
 

Diff for: compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -388,8 +388,8 @@ fn compare_method_predicate_entailment<'tcx>(
                 match obligation.predicate.kind().skip_binder() {
                     // We need to register Projection oblgiations too, because we may end up with
                     // an implied `X::Item: 'a`, which gets desugared into `X::Item = ?0`, `?0: 'a`.
-                    // If we only register the region outlives obligation, this leads to an unconstrained var.
-                    // See `implied_bounds_entailment_alias_var.rs` test.
+                    // If we only register the region outlives obligation, this leads to an
+                    // unconstrained var. See `implied_bounds_entailment_alias_var.rs` test.
                     ty::PredicateKind::Clause(
                         ty::ClauseKind::RegionOutlives(..)
                         | ty::ClauseKind::TypeOutlives(..)
@@ -673,10 +673,10 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
     match ocx.eq(&cause, param_env, trait_sig, impl_sig) {
         Ok(()) => {}
         Err(terr) => {
-            // This function gets called during `compare_method_predicate_entailment` when normalizing a
-            // signature that contains RPITIT. When the method signatures don't match, we have to
-            // emit an error now because `compare_method_predicate_entailment` will not report the error
-            // when normalization fails.
+            // This function gets called during `compare_method_predicate_entailment` when
+            // normalizing a signature that contains RPITIT. When the method signatures don't
+            // match, we have to emit an error now because `compare_method_predicate_entailment`
+            // will not report the error when normalization fails.
             let emitted = report_trait_method_mismatch(
                 infcx,
                 cause,

Diff for: compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

@@ -101,7 +101,7 @@ pub(crate) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
         if !tcx.hir().get_if_local(impl_opaque.def_id).is_some_and(|node| {
             matches!(
                 node.expect_opaque_ty().origin,
-                hir::OpaqueTyOrigin::AsyncFn { parent, .. }  | hir::OpaqueTyOrigin::FnReturn { parent, .. }
+                hir::OpaqueTyOrigin::AsyncFn { parent, .. } | hir::OpaqueTyOrigin::FnReturn { parent, .. }
                     if parent == impl_m.def_id.expect_local()
             )
         }) {

Diff for: compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -127,7 +127,8 @@ where
 
     let infcx_compat = infcx.fork();
 
-    // We specifically want to call the non-compat version of `implied_bounds_tys`; we do this always.
+    // We specifically want to call the non-compat version of `implied_bounds_tys`; we do this
+    // always.
     let implied_bounds =
         infcx.implied_bounds_tys_compat(param_env, body_def_id, &assumed_wf_types, false);
     let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
@@ -323,8 +324,8 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
         hir::ItemKind::ForeignMod { .. } => Ok(()),
         hir::ItemKind::TyAlias(hir_ty, hir_generics) => {
             if tcx.type_alias_is_lazy(item.owner_id) {
-                // Bounds of lazy type aliases and of eager ones that contain opaque types are respected.
-                // E.g: `type X = impl Trait;`, `type X = (impl Trait, Y);`.
+                // Bounds of lazy type aliases and of eager ones that contain opaque types are
+                // respected. E.g: `type X = impl Trait;`, `type X = (impl Trait, Y);`.
                 let res = check_item_type(tcx, def_id, hir_ty.span, UnsizedHandling::Allow);
                 check_variances_for_type_defn(tcx, item, hir_generics);
                 res
@@ -448,7 +449,8 @@ fn check_gat_where_clauses(tcx: TyCtxt<'_>, trait_def_id: LocalDefId) {
                     ty::AssocKind::Fn => {
                         // For methods, we check the function signature's return type for any GATs
                         // to constrain. In the `into_iter` case, we see that the return type
-                        // `Self::Iter<'a>` is a GAT we want to gather any potential missing bounds from.
+                        // `Self::Iter<'a>` is a GAT we want to gather any potential missing bounds
+                        // from.
                         let sig: ty::FnSig<'_> = tcx.liberate_late_bound_regions(
                             item_def_id.to_def_id(),
                             tcx.fn_sig(item_def_id).instantiate_identity(),
@@ -1007,7 +1009,8 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
                                 // `&mut` are not supported.
                                 ty::Ref(_, ty, ast::Mutability::Not) => ty_is_local(*ty),
                                 // Say that a tuple is local if any of its components are local.
-                                // This is not strictly correct, but it's likely that the user can fix the local component.
+                                // This is not strictly correct, but it's likely that the user can
+                                // fix the local component.
                                 ty::Tuple(tys) => tys.iter().any(|ty| ty_is_local(ty)),
                                 _ => false,
                             }
@@ -1350,8 +1353,8 @@ fn check_impl<'tcx>(
                 // therefore don't need to be WF (the trait's `Self: Trait` predicate
                 // won't hold).
                 let trait_ref = tcx.impl_trait_ref(item.owner_id).unwrap().instantiate_identity();
-                // Avoid bogus "type annotations needed `Foo: Bar`" errors on `impl Bar for Foo` in case
-                // other `Foo` impls are incoherent.
+                // Avoid bogus "type annotations needed `Foo: Bar`" errors on `impl Bar for Foo` in
+                // case other `Foo` impls are incoherent.
                 tcx.ensure().coherent_trait(trait_ref.def_id)?;
                 let trait_span = hir_trait_ref.path.span;
                 let trait_ref = wfcx.normalize(
@@ -1825,7 +1828,8 @@ fn receiver_is_valid<'tcx>(
     let cause =
         ObligationCause::new(span, wfcx.body_def_id, traits::ObligationCauseCode::MethodReceiver);
 
-    // Special case `receiver == self_ty`, which doesn't necessarily require the `Receiver` lang item.
+    // Special case `receiver == self_ty`, which doesn't necessarily require the `Receiver` lang
+    // item.
     if let Ok(()) = wfcx.infcx.commit_if_ok(|_| {
         let ocx = ObligationCtxt::new(wfcx.infcx);
         ocx.eq(&cause, wfcx.param_env, self_ty, receiver_ty)?;
@@ -1845,7 +1849,8 @@ fn receiver_is_valid<'tcx>(
         autoderef = autoderef.use_receiver_trait();
     }
 
-    // The `arbitrary_self_types_pointers` feature allows raw pointer receivers like `self: *const Self`.
+    // The `arbitrary_self_types_pointers` feature allows raw pointer receivers like `self: *const
+    // Self`.
     if arbitrary_self_types_enabled == Some(ArbitrarySelfTypesLevel::WithPointers) {
         autoderef = autoderef.include_raw_pointers();
     }

Diff for: compiler/rustc_hir_analysis/src/coherence/mod.rs

@@ -146,8 +146,9 @@ pub(crate) fn provide(providers: &mut Providers) {
 }
 
 fn coherent_trait(tcx: TyCtxt<'_>, def_id: DefId) -> Result<(), ErrorGuaranteed> {
-    // If there are no impls for the trait, then "all impls" are trivially coherent and we won't check anything
-    // anyway. Thus we bail out even before the specialization graph, avoiding the dep_graph edge.
+    // If there are no impls for the trait, then "all impls" are trivially coherent and we won't
+    // check anything anyway. Thus we bail out even before the specialization graph, avoiding the
+    // dep_graph edge.
     let Some(impls) = tcx.all_local_trait_impls(()).get(&def_id) else { return Ok(()) };
     // Trigger building the specialization graph for the trait. This will detect and report any
     // overlap errors.

Diff for: compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -201,7 +201,8 @@ pub(crate) fn orphan_check_impl(
                     // }
                     // impl<T: ?Sized> AutoTrait for S<T>::This {}
                     // ```
-                    // FIXME(inherent_associated_types): The example code above currently leads to a cycle
+                    // FIXME(inherent_associated_types): The example code above currently leads to
+                    // a cycle.
                     ty::Inherent => "associated type",
                 };
                 (LocalImpl::Disallow { problematic_kind }, NonlocalImpl::DisallowOther)

Diff for: compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -105,8 +105,9 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             }
 
             if in_param_ty {
-                // We do not allow generic parameters in anon consts if we are inside
-                // of a const parameter type, e.g. `struct Foo<const N: usize, const M: [u8; N]>` is not allowed.
+                // We do not allow generic parameters in anon consts if we are inside of a const
+                // parameter type, e.g. `struct Foo<const N: usize, const M: [u8; N]>` is not
+                // allowed.
                 None
             } else if tcx.features().generic_const_exprs() {
                 let parent_node = tcx.parent_hir_node(hir_id);
@@ -126,23 +127,27 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
                     //        ^         ^ param_id
                     //        ^ parent_def_id
                     //
-                    // then we only want to return generics for params to the left of `N`. If we don't do that we
-                    // end up with that const looking like: `ty::ConstKind::Unevaluated(def_id, args: [N#0])`.
+                    // then we only want to return generics for params to the left of `N`. If we
+                    // don't do that we end up with that const looking like:
+                    // `ty::ConstKind::Unevaluated(def_id, args: [N#0])`.
                     //
-                    // This causes ICEs (#86580) when building the args for Foo in `fn foo() -> Foo { .. }` as
-                    // we instantiate the defaults with the partially built args when we build the args. Instantiating
-                    // the `N#0` on the unevaluated const indexes into the empty args we're in the process of building.
+                    // This causes ICEs (#86580) when building the args for Foo in `fn foo() -> Foo
+                    // { .. }` as we instantiate the defaults with the partially built args when we
+                    // build the args. Instantiating the `N#0` on the unevaluated const indexes
+                    // into the empty args we're in the process of building.
                     //
-                    // We fix this by having this function return the parent's generics ourselves and truncating the
-                    // generics to only include non-forward declared params (with the exception of the `Self` ty)
+                    // We fix this by having this function return the parent's generics ourselves
+                    // and truncating the generics to only include non-forward declared params
+                    // (with the exception of the `Self` ty)
+                    //
+                    // For the above code example that means we want `args: []`.
+                    // For the following struct def we want `args: [N#0]` when generics_of is
+                    // called on the def id of the `{ N + 1 }` anon const
                     //
-                    // For the above code example that means we want `args: []`
-                    // For the following struct def we want `args: [N#0]` when generics_of is called on
-                    // the def id of the `{ N + 1 }` anon const
                     // struct Foo<const N: usize, const M: usize = { N + 1 }>;
                     //
-                    // This has some implications for how we get the predicates available to the anon const
-                    // see `explicit_predicates_of` for more information on this
+                    // This has some implications for how we get the predicates available to the
+                    // anon const see `explicit_predicates_of` for more information on this.
                     let generics = tcx.generics_of(parent_did);
                     let param_def_idx = generics.param_def_id_to_index[&param_id.to_def_id()];
                     // In the above example this would be .params[..N#0]
@@ -152,8 +157,8 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
 
                     return ty::Generics {
                         // we set the parent of these generics to be our parent's parent so that we
-                        // dont end up with args: [N, M, N] for the const default on a struct like this:
-                        // struct Foo<const N: usize, const M: usize = { ... }>;
+                        // dont end up with args: [N, M, N] for the const default on a struct like
+                        // this: struct Foo<const N: usize, const M: usize = { ... }>;
                         parent: generics.parent,
                         parent_count: generics.parent_count,
                         own_params,