Rollup merge of rust-lang#157248 - aerooneqq:delegation-statements-out-of-first-arg, r=petrochenkov

delegation: move statements out of the first arg

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:
```rust
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:
```rust
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
```rust
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 rust-lang#118212.
r? @petrochenkov

Author: JonathanBrouwer

compiler/rustc_ast_lowering/src/delegation.rs

@@ -408,11 +408,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let block_id = self.lower_body(|this| {
             let mut parameters: Vec<hir::Param<'_>> = Vec::with_capacity(param_count);
             let mut args: Vec<hir::Expr<'_>> = Vec::with_capacity(param_count);
+            let mut stmts: &[hir::Stmt<'hir>] = &[];
 
             for idx in 0..param_count {
                 let (param, pat_node_id) = this.generate_param(is_method, idx, span);
                 parameters.push(param);
 
+                let generate_arg =
+                    |this: &mut Self| this.generate_arg(is_method, idx, param.pat.hir_id, span);
+
                 let arg = if let Some(block) = block
                     && idx == 0
                 {
@@ -424,10 +428,24 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self_resolver.visit_block(block);
                     // Target expr needs to lower `self` path.
                     this.ident_and_label_to_local_id.insert(pat_node_id, param.pat.hir_id.local_id);
-                    this.lower_target_expr(&block)
+
+                    // Lower with `HirId::INVALID` as we will use only expr and stmts.
+                    // FIXME(fn_delegation): Alternatives for target expression lowering:
+                    // https://github.com/rust-lang/rfcs/pull/3530#issuecomment-2197170600.
+                    let block = this.lower_block_noalloc(HirId::INVALID, block, false);
+
+                    stmts = block.stmts;
+
+                    // The behavior of the delegation's target expression differs from the
+                    // behavior of the usual block, where if there is no final expression
+                    // the `()` is returned. In case of the similar situation in delegation
+                    // (no final expression) we propagate first argument instead of replacing
+                    // it with `()`.
+                    if let Some(&expr) = block.expr { expr } else { generate_arg(this) }
                 } else {
-                    this.generate_arg(is_method, idx, param.pat.hir_id, span)
+                    generate_arg(this)
                 };
+
                 args.push(arg);
             }
 
@@ -439,11 +457,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
             if param_count == 0
                 && let Some(block) = block
             {
-                args.push(this.lower_target_expr(&block));
+                args.push(this.lower_block_expr(&block));
             }
 
             let (final_expr, hir_id) =
-                this.finalize_body_lowering(delegation, args, generics, span);
+                this.finalize_body_lowering(delegation, stmts, args, generics, span);
 
             call_expr_id = hir_id;
 
@@ -455,22 +473,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
         (block_id, call_expr_id)
     }
 
-    // FIXME(fn_delegation): Alternatives for target expression lowering:
-    // https://github.com/rust-lang/rfcs/pull/3530#issuecomment-2197170600.
-    fn lower_target_expr(&mut self, block: &Block) -> hir::Expr<'hir> {
-        if let [stmt] = block.stmts.as_slice()
-            && let StmtKind::Expr(expr) = &stmt.kind
-        {
-            return self.lower_expr_mut(expr);
-        }
-
-        let block = self.lower_block(block, false);
-        self.mk_expr(hir::ExprKind::Block(block, None), block.span)
-    }
-
     fn finalize_body_lowering(
         &mut self,
         delegation: &Delegation,
+        stmts: &'hir [hir::Stmt<'hir>],
         args: Vec<hir::Expr<'hir>>,
         generics: &mut GenericsGenerationResults<'hir>,
         span: Span,
@@ -522,7 +528,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let call = self.arena.alloc(self.mk_expr(hir::ExprKind::Call(callee_path, args), span));
 
         let block = self.arena.alloc(hir::Block {
-            stmts: &[],
+            stmts,
             expr: Some(call),
             hir_id: self.next_id(),
             rules: hir::BlockCheckMode::DefaultBlock,
@@ -587,7 +593,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
             let callee_path = this.arena.alloc(this.mk_expr(hir::ExprKind::Path(path), span));
             let args = if let Some(block) = delegation.body.as_ref() {
-                this.arena.alloc_slice(&[this.lower_target_expr(block)])
+                this.arena.alloc_slice(&[this.lower_block_expr(block)])
             } else {
                 &mut []
             };

tests/pretty/delegation-inline-attribute.pp

@@ -38,34 +38,32 @@
     fn foo(self: _)
         ->
             _ {
-        Trait::foo(
-            // Check that #[inline(hint)] is added to foo0 reuse inside another reuse
-
-            // Check that #[inline(hint)] is added when other attributes present in inner reuse
-
-            // Check that #[inline(never)] is preserved in inner reuse
-
-            // Check that #[inline(always)] is preserved in inner reuse
-
-            // Check that #[inline(never)] is preserved when there are other attributes in inner reuse
-            {
-                #[attr = Inline(Hint)]
-                fn foo0(arg0: _) -> _ { to_reuse::foo(self + 1) }
-                #[attr = Cold]
-                #[attr = MustUse]
-                #[attr = Deprecated {deprecation: Deprecation {since: Unspecified}}]
-                #[attr = Inline(Hint)]
-                fn foo1(arg0: _) -> _ { to_reuse::foo(self / 2) }
-                #[attr = Inline(Never)]
-                fn foo2(arg0: _) -> _ { to_reuse::foo(self / 2) }
-                #[attr = Inline(Always)]
-                fn foo3(arg0: _) -> _ { to_reuse::foo(self / 2) }
-                #[attr = Cold]
-                #[attr = MustUse]
-                #[attr = Inline(Never)]
-                #[attr = Deprecated {deprecation: Deprecation {since: Unspecified}}]
-                fn foo4(arg0: _) -> _ { to_reuse::foo(self / 2) }
-            })
+        // Check that #[inline(hint)] is added to foo0 reuse inside another reuse
+        #[attr = Inline(Hint)]
+        fn foo0(arg0: _) -> _ { to_reuse::foo(self + 1) }
+
+        // Check that #[inline(hint)] is added when other attributes present in inner reuse
+        #[attr = Cold]
+        #[attr = MustUse]
+        #[attr = Deprecated {deprecation: Deprecation {since: Unspecified}}]
+        #[attr = Inline(Hint)]
+        fn foo1(arg0: _) -> _ { to_reuse::foo(self / 2) }
+
+        // Check that #[inline(never)] is preserved in inner reuse
+        #[attr = Inline(Never)]
+        fn foo2(arg0: _) -> _ { to_reuse::foo(self / 2) }
+
+        // Check that #[inline(always)] is preserved in inner reuse
+        #[attr = Inline(Always)]
+        fn foo3(arg0: _) -> _ { to_reuse::foo(self / 2) }
+
+        // Check that #[inline(never)] is preserved when there are other attributes in inner reuse
+        #[attr = Cold]
+        #[attr = MustUse]
+        #[attr = Inline(Never)]
+        #[attr = Deprecated {deprecation: Deprecation {since: Unspecified}}]
+        fn foo4(arg0: _) -> _ { to_reuse::foo(self / 2) }
+        Trait::foo(self)
     }
 
     // Check that #[inline(hint)] is added when there are other attributes present in trait reuse

tests/pretty/hir-delegation.pp

@@ -12,7 +12,7 @@
 
 trait G {
     #[attr = Inline(Hint)]
-    fn b<C>(arg0: _) -> _ { b::<C>({ }) }
+    fn b<C>(arg0: _) -> _ { b::<C>(arg0) }
 }
 
 mod m {

tests/ui/delegation/ice-issue-124347.stderr

@@ -14,7 +14,7 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied
   --> $DIR/ice-issue-124347.rs:4:18
    |
 LL |     reuse Trait::foo { &self.0 }
-   |                  ^^^   ------- unexpected argument
+   |                  ^^^ ----------- unexpected argument
    |
 note: associated function defined here
   --> $DIR/ice-issue-124347.rs:4:18
@@ -24,7 +24,7 @@ LL |     reuse Trait::foo { &self.0 }
 help: remove the extra argument
    |
 LL -     reuse Trait::foo { &self.0 }
-LL +     reuse Trait::fo&self.0 }
+LL +     reuse Trait::fo{ &self.0 }
    |
 
 warning: function cannot return without recursing

tests/ui/delegation/inner-attr.stderr

@@ -13,7 +13,7 @@ error[E0061]: this function takes 0 arguments but 1 argument was supplied
   --> $DIR/inner-attr.rs:5:7
    |
 LL | reuse a as b { #![rustc_dummy] self }
-   |       ^                        ---- unexpected argument
+   |       ^      ------------------------ unexpected argument
    |
 note: function defined here
   --> $DIR/inner-attr.rs:3:4
@@ -23,7 +23,7 @@ LL | fn a() {}
 help: remove the extra argument
    |
 LL - reuse a as b { #![rustc_dummy] self }
-LL + reuse self }
+LL + reuse { #![rustc_dummy] self }
    |
 
 error: aborting due to 2 previous errors

tests/ui/delegation/self-coercion-block-errors.rs

@@ -0,0 +1,58 @@
+// Test different scenarios with impossible adjustments due to blocks
+// or no-op target expressions.
+
+#![feature(fn_delegation)]
+
+trait Trait: Sized {
+    fn by_value(self) -> i32 { 1 }
+    fn by_mut_ref(&mut self) -> i32 { 2 }
+    fn by_ref(&self) -> i32 { 3 }
+}
+
+struct F;
+impl Trait for F {}
+
+struct Struct(F);
+reuse impl Trait for Struct { self.0 }
+
+struct S(F);
+reuse impl Trait for S { { self.0 } }
+//~^ ERROR: cannot move out of `self` which is behind a shared reference
+//~| ERROR: cannot move out of `self` which is behind a mutable reference
+
+struct S1(F);
+reuse impl Trait for S1 { { { { { { self.0 } } } } } }
+//~^ ERROR: cannot move out of `self` which is behind a shared reference
+//~| ERROR: cannot move out of `self` which is behind a mutable reference
+
+struct S2(F);
+reuse impl Trait for S2 { }
+//~^ WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+
+struct S3(F);
+reuse impl Trait for S3 { (); }
+//~^ WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+
+struct S4(F);
+reuse impl Trait for S4 { println!(); }
+//~^ WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+
+struct S5(F);
+reuse impl Trait for S5 { fn foo() {} }
+//~^ WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+
+struct S6(F);
+reuse impl Trait for S6;
+//~^ WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+//~| WARN: function cannot return without recursing [unconditional_recursion]
+
+fn main() {}