Início / coding / Perguntas / 77590672
Accepted
ChrisB
Asked: 2023-12-02 22:08:41 +0800 CST

Por que std::cell::Ref não usa uma referência em vez de NonNull?

  • 772

A std::cell::Refestrutura em Rust é definida da seguinte forma:

pub struct Ref<'b, T: ?Sized + 'b> {
    // NB: we use a pointer instead of `&'b T` to avoid `noalias` violations, because a
    // `Ref` argument doesn't hold immutability for its whole scope, only until it drops.
    // `NonNull` is also covariant over `T`, just like we would have with `&T`.
    value: NonNull<T>,
    borrow: BorrowRef<'b>,
}

O // NBcomentário (presumo Nota bene / Nasty Bug ou algo assim?) implica que a seguinte definição não funcionaria, porque seria uma noaliasviolação (eles se referem aos atributos LLVM no backend?):

pub struct Ref2<'b, T: ?Sized + 'b> {
    value: &'b T,
    borrow: BorrowRef<'b>,
}

Não entendo esse ponto, pois tive a impressão de que a semântica não lexical do tempo de vida foi devidamente preservada na geração de código. Caso contrário, o seguinte exemplo simples (que obviamente compila) também seria ilegal, certo?:

struct Foo<'a> {
    v: &'a i32,
}
fn foo(x: &mut i32) {
    let f = Foo { v: x };
    *x = 5; // value modified while the `noalias` f.v pointer is still in scope
}

Alguém com mais conhecimento sobre os internos poderia me esclarecer sobre isso? Temo estar entendendo mal algo crítico aqui, levando a possíveis problemas em meu próprio código inseguro.

rust

1 respostas

  1. Best Answer

    Os tempos de vida não lexicais nunca foram uma propriedade da geração de código. Eles eram puramente uma propriedade de verificação de empréstimo, e a verificação de empréstimo nunca afeta a geração de código.

    O exemplo que você forneceu não é ilegal de acordo com o LLVM. O problema é que noaliassó se manifesta com parâmetro de função, pois só eles recebem um noaliasatributo (pelo menos atualmente). Portanto, a única maneira de escrever um código problemático sem código inseguro será:

    fn foo(reference: &String, mut data: String) {
    // Do not use `reference` anymore here.
    
    // Write to data.
    data = String::new();
}

fn main() {
    let mut v = String::new();
    foo(&v, v);
}

    Exceto que não compila, porque você está movendo um arquivo v. Portanto, não havia como desencadear uma compilação incorreta.

    No RefCellentanto, podemos fazer isso:

    use std::cell::{RefCell, Ref};

fn foo<'a>(reference: Ref<'a, i32>, data: &'a RefCell<i32>) {
    drop(reference);
    // Do not use `reference` anymore here.
    
    *data.borrow_mut() = 0;
}

fn main() {
    let v = RefCell::new(0);
    foo(v.borrow(), &v);
}

    Qual seria LLVM UB se Refusasse uma referência.

    • 6

relate perguntas