Emit single explanatory note on unsized locals and fn params instead of two

On stable, unify wording of unsized locals and unsized fn params so the deduplication machinery can trigger. On nightly, mention the nightly feature to enable unsized locals or unsized fn params.

Author: estebank

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -3137,11 +3137,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  Node::LetStmt(hir::LetStmt { ty: Some(ty), .. }) => {
  err.span_suggestion_verbose(
  ty.span.shrink_to_lo(),
- "consider borrowing here",
+ "borrowed types have a statically known size",
  "&",
  Applicability::MachineApplicable,
  );
- err.note("all local variables must have a statically known size");
  }
  Node::LetStmt(hir::LetStmt {
  init: Some(hir::Expr { kind: hir::ExprKind::Index(..), span, .. }),
@@ -3152,11 +3151,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  // order to use have a slice instead.
  err.span_suggestion_verbose(
  span.shrink_to_lo(),
- "consider borrowing here",
+ "borrowed values have a statically known size",
  "&",
  Applicability::MachineApplicable,
  );
- err.note("all local variables must have a statically known size");
  }
  Node::Param(param) => {
  err.span_suggestion_verbose(
@@ -3168,11 +3166,20 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  );
  }
  _ => {
- err.note("all local variables must have a statically known size");
+ if !tcx.sess.opts.unstable_features.is_nightly_build()
+ && !tcx.features().unsized_locals
+ {
+ err.note("all bindings must have a statically known size");
+ }
  }
  }
