Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

A renamed body keeps its number: the next body does not take the freed name (#4957) (#5053)

vdirienzo92d1331978e4
diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs
index a027b1b862..5519439a1d 100644
--- a/crates/doc/src/document.rs
+++ b/crates/doc/src/document.rs
@@ -2419,6 +2419,12 @@ pub struct Document {
pub marker: Option<usize>,
#[serde(default)]
pub next_id: u64,
+ /// Body names the design used and must not use again: a name a `body.rename` freed (#4957).
+ /// The design's own counter starts over at every evaluation, so without these a design that
+ /// is evaluated again after a rename hands the freed name to the next body, and a script
+ /// that names a body finds another one.
+ #[serde(default, skip_serializing_if = "std::collections::BTreeSet::is_empty")]
+ pub reserved_body_names: std::collections::BTreeSet<String>,
/// Components below the root, as a tree (by parent).
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub components: Vec<Component>,
@@ -2665,6 +2671,7 @@ impl Document {
features: Vec::new(),
marker: None,
next_id: 1,
+ reserved_body_names: Default::default(),
components: Vec::new(),
occurrences: Vec::new(),
assembly: Default::default(),
@@ -2692,7 +2699,14 @@ impl Document {
/// Rename body `old` to `new` where the design keeps things by body name outside its
/// features: materials, appearances, configuration columns, offsets, components and the
/// browser's groups and order. (The features are the rename command's to change.)
+ ///
+ /// A name the design numbered (`Body1`) is not used again after the rename: the design's
+ /// counter starts over at every evaluation, so without this a design that is evaluated
+ /// again hands the freed name to the next body (#4957).
pub fn rename_body_keys(&mut self, old: &str, new: &str) {
+ if old.strip_prefix("Body").and_then(|n| n.parse::<usize>().ok()).is_some() {
+ self.reserved_body_names.insert(old.to_string());
+ }
if let Some(m) = self.materials.remove(old) {
self.materials.insert(new.to_string(), m);
}
diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rs
index fa9c82a045..e1d8a57ec1 100644
--- a/crates/doc/src/eval.rs
+++ b/crates/doc/src/eval.rs
@@ -716,6 +716,10 @@ pub struct ModelState {
/// Shared between states: a feature that does not change a sketch keeps it as it was.
pub sketches: Vec<Arc<SolvedSketch>>,
pub body_counter: usize,
+ /// Body names the design used and must not use again (a name a `body.rename` freed, #4957).
+ /// The counter starts over at every evaluation, so without these a design that is evaluated
+ /// again after a rename hands the freed name to the next body.
+ pub reserved_body_names: std::collections::BTreeSet<String>,
/// Sheet metal bodies (by body name) and their flat patterns.
pub sheets: Vec<crate::sheet::SheetBody>,
/// Construction planes, axes and points as evaluated (by feature).
@@ -751,6 +755,9 @@ impl ModelState {
self.sketch_keys.get(&s.feature).hash(&mut h);
}
self.body_counter.hash(&mut h);
+ for n in &self.reserved_body_names {
+ n.hash(&mut h);
+ }
for (feature, points) in &self.blend_edges {
feature.hash(&mut h);
for p in points {
@@ -1761,7 +1768,8 @@ impl Model {
let (vals, perr) = evaluation_values(doc);
self.param_errors = perr;
let mut prev_fp = 0u64;
- let mut state = self.empty.clone();
+ // The names the design must not use again travel with the state (#4957).
+ let mut state = std::sync::Arc::new(ModelState { reserved_body_names: doc.reserved_body_names.clone(), ..(*self.empty).clone() });
let mut out: Vec<FeatureResult> = Vec::with_capacity(doc.features.len());
let mut reuse = !self.no_cache;
let mut recomputed = 0;
@@ -1851,6 +1859,9 @@ impl Model {
recomputed += 1;
let t0 = now();
let mut next = (*state).clone();
+ // The names the design must not use again travel with the state (#4957): a state
+ // taken from an earlier evaluation may have been made before a rename freed one.
+ next.reserved_body_names = doc.reserved_body_names.clone();
for b in &mut next.bodies {
b.made = crate::lineage::Made::Before;
}
@@ -2028,6 +2039,8 @@ impl Model {
b.name = new.to_string();
b.names = b.names.renamed();
}
+ // The names the design must not use again travel with the state (#4957).
+ st.reserved_body_names = doc.reserved_body_names.clone();
Arc::new(st)
})
.clone();
@@ -2210,7 +2223,8 @@ fn new_name(state: &mut ModelState, f: &Feature, k: usize) -> String {
loop {
state.body_counter += 1;
let n = format!("Body{}", state.body_counter);
- if state.body(&n).is_none() {
+ // A name a rename freed is not handed out again (#4957).
+ if state.body(&n).is_none() && !state.reserved_body_names.contains(&n) {
return n;
}
}
diff --git a/crates/doc/src/format/pending/reserved-body-names.rs b/crates/doc/src/format/pending/reserved-body-names.rs
new file mode 100644
index 0000000000..287eb9f722
--- /dev/null
+++ b/crates/doc/src/format/pending/reserved-body-names.rs
@@ -0,0 +1,5 @@
+//! The design saves the body names a `body.rename` freed (`Body1` after the body it named was
+//! renamed), so a name the design used is not used again.
+//!
+//! A design saved before this has no such names: it keeps the names it has, and the next body
+//! it makes may take a name an earlier rename freed.
diff --git a/crates/doc/src/model_cache.rs b/crates/doc/src/model_cache.rs
index d2f0f732f2..2a9639bb37 100644
--- a/crates/doc/src/model_cache.rs
+++ b/crates/doc/src/model_cache.rs
@@ -181,6 +181,7 @@ impl Writer {
let sketches = st.sketches.iter().map(|s| self.sketch(s)).collect::<Option<Vec<_>>>()?;
let r = json!({
"bodies": runs(&bodies), "sketches": runs(&sketches), "body_counter": st.body_counter,
+ "reserved_body_names": st.reserved_body_names.iter().collect::<Vec<_>>(),
"sheets": serde_json::to_value(&st.sheets).ok()?, "construct": serde_json::to_value(&st.construct).ok()?,
"threads": serde_json::to_value(&st.threads).ok()?,
"sketch_keys": st.sketch_keys.iter().map(|(f, k)| json!([f, hex(*k)])).collect::<Vec<_>>(),
@@ -320,6 +321,11 @@ impl SavedModel {
bodies: ids("bodies", model_bodies.len())?.into_iter().filter_map(|i| model_bodies.get(i).cloned()).collect(),
sketches: ids("sketches", sketches.len())?.into_iter().filter_map(|i| sketches.get(i).cloned()).collect(),
body_counter: index(s.get("body_counter"), usize::MAX)?,
+ reserved_body_names: s
+ .get("reserved_body_names")
+ .and_then(Json::as_array)
+ .map(|a| a.iter().filter_map(|n| n.as_str().map(str::to_string)).collect())
+ .unwrap_or_default(),
sheets: serde_json::from_value(field("sheets")?).map_err(invalid)?,
construct: serde_json::from_value(field("construct")?).map_err(invalid)?,
threads: serde_json::from_value(field("threads")?).map_err(invalid)?,
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index f688ff47a1..e543ae9288 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -3587,6 +3587,36 @@ fn a_pattern_repeats_a_fillet_on_the_edges_it_found() {
assert!(rel(volume(&mut s), expect) < 1e-5, "{} vs {expect}", volume(&mut s));
}
+/// A body renamed after a join: the next new body does not take the name the rename freed
+/// (#4957). The join changed the body, so the rename is followed by a full evaluation of the
+/// design; the numbers the design handed out must not go back with it, or a script that names
+/// a body finds another one.
+#[test]
+fn a_renamed_body_keeps_its_number_from_the_next_body() {
+ for join in [false, true] {
+ let mut s = Session::default();
+ run(&mut s, "sketch.create", json!({"plane": "XY"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [10, 10]}));
+ run(&mut s, "sketch.finish", json!({}));
+ run(&mut s, "solid.extrude", json!({"distance": 5, "operation": "new"}));
+ if join {
+ // A second box joined to the first: the join changes the body, so the rename
+ // cannot be followed without evaluating the design again.
+ run(&mut s, "sketch.create", json!({"plane": "XY"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [5, 0], "p1": [15, 10]}));
+ run(&mut s, "sketch.finish", json!({}));
+ run(&mut s, "solid.extrude", json!({"distance": 5, "operation": "join"}));
+ }
+ run(&mut s, "body.rename", json!({"body": "Body1", "name": "First"}));
+ run(&mut s, "sketch.create", json!({"plane": "XY"}));
+ run(&mut s, "sketch.rectangle.two_point", json!({"p0": [20, 0], "p1": [30, 10]}));
+ run(&mut s, "sketch.finish", json!({}));
+ run(&mut s, "solid.extrude", json!({"distance": 5, "operation": "new"}));
+ let names: Vec<String> = s.model.state().bodies.iter().map(|b| b.name.clone()).collect();
+ assert_eq!(names, ["First", "Body2"], "with a join: {join}");
+ }
+}
+
/// A copy added by raising the count after a rename takes the next number, not the freed one (#372).
#[test]
fn raising_a_pattern_count_after_a_rename_numbers_the_new_copy_after_the_others() {