diff --git a/crates/doc/src/params.rs b/crates/doc/src/params.rs index a605622ea..48d452f81 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 = + 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 2645ddcc3..0500041a1 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 { - 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 f46b0e9a1..6b4ac99b0 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 { + 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, r: &SheetRule) -> Result { 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 { - 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 210737840..cdde63712 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 = 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 f2daa1667..d5afad126 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 2c7612ba0..6275d804b 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 = 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.