delegation: move statements out of the first arg

[aerooneqq]

This PR moves statements that precede final block expression out of the first argument, so we can apply adjustments to final block expression in more cases.

This changes behavior a bit, for example if we specify an empty block:

fn b<C>(e: C) {}
reuse b {}

// Desugaring:
fn b<C>(arg0: _) -> _ { b::<C>(arg0) }

So we generated the first arg and block is no-op.

In general scenario:

trait Trait: Sized { //~ WARN trait `Trait` is never used
    fn by_value(self, x: i32) -> i32 { x }
    fn by_ref(&self, x: i32) -> i32 { x }
    fn by_mut_ref(&mut self, x: i32) -> i32 { x }
}

struct F; //~ WARN struct `F` is never constructed
impl Trait for F {}

struct S(F); //~ WARN struct `S` is never constructed
impl Trait for S {
    reuse <F as Trait>::* {
        println!();
        // Final expression is adjusted even if it is in a block.
        self.0
    }
}

// Desugaring:
#[attr = Inline(Hint)]
fn by_value(self: _, arg1: _)
    ->
        _ {
    // Final expression is adjusted even if it is in a block.

    { ::std::io::_print(format_arguments::from_str("\n")); };
    <F as Trait>::by_value(self.0, arg1)
}
#[attr = Inline(Hint)]
fn by_ref(self: _, arg1: _)
    ->
        _ {
    { ::std::io::_print(format_arguments::from_str("\n")); };
    <F as Trait>::by_ref(self.0, arg1)
}
#[attr = Inline(Hint)]
fn by_mut_ref(self: _, arg1: _)
    ->
        _ {
    { ::std::io::_print(format_arguments::from_str("\n")); };
    <F as Trait>::by_mut_ref(self.0, arg1)
}

If we change target expression to

reuse <F as Trait>::* {
    println!();
    let x = 1;
}

// Desugaring:
#[attr = Inline(Hint)]
fn by_value(self: _, arg1: _)
    ->
        _ {

    { ::std::io::_print(format_arguments::from_str("\n")); };
    let x = 1;
    <F as Trait>::by_value(self, arg1)
}

Once again we generated default arguments for function and block is no-op now (meaning it does not affect callee arguments).

Part of #118212.
r? @petrochenkov

[petrochenkov]

Suggested change

	// Lower with `HirId::INVALID` as we will use only expr. and stmts.
	// Lower with `HirId::INVALID` as we will use only expr and stmts.

View changes since the review

[petrochenkov]

Suggested change

	arg
	if let Some(&expr) = block.expr { expr } else { generate_arg(this) }

View changes since the review

[petrochenkov]

The new semantics "no trailing statement means the first argument is passed through" needs to be written out in a comment.
It differs from the usual behavior, which is "no trailing statement means an empty tuple is passed".

View changes since the review

[petrochenkov]

Suggested change

	let mut statements = None;
	let mut statements = &[];

No need for an option.

View changes since the review

[petrochenkov]

It's a bit unfortunate that the behavior in the erroneous cases (here and in "If we have no params in signature...") differs from the good case, but not a big deal.

View changes since the review