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

[roife]

I have fixed both the second problem (*self should be *this) as well as the third one.

For the third question, the problem also lies in the expansion of macro. Should we assume an indent setting of 4 spaces when expanding macros for the third question? (Currently it is set to 2 spaces.) If we change it, it will affect other test cases which involving macro expansions.

[lnicola]

Currently it is set to 2 spaces

I hate that 😅.

[Veykril]

r-a currently assumes an indentation of 4 spaces for everything so that is fine

[antonilol]

got this bug again (rust-analyzer version: 0.4.1951-standalone)

inlining all in

let _ = [].iter().all(|&a: &i32| a == 2);

gives this:

let _ = {
    let this = &mut [].iter();
    let mutf = |&a: &i32| a == 2;
    while let Some(x) = self.next(){
        if!f(x){
            return false;
        }
    }true
};

let mutf = ... should be let mut f = ..., i thought the missing space was fixed because it is in the hash example (see issue post)

also, the return statement now tries to return from main (see #15471)