Change:
Notice how the last 2 suggestions aren't valid in such a closure: The suggestions given in should help me get closer to fixing the error, or at least not have invalid syntax. No response No response Output of :
(if is used in the snippet, comes up again with leaking implementation details)

Discussion:
// for simple cases like `fn foo(x: Trait)`, // where we would error once on the parameter as a whole, and once on the binding `x`. if param.pat.simple_ident().is_none() && !params_can_be_unsized { <del> fcx.require_type_is_sized(param_ty, param.pat.span, traits::SizedArgumentType(ty_span)); </del> <ins> fcx.require_type_is_sized( param_ty, param.pat.span, // ty_span == binding_span iff this is a closure parameter with no type ascription, // or if it's an implicit `self` parameter traits::SizedArgumentType( if ty_span == Some(param.span) && tcx.is_closure(fn_def_id.into()) { None } else { ty_span }, ), ); </ins> } fcx.write_ty(param.hir_id, param_ty);

self.fcx.require_type_is_sized( var_ty, p.span, <del> traits::SizedArgumentType(Some(ty_span)), </del> <ins> // ty_span == ident.span iff this is a closure parameter with no type // ascription, or if it's an implicit `self` parameter traits::SizedArgumentType( if ty_span == ident.span && self.fcx.tcx.is_closure(self.fcx.body_id.into()) { None } else { Some(ty_span) }, ), </ins> ); } } else {

err.help("unsized locals are gated as an unstable feature"); } } <del> ObligationCauseCode::SizedArgumentType(sp) => { if let Some(span) = sp { </del> <ins> ObligationCauseCode::SizedArgumentType(ty_span) => { if let Some(span) = ty_span { </ins> if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder() && let ty::Clause::Trait(trait_pred) = clause && let ty::Dynamic(..) = trait_pred.self_ty().kind()

<ins> trait Foo: std::fmt::Debug {} fn print_foos(foos: impl Iterator<Item = dyn Foo>) { foos.for_each(|foo| { //~ ERROR [E0277] println!("{:?}", foo); //~ ERROR [E0277] }); } fn main() {} </ins>

<ins> error[E0277]: the size for values of type `(dyn Foo + 'static)` cannot be known at compilation time --> $DIR/issue-111932.rs:4:20 | 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 error[E0277]: the size for values of type `dyn Foo` cannot be known at compilation time --> $DIR/issue-111932.rs:5:26 | LL |         println!("{:?}", foo); |                   ----   ^^^ doesn't have a size known at compile-time |                   | |                   required by a bound introduced by this call | = help: the trait `Sized` is not implemented for `dyn Foo` note: required by a bound in `core::fmt::rt::Argument::<'a>::new_debug` --> $SRC_DIR/core/src/fmt/rt.rs:LL:COL = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0277`. </ins>

|                        ^ doesn't have a size known at compile-time | = help: the trait `Sized` is not implemented for `[u8]` <del> help: function arguments must have a statically known size, borrowed types always have a known size | LL |     let f: fn([u8]) = |&_| {}; |                        + </del> <ins> = note: all function arguments must have a statically known size </ins> error: aborting due to previous error