* claim: #8865 * parameters.add: a parameter with no unit takes the design's units (#8865) A new parameter given no unit took "mm" for any length or bare number, so in an inch design `parameters.add {name: v, expression: "40/2"}` made a 20 mm parameter where the Parameters dialog makes 20 in. The unit a new parameter infers is now a length in the design's units (mm designs are unchanged); parameters.change on a new name and parameters.import share the same inference. Angles and unit-less values keep their units. A definition typed into a value of no fixed kind (a coupling's pitch, a joint's value) still reads its bare number as millimetres, as that field does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
207 lines
9.3 KiB
Rust
207 lines
9.3 KiB
Rust
//! Values typed as definitions, `name = expression` (#4071): any value input, typed or sent as
|
|
//! a command's parameter, can name its value. Until the design stores it, such a text evaluates
|
|
//! as its expression (`expr::definition`), so a command reads and checks it like any other value;
|
|
//! [`Document::define_inline`] then makes the user parameter `name` with that expression and
|
|
//! leaves `name` where the text was.
|
|
|
|
use serde::Serialize;
|
|
|
|
use crate::expr::{self, Kind};
|
|
use crate::params::ExprRole;
|
|
use crate::walk::Walk;
|
|
use crate::{DocError, Document, FeatureKind, Result};
|
|
|
|
/// A user parameter a value typed as `name = expression` defined.
|
|
#[derive(Clone, Debug, PartialEq, Serialize)]
|
|
pub struct Defined {
|
|
pub name: String,
|
|
pub expression: String,
|
|
pub unit: String,
|
|
}
|
|
|
|
/// How the place a definition was typed in reads a bare number, which the parameter keeps.
|
|
#[derive(Clone, Copy)]
|
|
enum Reads<'a> {
|
|
/// A typed value of this kind: lengths in the design's units, angles in degrees.
|
|
Typed(Kind),
|
|
/// A model parameter's (a dimension's) own unit.
|
|
Unit(&'a str),
|
|
/// A primitive's placement coordinate: millimetres whatever the design's units.
|
|
Millimetres,
|
|
/// A value of no fixed kind: the parameter takes its value's unit.
|
|
Inferred,
|
|
}
|
|
|
|
/// A definition found: the name, its expression and its unit (`None`: its value's own).
|
|
struct Pending {
|
|
name: String,
|
|
expression: String,
|
|
unit: Option<String>,
|
|
}
|
|
|
|
/// The definitions found so far: each slot's text becomes the name, the definition is kept.
|
|
struct Found {
|
|
units: String,
|
|
defs: Vec<Pending>,
|
|
problem: Option<String>,
|
|
}
|
|
|
|
impl Found {
|
|
/// If `text` is a definition, note it and leave the name in its place.
|
|
fn take(&mut self, text: &mut String, reads: Reads) {
|
|
let Some((name, rhs)) = expr::definition(text) else { return };
|
|
if rhs.is_empty() {
|
|
self.problem.get_or_insert_with(|| format!("`{name} =` needs a value after the `=`"));
|
|
return;
|
|
}
|
|
let (expression, unit) = match reads {
|
|
Reads::Typed(Kind::Length) => {
|
|
let units = expr::length_unit_or_mm(&self.units);
|
|
(with_unit(rhs, units), Some(units.to_string()))
|
|
}
|
|
Reads::Typed(Kind::Angle) => (rhs.to_string(), Some("deg".to_string())),
|
|
Reads::Typed(Kind::Unitless) => (rhs.to_string(), Some(String::new())),
|
|
Reads::Unit(u) => (rhs.to_string(), Some(u.to_string())),
|
|
Reads::Millimetres => (rhs.to_string(), Some("mm".to_string())),
|
|
Reads::Inferred => (rhs.to_string(), None),
|
|
};
|
|
let name = name.to_string();
|
|
match self.defs.iter().find(|d| d.name == name) {
|
|
// The same definition in two places (one typed value a command stores twice).
|
|
Some(d) if d.expression == expression && d.unit == unit => {}
|
|
Some(_) => {
|
|
self.problem.get_or_insert_with(|| format!("`{name}` is defined twice with different values"));
|
|
return;
|
|
}
|
|
None => self.defs.push(Pending { name: name.clone(), expression, unit }),
|
|
}
|
|
*text = name;
|
|
}
|
|
|
|
/// [`Found::take`] for an expression field.
|
|
fn take_expr(&mut self, e: &mut expr::Expr, reads: Reads) {
|
|
if expr::definition(e.as_str()).is_none() {
|
|
return;
|
|
}
|
|
let mut text = e.as_str().to_string();
|
|
self.take(&mut text, reads);
|
|
*e = text.into();
|
|
}
|
|
}
|
|
|
|
/// A bare number in the design's length unit, as a typed length reads it.
|
|
fn with_unit(rhs: &str, units: &str) -> String {
|
|
if units != "mm" && expr::is_bare_number(rhs) { format!("{} {units}", rhs.trim()) } else { rhs.to_string() }
|
|
}
|
|
|
|
impl Document {
|
|
/// Store every value typed as `name = expression`: the user parameter `name` with that
|
|
/// expression (a bare number read as the value would read it, in that unit), and `name`
|
|
/// where the text was. A name that is taken or reserved is refused, as is a definition where
|
|
/// none can be made: in a parameter's own expression or a configuration cell. All or nothing:
|
|
/// on an error the design is unchanged.
|
|
pub fn define_inline(&mut self) -> Result<Vec<Defined>> {
|
|
// Where a definition is refused: a parameter's expression defines nothing else (the
|
|
// parameters command renames the parameter instead), nor does a configuration row.
|
|
if let Some(p) = self.params.iter().find(|p| !p.model && expr::definition(&p.expr).is_some()) {
|
|
let other = expr::definition(&p.expr).map(|(n, _)| n).unwrap_or_default();
|
|
return Err(DocError::Invalid(format!(
|
|
"the expression of `{}` cannot define another parameter `{other}`: add `{other}` as a parameter of its own",
|
|
p.name
|
|
)));
|
|
}
|
|
// Only a parameter's cells are expressions (a text parameter's are texts).
|
|
let numeric: Vec<bool> =
|
|
self.configs.columns.iter().map(|c| matches!(c, crate::config::Column::Param(n) if self.text_param(n).is_none())).collect();
|
|
let mut cells = self.configs.rows.iter().flat_map(|r| r.cells.iter().zip(&numeric).filter(|(_, n)| **n).map(|(c, _)| c));
|
|
if let Some(other) = cells.find_map(|c| expr::definition(c).map(|(n, _)| n)) {
|
|
return Err(DocError::Invalid(format!("a configuration cell cannot define the parameter `{other}`: add it in Parameters first")));
|
|
}
|
|
let mut next = self.clone();
|
|
let mut found = Found { units: next.units.clone(), defs: Vec::new(), problem: None };
|
|
for p in next.params.iter_mut().filter(|p| p.model) {
|
|
let unit = p.unit.clone();
|
|
found.take(&mut p.expr, Reads::Unit(&unit));
|
|
}
|
|
for f in &mut next.features {
|
|
f.kind.walk_exprs_mut(&mut |(_, e, kind, role)| {
|
|
let reads = if role == ExprRole::Placement { Reads::Millimetres } else { Reads::Typed(kind) };
|
|
found.take_expr(e, reads);
|
|
});
|
|
if let FeatureKind::Sketch { sketch, .. } = &mut f.kind {
|
|
for p in &mut sketch.patterns {
|
|
if let Some(e) = p.count_expression.as_mut() {
|
|
found.take(e, Reads::Typed(Kind::Unitless));
|
|
}
|
|
for (key, e) in &mut p.expressions {
|
|
let kind = match key.as_str() {
|
|
"count" | "count2" => Kind::Unitless,
|
|
"angle" => Kind::Angle,
|
|
_ => Kind::Length,
|
|
};
|
|
found.take(e, Reads::Typed(kind));
|
|
}
|
|
}
|
|
for link in &mut sketch.links {
|
|
if let solidcraft_sketch::LinkSource::Text { exprs, .. } = &mut link.source {
|
|
for e in [&mut exprs.x, &mut exprs.y, &mut exprs.height].into_iter().flatten() {
|
|
found.take(e, Reads::Typed(Kind::Length));
|
|
}
|
|
if let Some(e) = exprs.angle.as_mut() {
|
|
found.take(e, Reads::Typed(Kind::Angle));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for e in next.assembly.exprs_mut() {
|
|
found.take(e, Reads::Inferred);
|
|
}
|
|
for r in &mut next.sheet.rules {
|
|
let kinds = r.fields().map(|(_, _, k)| k);
|
|
for ((_, e), k) in r.fields_mut().into_iter().zip(kinds) {
|
|
found.take(e, Reads::Typed(k));
|
|
}
|
|
}
|
|
for r in &mut next.plastic.rules {
|
|
let kinds = r.fields().map(|(_, _, k)| k);
|
|
for ((_, e), k) in r.fields_mut().into_iter().zip(kinds) {
|
|
found.take(e, Reads::Typed(k));
|
|
}
|
|
}
|
|
for c in &mut next.canvases {
|
|
c.plane.walk_exprs_mut(&mut |(_, e, kind, _)| found.take_expr(e, Reads::Typed(kind)));
|
|
}
|
|
if let Some(problem) = found.problem {
|
|
return Err(DocError::Invalid(problem));
|
|
}
|
|
if found.defs.is_empty() {
|
|
return Ok(Vec::new());
|
|
}
|
|
for d in &found.defs {
|
|
if let Some(problem) = Self::param_name_problem(&d.name) {
|
|
return Err(DocError::Invalid(problem));
|
|
}
|
|
if self.name_taken(&d.name) {
|
|
return Err(DocError::Invalid(format!(
|
|
"there is already a parameter `{}`: type `{}` to use it, or change it in Parameters",
|
|
d.name, d.name
|
|
)));
|
|
}
|
|
}
|
|
let mut out = Vec::with_capacity(found.defs.len());
|
|
for d in found.defs {
|
|
// A value of no fixed kind (a joint's) is evaluated without the design's units, so
|
|
// its bare number stays a millimetre length whatever they are (#8865): `w = 5` is
|
|
// what `5` is there.
|
|
let unit = d.unit.unwrap_or_else(|| Self::infer_unit_in(&next.param_values().0, &d.expression, "mm"));
|
|
next.add_user_param(&d.name, &d.expression, Some(&unit), None)
|
|
.map_err(|e| DocError::Invalid(format!("`{} = {}`: {e}", d.name, d.expression)))?;
|
|
let unit = next.param(&d.name).map(|p| p.unit.clone()).unwrap_or_default();
|
|
out.push(Defined { name: d.name, expression: d.expression, unit });
|
|
}
|
|
*self = next;
|
|
Ok(out)
|
|
}
|
|
}
|