rust - precio - ¿Por qué la compilación no falla cuando se asigna un miembro de un valor movido?

rust tutorial

Question

Estoy trabajando a través de ejemplos en Rust by Example .

#[derive(Debug)]
struct Point {
x: f64,
y: f64,
}
#[derive(Debug)]
struct Rectangle {
p1: Point,
p2: Point,
}
fn main() {
let mut point: Point = Point { x: 0.3, y: 0.4 };
println!("point coordinates: ({}, {})", point.x, point.y);
let rectangle = Rectangle {
p1: Point { x: 1.0, y: 1.0 },
p2: point,
};
point.x = 0.5; // Why does the compiler not break here,
println!(" x is {}", point.x); // but it breaks here?
println!("rectangle is {:?} ", rectangle);
}

Me sale este error (Rust 1.25.0):

error[E0382]: use of moved value: `point.x`
--> src/main.rs:23:26
|
19 | p2: point,
| ----- value moved here
...
23 | println!(" x is {}", point.x);
| ^^^^^^^ value used here after move
|
= note: move occurs because `point` has type `Point`, which does not implement the `Copy` trait

Entiendo que di point al objeto Rectangle y es por eso que ya no puedo acceder a él, ¡pero por qué falla la compilación en el println! y no la tarea en la línea anterior?

Answer 1

El problema es que el compilador permite la reinicialización parcial de una estructura, pero la estructura completa no se puede usar después de eso. Esto sucede incluso si la estructura contiene un solo campo, e incluso si solo intenta leer el campo que acaba de reinicializar.

struct Test {
f: u32,
}
fn main() {
let mut t = Test { f: 0 };
let t1 = t;
t.f = 1;
println!("{}", t.f);
}

Esto se discute en el número 21232

Answer 2

Lo que realmente pasa

fn main() {
let mut point: Point = Point { x: 0.3, y: 0.4 };
println!("point coordinates: ({}, {})", point.x, point.y);
drop(point);
{
let mut point: Point;
point.x = 0.5;
}
println!(" x is {}", point.x);
}

Resulta que ya se conoce como el problema # 21232 .