- if !tcx.features().unsized_locals {
- err.help("unsized locals are gated as an unstable feature");
+ if tcx.sess.opts.unstable_features.is_nightly_build()
+ && !tcx.features().unsized_locals
+ {
+ err.help(
+ "unsized locals are gated as unstable feature \
+ `#[feature(unsized_locals)]`",
+ );
  }
  }
  ObligationCauseCode::SizedArgumentType(hir_id) => {
@@ -3197,64 +3204,69 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  {
  ty = Some(t);
  }
- if let Some(ty) = ty {
- match ty.kind {
- hir::TyKind::TraitObject(traits, _, _) => {
- let (span, kw) = match traits {
- [first, ..] if first.span.lo() == ty.span.lo() => {
- // Missing `dyn` in front of trait object.
- (ty.span.shrink_to_lo(), "dyn ")
- }
- [first, ..] => (ty.span.until(first.span), ""),
- [] => span_bug!(ty.span, "trait object with no traits: {ty:?}"),
- };
- let needs_parens = traits.len() != 1;
- err.span_suggestion_verbose(
- span,
- "you can use `impl Trait` as the argument type",
- "impl ",
- Applicability::MaybeIncorrect,
- );
- let sugg = if !needs_parens {
- vec![(span.shrink_to_lo(), format!("&{kw}"))]
- } else {
- vec![
- (span.shrink_to_lo(), format!("&({kw}")),
- (ty.span.shrink_to_hi(), ")".to_string()),
- ]
- };
- err.multipart_suggestion_verbose(
- borrowed_msg,
- sugg,
- Applicability::MachineApplicable,
- );
- }
- hir::TyKind::Slice(_ty) => {
- err.span_suggestion_verbose(
- ty.span.shrink_to_lo(),
- "function arguments must have a statically known size, borrowed \
- slices always have a known size",
- "&",
- Applicability::MachineApplicable,
- );
- }
- hir::TyKind::Path(_) => {
- err.span_suggestion_verbose(
- ty.span.shrink_to_lo(),
- borrowed_msg,
- "&",
- Applicability::MachineApplicable,
- );
+ match ty.map(|ty| (ty.kind, ty.span)) {
+ Some((hir::TyKind::TraitObject(traits, _, _), sp)) => {
+ let (span, kw) = match traits {
+ [first, ..] if first.span.lo() == sp.lo() => {
+ // Missing `dyn` in front of trait object.
+ (sp.shrink_to_lo(), "dyn ")
+ }
+ [first, ..] => (sp.until(first.span), ""),
+ [] => span_bug!(sp, "trait object with no traits: {ty:?}"),
+ };
+ let needs_parens = traits.len() != 1;
+ err.span_suggestion_verbose(
+ span,
+ "you can use `impl Trait` as the argument type",
+ "impl ",
+ Applicability::MaybeIncorrect,
+ );
+ let sugg = if !needs_parens {
+ vec![(span.shrink_to_lo(), format!("&{kw}"))]
+ } else {
+ vec![
+ (span.shrink_to_lo(), format!("&({kw}")),
+ (sp.shrink_to_hi(), ")".to_string()),
+ ]
+ };
+ err.multipart_suggestion_verbose(
+ borrowed_msg,
+ sugg,
+ Applicability::MachineApplicable,
+ );
+ }
+ Some((hir::TyKind::Slice(_ty), span)) => {
+ err.span_suggestion_verbose(
+ span.shrink_to_lo(),
+ "function arguments must have a statically known size, borrowed \
+ slices always have a known size",
+ "&",
+ Applicability::MachineApplicable,
+ );
+ }
+ Some((hir::TyKind::Path(_), span)) => {
+ err.span_suggestion_verbose(
+ span.shrink_to_lo(),
+ borrowed_msg,
+ "&",
+ Applicability::MachineApplicable,
+ );
+ }
+ _ => {
+ if !tcx.sess.opts.unstable_features.is_nightly_build()
+ && !tcx.features().unsized_fn_params
+ {
+ err.note("all bindings must have a statically known size");
  }
- _ => {}
  }
- } else {
- err.note("all function arguments must have a statically known size");
  }
  if tcx.sess.opts.unstable_features.is_nightly_build()
  && !tcx.features().unsized_fn_params
  {
- err.help("unsized fn params are gated as an unstable feature");
+ err.help(
+ "unsized fn params are gated as unstable feature \
+ `#[feature(unsized_fn_params)]`",
+ );
  }
  }
  ObligationCauseCode::SizedReturnType | ObligationCauseCode::SizedCallReturnType(_) => {

src/tools/clippy/tests/ui/crashes/ice-6251.stderr

@@ -5,7 +5,7 @@ LL | fn bug<T>() -> impl Iterator<Item = [(); { |x: [u8]| x }]> {
  | ^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `std::marker::Sized` is not implemented for `[u8]`
- = help: unsized fn params are gated as an unstable feature
+ = help: unsized fn params are gated as unstable feature `#[feature(unsized_fn_params)]`
 help: function arguments must have a statically known size, borrowed slices always have a known size
  |
 LL | fn bug<T>() -> impl Iterator<Item = [(); { |x: &[u8]| x }]> {

tests/ui/associated-types/associated-types-unsized.stderr

@@ -5,8 +5,7 @@ LL | let x = t.get();
  | ^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `<T as Get>::Value`
- = note: all local variables must have a statically known size
- = help: unsized locals are gated as an unstable feature
+ = help: unsized locals are gated as unstable feature `#[feature(unsized_locals)]`
 help: consider further restricting the associated type
  |
 LL | fn foo<T:Get>(t: T) where <T as Get>::Value: Sized {

tests/ui/associated-types/issue-20005.stderr

@@ -24,7 +24,7 @@ error[E0277]: the size for values of type `Self` cannot be known at compilation
 LL | self
  | ^^^^ doesn't have a size known at compile-time
  |
- = help: unsized fn params are gated as an unstable feature
+ = help: unsized fn params are gated as unstable feature `#[feature(unsized_fn_params)]`
 help: consider further restricting `Self`
  |
 LL | ) -> <Dst as From<Self>>::Result where Dst: From<Self>, Self: Sized {
@@ -60,8 +60,7 @@ error[E0277]: the size for values of type `Self` cannot be known at compilation
 LL | From::from(self)
  | ^^^^ doesn't have a size known at compile-time
  |
- = note: all function arguments must have a statically known size
- = help: unsized fn params are gated as an unstable feature
+ = help: unsized fn params are gated as unstable feature `#[feature(unsized_fn_params)]`
 help: consider further restricting `Self`
  |
 LL | ) -> <Dst as From<Self>>::Result where Dst: From<Self>, Self: Sized {

tests/ui/associated-types/issue-59324.stderr

@@ -85,7 +85,7 @@ LL | fn with_factory<H>(factory: dyn ThriftService<()>) {}
  | ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `(dyn ThriftService<(), AssocType = _> + 'static)`
- = help: unsized fn params are gated as an unstable feature
+ = help: unsized fn params are gated as unstable feature `#[feature(unsized_fn_params)]`
 help: you can use `impl Trait` as the argument type
  |
 LL | fn with_factory<H>(factory: impl ThriftService<()>) {}

tests/ui/async-await/issue-72590-type-error-sized.stderr

@@ -22,7 +22,7 @@ note: required because it appears within the type `Foo`
  |
 LL | struct Foo {
  | ^^^
- = help: unsized fn params are gated as an unstable feature
+ = help: unsized fn params are gated as unstable feature `#[feature(unsized_fn_params)]`
 help: function arguments must have a statically known size, borrowed types always have a known size
  |
 LL | async fn frob(&self) {}

tests/ui/closures/cannot-call-unsized-via-ptr-2.stderr

@@ -5,7 +5,6 @@ LL | let f = if true { |_a| {} } else { |_b| {} };
  | ^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `[u8]`
- = note: all function arguments must have a statically known size
 
 error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
  --> $DIR/cannot-call-unsized-via-ptr-2.rs:5:41
@@ -14,7 +13,6 @@ LL | let f = if true { |_a| {} } else { |_b| {} };
  | ^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `[u8]`
- = note: all function arguments must have a statically known size
 
 error: aborting due to 2 previous errors
 

tests/ui/closures/cannot-call-unsized-via-ptr.stderr

@@ -5,7 +5,6 @@ LL | let f: fn([u8]) = |_result| {};
  | ^^^^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `[u8]`
- = note: all function arguments must have a statically known size
 
 error: aborting due to 1 previous error
 

tests/ui/closures/issue-111932.stderr

@@ -5,8 +5,7 @@ LL | foos.for_each(|foo| {
  | ^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `(dyn Foo + 'static)`
- = note: all function arguments must have a statically known size
- = help: unsized fn params are gated as an unstable feature
+ = help: unsized fn params are gated as unstable feature `#[feature(unsized_fn_params)]`
 
 error: aborting due to 1 previous error
 

tests/ui/closures/issue-78720.stderr

@@ -43,7 +43,7 @@ error[E0277]: the size for values of type `Self` cannot be known at compilation
 LL | fn map2<F>(self, f: F) -> Map2<F> {}
  | ^^^^ doesn't have a size known at compile-time
  |
- = help: unsized fn params are gated as an unstable feature
+ = help: unsized fn params are gated as unstable feature `#[feature(unsized_fn_params)]`
 help: consider further restricting `Self`
  |
 LL | fn map2<F>(self, f: F) -> Map2<F> where Self: Sized {}