Skip to content

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

Sheet metal rules: a design parameter named Thickness no longer overrides it (#9623) (#9633)

rugbymauri67c58cbd28d7
diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rs
index a605622ea5..48d452f817 100644
--- a/crates/doc/src/params.rs
+++ b/crates/doc/src/params.rs
@@ -9,6 +9,7 @@ use std::collections::{BTreeMap, BTreeSet};
use serde::{Deserialize, Serialize};
use crate::expr::{self, Expr, Kind, ParamDef, Value};
+use crate::sheet::rule_references;
use crate::walk::Walk;
use crate::{DocError, Document, FeatureKind, MAX_PARAMS, Result};
@@ -797,13 +798,14 @@ impl Document {
}
}
let uses = |e: &str| expr::references(e).iter().any(|r| r == name);
+ let rule_uses = |field: &str, e: &str| rule_references(field, e).iter().any(|r| r == name);
for r in &self.sheet.rules {
- for (field, _, _) in r.fields().into_iter().filter(|(_, e, _)| uses(e)) {
+ for (field, _, _) in r.fields().into_iter().filter(|(f, e, _)| rule_uses(f, e)) {
out.push(ParamUser::Rule { kind: "sheet metal".into(), name: r.name.clone(), field: field.into() });
}
}
for r in &self.plastic.rules {
- for (field, _, _) in r.fields().into_iter().filter(|(_, e, _)| uses(e)) {
+ for (field, _, _) in r.fields().into_iter().filter(|(f, e, _)| rule_uses(f, e)) {
out.push(ParamUser::Rule { kind: "plastic".into(), name: r.name.clone(), field: field.into() });
}
}
@@ -855,6 +857,21 @@ impl Document {
if self.name_taken(new) {
return Err(DocError::Invalid(format!("there is already a parameter `{new}`")));
}
+ // Outside a rule's own thickness, `Thickness` is the rule's thickness (#9623): renaming to
+ // it would turn those references into the rule's thickness and change their values.
+ if new == "Thickness" {
+ let uses_old = |field: &str, e: &str| field != "thickness" && expr::references(e).iter().any(|r| r == old);
+ let sheet = self.sheet.rules.iter().flat_map(|r| r.fields().into_iter().map(move |(f, e, _)| ("sheet metal", &r.name, f, e)));
+ let plastic = self.plastic.rules.iter().flat_map(|r| r.fields().into_iter().map(move |(f, e, _)| ("plastic", &r.name, f, e)));
+ let list: Vec<String> =
+ sheet.chain(plastic).filter(|(_, _, f, e)| uses_old(f, e)).map(|(kind, name, f, _)| format!("{kind} rule {name} ({f})")).collect();
+ if !list.is_empty() {
+ return Err(DocError::Invalid(format!(
+ "`{old}` can't be renamed to `Thickness`: {} would read the rule's thickness instead",
+ list.join(", ")
+ )));
+ }
+ }
let mut n = 0;
let text = self.text_param(old).is_some();
for p in &mut self.text_params {
@@ -964,7 +981,8 @@ impl Document {
}
// Sheet metal and plastic rules and canvas planes hold expressions too (#4420).
let rules = self.sheet.rules.iter_mut().flat_map(|r| r.fields_mut()).chain(self.plastic.rules.iter_mut().flat_map(|r| r.fields_mut()));
- for (_, e) in rules {
+ // `Thickness` outside a rule's own thickness is the rule's, not the parameter (#9623).
+ for (_, e) in rules.filter(|(field, _)| old != "Thickness" || *field == "thickness") {
let r = expr::rename_reference(e, old, new);
if r != *e {
*e = r;
@@ -1025,10 +1043,10 @@ impl Document {
}
// Sheet metal and plastic features rebuild when their rules' parameters change (#4420).
if f.kind.is_sheet() {
- names.extend(self.sheet.rules.iter().flat_map(|r| r.fields()).flat_map(|(_, e, _)| expr::references(e)));
+ names.extend(self.sheet.rules.iter().flat_map(|r| r.fields()).flat_map(|(f, e, _)| rule_references(f, e)));
}
if f.kind.is_plastic() {
- names.extend(self.plastic.rules.iter().flat_map(|r| r.fields()).flat_map(|(_, e, _)| expr::references(e)));
+ names.extend(self.plastic.rules.iter().flat_map(|r| r.fields()).flat_map(|(f, e, _)| rule_references(f, e)));
}
out.extend(names.into_iter().map(|n| (format!("Feature:{}", f.name), n)));
}
@@ -1052,9 +1070,9 @@ impl Document {
}
// A rule that uses it changes every sheet metal (or plastic) feature: the evaluation
// hashes the rules into their fingerprint.
- let uses = |e: &String| expr::references(e).iter().any(|r| affected.contains(r));
- let sheet = self.sheet.rules.iter().any(|r| r.fields().iter().any(|(_, e, _)| uses(e)));
- let plastic = self.plastic.rules.iter().any(|r| r.fields().iter().any(|(_, e, _)| uses(e)));
+ let uses = |field: &str, e: &str| rule_references(field, e).iter().any(|r| affected.contains(r));
+ let sheet = self.sheet.rules.iter().any(|r| r.fields().iter().any(|(f, e, _)| uses(f, e)));
+ let plastic = self.plastic.rules.iter().any(|r| r.fields().iter().any(|(f, e, _)| uses(f, e)));
let mut out = Vec::new();
for f in &self.features {
let mut hit = f.param_names.iter().any(|n| affected.contains(n));
diff --git a/crates/doc/src/plastic.rs b/crates/doc/src/plastic.rs
index 2645ddcc33..0500041a1b 100644
--- a/crates/doc/src/plastic.rs
+++ b/crates/doc/src/plastic.rs
@@ -167,7 +167,7 @@ impl Document {
return Err(DocError::Invalid("the plastic thickness must be positive".into()));
}
let with_t = |e: &str, k: Kind| -> Result<f64> {
- let f = |n: &str| if n == "Thickness" && !vals.contains_key("Thickness") { Ok(Value::length(t)) } else { look(n) };
+ let f = |n: &str| if n == "Thickness" { Ok(Value::length(t)) } else { look(n) };
let v = expr::eval_with(e, &f)?.to_kind(k)?;
if !v.is_finite() || v < 0.0 {
return Err(DocError::Invalid(format!("plastic rule `{}`: `{e}` must not be negative", r.name)));
diff --git a/crates/doc/src/sheet.rs b/crates/doc/src/sheet.rs
index f46b0e9a1a..6b4ac99b0e 100644
--- a/crates/doc/src/sheet.rs
+++ b/crates/doc/src/sheet.rs
@@ -284,6 +284,16 @@ impl SheetRule {
}
}
+/// The design parameters a rule's `field` expression `e` reads: outside the rule's own
+/// `thickness`, `Thickness` is the rule's thickness (sheet metal and plastic rules alike).
+pub fn rule_references(field: &str, e: &str) -> Vec<String> {
+ let mut names = expr::references(e);
+ if field != "thickness" {
+ names.retain(|n| n != "Thickness");
+ }
+ names
+}
+
fn rule_gap() -> String {
"Thickness".into()
}
@@ -464,7 +474,8 @@ impl Document {
.unwrap_or_else(SheetRule::steel)
}
- /// Evaluate a rule: `Thickness` in its expressions is the rule's thickness.
+ /// Evaluate a rule: `Thickness` in its expressions is the rule's thickness, even where the
+ /// design has a parameter of that name (#9623); only the rule's `thickness` itself reads it.
pub fn rule_values(&self, vals: &std::collections::BTreeMap<String, Value>, r: &SheetRule) -> Result<RuleValues> {
self.rule_values_at(vals, r, None)
}
@@ -481,7 +492,7 @@ impl Document {
return Err(DocError::Invalid("the sheet thickness must be more than 0 and less than 10000 mm".into()));
}
let with_t = |e: &str, k: Kind| -> Result<f64> {
- let f = |n: &str| if n == "Thickness" && !vals.contains_key("Thickness") { Ok(Value::length(t)) } else { look(n) };
+ let f = |n: &str| if n == "Thickness" { Ok(Value::length(t)) } else { look(n) };
expr::eval_with(e, &f)?.to_kind(k)
};
let v = RuleValues {
diff --git a/crates/engine/src/cmd/parameters_tests.rs b/crates/engine/src/cmd/parameters_tests.rs
index 210737840f..cdde63712b 100644
--- a/crates/engine/src/cmd/parameters_tests.rs
+++ b/crates/engine/src/cmd/parameters_tests.rs
@@ -257,6 +257,41 @@ fn rules_and_canvases_follow_a_renamed_parameter() {
assert_eq!(s.doc.sheet.rules[0].thickness, "gauge");
}
+/// #9623: outside a rule's own `thickness`, `Thickness` is the rule's thickness, not a design
+/// parameter of that name: renaming that parameter leaves it, and it doesn't count as a user.
+#[test]
+fn a_rules_own_thickness_is_not_a_parameter_named_thickness() {
+ let mut s = Session::default();
+ run(&mut s, "parameters.add", json!({"name": "Thickness", "expression": "2 mm"}));
+ run(&mut s, "sheet.manage_rules", json!({"name": "R", "thickness": "Thickness", "bend_radius": "Thickness", "active": true}));
+ run(&mut s, "plastic.manage_rules", json!({"name": "Housing", "thickness": "3 mm", "clearance": "Thickness / 10"}));
+ let u = run(&mut s, "parameters.users", json!({"name": "Thickness"}));
+ let fields: Vec<String> = u["users"].as_array().unwrap().iter().map(|x| x.to_string()).collect();
+ assert_eq!(fields.len(), 1, "only the sheet metal rule's thickness: {u}");
+ run(&mut s, "parameters.rename", json!({"name": "Thickness", "new_name": "Gauge"}));
+ let r = &s.doc.sheet.rules[0];
+ assert_eq!((r.thickness.as_str(), r.bend_radius.as_str(), r.gap.as_str()), ("Gauge", "Thickness", "Thickness"));
+ let housing = s.doc.plastic.rules.iter().find(|r| r.name == "Housing").unwrap();
+ assert_eq!(housing.clearance, "Thickness / 10");
+}
+
+/// #9623: renaming a parameter to `Thickness` is refused while a rule field other than its own
+/// thickness uses it (that field would then read the rule's thickness), and nothing changes.
+#[test]
+fn renaming_to_thickness_is_refused_where_a_rule_would_read_its_own() {
+ let mut s = Session::default();
+ run(&mut s, "parameters.add", json!({"name": "Factor", "expression": "0.3", "unit": ""}));
+ run(&mut s, "parameters.add", json!({"name": "Gauge", "expression": "2 mm"}));
+ run(&mut s, "sheet.manage_rules", json!({"name": "R", "thickness": "Gauge", "k_factor": "Factor", "active": true}));
+ let before = s.doc.clone();
+ let e = err(&mut s, "parameters.rename", json!({"name": "Factor", "new_name": "Thickness"}));
+ assert!(e.contains("sheet metal rule R (k_factor)"), "{e}");
+ assert!(s.doc == before, "a refused rename changes nothing");
+ // Used only by a rule's own thickness, the rename goes through.
+ run(&mut s, "parameters.rename", json!({"name": "Gauge", "new_name": "Thickness"}));
+ assert_eq!((s.doc.sheet.rules[0].thickness.as_str(), s.doc.sheet.rules[0].k_factor.as_str()), ("Thickness", "Factor"));
+}
+
#[test]
fn favorites_comments_and_completion() {
let mut s = Session::default();
diff --git a/crates/engine/src/cmd/plastic.rs b/crates/engine/src/cmd/plastic.rs
index f2daa1667d..d5afad1261 100644
--- a/crates/engine/src/cmd/plastic.rs
+++ b/crates/engine/src/cmd/plastic.rs
@@ -594,6 +594,26 @@ mod tests {
assert!(s.execute("plastic.assign_rule", &json!({"bodies": ["Nope"], "rule": "Thick ABS"})).is_err());
}
+ /// #9623: `Thickness` in a rule's expressions is the rule's thickness, also when the design
+ /// has a parameter of that name; the rule's own `thickness` may still use that parameter.
+ #[test]
+ fn thickness_in_a_plastic_rule_is_the_rules_even_beside_a_parameter_of_that_name() {
+ let values = |param: Option<&str>, thickness: &str| -> Value {
+ let mut s = Session::default();
+ if let Some(e) = param {
+ run(&mut s, "parameters.add", json!({"name": "Thickness", "expression": e}));
+ }
+ run(&mut s, "plastic.manage_rules", json!({"name": "Thick ABS", "thickness": thickness, "clearance": "Thickness / 10"}))["rule"]["values"]
+ .clone()
+ };
+ let want = values(None, "3 mm");
+ assert_eq!((want["thickness"].as_f64(), want["nominal_radius"].as_f64()), (Some(3.0), Some(1.5)), "{want}");
+ assert!(want["clearance"].as_f64().is_some_and(|c| (c - 0.3).abs() < 1e-12), "{want}");
+ assert!(want["thickness_variation"].as_f64().is_some_and(|v| (v - 0.45).abs() < 1e-12), "{want}");
+ assert_eq!(values(Some("10 mm"), "3 mm"), want);
+ assert_eq!(values(Some("3 mm"), "Thickness"), want);
+ }
+
#[test]
fn groove_takes_the_rule_clearance() {
let mut g = Session::default();
diff --git a/crates/engine/src/cmd/sheet_tests.rs b/crates/engine/src/cmd/sheet_tests.rs
index 2c7612ba01..6275d804b1 100644
--- a/crates/engine/src/cmd/sheet_tests.rs
+++ b/crates/engine/src/cmd/sheet_tests.rs
@@ -546,6 +546,47 @@ fn a_refused_rule_names_the_value_at_fault() {
run(&mut s, "sheet.manage_rules", json!({"name": "R", "thickness": 2, "bend_radius": 0}));
}
+/// #9623: `Thickness` in a rule's expressions is the rule's thickness, also when the design has a
+/// parameter of that name; the rule's own `thickness` may still use that parameter.
+#[test]
+fn thickness_in_a_rule_is_the_rules_even_beside_a_parameter_of_that_name() {
+ fn build(param: Option<&str>, rule: Value) -> (Value, f64) {
+ let mut s = Session::default();
+ if let Some(e) = param {
+ run(&mut s, "parameters.add", json!({"name": "Thickness", "expression": e}));
+ }
+ run(&mut s, "sheet.manage_rules", rule);
+ base(&mut s, 100.0, 50.0);
+ let t = s.model.state().sheets[0].t;
+ run(&mut s, "sheet.flange", json!({"edges": [[50, 0, t], [100, 25, t]], "height": 20}));
+ let failing: Vec<String> = s.model.results.iter().filter_map(|r| r.error.clone()).collect();
+ assert!(failing.is_empty(), "{failing:?}");
+ let l = run(&mut s, "sheet.rules", json!({}));
+ let values = l["rules"].as_array().and_then(|r| r.iter().find(|r| r["rule"]["name"] == "R")).map(|r| r["values"].clone()).unwrap_or_default();
+ (values, volume(&mut s))
+ }
+ let rule = json!({"name": "R", "thickness": 2, "k_factor": 0.5, "bend_radius": 2, "corner_relief_shape": "round", "active": true});
+ let (want, v) = build(None, rule.clone());
+ for (k, x) in [("thickness", 2.0), ("gap", 2.0), ("relief_width", 2.0), ("relief_depth", 1.0), ("corner_relief", 8.0), ("bend_radius", 2.0)] {
+ assert_eq!(want[k].as_f64(), Some(x), "{k}: {want}");
+ }
+ assert!(rel(v, 14651.157) < 1e-4, "{v}");
+ let (got, w) = build(Some("10 mm"), rule);
+ assert_eq!(got, want);
+ assert!(rel(w, v) < 1e-9, "{w} against {v}");
+ // A bend radius of `Thickness` is the rule's 2 mm, not the parameter's 10.
+ let rule = json!({"name": "R", "thickness": 2, "k_factor": 0.5, "bend_radius": "Thickness", "corner_relief_shape": "round", "active": true});
+ let (got, w) = build(Some("10 mm"), rule);
+ assert_eq!(got, want);
+ assert!(rel(w, v) < 1e-9, "{w} against {v}");
+ // The rule's thickness itself reads the design's `Thickness`, and the rest follow it.
+ let rule =
+ json!({"name": "R", "thickness": "Thickness", "k_factor": 0.5, "bend_radius": "Thickness", "corner_relief_shape": "round", "active": true});
+ let (got, w) = build(Some("2 mm"), rule);
+ assert_eq!(got, want);
+ assert!(rel(w, v) < 1e-9, "{w} against {v}");
+}
+
#[test]
fn contour_flange_hem_and_tray() {
// Oracle 72.