New assist: Generate IndexMut implementation from Index implementation

[kpreid]

Given an existing core::ops::Index implementation, this assist would generate a copy of it where

• Index becomes IndexMut
• The method signature is updated
• & in the return value position in the function body (and perhaps other obviously-relevant positions) is replaced with &mut

For an example from the code I'm working on right now,

pub enum Axis { X = 0, Y = 1, Z = 2 }

impl<T> ops::Index<Axis> for [T; 3] {
    type Output = T;

    fn index(&self, index: Axis) -> &Self::Output {
        &self[index as usize]
    }
}

could be used to generate

impl<T> ops::IndexMut<Axis> for [T; 3] {
    fn index_mut(&mut self, index: Axis) -> &mut Self::Output {
        &mut self[index as usize]
    }
}

with no manual changes instead of 6. There might be other ref/mut trait pairs that could be assisted similarly, too.

[Veykril]

Borrow/BorrowMut, AsRef/AsMut come to mind here as well

[Young-Flash]

I'd like to have a try

@rustbot claim

[Young-Flash]

from

impl<T> ops::Index<Axis> for [T; 3] {
    type Output = T;

    fn index(&self, index: Axis) -> &Self::Output {
        &self[index as usize]
    }
}

to generate

impl<T> ops::IndexMut<Axis> for [T; 3] {
    fn index_mut(&mut self, index: Axis) -> &mut Self::Output {
        &mut self[index as usize]
    }
}

this example is simple and easy to achieve, just replace self with mut self, but this 'replace' way isn't generic, given the following example

struct Map {
    data: HashMap<String, i32>   
}

impl Index<String> for Map {
    type Output = i32;

    fn index(&self, key: String) -> &Self::Output {
        self.data.get(&key).unwrap()
    }
}

there should generate

impl IndexMut<String> for Map {
    fn index_mut(&mut self, key: String) -> &mut Self::Output {
        self.data.get_mut(&key).unwrap()
    }
}

there problem here is that the index_mut method body may various, so there isn't a way to deal with it generally. how about just generate index_mut method body with a todo!() ? any suggestion? @Veykril @kpreid

impl IndexMut<String> for Map {
    fn index_mut(&mut self, key: String) -> &mut Self::Output {
        todo!()
    }
}

[kpreid]

I think a good compromise would be to keep the Index body unchanged for IndexMut if no rules can automatically adapt it. It won't compile, but the user will probably know what to do. Placing todo!() would just make the user do the copy and paste themselves, to no particular benefit.

But there should definitely be a rewrite rule for &(...)[...] to &mut (...)[...], and perhaps other common cases. Just because the general problem is impossible doesn't mean the easy cases shouldn't be done; doing the easy cases is what assists are for.

[Young-Flash]

make a rewrite rule based on rust-analyzer internal api for unpredicable index body seems complicated. I'd like to make a PR which leave the Index body unchanged for IndexMut first, and leave the rest for further consideration.

[Veykril]

Can this be closed or is there something not yet covered in this issue?

[Young-Flash]

I think yes, will add other ref/mut trait pair next

[alibektas]

Can this be closed or is there something not yet covered in this issue?

The PR decided to leave some editing to the user as there wasn't a unified way to create IndexMut from Index. If you ask me we can add a simple routine which checks if Index uses self.array[index as u32] in its index function and if so translate it to &mut self.array.... I will do it so don't close it for now.