Clean up comments and formatting.

Mostly by reflowing overly long comment lines.

Author: nnethercote

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));
  }
 

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<_, _>>()
  });
 

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,

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()
  )
  }) {

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();
  }

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.

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)

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,