From bc4d35b0977d2f2c15df4297b91239e02b10bddd Mon Sep 17 00:00:00 2001 From: Colin Faulkingham Date: Sun, 1 Nov 2026 12:15:47 +0000 Subject: [PATCH] Avoid rebuilding bodies when rename updates feature references (#6287) (#10588) * claim: #6287 * fix: reuse body geometry when renaming references (#6287) --- crates/doc/src/document.rs | 12 +++++- crates/engine/src/cmd/browser.rs | 73 +++++++++++++++++++++++++++++++- crates/engine/src/tests.rs | 9 ++-- 3 files changed, 87 insertions(+), 7 deletions(-) diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs index 696881ae3..42667471f 100644 --- a/crates/doc/src/document.rs +++ b/crates/doc/src/document.rs @@ -3164,8 +3164,8 @@ impl Document { /// The single body rename (old name, new name) that turns `previous` into this design, /// when that is all that changed: the features' stored body names (`made` gives the names - /// each feature's bodies have now, by feature id) and what [`Document::rename_body_keys`] - /// renames. `None` for any other change. + /// each feature's bodies have now, by feature id), typed body references, participants and + /// what [`Document::rename_body_keys`] renames. `None` for any other change. pub fn body_rename_from(&self, previous: &Document, made: impl Fn(u64) -> Vec) -> Option<(String, String)> { if self.features.len() != previous.features.len() { return None; @@ -3196,8 +3196,16 @@ impl Document { } let (old, new) = rename?; let mut expected = previous.clone(); + let bodies = std::collections::BTreeMap::from([(old.clone(), new.clone())]); for (f, g) in expected.features.iter_mut().zip(&self.features) { f.body_names.clone_from(&g.body_names); + // Updating references to the renamed body changes no feature input other than its + // name (#6287). Keep the full comparison below: geometry, expressions, sketch links + // and face anchors must still agree before the model may reuse its geometry. + f.kind.remap_bodies(&bodies); + for body in f.participants.iter_mut().filter(|body| **body == old) { + body.clone_from(&new); + } } expected.rename_body_keys(&old, &new); (expected == *self).then_some((old, new)) diff --git a/crates/engine/src/cmd/browser.rs b/crates/engine/src/cmd/browser.rs index 685f961d5..39e6d4b28 100644 --- a/crates/engine/src/cmd/browser.rs +++ b/crates/engine/src/cmd/browser.rs @@ -1802,7 +1802,9 @@ mod tests { run(&mut s, "solid.box", json!({"length": 5, "width": 5, "height": 5, "corner": [20, 0, 0], "operation": "new", "body_name": "Tab"})); run(&mut s, "solid.combine", json!({"target": "A", "tools": ["Tab"], "operation": "join", "name": "Joined"})); let want = total(&mut s); + s.evaluations = 0; run(&mut s, "body.rename", json!({"body": "A", "name": "B"})); + assert_eq!(s.evaluations, 0, "renaming primitive participants changes no geometry"); assert!( s.model.results.iter().all(|r| r.error.is_none()), "{:?}", @@ -1812,6 +1814,7 @@ mod tests { assert!((total(&mut s) - want).abs() < 1e-6); run(&mut s, "edit.undo", json!({})); assert_eq!(s.doc.find_feature("Hole").unwrap().participants, vec!["A".to_string()]); + assert_eq!(s.evaluations, 0); } /// #1109: renaming counted bodies (`Body1`, `Body2` of one pattern) leaves the counted bodies @@ -1875,14 +1878,80 @@ mod tests { assert_eq!(names(&s), vec!["Plate".to_string(), "B".to_string()]); assert_eq!(s.evaluations, 0, "undo and redo of a rename evaluate nothing"); assert_eq!(meshes(&s), shown); - // A body a later feature uses is renamed in that feature too: that is evaluated. + // A later feature's body reference follows the rename without rebuilding geometry. run(&mut s, "solid.combine", json!({"target": "Plate", "tools": ["B"], "operation": "join", "keep_tools": true})); + let shown = meshes(&s); s.evaluations = 0; run(&mut s, "body.rename", json!({"body": "B", "name": "Tool"})); - assert!(s.evaluations > 0); + assert_eq!(s.evaluations, 0); + assert_eq!(meshes(&s), shown); assert!(names(&s).contains(&"Tool".to_string())); } + /// #6287: one rename in a timeline of named body references used to rebuild every feature + /// and replace every mesh, including the other bodies' meshes. + #[test] + fn renaming_a_body_with_downstream_references_keeps_every_mesh() { + let mut s = Session::default(); + for i in 0..18 { + run( + &mut s, + "solid.box", + json!({"length": 40, "width": 30, "height": 10, "center": [50 * i, 0, 0], "operation": "new", "body_name": format!("Block{i}")}), + ); + } + for _ in 0..2 { + for i in 0..18 { + run(&mut s, "solid.move", json!({"bodies": [format!("Block{i}")], "translate": [0, 5, 0]})); + } + } + assert_eq!(s.doc.features.len(), 54); + let meshes = |s: &Session| s.model.state().bodies.iter().map(|b| b.mesh()).collect::>(); + let looks = |s: &Session| { + s.model.state().bodies.iter().map(|b| (b.name.clone(), (*solidcraft_doc::naming::face_names(b)).clone())).collect::>() + }; + let shown = meshes(&s); + let before = looks(&s); + let measurements = run(&mut s, "inspect.measure", json!({}))["total"].clone(); + assert!((measurements["volume_mm3"].as_f64().unwrap() - 216_000.0).abs() < 1e-6); + s.evaluations = 0; + run(&mut s, "body.rename", json!({"body": "Block0", "name": "Bracket"})); + assert_eq!(s.evaluations, 0, "renaming references must not evaluate the timeline"); + let after = looks(&s); + assert_eq!(after[0].0, "Bracket"); + let mut fresh = Session::new((*s.doc).clone()); + fresh.refresh(); + assert_eq!(looks(&fresh), after, "the same bodies and face names as rebuilding"); + assert_eq!(run(&mut fresh, "inspect.measure", json!({}))["total"], measurements); + run(&mut s, "edit.undo", json!({})); + assert_eq!(looks(&s), before); + run(&mut s, "edit.redo", json!({})); + assert_eq!(looks(&s), after); + assert_eq!(s.evaluations, 0, "undo and redo must also retain the evaluated model"); + assert!(shown.iter().zip(meshes(&s)).all(|(a, b)| std::sync::Arc::ptr_eq(a, &b)), "every body retains its display mesh"); + } + + #[test] + fn a_body_rename_with_changed_dimensions_still_evaluates() { + let mut s = Session::default(); + run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 10, "body_name": "Block"})); + run(&mut s, "solid.move", json!({"bodies": ["Block"], "translate": [5, 0, 0]})); + let before = s.doc.clone(); + let model = s.model.clone(); + run(&mut s, "body.rename", json!({"body": "Block", "name": "Bracket"})); + // An outside edit can include a rename and a geometry change together. It must not + // take the rename shortcut merely because the later Move's body reference matches. + let solidcraft_doc::FeatureKind::Box { height, .. } = &mut s.doc_mut().features[0].kind else { panic!("expected the box") }; + *height = "20".into(); + s.model = model; + s.evaluations = 0; + s.refresh_from(&before, false); + assert_eq!(s.evaluations, 1); + assert_eq!(names(&s), ["Bracket"]); + let volume = run(&mut s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap(); + assert!((volume - 24_000.0).abs() < 1e-6, "the changed height must be evaluated: {volume}"); + } + #[test] fn renaming_a_body_leaves_other_text_with_its_name_alone() { let mut s = Session::default(); diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 540f634df..e689a8ff8 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -4516,10 +4516,10 @@ fn renaming_a_body_later_features_change_evaluates_nothing() { assert_eq!(s.evaluations, 0, "nor do its undo and redo"); } -/// A body whose name later bodies' names are worked out from (`X` patterned into `X (2)`) is still -/// renamed by evaluating the design, so the copies follow it as they would on opening it. +/// A body whose name later bodies' names are worked out from (`X` patterned into `X (2)`) keeps +/// the same copies and face names as opening the renamed design. #[test] -fn renaming_a_body_whose_copies_take_its_name_evaluates_the_design() { +fn renaming_a_body_keeps_its_copies_consistent_with_rebuilding() { let mut s = Session::default(); run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "X"})); run(&mut s, "solid.pattern.rectangular", json!({"bodies": ["X"], "dir1": [1, 0, 0], "count1": 3, "spacing1": 20})); @@ -4529,6 +4529,9 @@ fn renaming_a_body_whose_copies_take_its_name_evaluates_the_design() { let mut fresh = Session::new((*s.doc).clone()); fresh.refresh(); assert_eq!(names(&fresh), names(&s)); + for (a, b) in fresh.model.state().bodies.iter().zip(&s.model.state().bodies) { + assert_eq!(solidcraft_doc::naming::face_names(a), solidcraft_doc::naming::face_names(b)); + } } /// #3044: on a design with thousands of bodies the cheap commands stay cheap: showing, hiding,