Unary operator applied to block fails to compile with type mismatch `<T as UnaryOp>::Output != T`

[tsionyx]

Providing the unary operator (! or -) for a type T with the Output of different type results in inability to apply
this operator to the block returning this T (the compiler expects the value of type <T as UnaryOp>::Output be the return type of the block instead).

I tried this code:

struct Foo;

// the same problem persists for core::ops::Not
impl core::ops::Neg for Foo {
    type Output = u8;
    
    fn neg(self) -> Self::Output {
        42
    }
}

fn main() {
    let x: u8 = core::ops::Neg::neg({
        println!("Entered block in explicit function call");
        Foo
    });
    println!("{x}");
    
    let x: u8 = -{
        println!("Entered block in sugared operator call");
        Foo
    };
}

The first usage with operator in its explicit function form has no problem, while the second one fails with the error[E0308]: mismatched types.

[dianne]

Two things seem to be happening here. First, when type-checking -/!, we set an expectation that the operand has the same type as the result:

rust/compiler/rustc_hir_typeck/src/expr.rs

Lines 433 to 437 in 503745e

	let expected_inner = match unop {
	hir::UnOp::Not | hir::UnOp::Neg => expected,
	hir::UnOp::Deref => NoExpectation,
	};
	let mut oprnd_t = self.check_expr_with_expectation(oprnd, expected_inner);

Then, when the operand is a block, we force the result of the block to coerce to that expected type, making it an error when it can't:

rust/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

Line 1035 in 503745e

let coerce_to_ty = expected.coercion_target_type(self, blk.span);

Edit: Not totally sure if the A-inference Area: Type inference label I added is right. I couldn't find a better-fitting area label, but this isn't quite due mishandling type variables (which is what I expect from inference issues). It seems to be due to check_expr_unop setting an expectation when it shouldn't, so instead of guiding inference it causes type-checking to fail.