Add sketch under-constrained analysis (#9297)

* Use local ezpz with underconstrained analysis

* Add new config parameter so that the executor knows if it should do the analysis

* Use under-constrained analysis

* Use released kcl-ezpz 0.2.2

* Fix to do freedom analysis when editing a sketch

Author: jtran

rust/Cargo.lock

@@ -23,7 +23,7 @@ console_error_panic_hook = "0.1.7"
 dashmap = { version = "6.1.0" }
 http = "1"
 indexmap = "2.12.1"
-kcl-ezpz = "0.2.1"
+kcl-ezpz = "0.2.2"
 kittycad = { version = "0.4.2", default-features = false, features = [
   "js",
   "requests",

rust/Cargo.toml

@@ -33,13 +33,10 @@ pub fn bench_mock_warmed_up(c: &mut Criterion) {
             let rt = tokio::runtime::Runtime::new().unwrap();
             let ctx = rt.block_on(async { kcl_lib::ExecutorContext::new_mock(None).await });
             // First run outside the benchmark measurement, to initialize KCL memory.
-            #[cfg(feature = "artifact-graph")]
             let mock_config = kcl_lib::MockConfig {
                 use_prev_memory: false,
                 ..Default::default()
             };
-            #[cfg(not(feature = "artifact-graph"))]
-            let mock_config = kcl_lib::MockConfig { use_prev_memory: false };
             let _out = rt.block_on(async { ctx.run_mock(&program, &mock_config).await.unwrap() });
             b.iter(|| {
                 if let Err(err) = rt.block_on(async {

rust/kcl-lib/benches/compiler_benchmark_criterion.rs

@@ -151,6 +151,7 @@ impl ExecutorContext {
             exec_state.stack().memory.clone(),
             Some(module_id),
             next_object_id,
+            exec_state.mod_local.freedom_analysis,
         );
         if !preserve_mem {
             std::mem::swap(&mut exec_state.mod_local, &mut local_state);
@@ -998,6 +999,7 @@ impl Node<SketchBlock> {
                     },
                     segments: Default::default(),
                     constraints: Default::default(),
+                    is_underconstrained: None,
                 }),
                 label: Default::default(),
                 comments: Default::default(),
@@ -1104,7 +1106,13 @@ impl Node<SketchBlock> {
             max_iterations: 50,
             ..Default::default()
         };
-        let solve_outcome = match kcl_ezpz::solve_with_priority(&constraints, initial_guesses.clone(), config) {
+        let solve_result = if exec_state.mod_local.freedom_analysis {
+            kcl_ezpz::solve_with_priority_analysis(&constraints, initial_guesses.clone(), config)
+                .map(|outcome| (outcome.outcome, Some(outcome.analysis)))
+        } else {
+            kcl_ezpz::solve_with_priority(&constraints, initial_guesses.clone(), config).map(|outcome| (outcome, None))
+        };
+        let (solve_outcome, solve_analysis) = match solve_result {
             Ok(o) => o,
             Err(failure) => {
                 if let kcl_ezpz::Error::Solver(_) = &failure.error {
@@ -1115,13 +1123,16 @@ impl Node<SketchBlock> {
                         annotations::WARN_SOLVER,
                     );
                     let final_values = initial_guesses.iter().map(|(_, v)| *v).collect::<Vec<_>>();
-                    kcl_ezpz::SolveOutcome {
-                        final_values,
-                        iterations: Default::default(),
-                        warnings: failure.warnings,
-                        unsatisfied: Default::default(),
-                        priority_solved: Default::default(),
-                    }
+                    (
+                        kcl_ezpz::SolveOutcome {
+                            final_values,
+                            iterations: Default::default(),
+                            warnings: failure.warnings,
+                            unsatisfied: Default::default(),
+                            priority_solved: Default::default(),
+                        },
+                        None,
+                    )
                 } else {
                     return Err(KclError::new_internal(KclErrorDetails::new(
                         format!("Error from constraint solver: {}", &failure.error),
@@ -1130,6 +1141,8 @@ impl Node<SketchBlock> {
                 }
             }
         };
+        #[cfg(not(feature = "artifact-graph"))]
+        let _ = solve_analysis;
         // Propagate warnings.
         for warning in &solve_outcome.warnings {
             let message = if let Some(index) = warning.about_constraint.as_ref() {
@@ -1196,6 +1209,8 @@ impl Node<SketchBlock> {
             sketch
                 .constraints
                 .extend(std::mem::take(&mut sketch_block_state.sketch_constraints));
+            // Update the sketch object with freedom.
+            sketch.is_underconstrained = solve_analysis.map(|analysis| analysis.is_underconstrained);
 
             // Push sketch solve operation
             exec_state.push_op(Operation::SketchSolve {

rust/kcl-lib/src/execution/exec_ast.rs

@@ -113,6 +113,9 @@ pub struct ExecOutcome {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct MockConfig {
     pub use_prev_memory: bool,
+    /// True to do more costly analysis of whether the sketch block segments are
+    /// under-constrained.
+    pub freedom_analysis: bool,
     /// The segments that were edited that triggered this execution.
     #[cfg(feature = "artifact-graph")]
     pub segment_ids_edited: AhashIndexSet<ObjectId>,
@@ -123,6 +126,7 @@ impl Default for MockConfig {
         Self {
             // By default, use previous memory. This is usually what you want.
             use_prev_memory: true,
+            freedom_analysis: false,
             #[cfg(feature = "artifact-graph")]
             segment_ids_edited: AhashIndexSet::default(),
         }
@@ -617,11 +621,12 @@ impl ExecutorContext {
             "To use mock execution, instantiate via ExecutorContext::new_mock, not ::new"
         );
 
+        let use_prev_memory = mock_config.use_prev_memory;
         #[cfg(not(feature = "artifact-graph"))]
         let mut exec_state = ExecState::new(self);
         #[cfg(feature = "artifact-graph")]
-        let mut exec_state = ExecState::new_sketch_mode(self, mock_config.segment_ids_edited.clone());
-        if mock_config.use_prev_memory {
+        let mut exec_state = ExecState::new_sketch_mode(self, mock_config);
+        if use_prev_memory {
             match cache::read_old_memory().await {
                 Some(mem) => {
                     *exec_state.mut_stack() = mem.0;

rust/kcl-lib/src/execution/mod.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{
-    CompilationError, EngineManager, ExecutorContext, KclErrorWithOutputs, SourceRange,
+    CompilationError, EngineManager, ExecutorContext, KclErrorWithOutputs, MockConfig, SourceRange,
     collections::AhashIndexSet,
     errors::{KclError, KclErrorDetails, Severity},
     exec::DefaultPlanes,
@@ -128,6 +128,9 @@ pub(super) struct ModuleState {
     pub module_exports: Vec<String>,
     /// Settings specified from annotations.
     pub settings: MetaSettings,
+    /// True to do more costly analysis of whether the sketch block segments are
+    /// under-constrained.
+    pub freedom_analysis: bool,
     pub(super) explicit_length_units: bool,
     pub(super) path: ModulePath,
     /// Artifacts for only this module.
@@ -151,14 +154,24 @@ impl ExecState {
     pub fn new(exec_context: &super::ExecutorContext) -> Self {
         ExecState {
             global: GlobalState::new(&exec_context.settings, Default::default()),
-            mod_local: ModuleState::new(ModulePath::Main, ProgramMemory::new(), Default::default(), 0),
+            mod_local: ModuleState::new(ModulePath::Main, ProgramMemory::new(), Default::default(), 0, false),
         }
     }
 
-    pub fn new_sketch_mode(exec_context: &super::ExecutorContext, segment_ids_edited: AhashIndexSet<ObjectId>) -> Self {
+    pub fn new_sketch_mode(exec_context: &super::ExecutorContext, mock_config: &MockConfig) -> Self {
+        #[cfg(feature = "artifact-graph")]
+        let segment_ids_edited = mock_config.segment_ids_edited.clone();
+        #[cfg(not(feature = "artifact-graph"))]
+        let segment_ids_edited = Default::default();
         ExecState {
             global: GlobalState::new(&exec_context.settings, segment_ids_edited),
-            mod_local: ModuleState::new(ModulePath::Main, ProgramMemory::new(), Default::default(), 0),
+            mod_local: ModuleState::new(
+                ModulePath::Main,
+                ProgramMemory::new(),
+                Default::default(),
+                0,
+                mock_config.freedom_analysis,
+            ),
         }
     }
 
@@ -167,7 +180,13 @@ impl ExecState {
 
         *self = ExecState {
             global,
-            mod_local: ModuleState::new(self.mod_local.path.clone(), ProgramMemory::new(), Default::default(), 0),
+            mod_local: ModuleState::new(
+                self.mod_local.path.clone(),
+                ProgramMemory::new(),
+                Default::default(),
+                0,
+                false,
+            ),
         };
     }
 
@@ -639,6 +658,7 @@ impl ModuleState {
         memory: Arc<ProgramMemory>,
         module_id: Option<ModuleId>,
         next_object_id: usize,
+        freedom_analysis: bool,
     ) -> Self {
         #[cfg(not(feature = "artifact-graph"))]
         let _ = next_object_id;
@@ -653,6 +673,7 @@ impl ModuleState {
             explicit_length_units: false,
             path,
             settings: Default::default(),
+            freedom_analysis,
             #[cfg(not(feature = "artifact-graph"))]
             artifacts: Default::default(),
             #[cfg(feature = "artifact-graph")]

rust/kcl-lib/src/execution/state.rs

@@ -228,17 +228,19 @@ impl SketchApi for FrontendState {
         // Enter sketch mode by setting the sketch_mode.
         self.scene_graph.sketch_mode = Some(sketch);
 
-        // Execute in mock mode to ensure state is up to date.
-        let outcome = ctx
-            .run_mock(&self.program, &MockConfig::default())
-            .await
-            .map_err(|err| {
-                // TODO: sketch-api: Yeah, this needs to change. We need to
-                // return the full error.
-                Error {
-                    msg: err.error.message().to_owned(),
-                }
-            })?;
+        // Execute in mock mode to ensure state is up to date. The caller will
+        // want freedom analysis to display segments correctly.
+        let mock_config = MockConfig {
+            freedom_analysis: true,
+            ..Default::default()
+        };
+        let outcome = ctx.run_mock(&self.program, &mock_config).await.map_err(|err| {
+            // TODO: sketch-api: Yeah, this needs to change. We need to
+            // return the full error.
+            Error {
+                msg: err.error.message().to_owned(),
+            }
+        })?;
 
         let outcome = self.update_state_after_exec(outcome);
         let scene_graph_delta = SceneGraphDelta {
@@ -884,6 +886,7 @@ impl FrontendState {
         // Execute.
         let mock_config = MockConfig {
             use_prev_memory: !is_delete,
+            freedom_analysis: is_delete,
             #[cfg(feature = "artifact-graph")]
             segment_ids_edited,
         };
@@ -1425,16 +1428,17 @@ impl FrontendState {
         self.program = new_program.clone();
 
         // Execute.
-        let outcome = ctx
-            .run_mock(&new_program, &MockConfig::default())
-            .await
-            .map_err(|err| {
-                // TODO: sketch-api: Yeah, this needs to change. We need to
-                // return the full error.
-                Error {
-                    msg: err.error.message().to_owned(),
-                }
-            })?;
+        let mock_config = MockConfig {
+            freedom_analysis: true,
+            ..Default::default()
+        };
+        let outcome = ctx.run_mock(&new_program, &mock_config).await.map_err(|err| {
+            // TODO: sketch-api: Yeah, this needs to change. We need to
+            // return the full error.
+            Error {
+                msg: err.error.message().to_owned(),
+            }
+        })?;
 
         let src_delta = SourceDelta { text: new_source };
         let outcome = self.update_state_after_exec(outcome);
@@ -2056,6 +2060,7 @@ mod tests {
                 },
                 segments: vec![],
                 constraints: vec![],
+                is_underconstrained: None,
             })
         );
         assert_eq!(scene_delta.new_graph.objects.len(), 1);
@@ -2159,6 +2164,7 @@ sketch(on = XY) {
                 },
                 segments: vec![],
                 constraints: vec![],
+                is_underconstrained: None,
             })
         );
         assert_eq!(scene_delta.new_graph.objects.len(), 1);

rust/kcl-lib/src/frontend.rs

@@ -90,6 +90,7 @@ pub struct Sketch {
     pub args: SketchArgs,
     pub segments: Vec<ObjectId>,
     pub constraints: Vec<ObjectId>,
+    pub is_underconstrained: Option<bool>,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]

rust/kcl-lib/src/frontend/sketch.rs

@@ -1217,6 +1217,7 @@ describe('createOnDragCallback', () => {
         args: { on: { default: 'xy' } },
         segments: [],
         constraints: [],
+        is_underconstrained: null,
       },
       label: '',
       comments: '',