solid.cylinder, box, sphere, torus and coil place by expressions: base, corner and center take numbers or length expressions per coordinate ("basin_width/2", "10 mm") and follow parameter changes, renames and component frames; before, a point that was not three plain numbers (or an unreadable axis) was silently replaced by the origin (or Z). The features now store the point as expressions (plain numbers still saved as numbers, so existing designs read and write the same) and evaluate it on every recompute; an unreadable or out-of-range point or axis is refused with an error. Tests: primitive points take expressions, follow parameters, renames and a moved component, and bad points are refused

crates/doc/src/assembly.rs

@@ -164,6 +164,39 @@ fn map_geo_ref(m: &Mat, g: &mut crate::construct::GeoRef) {
     g.map_points(&mut |p: &mut Vec3| *p = apply_point(m, *p), &mut |pl: &mut PlaneRef| map_plane_ref(m, pl));
 }
 
+/// Map a point given as expressions by `m`: numbers stay numbers; a coordinate that is an
+/// expression stays one (`m · (x, y, z) + t`, written out), so it still follows its parameters.
+pub fn map_point_expr(m: &Mat, p: &mut crate::PointExpr) {
+    let num = |e: &String| e.trim().parse::<f64>().ok().filter(|v| v.is_finite());
+    if let [Some(x), Some(y), Some(z)] = [num(&p[0]), num(&p[1]), num(&p[2])] {
+        *p = crate::point_expr(apply_point(m, Vec3::new(x, y, z)));
+        return;
+    }
+    let old = p.clone();
+    for (row, out) in p.iter_mut().enumerate() {
+        let mut constant = m[3][row];
+        let mut terms: Vec<String> = Vec::new();
+        for (col, e) in old.iter().enumerate() {
+            let c = m[col][row];
+            if c.abs() < 1e-12 {
+                continue;
+            }
+            match num(e) {
+                Some(v) => constant += c * v,
+                None if (c - 1.0).abs() < 1e-12 => terms.push(format!("({e})")),
+                None => terms.push(format!("{c} * ({e})")),
+            }
+        }
+        let mut e = terms.join(" + ");
+        if terms.is_empty() {
+            e = format!("{constant} mm");
+        } else if constant.abs() >= 1e-12 {
+            e = format!("{e} {} {} mm", if constant < 0.0 { '-' } else { '+' }, constant.abs());
+        }
+        *out = e;
+    }
+}
+
 impl FeatureKind {
     /// Map the feature's world geometry (points, directions, explicit planes) by `m`.
     pub fn transform_geometry(&mut self, m: &Mat) {
@@ -207,12 +240,12 @@ impl FeatureKind {
                 map_plane_ref(m, neutral);
                 dir(pull);
             }
-            FeatureKind::Box { corner, .. } => pt(corner),
+            FeatureKind::Box { corner, .. } => map_point_expr(m, corner),
             FeatureKind::Cylinder { base, axis, .. } => {
-                pt(base);
+                map_point_expr(m, base);
                 dir(axis);
             }
-            FeatureKind::Sphere { center, .. } | FeatureKind::Torus { center, .. } => pt(center),
+            FeatureKind::Sphere { center, .. } | FeatureKind::Torus { center, .. } => map_point_expr(m, center),
             FeatureKind::Pattern { pattern: PatternKind::Rectangular { dir1, dir2, .. }, .. } => {
                 dir(dir1);
                 if let Some(d) = dir2 {
@@ -259,7 +292,7 @@ impl FeatureKind {
             }
             FeatureKind::SheetBase { .. } | FeatureKind::SheetContour { .. } | FeatureKind::SheetUnfold { .. } => {}
             FeatureKind::Coil { base, axis, .. } => {
-                pt(base);
+                map_point_expr(m, base);
                 dir(axis);
             }
             FeatureKind::ReplaceFace { faces, target, .. } => {

crates/doc/src/document.rs

@@ -226,7 +226,8 @@ pub enum FeatureKind {
         body: Option<String>,
     },
     Box {
-        corner: Vec3,
+        #[serde(with = "point_expr")]
+        corner: PointExpr,
         length: String,
         width: String,
         height: String,
@@ -234,7 +235,8 @@ pub enum FeatureKind {
         operation: Operation,
     },
     Cylinder {
-        base: Vec3,
+        #[serde(with = "point_expr")]
+        base: PointExpr,
         #[serde(default = "z_axis")]
         axis: Vec3,
         radius: String,
@@ -243,13 +245,15 @@ pub enum FeatureKind {
         operation: Operation,
     },
     Sphere {
-        center: Vec3,
+        #[serde(with = "point_expr")]
+        center: PointExpr,
         radius: String,
         #[serde(default)]
         operation: Operation,
     },
     Torus {
-        center: Vec3,
+        #[serde(with = "point_expr")]
+        center: PointExpr,
         major: String,
         minor: String,
         #[serde(default)]
@@ -482,7 +486,8 @@ pub enum FeatureKind {
     /// A helical coil: a circular or square section swept `turns` times about `axis`, rising
     /// `pitch` per turn, on a helix of `diameter` (the section's centre, or its inside or outside).
     Coil {
-        base: Vec3,
+        #[serde(with = "point_expr")]
+        base: PointExpr,
         #[serde(default = "z_axis")]
         axis: Vec3,
         diameter: String,
@@ -939,6 +944,45 @@ fn z_axis() -> Vec3 {
     Vec3::Z
 }
 
+/// A point whose coordinates are length expressions (`["basin_width / 2", "10 mm", "0"]`), so
+/// it follows parameter changes. Primitives are placed by one.
+pub type PointExpr = [String; 3];
+
+/// A point as expressions (plain numbers, mm).
+pub fn point_expr(p: Vec3) -> PointExpr {
+    [format!("{}", p.x), format!("{}", p.y), format!("{}", p.z)]
+}
+
+/// Stored as `[x, y, z]`: plain numbers as numbers (as points were before they took
+/// expressions, so such designs read and write the same), anything else as a string.
+mod point_expr {
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(untagged)]
+    enum Coord {
+        Num(f64),
+        Expr(String),
+    }
+
+    pub fn serialize<S: Serializer>(p: &super::PointExpr, s: S) -> Result<S::Ok, S::Error> {
+        let c = |e: &String| match e.parse::<f64>() {
+            Ok(v) if v.is_finite() && format!("{v}") == *e => Coord::Num(v),
+            _ => Coord::Expr(e.clone()),
+        };
+        [c(&p[0]), c(&p[1]), c(&p[2])].serialize(s)
+    }
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<super::PointExpr, D::Error> {
+        let c = |x: Coord| match x {
+            Coord::Num(v) => format!("{v}"),
+            Coord::Expr(e) => e,
+        };
+        let [x, y, z] = <[Coord; 3]>::deserialize(d)?;
+        Ok([c(x), c(y), c(z)])
+    }
+}
+
 impl FeatureKind {
     /// Sketches the feature is built from (profiles, paths, points): deleting one of them
     /// deletes the feature. Every kind is listed, so a new one has to say what it uses.
@@ -1228,10 +1272,22 @@ impl FeatureKind {
                 v.extend(distance2.iter().map(String::as_str));
                 v.extend(angle.iter().map(String::as_str));
             }
-            FeatureKind::Box { length, width, height, .. } => v.extend([length.as_str(), width, height]),
-            FeatureKind::Cylinder { radius, height, .. } => v.extend([radius.as_str(), height]),
-            FeatureKind::Sphere { radius, .. } => v.push(radius),
-            FeatureKind::Torus { major, minor, .. } => v.extend([major.as_str(), minor]),
+            FeatureKind::Box { length, width, height, corner, .. } => {
+                v.extend([length.as_str(), width, height]);
+                v.extend(corner.iter().map(String::as_str));
+            }
+            FeatureKind::Cylinder { radius, height, base, .. } => {
+                v.extend([radius.as_str(), height]);
+                v.extend(base.iter().map(String::as_str));
+            }
+            FeatureKind::Sphere { radius, center, .. } => {
+                v.push(radius);
+                v.extend(center.iter().map(String::as_str));
+            }
+            FeatureKind::Torus { major, minor, center, .. } => {
+                v.extend([major.as_str(), minor]);
+                v.extend(center.iter().map(String::as_str));
+            }
             FeatureKind::Combine { .. } => {}
             FeatureKind::Pattern { pattern, .. } => match pattern {
                 PatternKind::Rectangular { count1, spacing1, count2, spacing2, .. } => {
@@ -1308,9 +1364,10 @@ impl FeatureKind {
                 v.extend(gap.iter().map(String::as_str));
             }
             FeatureKind::SheetBase { .. } | FeatureKind::SheetUnfold { .. } | FeatureKind::SheetConvert { .. } => {}
-            FeatureKind::Coil { diameter, pitch, turns, section_size, start_angle, .. } => {
+            FeatureKind::Coil { diameter, pitch, turns, section_size, start_angle, base, .. } => {
                 v.extend([diameter.as_str(), pitch, turns, section_size]);
                 v.extend(start_angle.iter().map(String::as_str));
+                v.extend(base.iter().map(String::as_str));
             }
             FeatureKind::Rib { thickness, depth, .. } => {
                 v.push(thickness);

crates/doc/src/eval.rs

@@ -684,6 +684,13 @@ pub(crate) const DESIGN_LEN: &str = "\u{1}design_len";
 
 /// An expression's value. A length that comes out unit-less without being a bare number (a
 /// unit-less parameter used as a length) is in the design's units.
+/// A point given as length expressions.
+fn point(vals: &BTreeMap<String, Value>, p: &crate::PointExpr) -> Result<Vec3> {
+    let [x, y, z] = p;
+    let v = Vec3::new(val(vals, x, Kind::Length)?, val(vals, y, Kind::Length)?, val(vals, z, Kind::Length)?);
+    if [v.x, v.y, v.z].iter().all(|c| c.is_finite() && c.abs() < 1e9) { Ok(v) } else { Err(DocError::Invalid("the position is out of range".into())) }
+}
+
 fn val(vals: &BTreeMap<String, Value>, e: &str, k: Kind) -> Result<f64> {
     let scale = vals.get(DESIGN_LEN).map(|x| x.v).unwrap_or(1.0);
     if k == Kind::Length && scale != 1.0 && !expr::is_literal(e) {
@@ -1537,6 +1544,7 @@ fn feature_tools(vals: &BTreeMap<String, Value>, f: &Feature, st: &ModelState) -
             Ok(vec![kernel::loft_to_point(&ss.plane, &r.outer, ps.plane.to_world(q.pos))?])
         }
         FeatureKind::Coil { base, axis, diameter, pitch, turns, section_size, section, position, start_angle, clockwise, .. } => {
+            let base = &point(vals, base)?;
             let k = axis.normalized().ok_or_else(|| DocError::Invalid("coil axis".into()))?;
             let (d, p, n, s) = (
                 val(vals, diameter, Kind::Length)?,
@@ -1624,14 +1632,15 @@ fn feature_tools(vals: &BTreeMap<String, Value>, f: &Feature, st: &ModelState) -
         }
         FeatureKind::Box { corner, length, width, height, .. } => {
             let s = Vec3::new(val(vals, length, Kind::Length)?, val(vals, width, Kind::Length)?, val(vals, height, Kind::Length)?);
-            Ok(vec![kernel::box_solid(*corner, *corner + s)?])
+            let corner = point(vals, corner)?;
+            Ok(vec![kernel::box_solid(corner, corner + s)?])
         }
         FeatureKind::Cylinder { base, axis, radius, height, .. } => {
-            Ok(vec![kernel::cylinder(*base, *axis, val(vals, radius, Kind::Length)?, val(vals, height, Kind::Length)?)?])
+            Ok(vec![kernel::cylinder(point(vals, base)?, *axis, val(vals, radius, Kind::Length)?, val(vals, height, Kind::Length)?)?])
         }
-        FeatureKind::Sphere { center, radius, .. } => Ok(vec![kernel::sphere(*center, val(vals, radius, Kind::Length)?)?]),
+        FeatureKind::Sphere { center, radius, .. } => Ok(vec![kernel::sphere(point(vals, center)?, val(vals, radius, Kind::Length)?)?]),
         FeatureKind::Torus { center, major, minor, .. } => {
-            Ok(vec![kernel::torus(*center, val(vals, major, Kind::Length)?, val(vals, minor, Kind::Length)?)?])
+            Ok(vec![kernel::torus(point(vals, center)?, val(vals, major, Kind::Length)?, val(vals, minor, Kind::Length)?)?])
         }
         FeatureKind::Hole { diameter, depth, hole, to, .. } => {
             let (spots, dir) = hole_spots(st, f)?;
@@ -2689,19 +2698,20 @@ fn eval_feature(doc: &Document, vals: &BTreeMap<String, Value>, f: &Feature, st:
         }
         FeatureKind::Box { corner, length, width, height, operation } => {
             let s = Vec3::new(val(vals, length, Kind::Length)?, val(vals, width, Kind::Length)?, val(vals, height, Kind::Length)?);
-            let b = kernel::box_solid(*corner, *corner + s)?;
+            let corner = point(vals, corner)?;
+            let b = kernel::box_solid(corner, corner + s)?;
             apply_op(st, f, vec![b], *operation, &[])
         }
         FeatureKind::Cylinder { base, axis, radius, height, operation } => {
-            let b = kernel::cylinder(*base, *axis, val(vals, radius, Kind::Length)?, val(vals, height, Kind::Length)?)?;
+            let b = kernel::cylinder(point(vals, base)?, *axis, val(vals, radius, Kind::Length)?, val(vals, height, Kind::Length)?)?;
             apply_op(st, f, vec![b], *operation, &[])
         }
         FeatureKind::Sphere { center, radius, operation } => {
-            let b = kernel::sphere(*center, val(vals, radius, Kind::Length)?)?;
+            let b = kernel::sphere(point(vals, center)?, val(vals, radius, Kind::Length)?)?;
             apply_op(st, f, vec![b], *operation, &[])
         }
         FeatureKind::Torus { center, major, minor, operation } => {
-            let b = kernel::torus(*center, val(vals, major, Kind::Length)?, val(vals, minor, Kind::Length)?)?;
+            let b = kernel::torus(point(vals, center)?, val(vals, major, Kind::Length)?, val(vals, minor, Kind::Length)?)?;
             apply_op(st, f, vec![b], *operation, &[])
         }
         FeatureKind::Combine { target, tools, operation, keep_tools } => {
@@ -2970,7 +2980,13 @@ mod chain_tests {
     fn tangent_chain_follows_smooth_edges() {
         let mut doc = Document::new("T");
         doc.add_feature(
-            FeatureKind::Box { corner: Vec3::ZERO, length: "40".into(), width: "30".into(), height: "20".into(), operation: Operation::NewBody },
+            FeatureKind::Box {
+                corner: crate::point_expr(Vec3::ZERO),
+                length: "40".into(),
+                width: "30".into(),
+                height: "20".into(),
+                operation: Operation::NewBody,
+            },
             None,
         )
         .unwrap();

crates/doc/src/lib.rs

@@ -25,7 +25,7 @@ mod project3d;
 pub use project3d::iso_grid;
 pub mod sheet;
 
-pub use assembly::{IDENTITY, Mat, Occurrence, apply_point, apply_vector, is_identity, mat_inverse, mat_mul, rigid};
+pub use assembly::{IDENTITY, Mat, Occurrence, apply_point, apply_vector, is_identity, map_point_expr, mat_inverse, mat_mul, rigid};
 pub use document::*;
 pub use eval::{
     EdgeRef, FeatureResult, Model, ModelBody, ModelState, SolvedSketch, ThreadInfo, edge_names_for, edge_refs, parse_metric_thread, pattern_matrices,

crates/doc/src/params.rs

@@ -276,6 +276,32 @@ impl FeatureKind {
         v
     }
 
+    /// A primitive's placement point (length expressions). Its coordinates are not inputs:
+    /// they get no parameter names and keep bare numbers in mm whatever the design's units, as
+    /// every other position does; renames and users still find them.
+    pub fn point_expr_mut(&mut self) -> Option<&mut crate::PointExpr> {
+        match self {
+            FeatureKind::Box { corner: p, .. }
+            | FeatureKind::Cylinder { base: p, .. }
+            | FeatureKind::Sphere { center: p, .. }
+            | FeatureKind::Torus { center: p, .. }
+            | FeatureKind::Coil { base: p, .. } => Some(p),
+            _ => None,
+        }
+    }
+
+    /// Read-only view of [`FeatureKind::point_expr_mut`].
+    pub fn point_expr(&self) -> Option<&crate::PointExpr> {
+        match self {
+            FeatureKind::Box { corner: p, .. }
+            | FeatureKind::Cylinder { base: p, .. }
+            | FeatureKind::Sphere { center: p, .. }
+            | FeatureKind::Torus { center: p, .. }
+            | FeatureKind::Coil { base: p, .. } => Some(p),
+            _ => None,
+        }
+    }
+
     /// Read-only view of [`FeatureKind::inputs_mut`]: (label, expression, kind).
     pub fn inputs(&self) -> Vec<(&'static str, String, Kind)> {
         // Imports have no inputs (and their STEP text is large: don't clone it).
@@ -655,6 +681,9 @@ impl Document {
                     }
                 }
             }
+            if f.kind.point_expr().is_some_and(|p| p.iter().any(|e| expr::references(e).iter().any(|r| r == name))) {
+                out.push(ParamUser::Feature { feature: f.id, name: f.name.clone(), input: "Position".into() });
+            }
             if let FeatureKind::Sketch { sketch, .. } = &f.kind {
                 for c in &sketch.constraints {
                     if c.param.as_deref() == Some(name) {
@@ -718,6 +747,13 @@ impl Document {
                     *x = new.to_string();
                 }
             }
+            for e in f.kind.point_expr_mut().into_iter().flatten() {
+                let r = expr::rename_reference(e, old, new);
+                if r != *e {
+                    *e = r;
+                    n += 1;
+                }
+            }
             for (_, e, _) in f.kind.inputs_mut() {
                 let r = expr::rename_reference(e, old, new);
                 if r != *e {

crates/doc/src/tests.rs

@@ -165,7 +165,13 @@ fn errors_are_reported_not_fatal() {
     doc.add_feature(FeatureKind::Fillet { edges: vec![Vec3::new(500.0, 0.0, 0.0)], radius: "1".into(), body: None, style: Default::default() }, None)
         .unwrap();
     doc.add_feature(
-        FeatureKind::Box { corner: Vec3::ZERO, length: "nope".into(), width: "1".into(), height: "1".into(), operation: Operation::NewBody },
+        FeatureKind::Box {
+            corner: point_expr(Vec3::ZERO),
+            length: "nope".into(),
+            width: "1".into(),
+            height: "1".into(),
+            operation: Operation::NewBody,
+        },
         None,
     )
     .unwrap();
@@ -202,13 +208,19 @@ fn params_and_serialization() {
 fn primitives_and_combine() {
     let mut doc = Document::new("p");
     doc.add_feature(
-        FeatureKind::Box { corner: Vec3::ZERO, length: "10".into(), width: "10".into(), height: "10".into(), operation: Operation::NewBody },
+        FeatureKind::Box {
+            corner: point_expr(Vec3::ZERO),
+            length: "10".into(),
+            width: "10".into(),
+            height: "10".into(),
+            operation: Operation::NewBody,
+        },
         None,
     )
     .unwrap();
     doc.add_feature(
         FeatureKind::Cylinder {
-            base: Vec3::new(5.0, 5.0, 0.0),
+            base: point_expr(Vec3::new(5.0, 5.0, 0.0)),
             axis: Vec3::Z,
             radius: "2".into(),
             height: "20".into(),