diff --git a/crates/doc/src/clipboard.rs b/crates/doc/src/clipboard.rs index 44ce0a109..99cab241c 100644 --- a/crates/doc/src/clipboard.rs +++ b/crates/doc/src/clipboard.rs @@ -77,13 +77,7 @@ pub fn clone_expression(source: &str, parameters: &BTreeMap) -> result } -fn remap_geo( - g: &mut crate::construct::GeoRef, - ids: &BTreeMap, - names: &BTreeMap, - bodies: &BTreeMap, - depth: usize, -) -> crate::Result<()> { +fn remap_geo(g: &mut crate::construct::GeoRef, ids: &BTreeMap, bodies: &BTreeMap, depth: usize) -> crate::Result<()> { use crate::construct::GeoRef; if depth > 64 { return Err(crate::DocError::Invalid("clone plane reference depth exceeded".into())); @@ -100,28 +94,18 @@ fn remap_geo( *n = remap_topology(n, ids, bodies); } } - GeoRef::ConstructPoint { name } | GeoRef::Axis { name } => mapped_name(name, names), - GeoRef::Plane { plane } => remap_plane(plane, ids, names, bodies, depth + 1)?, + GeoRef::Plane { plane } => remap_plane(plane, ids, bodies, depth + 1)?, _ => {} } Ok(()) } -fn remap_plane( - p: &mut PlaneRef, - ids: &BTreeMap, - names: &BTreeMap, - bodies: &BTreeMap, - depth: usize, -) -> crate::Result<()> { +fn remap_plane(p: &mut PlaneRef, ids: &BTreeMap, bodies: &BTreeMap, depth: usize) -> crate::Result<()> { if depth > 64 { return Err(crate::DocError::Invalid("clone plane reference depth exceeded".into())); } match p { - PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => { - remap_plane(base, ids, names, bodies, depth + 1)? - } - PlaneRef::Construction { name } => mapped_name(&mut name.0, names), + PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => remap_plane(base, ids, bodies, depth + 1)?, PlaneRef::Face { name, anchor, .. } => { if let Some(name) = name { *name = remap_topology(name, ids, bodies); @@ -132,7 +116,7 @@ fn remap_plane( } _ => { for r in p.refs_mut() { - remap_geo(r, ids, names, bodies, depth + 1)?; + remap_geo(r, ids, bodies, depth + 1)?; } } } @@ -214,6 +198,8 @@ impl crate::Feature { } _ => {} } + // Feature names are remapped once here; the geometry pass below handles only + // sketch ids and topology, so a copy whose new name is also an old key is not remapped twice. self.kind.remap_refs(ids, names); for n in &mut self.body_names { mapped_name(n, bodies); @@ -236,7 +222,7 @@ impl crate::Feature { self.kind.remap_bodies(bodies); match &mut self.kind { K::Sketch { plane, sketch } => { - remap_plane(plane, ids, names, bodies, 0)?; + remap_plane(plane, ids, bodies, 0)?; for c in &mut sketch.constraints { if let Some(n) = &mut c.param { mapped_name(n, parameters); @@ -256,18 +242,18 @@ impl crate::Feature { | K::Split { plane, .. } | K::SplitFace { plane, .. } | K::Mirror { plane, .. } - | K::SurfaceTrim { plane, .. } => remap_plane(plane, ids, names, bodies, 0)?, - K::Draft { neutral, .. } => remap_plane(neutral, ids, names, bodies, 0)?, - K::ReplaceFace { target, .. } => remap_plane(target, ids, names, bodies, 0)?, - K::SurfaceExtend { up_to: Some(crate::ExtendTo::Plane(plane)), .. } => remap_plane(plane, ids, names, bodies, 0)?, + | K::SurfaceTrim { plane, .. } => remap_plane(plane, ids, bodies, 0)?, + K::Draft { neutral, .. } => remap_plane(neutral, ids, bodies, 0)?, + K::ReplaceFace { target, .. } => remap_plane(target, ids, bodies, 0)?, + K::SurfaceExtend { up_to: Some(crate::ExtendTo::Plane(plane)), .. } => remap_plane(plane, ids, bodies, 0)?, K::ConstructionAxis { def } => { for r in def.refs_mut() { - remap_geo(r, ids, names, bodies, 0)?; + remap_geo(r, ids, bodies, 0)?; } } K::ConstructionPoint { def } => { for r in def.refs_mut() { - remap_geo(r, ids, names, bodies, 0)?; + remap_geo(r, ids, bodies, 0)?; } } _ => {} @@ -324,6 +310,28 @@ fn checked_link(source: &solidcraft_sketch::LinkSource, depth: usize) -> crate:: #[cfg(test)] mod clone_tests { use super::*; + + #[test] + fn construction_feature_names_are_remapped_only_once_when_copied() { + use serde_json::json; + + let names = BTreeMap::from([("Old".into(), "New".into()), ("New".into(), "Wrong".into())]); + let origin = json!({"type": "plane", "plane": {"type": "construction", "name": "Old"}}); + for kind in [ + json!({"type": "construction_axis", "def": {"type": "two_points", "a": {"type": "construct_point", "name": "Old"}, "b": {"type": "point", "p": [1, 2, 3]}}}), + json!({"type": "construction_point", "def": {"type": "edge_and_plane", "edge": {"type": "axis", "name": "Old"}, "plane": origin}}), + json!({"type": "construction_plane", "plane": {"type": "perpendicular", "plane": origin, "line": {"type": "axis", "name": "Old"}}}), + ] { + let mut value = kind; + value["id"] = json!(1); + value["name"] = json!("Copy"); + let mut feature: crate::Feature = serde_json::from_value(value).unwrap(); + let before = serde_json::to_string(&feature).unwrap(); + feature.remap_clone(&BTreeMap::new(), &names, &BTreeMap::new(), &BTreeMap::new()).unwrap(); + assert_eq!(serde_json::to_string(&feature).unwrap(), before.replace("\"Old\"", "\"New\"")); + } + } + #[test] fn imported_names_and_topology_tokens_have_separate_identity() { let ids = BTreeMap::from([(1, 2), (10, 20)]); diff --git a/crates/doc/src/construct.rs b/crates/doc/src/construct.rs index e5f589bb2..0f5a2d26b 100644 --- a/crates/doc/src/construct.rs +++ b/crates/doc/src/construct.rs @@ -48,9 +48,9 @@ pub enum GeoRef { /// World X, Y or Z axis. World { axis: String }, /// A construction axis feature, by name. - Axis { name: String }, + Axis { name: crate::FeatureName }, /// A construction point feature, by name. - ConstructPoint { name: String }, + ConstructPoint { name: crate::FeatureName }, /// A sketch point (by sketch feature id and point id). SketchPoint { sketch: u64, point: String }, /// A sketch curve (by sketch feature id and curve id). diff --git a/crates/doc/src/feature_walk_tests.rs b/crates/doc/src/feature_walk_tests.rs index 2db17da0c..c31525f6a 100644 --- a/crates/doc/src/feature_walk_tests.rs +++ b/crates/doc/src/feature_walk_tests.rs @@ -177,6 +177,85 @@ fn references_match_the_golden_record() { check_golden("golden_refs.txt", GOLDEN_REFS, &ref_record()); } +#[test] +fn construction_names_follow_renames_in_every_definition() { + use crate::walk::{Ref, Walk}; + use serde_json::json; + + let axis = json!({"type": "axis", "name": "Old"}); + let point = json!({"type": "construct_point", "name": "Old"}); + let plane = json!({"type": "plane", "plane": {"type": "construction", "name": "Old"}}); + let definitions = [ + json!({"type": "construction_axis", "def": {"type": "through_face", "face": axis}}), + json!({"type": "construction_axis", "def": {"type": "normal_to_face", "face": plane, "point": point}}), + json!({"type": "construction_axis", "def": {"type": "two_planes", "a": plane, "b": plane}}), + json!({"type": "construction_axis", "def": {"type": "two_points", "a": point, "b": point}}), + json!({"type": "construction_axis", "def": {"type": "edge", "edge": axis}}), + json!({"type": "construction_point", "def": {"type": "at", "point": point}}), + json!({"type": "construction_point", "def": {"type": "two_edges", "a": axis, "b": axis}}), + json!({"type": "construction_point", "def": {"type": "three_planes", "a": plane, "b": plane, "c": plane}}), + json!({"type": "construction_point", "def": {"type": "center", "of": axis}}), + json!({"type": "construction_point", "def": {"type": "edge_and_plane", "edge": axis, "plane": plane}}), + json!({"type": "construction_point", "def": {"type": "along_path", "path": axis, "t": "0.5"}}), + ]; + let planes = [ + json!({"type": "midplane", "a": plane, "b": plane}), + json!({"type": "two_edges", "a": axis, "b": axis}), + json!({"type": "three_points", "a": point, "b": point, "c": point}), + json!({"type": "tangent", "face": plane, "at": [0, 0, 0]}), + json!({"type": "along_path", "path": axis, "t": "0.5"}), + json!({"type": "perpendicular", "plane": plane, "line": axis}), + ]; + let wrapped = planes.into_iter().map(|plane| { + json!({"type": "construction_plane", "plane": {"type": "flipped", "base": { + "type": "offset", "distance": "10", "base": {"type": "at_angle", "angle": "20 deg", + "axis_origin": [0, 0, 0], "axis_dir": [1, 0, 0], "base": plane}}}}) + }); + let names = BTreeMap::from([("Old".into(), "New".into()), ("New".into(), "Wrong".into())]); + for definition in definitions.into_iter().chain(wrapped) { + let mut kind: FeatureKind = serde_json::from_value(definition.clone()).unwrap(); + let expected_count = definition.to_string().matches("\"Old\"").count(); + let mut seen = Vec::new(); + kind.walk_refs(&mut |r| { + if let Ref::Feature(name) = r { + seen.push(name.to_string()); + } + }); + assert_eq!(seen, vec!["Old"; expected_count], "{definition}"); + kind.remap_refs(&BTreeMap::new(), &names); + let expected: serde_json::Value = serde_json::from_str(&definition.to_string().replace("\"Old\"", "\"New\"")).unwrap(); + assert_eq!(serde_json::to_value(kind).unwrap(), serde_json::to_value(serde_json::from_value::(expected).unwrap()).unwrap()); + } +} + +#[test] +fn construction_reference_walk_keeps_its_depth_limit_across_geometry() { + use crate::construct::GeoRef; + use crate::walk::{Ref, Walk}; + + let mut plane = crate::PlaneRef::Construction { name: "TooDeep".into() }; + for _ in 0..80 { + plane = crate::PlaneRef::Perpendicular { plane: Box::new(GeoRef::Plane { plane }), line: Box::new(GeoRef::Axis { name: "Side".into() }) }; + } + let mut seen = Vec::new(); + plane.walk_refs(&mut |r| { + if let Ref::Feature(name) = r { + seen.push(name.to_string()); + } + }); + assert!(!seen.is_empty() && seen.len() < 64); + assert!(seen.iter().all(|name| name == "Side")); + let mut changed = 0; + plane.walk_refs_mut(&mut |r| { + if let Ref::Feature(name) = r { + assert_eq!(name.as_ref(), "Side"); + *name = "Renamed".into(); + changed += 1; + } + }); + assert_eq!(changed, seen.len()); +} + #[test] fn inputs_and_expressions_match_the_golden_record() { check_golden("golden_exprs.txt", GOLDEN_EXPRS, &record()); diff --git a/crates/doc/src/feature_walk_tests/golden_refs.txt b/crates/doc/src/feature_walk_tests/golden_refs.txt index edf8d47f9..6871a9968 100644 --- a/crates/doc/src/feature_walk_tests/golden_refs.txt +++ b/crates/doc/src/feature_walk_tests/golden_refs.txt @@ -86,7 +86,9 @@ split_line remap_refs: plane.base.base.name, sketch remap_bodies: body construction_axis + remap_refs: def.a.plane.base.base.name, def.b.plane.base.base.name construction_point_planes + remap_refs: def.a.plane.base.base.name, def.b.plane.base.base.name, def.c.plane.base.base.name construction_point_along split_face sketches: [6] diff --git a/crates/doc/src/walk.rs b/crates/doc/src/walk.rs index 4638936c0..b484b4206 100644 --- a/crates/doc/src/walk.rs +++ b/crates/doc/src/walk.rs @@ -319,7 +319,7 @@ impl &'static str> Label for F { /// The offsets and angles of a plane, outermost first, and an explicit origin's coordinates /// (nesting is capped like every walk over a plane), the construction plane it is built on, and -/// the plane itself. +/// the plane itself. Feature references also reach the geometry used to construct a plane. impl Walk for PlaneRef { fn walk_exprs<'a>(&'a self, f: &mut dyn FnMut(ExprItem<'a>)) { let mut p = self; @@ -374,24 +374,10 @@ impl Walk for PlaneRef { } } fn walk_refs<'a>(&'a self, f: &mut dyn FnMut(RefItem<'a>)) { - let mut p = self; - for _ in 0..64 { - match p { - PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => p = base, - PlaneRef::Construction { name } => return f(Ref::Feature(name)), - _ => return, - } - } + self.walk_feature_refs(f, 0); } fn walk_refs_mut<'a>(&'a mut self, f: &mut dyn FnMut(RefItemMut<'a>)) { - let mut p = self; - for _ in 0..64 { - match p { - PlaneRef::Offset { base, .. } | PlaneRef::AtAngle { base, .. } | PlaneRef::Flipped { base, .. } => p = base, - PlaneRef::Construction { name } => return f(Ref::Feature(name)), - _ => return, - } - } + self.walk_feature_refs_mut(f, 0); } fn walk_geometry<'a>(&'a self, f: &mut dyn FnMut(GeoItem<'a>)) { f(Geo::Plane(self)) @@ -401,9 +387,92 @@ impl Walk for PlaneRef { } } +impl PlaneRef { + fn walk_feature_refs<'a>(&'a self, f: &mut dyn FnMut(RefItem<'a>), depth: usize) { + if depth >= 64 { + return; + } + match self { + Self::Construction { name } => f(Ref::Feature(name)), + Self::Offset { base, .. } | Self::AtAngle { base, .. } | Self::Flipped { base, .. } => base.walk_feature_refs(f, depth + 1), + Self::Midplane { a, b } | Self::TwoEdges { a, b } | Self::Perpendicular { plane: a, line: b } => { + a.walk_feature_refs(f, depth + 1); + b.walk_feature_refs(f, depth + 1); + } + Self::ThreePoints { a, b, c } => { + a.walk_feature_refs(f, depth + 1); + b.walk_feature_refs(f, depth + 1); + c.walk_feature_refs(f, depth + 1); + } + Self::Tangent { face, .. } | Self::AlongPath { path: face, .. } => face.walk_feature_refs(f, depth + 1), + Self::Origin { .. } | Self::Custom { .. } | Self::Placed { .. } | Self::Face { .. } => {} + } + } + + fn walk_feature_refs_mut<'a>(&'a mut self, f: &mut dyn FnMut(RefItemMut<'a>), depth: usize) { + if depth >= 64 { + return; + } + match self { + Self::Construction { name } => f(Ref::Feature(name)), + Self::Offset { base, .. } | Self::AtAngle { base, .. } | Self::Flipped { base, .. } => base.walk_feature_refs_mut(f, depth + 1), + Self::Midplane { a, b } | Self::TwoEdges { a, b } | Self::Perpendicular { plane: a, line: b } => { + a.walk_feature_refs_mut(f, depth + 1); + b.walk_feature_refs_mut(f, depth + 1); + } + Self::ThreePoints { a, b, c } => { + a.walk_feature_refs_mut(f, depth + 1); + b.walk_feature_refs_mut(f, depth + 1); + c.walk_feature_refs_mut(f, depth + 1); + } + Self::Tangent { face, .. } | Self::AlongPath { path: face, .. } => face.walk_feature_refs_mut(f, depth + 1), + Self::Origin { .. } | Self::Custom { .. } | Self::Placed { .. } | Self::Face { .. } => {} + } + } +} + +impl GeoRef { + // Carry the depth across GeoRef -> PlaneRef -> GeoRef, rather than restarting its cap. + fn walk_feature_refs<'a>(&'a self, f: &mut dyn FnMut(RefItem<'a>), depth: usize) { + if depth >= 64 { + return; + } + match self { + Self::Axis { name } | Self::ConstructPoint { name } => f(Ref::Feature(name)), + Self::Plane { plane } => plane.walk_feature_refs(f, depth + 1), + Self::Point { .. } + | Self::Origin + | Self::Vertex { .. } + | Self::Edge { .. } + | Self::Face { .. } + | Self::World { .. } + | Self::SketchPoint { .. } + | Self::SketchCurve { .. } => {} + } + } + + fn walk_feature_refs_mut<'a>(&'a mut self, f: &mut dyn FnMut(RefItemMut<'a>), depth: usize) { + if depth >= 64 { + return; + } + match self { + Self::Axis { name } | Self::ConstructPoint { name } => f(Ref::Feature(name)), + Self::Plane { plane } => plane.walk_feature_refs_mut(f, depth + 1), + Self::Point { .. } + | Self::Origin + | Self::Vertex { .. } + | Self::Edge { .. } + | Self::Face { .. } + | Self::World { .. } + | Self::SketchPoint { .. } + | Self::SketchCurve { .. } => {} + } + } +} + /// Construction axes and points: the expressions of the planes they are built from (and a point -/// along a path's distance), and their references to the model. They name no sketches, features -/// or bodies: copies remap their geometry references on their own (`Feature::remap_clone`). +/// along a path's distance), and their feature and geometry references. Copies still remap +/// sketch ids and persistent topology names through their geometry (`Feature::remap_clone`). fn plane_exprs<'a>(refs: Vec<&'a GeoRef>, f: &mut dyn FnMut(ExprItem<'a>)) { for r in refs { if let GeoRef::Plane { plane } = r { @@ -422,6 +491,16 @@ fn plane_exprs_mut<'a>(refs: Vec<&'a mut GeoRef>, f: &mut dyn FnMut(ExprItemMut< macro_rules! construct_geometry { () => { + fn walk_refs<'a>(&'a self, f: &mut dyn FnMut(RefItem<'a>)) { + for r in self.refs() { + r.walk_feature_refs(f, 0); + } + } + fn walk_refs_mut<'a>(&'a mut self, f: &mut dyn FnMut(RefItemMut<'a>)) { + for r in self.refs_mut() { + r.walk_feature_refs_mut(f, 0); + } + } fn walk_geometry<'a>(&'a self, f: &mut dyn FnMut(GeoItem<'a>)) { for r in self.refs() { f(Geo::Construct(r)); diff --git a/crates/engine/src/cmd/construct.rs b/crates/engine/src/cmd/construct.rs index 12ed05e37..5762ce933 100644 --- a/crates/engine/src/cmd/construct.rs +++ b/crates/engine/src/cmd/construct.rs @@ -116,13 +116,13 @@ fn geo(s: &Session, v: Option<&Value>, cmd: &str, what: &str) -> Result GeoRef::World { axis: a.to_ascii_uppercase() } } else { match s.doc.find_feature(a).map(|f| &f.kind) { - Some(FeatureKind::ConstructionAxis { .. }) => GeoRef::Axis { name: a.to_string() }, + Some(FeatureKind::ConstructionAxis { .. }) => GeoRef::Axis { name: a.into() }, _ => return Err(bad(cmd, format!("no axis `{a}`"))), } } } else if let Some(n) = str_(v, "construct_point") { match s.doc.find_feature(n).map(|f| &f.kind) { - Some(FeatureKind::ConstructionPoint { .. }) => GeoRef::ConstructPoint { name: n.to_string() }, + Some(FeatureKind::ConstructionPoint { .. }) => GeoRef::ConstructPoint { name: n.into() }, _ => return Err(bad(cmd, format!("no construction point `{n}`"))), } } else if v.as_str().is_some() { diff --git a/crates/engine/src/construct_tests.rs b/crates/engine/src/construct_tests.rs index bc278b7b3..204b47125 100644 --- a/crates/engine/src/construct_tests.rs +++ b/crates/engine/src/construct_tests.rs @@ -43,6 +43,61 @@ fn plane(s: &Session, name: &str) -> Plane { construction_planes(s).into_iter().find(|p| p.1 == name).map(|p| p.2).unwrap_or_else(|| panic!("no plane {name}")) } +#[test] +fn renamed_construction_references_survive_edits_and_reopening() { + let mut s = Session::default(); + run(&mut s, "construct.axis.two_planes", json!({"a": "XZ", "b": "YZ", "name": "Spine"})); + run(&mut s, "construct.plane.perpendicular", json!({"plane": "XZ", "line": {"axis": "Spine"}, "name": "Fence"})); + run(&mut s, "construct.point.three_planes", json!({"a": "XY", "b": "XZ", "c": "YZ", "name": "Pin"})); + run(&mut s, "construct.axis.two_points", json!({"a": {"construct_point": "Pin"}, "b": {"point": [30, 30, 30]}, "name": "Brace"})); + run(&mut s, "construct.point.vertex", json!({"point": {"construct_point": "Pin"}, "name": "Copy"})); + let before = (*s.doc).clone(); + run(&mut s, "timeline.rename", json!({"feature": "Spine", "name": "Mast"})); + run(&mut s, "timeline.rename", json!({"feature": "Pin", "name": "Peg"})); + let fence = run(&mut s, "timeline.inspect", json!({"feature": "Fence"})); + assert_eq!(fence["definition"]["plane"]["line"]["name"], "Mast"); + let brace = run(&mut s, "timeline.inspect", json!({"feature": "Brace"})); + assert_eq!(brace["definition"]["def"]["a"]["name"], "Peg"); + let renamed = (*s.doc).clone(); + for _ in 0..2 { + run(&mut s, "edit.undo", json!({})); + } + assert_eq!(*s.doc, before); + for _ in 0..2 { + run(&mut s, "edit.redo", json!({})); + } + assert_eq!(*s.doc, renamed); + run(&mut s, "timeline.edit", json!({"feature": "Mast", "set": {"def.b": {"type": "plane", "plane": {"type": "origin", "name": "XY"}}}})); + let saved = serde_json::to_vec(&*s.doc).unwrap(); + let mut reopened = Session::new(serde_json::from_slice(&saved).unwrap()); + reopened.refresh(); + for session in [&s, &reopened] { + assert!(session.model.results.iter().all(|r| r.error.is_none()), "{:?}", session.model.results); + assert!(parallel(plane(session, "Fence").normal(), Vec3::Z)); + assert!(parallel(axis(session, "Brace").1, Vec3::new(1.0, 1.0, 1.0))); + assert!(near(point(session, "Copy"), Vec3::ZERO)); + } +} + +#[test] +fn renamed_hidden_axes_and_points_stay_hidden_through_undo_redo() { + let mut s = Session::default(); + run(&mut s, "construct.axis.two_planes", json!({"a": "XZ", "b": "YZ", "name": "Spine"})); + run(&mut s, "construct.point.three_planes", json!({"a": "XY", "b": "XZ", "c": "YZ", "name": "Pin"})); + run(&mut s, "browser.visibility", json!({"items": ["Spine", "Pin", "XY"], "visible": false})); + for (old, new) in [("Spine", "Mast"), ("Pin", "Peg")] { + run(&mut s, "timeline.rename", json!({"feature": old, "name": new})); + assert!(!s.construction_visible(new)); + assert!(!s.visibility.hidden_origin.iter().any(|n| n == old)); + run(&mut s, "edit.undo", json!({})); + assert!(!s.construction_visible(old)); + assert!(!s.visibility.hidden_origin.iter().any(|n| n == new)); + run(&mut s, "edit.redo", json!({})); + assert!(!s.construction_visible(new)); + } + assert!(!s.construction_visible("XY")); +} + /// The line through `o` along `d` contains `p`. fn on_line(o: Vec3, d: Vec3, p: Vec3) -> bool { let d = d.normalized().unwrap_or(Vec3::Z); diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 241cb4699..e9cbf9d8d 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -685,6 +685,7 @@ impl Session { /// which keeps every result and mesh (#3044). fn refresh_from(&mut self, previous: &Arc) { self.follow_plane_renames(previous); + self.follow_axis_point_renames(previous); if let Some((old, new)) = self.body_rename(previous) && self.model.rename_body(&self.doc, &old, &new) { diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rs index 342f131c8..d50a268d1 100644 --- a/crates/engine/src/occurrences.rs +++ b/crates/engine/src/occurrences.rs @@ -41,6 +41,26 @@ pub(crate) struct RemovedLaterCache { } impl Session { + /// Visibility keeps construction names, while undo history keeps feature ids. Follow the + /// same axis or point into the new document on rename, undo and redo (#4419). + pub(crate) fn follow_axis_point_renames(&mut self, previous: &solidcraft_doc::Document) { + if self.visibility.hidden_origin.is_empty() { + return; + } + let names: std::collections::HashMap<_, _> = self.doc.features.iter().map(|f| (f.id, &f.name)).collect(); + let renamed: std::collections::HashMap<_, _> = previous + .features + .iter() + .filter(|f| matches!(f.kind, FeatureKind::ConstructionAxis { .. } | FeatureKind::ConstructionPoint { .. })) + .filter_map(|f| names.get(&f.id).filter(|name| **name != &f.name).map(|name| (f.name.as_str(), *name))) + .collect(); + for name in &mut self.visibility.hidden_origin { + if let Some(new) = renamed.get(name.as_str()) { + name.clone_from(new); + } + } + } + /// Document with uncaptured occurrence positions applied, without changing saved geometry. pub fn placed_document(&self) -> std::borrow::Cow<'_, solidcraft_doc::Document> { if self.pending_moves.is_empty() {