inline assist not working properly on `Hash::hash`

[antonilol]

rust-analyzer version: 0.4.1810-standalone

rustc version: rustc 1.75.0 (82e1608df 2023-12-21)

relevant settings: None

with this code,

pub struct MyStruct {
    value: u64,
}

impl std::hash::Hash for MyStruct {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.value.hash(state);
    }
}

impl MyStruct {
    pub fn as_u64(&self) -> u64 {
        self.value
    }
}

place the cursor on hash in self.value.hash(state); and apply the inline function assist

this is the result:

...
        {
            let this = &self.value;
            let state: &mutH = state;
          state.write_u64(*self)
        };
...

• &mutH should be &mut H
• *self should be *this
• the first two lines are indented with 4 spaces (normal), but state.write_u64(*self) only with 2, this is automatically fixed with the formatter but still doesnt look nice

the cause could be that the Hash impl for u64 is macro generated, but i dont know exactly

[evertedsphere]

I'd like to work on this ticket; it seems simple enough for a starter issue. I have a test in ide-assists that reproduces the bug.

[evertedsphere]

Leaving the formatting issue aside for now, this does not reproduce either of the remaining issues:

fn _write_u64(s: &mut u64, x: u64) {
    *s += x;
}
fn _hash_nonmacro(inner_self_: &u64, state: &mut u64) {
    _write_u64(state, *inner_self_)
}
fn _hash2_nonmacro(self_: &u64, state: &mut u64) {
    // works fine
    _hash_nonmacro(&self_, state);
}

The macro_rules! by itself is sufficient to produce the broken syntax (1), but not to produce a dangling reference (2) because the this parameter is never created:

fn _write_u64(s: &mut u64, x: u64) {
    *s += x;
}
macro_rules! impl_write {
    ($(($ty:ident, $meth:ident),)*) => {$(
        fn _hash(inner_self_: &u64, state: &mut u64) {
            $meth(state, *inner_self_)
        }
    )*}
}
impl_write! { (u64, _write_u64), }
fn _hash2(self_: &u64, state: &mut u64) {
    $0_hash(&self_, state);
}

[evertedsphere]

It looks like hir::semantics::SemanticsImpl::source is returning invalid syntax:

    let fn_source = ctx.sema.source(function)?;
    println!("{}", fn_source.value);
// fn_hash(inner_self_: &u64,state: &mutu64){_write_u64(state, *inner_self_)}

which is missing spaces both after fn and &mut. We then ask fn_source for its .param_list(), which carries the invalid syntax for &mut u64 over.

[Veykril]

Macro expanded source lacks almost all whitespace because its not relevant in macro expansions. We need to fix the output up in the assist, there is some helper function for that somewhere but I forgot what its called.

[evertedsphere]

I can take a look in ide-assists.

[evertedsphere]

@rustbot claim

[evertedsphere]

The missing whitespace has been fixed by #16497; this assist should no longer produce invalid syntax (but the occurrence of self remains.)

[roife]

@rustbot claim