O que “não pode pedir emprestado como imutável porque também é emprestado como mutável” significa em um índice de matriz aninhada?

O que o erro significa neste caso:

fn main() {
    let mut v: Vec<usize> = vec![1, 2, 3, 4, 5];
    v[v[1]] = 999;
}

error[E0502]: cannot borrow `v` as immutable because it is also borrowed as mutable
 --> src/main.rs:3:7
  |
3 |     v[v[1]] = 999;
  |     --^----
  |     | |
  |     | immutable borrow occurs here
  |     mutable borrow occurs here
  |     mutable borrow later used here

Eu descobri que a indexação é implementada via IndexeIndexMut características e que v[1]é açúcar sintático para *v.index(1). Equipado com esse conhecimento, tentei executar o seguinte código:

use std::ops::{Index, IndexMut};

fn main() {
    let mut v: Vec<usize> = vec![1, 2, 3, 4, 5];
    *v.index_mut(*v.index(1)) = 999;
}

Para minha surpresa, isso funciona perfeitamente! Por que o primeiro trecho não funciona, mas o segundo funciona? Do jeito que eu entendo a documentação, eles devem ser equivalentes, mas isso obviamente não é o caso.

A versão sugerida é um pouco diferente do que você tem. A linha

v[v[1]] = 999;

realmente desugars para

*IndexMut::index_mut(&mut v, *Index::index(&v, 1)) = 999;

Isso resulta na mesma mensagem de erro, mas as anotações dão uma dica do que está acontecendo:

error[E0502]: cannot borrow `v` as immutable because it is also borrowed as mutable
 --> src/main.rs:7:48
  |
7 |     *IndexMut::index_mut(&mut v, *Index::index(&v, 1)) = 999;
  |      ------------------- ------                ^^ immutable borrow occurs here
  |      |                   |
  |      |                   mutable borrow occurs here
  |      mutable borrow later used by call

A diferença importante para sua versão desejada é a ordem de avaliação. Os argumentos de uma chamada de função são avaliados da esquerda para a direita na ordem listada, antes de realmente fazer a chamada de função. Nesse caso, isso significa que primeiro &mut vé avaliado, mutuamente emprestado v. Em seguida, Index::index(&v, 1)deve ser avaliado, mas isso não é possível -v já é mutuamente emprestado. Finalmente, o compilador mostra que a referência mutável ainda é necessária para a chamada de função index_mut(), portanto, a referência mutável ainda está ativa quando a referência compartilhada é tentada.

A versão que realmente compila tem uma ordem de avaliação ligeiramente diferente.

*v.index_mut(*v.index(1)) = 999;

Primeiro, os argumentos da função para as chamadas do método são avaliados da esquerda para a direita, ou seja, *v.index(1)são avaliados primeiro. Isso resulta em usizeae o empréstimo compartilhado temporário de vpode ser liberado novamente. Então, o receptor de index_mut()é avaliado, ou seja,v é mutuamente emprestado. Isso funciona bem, pois o empréstimo compartilhado já foi finalizado e toda a expressão passa no verificador de empréstimo.

Observe que a versão que compila apenas o faz desde a introdução de "vidas úteis não-lexicais". Nas versões anteriores do Rust, o empréstimo compartilhado permaneceria até o final da expressão e resultaria em um erro semelhante.

A solução mais limpa na minha opinião é usar uma variável temporária:

let i = v[1];
v[i] = 999;