Give a default value to projectName in Text-to-CAD Create command to allow invocation through command palette (#7061)

Give a default value to projectName

This argument is hidden since it's marked as skip, so browser users who
must now invoke the command through the command palette have no way of
setting the value. Since it is also required, the command palette fails
silently on submission (which we need to fix more broadly). This gives
it a default value so that users can submit properly.

.github/workflows/cargo-test.yml

@@ -88,6 +88,7 @@ jobs:
           KITTYCAD_API_TOKEN: ${{secrets.KITTYCAD_API_TOKEN_DEV}}
           ZOO_HOST: https://api.dev.zoo.dev
           RUST_BACKTRACE: full
+          RUST_MIN_STACK: 10485760000
       - name: Commit differences
         if: steps.path-changes.outputs.outside-kcl-samples == 'false' && steps.cargo-test-kcl-samples.outcome == 'failure'
         shell: bash
@@ -119,6 +120,7 @@ jobs:
           # Configure nextest when it's run by insta (via just).
           NEXTEST_PROFILE: ci
           RUST_BACKTRACE: full
+          RUST_MIN_STACK: 10485760000
       - name: Build and archive tests
         run: |
           cd rust
@@ -182,6 +184,7 @@ jobs:
         env:
           KITTYCAD_API_TOKEN: ${{secrets.KITTYCAD_API_TOKEN_DEV}}
           ZOO_HOST: https://api.dev.zoo.dev
+          RUST_MIN_STACK: 10485760000
       - name: Upload results
         if: always()
         run: .github/ci-cd-scripts/upload-results.sh
@@ -238,6 +241,7 @@ jobs:
           KITTYCAD_API_TOKEN: ${{secrets.KITTYCAD_API_TOKEN_DEV}}
           ZOO_HOST: https://api.dev.zoo.dev
           MODELING_APP_INTERNAL_SAMPLES_SECRET: ${{secrets.MODELING_APP_INTERNAL_SAMPLES_SECRET}}
+          RUST_MIN_STACK: 10485760000
   run-wasm-tests:
     name: Run wasm tests
     strategy:

e2e/playwright/code-pane-and-errors.spec.ts

@@ -235,6 +235,48 @@ extrude001 = extrude(sketch001, length = 5)`
         .first()
     ).toBeVisible()
   })
+
+  test('KCL errors with functions show hints for the entire backtrace', async ({
+    page,
+    homePage,
+    scene,
+    cmdBar,
+    editor,
+    toolbar,
+  }) => {
+    await homePage.goToModelingScene()
+    await scene.settled(cmdBar)
+
+    const code = `fn check(@x) {
+  return assert(x, isGreaterThan = 0)
+}
+
+fn middle(@x) {
+  return check(x)
+}
+
+middle(1)
+middle(0)
+`
+    await test.step('Set the code with a KCL error', async () => {
+      await toolbar.openPane('code')
+      await editor.replaceCode('', code)
+    })
+    // This shows all the diagnostics in a way that doesn't require the mouse
+    // pointer hovering over a coordinate, which would be brittle.
+    await test.step('Open CodeMirror diagnostics list', async () => {
+      // Ensure keyboard focus is in the editor.
+      await page.getByText('fn check(').click()
+      await page.keyboard.press('ControlOrMeta+Shift+M')
+    })
+    await expect(
+      page.getByText(`assert failed: Expected 0 to be greater than 0 but it wasn't
+check()
+middle()`)
+    ).toBeVisible()
+    // There should be one hint inside middle() and one at the top level.
+    await expect(page.getByText('Part of the error backtrace')).toHaveCount(2)
+  })
 })
 
 test(

rust/kcl-lib/e2e/executor/main.rs

@@ -2,7 +2,7 @@ mod cache;
 
 use kcl_lib::{
     test_server::{execute_and_export_step, execute_and_snapshot, execute_and_snapshot_no_auth},
-    ExecError,
+    BacktraceItem, ExecError, ModuleId, SourceRange,
 };
 
 /// The minimum permissible difference between asserted twenty-twenty images.
@@ -441,10 +441,15 @@ async fn kcl_test_import_file_doesnt_exist() {
 model = cube"#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "File `thing.obj` does not exist.");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"semantic: KclErrorDetails { source_ranges: [SourceRange([0, 18, 0])], message: "File `thing.obj` does not exist." }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(0, 18, ModuleId::default()),
+            fn_name: None,
+        }]
     );
 }
 
@@ -519,10 +524,18 @@ import 'e2e/executor/inputs/cube.gltf'
 model = cube"#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.message(),
-        r#"semantic: KclErrorDetails { source_ranges: [SourceRange([32, 70, 0])], message: "The given format does not match the file extension. Expected: `gltf`, Given: `obj`" }"#
+        "The given format does not match the file extension. Expected: `gltf`, Given: `obj`"
+    );
+    assert_eq!(
+        err.backtrace(),
+        vec![BacktraceItem {
+            source_range: SourceRange::new(32, 70, ModuleId::default()),
+            fn_name: None,
+        }]
     );
 }
 
@@ -1666,10 +1679,15 @@ example = extrude(exampleSketch, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have an x constrained angle of 90 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([70, 111, 0])], message: "Cannot have an x constrained angle of 90 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(70, 111, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1686,10 +1704,15 @@ example = extrude(exampleSketch, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have an x constrained angle of 270 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([70, 112, 0])], message: "Cannot have an x constrained angle of 270 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(70, 112, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1706,10 +1729,15 @@ example = extrude(exampleSketch, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have a y constrained angle of 0 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([70, 110, 0])], message: "Cannot have a y constrained angle of 0 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(70, 110, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1726,10 +1754,15 @@ example = extrude(exampleSketch, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have a y constrained angle of 180 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([70, 112, 0])], message: "Cannot have a y constrained angle of 180 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(70, 112, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1746,10 +1779,15 @@ extrusion = extrude(sketch001, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have an x constrained angle of 90 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([66, 116, 0])], message: "Cannot have an x constrained angle of 90 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(66, 116, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1757,7 +1795,7 @@ extrusion = extrude(sketch001, length = 10)
 async fn kcl_test_angled_line_of_x_length_270() {
     let code = r#"sketch001 = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
-  |> angledLine(angle = 90, lengthX = 90, tag = $edge1)
+  |> angledLine(angle = 270, lengthX = 90, tag = $edge1)
   |> angledLine(angle = -15, lengthX = -15, tag = $edge2)
   |> line(end = [0, -5])
   |> close(tag = $edge3)
@@ -1766,10 +1804,15 @@ extrusion = extrude(sketch001, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have an x constrained angle of 270 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([66, 116, 0])], message: "Cannot have an x constrained angle of 90 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(66, 117, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1788,10 +1831,15 @@ example = extrude(exampleSketch, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have a y constrained angle of 0 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([95, 130, 0])], message: "Cannot have a y constrained angle of 0 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(95, 130, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1810,10 +1858,15 @@ example = extrude(exampleSketch, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have a y constrained angle of 180 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([95, 132, 0])], message: "Cannot have a y constrained angle of 180 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(95, 132, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1832,10 +1885,15 @@ example = extrude(exampleSketch, length = 10)
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
+    assert_eq!(err.message(), "Cannot have a y constrained angle of 180 degrees");
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.backtrace(),
-        r#"type: KclErrorDetails { source_ranges: [SourceRange([95, 133, 0])], message: "Cannot have a y constrained angle of 180 degrees" }"#
+        vec![BacktraceItem {
+            source_range: SourceRange::new(95, 133, ModuleId::default()),
+            fn_name: Some("angledLine".to_owned())
+        }]
     );
 }
 
@@ -1849,10 +1907,31 @@ someFunction('INVALID')
 "#;
 
     let result = execute_and_snapshot(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
+    let err = err.as_kcl_error().unwrap();
     assert_eq!(
-        result.err().unwrap().to_string(),
+        err.message(),
-        r#"semantic: KclErrorDetails { source_ranges: [SourceRange([46, 55, 0]), SourceRange([60, 83, 0])], message: "This function expected the input argument to be Solid or Plane but it's actually of type string" }"#
+        "This function expected the input argument to be Solid or Plane but it's actually of type string"
+    );
+    assert_eq!(
+        err.source_ranges(),
+        vec![
+            SourceRange::new(46, 55, ModuleId::default()),
+            SourceRange::new(60, 83, ModuleId::default()),
+        ]
+    );
+    assert_eq!(
+        err.backtrace(),
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(46, 55, ModuleId::default()),
+                fn_name: Some("someFunction".to_owned()),
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(60, 83, ModuleId::default()),
+                fn_name: None,
+            },
+        ]
     );
 }
 
@@ -1873,12 +1952,14 @@ async fn kcl_test_error_no_auth_websocket() {
 "#;
 
     let result = execute_and_snapshot_no_auth(code, None).await;
-    assert!(result.is_err());
+    let err = result.unwrap_err();
-    assert!(result
+    let err = err.as_kcl_error().unwrap();
-        .err()
+    assert!(
-        .unwrap()
+        err.message()
-        .to_string()
+            .contains("Please send the following object over this websocket"),
-        .contains("Please send the following object over this websocket"));
+        "actual: {}",
+        err.message()
+    );
 }
 
 #[tokio::test(flavor = "multi_thread")]

rust/kcl-lib/src/engine/conn.rs

@@ -439,12 +439,7 @@ impl EngineManager for EngineConnection {
                 request_sent: tx,
             })
             .await
-            .map_err(|e| {
+            .map_err(|e| KclError::Engine(KclErrorDetails::new(format!("Failed to send debug: {}", e), vec![])))?;
-                KclError::Engine(KclErrorDetails {
-                    message: format!("Failed to send debug: {}", e),
-                    source_ranges: vec![],
-                })
-            })?;
 
         let _ = rx.await;
         Ok(())
@@ -479,25 +474,25 @@ impl EngineManager for EngineConnection {
             })
             .await
             .map_err(|e| {
-                KclError::Engine(KclErrorDetails {
+                KclError::Engine(KclErrorDetails::new(
-                    message: format!("Failed to send modeling command: {}", e),
+                    format!("Failed to send modeling command: {}", e),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             })?;
 
         // Wait for the request to be sent.
         rx.await
             .map_err(|e| {
-                KclError::Engine(KclErrorDetails {
+                KclError::Engine(KclErrorDetails::new(
-                    message: format!("could not send request to the engine actor: {e}"),
+                    format!("could not send request to the engine actor: {e}"),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             })?
             .map_err(|e| {
-                KclError::Engine(KclErrorDetails {
+                KclError::Engine(KclErrorDetails::new(
-                    message: format!("could not send request to the engine: {e}"),
+                    format!("could not send request to the engine: {e}"),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             })?;
 
         Ok(())
@@ -521,15 +516,15 @@ impl EngineManager for EngineConnection {
                 // Check if we have any pending errors.
                 let pe = self.pending_errors.read().await;
                 if !pe.is_empty() {
-                    return Err(KclError::Engine(KclErrorDetails {
+                    return Err(KclError::Engine(KclErrorDetails::new(
-                        message: pe.join(", ").to_string(),
+                        pe.join(", ").to_string(),
-                        source_ranges: vec![source_range],
+                        vec![source_range],
-                    }));
+                    )));
                 } else {
-                    return Err(KclError::Engine(KclErrorDetails {
+                    return Err(KclError::Engine(KclErrorDetails::new(
-                        message: "Modeling command failed: websocket closed early".to_string(),
+                        "Modeling command failed: websocket closed early".to_string(),
-                        source_ranges: vec![source_range],
+                        vec![source_range],
-                    }));
+                    )));
                 }
             }
 
@@ -548,10 +543,10 @@ impl EngineManager for EngineConnection {
             }
         }
 
-        Err(KclError::Engine(KclErrorDetails {
+        Err(KclError::Engine(KclErrorDetails::new(
-            message: format!("Modeling command timed out `{}`", id),
+            format!("Modeling command timed out `{}`", id),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        }))
+        )))
     }
 
     async fn get_session_data(&self) -> Option<ModelingSessionData> {

rust/kcl-lib/src/engine/conn_wasm.rs

@@ -147,32 +147,27 @@ impl EngineConnection {
         id_to_source_range: HashMap<uuid::Uuid, SourceRange>,
     ) -> Result<(), KclError> {
         let source_range_str = serde_json::to_string(&source_range).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to serialize source range: {:?}", e),
+                format!("Failed to serialize source range: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
         let cmd_str = serde_json::to_string(&cmd).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to serialize modeling command: {:?}", e),
+                format!("Failed to serialize modeling command: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
         let id_to_source_range_str = serde_json::to_string(&id_to_source_range).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to serialize id to source range: {:?}", e),
+                format!("Failed to serialize id to source range: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         self.manager
             .fire_modeling_cmd_from_wasm(id.to_string(), source_range_str, cmd_str, id_to_source_range_str)
-            .map_err(|e| {
+            .map_err(|e| KclError::Engine(KclErrorDetails::new(e.to_string().into(), vec![source_range])))?;
-                KclError::Engine(KclErrorDetails {
-                    message: e.to_string().into(),
-                    source_ranges: vec![source_range],
-                })
-            })?;
 
         Ok(())
     }
@@ -185,33 +180,28 @@ impl EngineConnection {
         id_to_source_range: HashMap<uuid::Uuid, SourceRange>,
     ) -> Result<WebSocketResponse, KclError> {
         let source_range_str = serde_json::to_string(&source_range).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to serialize source range: {:?}", e),
+                format!("Failed to serialize source range: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
         let cmd_str = serde_json::to_string(&cmd).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to serialize modeling command: {:?}", e),
+                format!("Failed to serialize modeling command: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
         let id_to_source_range_str = serde_json::to_string(&id_to_source_range).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to serialize id to source range: {:?}", e),
+                format!("Failed to serialize id to source range: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         let promise = self
             .manager
             .send_modeling_cmd_from_wasm(id.to_string(), source_range_str, cmd_str, id_to_source_range_str)
-            .map_err(|e| {
+            .map_err(|e| KclError::Engine(KclErrorDetails::new(e.to_string().into(), vec![source_range])))?;
-                KclError::Engine(KclErrorDetails {
-                    message: e.to_string().into(),
-                    source_ranges: vec![source_range],
-                })
-            })?;
 
         let value = crate::wasm::JsFuture::from(promise).await.map_err(|e| {
             // Try to parse the error as an engine error.
@@ -219,53 +209,52 @@ impl EngineConnection {
             if let Ok(kittycad_modeling_cmds::websocket::FailureWebSocketResponse { errors, .. }) =
                 serde_json::from_str(&err_str)
             {
-                KclError::Engine(KclErrorDetails {
+                KclError::Engine(KclErrorDetails::new(
-                    message: errors.iter().map(|e| e.message.clone()).collect::<Vec<_>>().join("\n"),
+                    errors.iter().map(|e| e.message.clone()).collect::<Vec<_>>().join("\n"),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             } else if let Ok(data) =
                 serde_json::from_str::<Vec<kittycad_modeling_cmds::websocket::FailureWebSocketResponse>>(&err_str)
             {
                 if let Some(data) = data.first() {
                     // It could also be an array of responses.
-                    KclError::Engine(KclErrorDetails {
+                    KclError::Engine(KclErrorDetails::new(
-                        message: data
+                        data.errors
-                            .errors
                             .iter()
                             .map(|e| e.message.clone())
                             .collect::<Vec<_>>()
                             .join("\n"),
-                        source_ranges: vec![source_range],
+                        vec![source_range],
-                    })
+                    ))
                 } else {
-                    KclError::Engine(KclErrorDetails {
+                    KclError::Engine(KclErrorDetails::new(
-                        message: "Received empty response from engine".into(),
+                        "Received empty response from engine".into(),
-                        source_ranges: vec![source_range],
+                        vec![source_range],
-                    })
+                    ))
                 }
             } else {
-                KclError::Engine(KclErrorDetails {
+                KclError::Engine(KclErrorDetails::new(
-                    message: format!("Failed to wait for promise from send modeling command: {:?}", e),
+                    format!("Failed to wait for promise from send modeling command: {:?}", e),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             }
         })?;
 
         if value.is_null() || value.is_undefined() {
-            return Err(KclError::Engine(KclErrorDetails {
+            return Err(KclError::Engine(KclErrorDetails::new(
-                message: "Received null or undefined response from engine".into(),
+                "Received null or undefined response from engine".into(),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            }));
+            )));
         }
 
         // Convert JsValue to a Uint8Array
         let data = js_sys::Uint8Array::from(value);
 
         let ws_result: WebSocketResponse = bson::from_slice(&data.to_vec()).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to deserialize bson response from engine: {:?}", e),
+                format!("Failed to deserialize bson response from engine: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         Ok(ws_result)
@@ -316,18 +305,16 @@ impl crate::engine::EngineManager for EngineConnection {
         *self.default_planes.write().await = Some(new_planes);
 
         // Start a new session.
-        let promise = self.manager.start_new_session().map_err(|e| {
+        let promise = self
-            KclError::Engine(KclErrorDetails {
+            .manager
-                message: e.to_string().into(),
+            .start_new_session()
-                source_ranges: vec![source_range],
+            .map_err(|e| KclError::Engine(KclErrorDetails::new(e.to_string().into(), vec![source_range])))?;
-            })
-        })?;
 
         crate::wasm::JsFuture::from(promise).await.map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to wait for promise from start new session: {:?}", e),
+                format!("Failed to wait for promise from start new session: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         Ok(())

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

@@ -276,10 +276,10 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
                 {
                     let duration = instant::Duration::from_millis(1);
                     wasm_timer::Delay::new(duration).await.map_err(|err| {
-                        KclError::Internal(KclErrorDetails {
+                        KclError::Internal(KclErrorDetails::new(
-                            message: format!("Failed to sleep: {:?}", err),
+                            format!("Failed to sleep: {:?}", err),
-                            source_ranges: vec![source_range],
+                            vec![source_range],
-                        })
+                        ))
                     })?;
                 }
                 #[cfg(not(target_arch = "wasm32"))]
@@ -293,10 +293,10 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
             return Ok(response);
         }
 
-        Err(KclError::Engine(KclErrorDetails {
+        Err(KclError::Engine(KclErrorDetails::new(
-            message: "async command timed out".to_string(),
+            "async command timed out".to_string(),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        }))
+        )))
     }
 
     /// Ensure ALL async commands have been completed.
@@ -547,10 +547,10 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
                     id_to_source_range.insert(Uuid::from(*cmd_id), *range);
                 }
                 _ => {
-                    return Err(KclError::Engine(KclErrorDetails {
+                    return Err(KclError::Engine(KclErrorDetails::new(
-                        message: format!("The request is not a modeling command: {:?}", req),
+                        format!("The request is not a modeling command: {:?}", req),
-                        source_ranges: vec![*range],
+                        vec![*range],
-                    }));
+                    )));
                 }
             }
         }
@@ -595,10 +595,10 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
                     self.parse_batch_responses(last_id.into(), id_to_source_range, responses)
                 } else {
                     // We should never get here.
-                    Err(KclError::Engine(KclErrorDetails {
+                    Err(KclError::Engine(KclErrorDetails::new(
-                        message: format!("Failed to get batch response: {:?}", response),
+                        format!("Failed to get batch response: {:?}", response),
-                        source_ranges: vec![source_range],
+                        vec![source_range],
-                    }))
+                    )))
                 }
             }
             WebSocketRequest::ModelingCmdReq(ModelingCmdReq { cmd: _, cmd_id }) => {
@@ -610,20 +610,20 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
                 // request so we need the original request source range in case the engine returns
                 // an error.
                 let source_range = id_to_source_range.get(cmd_id.as_ref()).cloned().ok_or_else(|| {
-                    KclError::Engine(KclErrorDetails {
+                    KclError::Engine(KclErrorDetails::new(
-                        message: format!("Failed to get source range for command ID: {:?}", cmd_id),
+                        format!("Failed to get source range for command ID: {:?}", cmd_id),
-                        source_ranges: vec![],
+                        vec![],
-                    })
+                    ))
                 })?;
                 let ws_resp = self
                     .inner_send_modeling_cmd(cmd_id.into(), source_range, final_req, id_to_source_range)
                     .await?;
                 self.parse_websocket_response(ws_resp, source_range)
             }
-            _ => Err(KclError::Engine(KclErrorDetails {
+            _ => Err(KclError::Engine(KclErrorDetails::new(
-                message: format!("The final request is not a modeling command: {:?}", final_req),
+                format!("The final request is not a modeling command: {:?}", final_req),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })),
+            ))),
         }
     }
 
@@ -729,10 +729,10 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
         for (name, plane_id, color) in plane_settings {
             let info = DEFAULT_PLANE_INFO.get(&name).ok_or_else(|| {
                 // We should never get here.
-                KclError::Engine(KclErrorDetails {
+                KclError::Engine(KclErrorDetails::new(
-                    message: format!("Failed to get default plane info for: {:?}", name),
+                    format!("Failed to get default plane info for: {:?}", name),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             })?;
             planes.insert(
                 name,
@@ -763,15 +763,14 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
             WebSocketResponse::Success(success) => Ok(success.resp),
             WebSocketResponse::Failure(fail) => {
                 let _request_id = fail.request_id;
-                Err(KclError::Engine(KclErrorDetails {
+                Err(KclError::Engine(KclErrorDetails::new(
-                    message: fail
+                    fail.errors
-                        .errors
                         .iter()
                         .map(|e| e.message.clone())
                         .collect::<Vec<_>>()
                         .join("\n"),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                }))
+                )))
             }
         }
     }
@@ -806,25 +805,25 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
                 BatchResponse::Failure { errors } => {
                     // Get the source range for the command.
                     let source_range = id_to_source_range.get(cmd_id).cloned().ok_or_else(|| {
-                        KclError::Engine(KclErrorDetails {
+                        KclError::Engine(KclErrorDetails::new(
-                            message: format!("Failed to get source range for command ID: {:?}", cmd_id),
+                            format!("Failed to get source range for command ID: {:?}", cmd_id),
-                            source_ranges: vec![],
+                            vec![],
-                        })
+                        ))
                     })?;
-                    return Err(KclError::Engine(KclErrorDetails {
+                    return Err(KclError::Engine(KclErrorDetails::new(
-                        message: errors.iter().map(|e| e.message.clone()).collect::<Vec<_>>().join("\n"),
+                        errors.iter().map(|e| e.message.clone()).collect::<Vec<_>>().join("\n"),
-                        source_ranges: vec![source_range],
+                        vec![source_range],
-                    }));
+                    )));
                 }
             }
         }
 
         // Return an error that we did not get an error or the response we wanted.
         // This should never happen but who knows.
-        Err(KclError::Engine(KclErrorDetails {
+        Err(KclError::Engine(KclErrorDetails::new(
-            message: format!("Failed to find response for command ID: {:?}", id),
+            format!("Failed to find response for command ID: {:?}", id),
-            source_ranges: vec![],
+            vec![],
-        }))
+        )))
     }
 
     async fn modify_grid(

rust/kcl-lib/src/errors.rs

@@ -380,20 +380,39 @@ impl miette::Diagnostic for Report {
 }
 
 #[derive(Debug, Serialize, Deserialize, ts_rs::TS, Clone, PartialEq, Eq, thiserror::Error, miette::Diagnostic)]
+#[serde(rename_all = "camelCase")]
 #[error("{message}")]
 #[ts(export)]
 pub struct KclErrorDetails {
-    #[serde(rename = "sourceRanges")]
     #[label(collection, "Errors")]
     pub source_ranges: Vec<SourceRange>,
+    pub backtrace: Vec<BacktraceItem>,
     #[serde(rename = "msg")]
     pub message: String,
 }
 
+impl KclErrorDetails {
+    pub fn new(message: String, source_ranges: Vec<SourceRange>) -> KclErrorDetails {
+        let backtrace = source_ranges
+            .iter()
+            .map(|s| BacktraceItem {
+                source_range: *s,
+                fn_name: None,
+            })
+            .collect();
+        KclErrorDetails {
+            source_ranges,
+            backtrace,
+            message,
+        }
+    }
+}
+
 impl KclError {
     pub fn internal(message: String) -> KclError {
         KclError::Internal(KclErrorDetails {
             source_ranges: Default::default(),
+            backtrace: Default::default(),
             message,
         })
     }
@@ -455,45 +474,122 @@ impl KclError {
         }
     }
 
+    pub fn backtrace(&self) -> Vec<BacktraceItem> {
+        match self {
+            KclError::Lexical(e)
+            | KclError::Syntax(e)
+            | KclError::Semantic(e)
+            | KclError::ImportCycle(e)
+            | KclError::Type(e)
+            | KclError::Io(e)
+            | KclError::Unexpected(e)
+            | KclError::ValueAlreadyDefined(e)
+            | KclError::UndefinedValue(e)
+            | KclError::InvalidExpression(e)
+            | KclError::Engine(e)
+            | KclError::Internal(e) => e.backtrace.clone(),
+        }
+    }
+
     pub(crate) fn override_source_ranges(&self, source_ranges: Vec<SourceRange>) -> Self {
         let mut new = self.clone();
         match &mut new {
-            KclError::Lexical(e) => e.source_ranges = source_ranges,
+            KclError::Lexical(e)
-            KclError::Syntax(e) => e.source_ranges = source_ranges,
+            | KclError::Syntax(e)
-            KclError::Semantic(e) => e.source_ranges = source_ranges,
+            | KclError::Semantic(e)
-            KclError::ImportCycle(e) => e.source_ranges = source_ranges,
+            | KclError::ImportCycle(e)
-            KclError::Type(e) => e.source_ranges = source_ranges,
+            | KclError::Type(e)
-            KclError::Io(e) => e.source_ranges = source_ranges,
+            | KclError::Io(e)
-            KclError::Unexpected(e) => e.source_ranges = source_ranges,
+            | KclError::Unexpected(e)
-            KclError::ValueAlreadyDefined(e) => e.source_ranges = source_ranges,
+            | KclError::ValueAlreadyDefined(e)
-            KclError::UndefinedValue(e) => e.source_ranges = source_ranges,
+            | KclError::UndefinedValue(e)
-            KclError::InvalidExpression(e) => e.source_ranges = source_ranges,
+            | KclError::InvalidExpression(e)
-            KclError::Engine(e) => e.source_ranges = source_ranges,
+            | KclError::Engine(e)
-            KclError::Internal(e) => e.source_ranges = source_ranges,
+            | KclError::Internal(e) => {
+                e.backtrace = source_ranges
+                    .iter()
+                    .map(|s| BacktraceItem {
+                        source_range: *s,
+                        fn_name: None,
+                    })
+                    .collect();
+                e.source_ranges = source_ranges;
+            }
         }
 
         new
     }
 
-    pub(crate) fn add_source_ranges(&self, source_ranges: Vec<SourceRange>) -> Self {
+    pub(crate) fn set_last_backtrace_fn_name(&self, last_fn_name: Option<String>) -> Self {
         let mut new = self.clone();
         match &mut new {
-            KclError::Lexical(e) => e.source_ranges.extend(source_ranges),
+            KclError::Lexical(e)
-            KclError::Syntax(e) => e.source_ranges.extend(source_ranges),
+            | KclError::Syntax(e)
-            KclError::Semantic(e) => e.source_ranges.extend(source_ranges),
+            | KclError::Semantic(e)
-            KclError::ImportCycle(e) => e.source_ranges.extend(source_ranges),
+            | KclError::ImportCycle(e)
-            KclError::Type(e) => e.source_ranges.extend(source_ranges),
+            | KclError::Type(e)
-            KclError::Io(e) => e.source_ranges.extend(source_ranges),
+            | KclError::Io(e)
-            KclError::Unexpected(e) => e.source_ranges.extend(source_ranges),
+            | KclError::Unexpected(e)
-            KclError::ValueAlreadyDefined(e) => e.source_ranges.extend(source_ranges),
+            | KclError::ValueAlreadyDefined(e)
-            KclError::UndefinedValue(e) => e.source_ranges.extend(source_ranges),
+            | KclError::UndefinedValue(e)
-            KclError::InvalidExpression(e) => e.source_ranges.extend(source_ranges),
+            | KclError::InvalidExpression(e)
-            KclError::Engine(e) => e.source_ranges.extend(source_ranges),
+            | KclError::Engine(e)
-            KclError::Internal(e) => e.source_ranges.extend(source_ranges),
+            | KclError::Internal(e) => {
+                if let Some(item) = e.backtrace.last_mut() {
+                    item.fn_name = last_fn_name;
+                }
+            }
         }
 
         new
     }
+
+    pub(crate) fn add_unwind_location(&self, last_fn_name: Option<String>, source_range: SourceRange) -> Self {
+        let mut new = self.clone();
+        match &mut new {
+            KclError::Lexical(e)
+            | KclError::Syntax(e)
+            | KclError::Semantic(e)
+            | KclError::ImportCycle(e)
+            | KclError::Type(e)
+            | KclError::Io(e)
+            | KclError::Unexpected(e)
+            | KclError::ValueAlreadyDefined(e)
+            | KclError::UndefinedValue(e)
+            | KclError::InvalidExpression(e)
+            | KclError::Engine(e)
+            | KclError::Internal(e) => {
+                if let Some(item) = e.backtrace.last_mut() {
+                    item.fn_name = last_fn_name;
+                }
+                e.backtrace.push(BacktraceItem {
+                    source_range,
+                    fn_name: None,
+                });
+                e.source_ranges.push(source_range);
+            }
+        }
+
+        new
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ts_rs::TS, thiserror::Error, miette::Diagnostic)]
+#[serde(rename_all = "camelCase")]
+#[ts(export)]
+pub struct BacktraceItem {
+    pub source_range: SourceRange,
+    pub fn_name: Option<String>,
+}
+
+impl std::fmt::Display for BacktraceItem {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(fn_name) = &self.fn_name {
+            write!(f, "{fn_name}: {:?}", self.source_range)
+        } else {
+            write!(f, "(fn): {:?}", self.source_range)
+        }
+    }
 }
 
 impl IntoDiagnostic for KclError {
@@ -551,6 +647,7 @@ impl From<pyo3::PyErr> for KclError {
     fn from(error: pyo3::PyErr) -> Self {
         KclError::Internal(KclErrorDetails {
             source_ranges: vec![],
+            backtrace: Default::default(),
             message: error.to_string(),
         })
     }
@@ -629,8 +726,13 @@ impl CompilationError {
 
 impl From<CompilationError> for KclErrorDetails {
     fn from(err: CompilationError) -> Self {
+        let backtrace = vec![BacktraceItem {
+            source_range: err.source_range,
+            fn_name: None,
+        }];
         KclErrorDetails {
             source_ranges: vec![err.source_range],
+            backtrace,
             message: err.message,
         }
     }

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

@@ -70,10 +70,10 @@ pub(super) fn expect_properties<'a>(
 ) -> Result<&'a [Node<ObjectProperty>], KclError> {
     assert_eq!(annotation.name().unwrap(), for_key);
     Ok(&**annotation.properties.as_ref().ok_or_else(|| {
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            message: format!("Empty `{for_key}` annotation"),
+            format!("Empty `{for_key}` annotation"),
-            source_ranges: vec![annotation.as_source_range()],
+            vec![annotation.as_source_range()],
-        })
+        ))
     })?)
 }
 
@@ -84,10 +84,10 @@ pub(super) fn expect_ident(expr: &Expr) -> Result<&str, KclError> {
         }
     }
 
-    Err(KclError::Semantic(KclErrorDetails {
+    Err(KclError::Semantic(KclErrorDetails::new(
-        message: "Unexpected settings value, expected a simple name, e.g., `mm`".to_owned(),
+        "Unexpected settings value, expected a simple name, e.g., `mm`".to_owned(),
-        source_ranges: vec![expr.into()],
+        vec![expr.into()],
-    }))
+    )))
 }
 
 // Returns the unparsed number literal.
@@ -98,10 +98,10 @@ pub(super) fn expect_number(expr: &Expr) -> Result<String, KclError> {
         }
     }
 
-    Err(KclError::Semantic(KclErrorDetails {
+    Err(KclError::Semantic(KclErrorDetails::new(
-        message: "Unexpected settings value, expected a number, e.g., `1.0`".to_owned(),
+        "Unexpected settings value, expected a number, e.g., `1.0`".to_owned(),
-        source_ranges: vec![expr.into()],
+        vec![expr.into()],
-    }))
+    )))
 }
 
 pub(super) fn get_impl(annotations: &[Node<Annotation>], source_range: SourceRange) -> Result<Option<Impl>, KclError> {
@@ -113,14 +113,14 @@ pub(super) fn get_impl(annotations: &[Node<Annotation>], source_range: SourceRan
             if &*p.key.name == IMPL {
                 if let Some(s) = p.value.ident_name() {
                     return Impl::from_str(s).map(Some).map_err(|_| {
-                        KclError::Semantic(KclErrorDetails {
+                        KclError::Semantic(KclErrorDetails::new(
-                            message: format!(
+                            format!(
                                 "Invalid value for {} attribute, expected one of: {}",
                                 IMPL,
                                 IMPL_VALUES.join(", ")
                             ),
-                            source_ranges: vec![source_range],
+                            vec![source_range],
-                        })
+                        ))
                     });
                 }
             }
@@ -139,12 +139,12 @@ impl UnitLen {
             "inch" | "in" => Ok(UnitLen::Inches),
             "ft" => Ok(UnitLen::Feet),
             "yd" => Ok(UnitLen::Yards),
-            value => Err(KclError::Semantic(KclErrorDetails {
+            value => Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Unexpected value for length units: `{value}`; expected one of `mm`, `cm`, `m`, `in`, `ft`, `yd`"
                 ),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })),
+            ))),
         }
     }
 }
@@ -154,10 +154,10 @@ impl UnitAngle {
         match s {
             "deg" => Ok(UnitAngle::Degrees),
             "rad" => Ok(UnitAngle::Radians),
-            value => Err(KclError::Semantic(KclErrorDetails {
+            value => Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Unexpected value for angle units: `{value}`; expected one of `deg`, `rad`"),
+                format!("Unexpected value for angle units: `{value}`; expected one of `deg`, `rad`"),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })),
+            ))),
         }
     }
 }

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

@@ -941,12 +941,10 @@ fn artifacts_to_update(
         ModelingCmd::StartPath(_) => {
             let mut return_arr = Vec::new();
             let current_plane_id = path_to_plane_id_map.get(&artifact_command.cmd_id).ok_or_else(|| {
-                KclError::Internal(KclErrorDetails {
+                KclError::Internal(KclErrorDetails::new(
-                    message: format!(
+                    format!("Expected a current plane ID when processing StartPath command, but we have none: {id:?}"),
-                        "Expected a current plane ID when processing StartPath command, but we have none: {id:?}"
+                    vec![range],
-                    ),
+                ))
-                    source_ranges: vec![range],
-                })
             })?;
             return_arr.push(Artifact::Path(Path {
                 id,
@@ -1065,10 +1063,10 @@ fn artifacts_to_update(
                 // TODO: Using the first one.  Make sure to revisit this
                 // choice, don't think it matters for now.
                 path_id: ArtifactId::new(*loft_cmd.section_ids.first().ok_or_else(|| {
-                    KclError::Internal(KclErrorDetails {
+                    KclError::Internal(KclErrorDetails::new(
-                        message: format!("Expected at least one section ID in Loft command: {id:?}; cmd={cmd:?}"),
+                        format!("Expected at least one section ID in Loft command: {id:?}; cmd={cmd:?}"),
-                        source_ranges: vec![range],
+                        vec![range],
-                    })
+                    ))
                 })?),
                 surface_ids: Vec::new(),
                 edge_ids: Vec::new(),
@@ -1108,12 +1106,12 @@ fn artifacts_to_update(
                 };
                 last_path = Some(path);
                 let path_sweep_id = path.sweep_id.ok_or_else(|| {
-                    KclError::Internal(KclErrorDetails {
+                    KclError::Internal(KclErrorDetails::new(
-                        message:format!(
+                        format!(
                             "Expected a sweep ID on the path when processing Solid3dGetExtrusionFaceInfo command, but we have none: {id:?}, {path:?}"
                         ),
-                        source_ranges: vec![range],
+                        vec![range],
-                    })
+                    ))
                 })?;
                 let extra_artifact = exec_artifacts.values().find(|a| {
                     if let Artifact::StartSketchOnFace(s) = a {
@@ -1162,12 +1160,12 @@ fn artifacts_to_update(
                         continue;
                     };
                     let path_sweep_id = path.sweep_id.ok_or_else(|| {
-                        KclError::Internal(KclErrorDetails {
+                        KclError::Internal(KclErrorDetails::new(
-                            message:format!(
+                            format!(
                                 "Expected a sweep ID on the path when processing last path's Solid3dGetExtrusionFaceInfo command, but we have none: {id:?}, {path:?}"
                             ),
-                            source_ranges: vec![range],
+                            vec![range],
-                        })
+                        ))
                     })?;
                     let extra_artifact = exec_artifacts.values().find(|a| {
                         if let Artifact::StartSketchOnFace(s) = a {

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

@@ -131,10 +131,10 @@ impl ExecutorContext {
             match statement {
                 BodyItem::ImportStatement(import_stmt) => {
                     if !matches!(body_type, BodyType::Root) {
-                        return Err(KclError::Semantic(KclErrorDetails {
+                        return Err(KclError::Semantic(KclErrorDetails::new(
-                            message: "Imports are only supported at the top-level of a file.".to_owned(),
+                            "Imports are only supported at the top-level of a file.".to_owned(),
-                            source_ranges: vec![import_stmt.into()],
+                            vec![import_stmt.into()],
-                        }));
+                        )));
                     }
 
                     let source_range = SourceRange::from(import_stmt);
@@ -157,28 +157,25 @@ impl ExecutorContext {
                                 let mut ty = mem.get_from(&ty_name, env_ref, import_item.into(), 0).cloned();
 
                                 if value.is_err() && ty.is_err() {
-                                    return Err(KclError::UndefinedValue(KclErrorDetails {
+                                    return Err(KclError::UndefinedValue(KclErrorDetails::new(
-                                        message: format!("{} is not defined in module", import_item.name.name),
+                                        format!("{} is not defined in module", import_item.name.name),
-                                        source_ranges: vec![SourceRange::from(&import_item.name)],
+                                        vec![SourceRange::from(&import_item.name)],
-                                    }));
+                                    )));
                                 }
 
                                 // Check that the item is allowed to be imported (in at least one namespace).
                                 if value.is_ok() && !module_exports.contains(&import_item.name.name) {
-                                    value = Err(KclError::Semantic(KclErrorDetails {
+                                    value = Err(KclError::Semantic(KclErrorDetails::new(
-                                        message: format!(
+                                        format!(
                                             "Cannot import \"{}\" from module because it is not exported. Add \"export\" before the definition to export it.",
                                             import_item.name.name
                                         ),
-                                        source_ranges: vec![SourceRange::from(&import_item.name)],
+                                        vec![SourceRange::from(&import_item.name)],
-                                    }));
+                                    )));
                                 }
 
                                 if ty.is_ok() && !module_exports.contains(&ty_name) {
-                                    ty = Err(KclError::Semantic(KclErrorDetails {
+                                    ty = Err(KclError::Semantic(KclErrorDetails::new(String::new(), vec![])));
-                                        message: String::new(),
-                                        source_ranges: vec![],
-                                    }));
                                 }
 
                                 if value.is_err() && ty.is_err() {
@@ -225,10 +222,10 @@ impl ExecutorContext {
                                     .memory
                                     .get_from(name, env_ref, source_range, 0)
                                     .map_err(|_err| {
-                                        KclError::Internal(KclErrorDetails {
+                                        KclError::Internal(KclErrorDetails::new(
-                                            message: format!("{} is not defined in module (but was exported?)", name),
+                                            format!("{} is not defined in module (but was exported?)", name),
-                                            source_ranges: vec![source_range],
+                                            vec![source_range],
-                                        })
+                                        ))
                                     })?
                                     .clone();
                                 exec_state.mut_stack().add(name.to_owned(), item, source_range)?;
@@ -297,10 +294,10 @@ impl ExecutorContext {
                             let std_path = match &exec_state.mod_local.std_path {
                                 Some(p) => p,
                                 None => {
-                                    return Err(KclError::Semantic(KclErrorDetails {
+                                    return Err(KclError::Semantic(KclErrorDetails::new(
-                                        message: "User-defined types are not yet supported.".to_owned(),
+                                        "User-defined types are not yet supported.".to_owned(),
-                                        source_ranges: vec![metadata.source_range],
+                                        vec![metadata.source_range],
-                                    }));
+                                    )));
                                 }
                             };
                             let (t, props) = crate::std::std_ty(std_path, &ty.name.name);
@@ -313,10 +310,10 @@ impl ExecutorContext {
                                 .mut_stack()
                                 .add(name_in_mem.clone(), value, metadata.source_range)
                                 .map_err(|_| {
-                                    KclError::Semantic(KclErrorDetails {
+                                    KclError::Semantic(KclErrorDetails::new(
-                                        message: format!("Redefinition of type {}.", ty.name.name),
+                                        format!("Redefinition of type {}.", ty.name.name),
-                                        source_ranges: vec![metadata.source_range],
+                                        vec![metadata.source_range],
-                                    })
+                                    ))
                                 })?;
 
                             if let ItemVisibility::Export = ty.visibility {
@@ -343,10 +340,10 @@ impl ExecutorContext {
                                     .mut_stack()
                                     .add(name_in_mem.clone(), value, metadata.source_range)
                                     .map_err(|_| {
-                                        KclError::Semantic(KclErrorDetails {
+                                        KclError::Semantic(KclErrorDetails::new(
-                                            message: format!("Redefinition of type {}.", ty.name.name),
+                                            format!("Redefinition of type {}.", ty.name.name),
-                                            source_ranges: vec![metadata.source_range],
+                                            vec![metadata.source_range],
-                                        })
+                                        ))
                                     })?;
 
                                 if let ItemVisibility::Export = ty.visibility {
@@ -354,10 +351,10 @@ impl ExecutorContext {
                                 }
                             }
                             None => {
-                                return Err(KclError::Semantic(KclErrorDetails {
+                                return Err(KclError::Semantic(KclErrorDetails::new(
-                                    message: "User-defined types are not yet supported.".to_owned(),
+                                    "User-defined types are not yet supported.".to_owned(),
-                                    source_ranges: vec![metadata.source_range],
+                                    vec![metadata.source_range],
-                                }))
+                                )))
                             }
                         },
                     }
@@ -368,10 +365,10 @@ impl ExecutorContext {
                     let metadata = Metadata::from(return_statement);
 
                     if matches!(body_type, BodyType::Root) {
-                        return Err(KclError::Semantic(KclErrorDetails {
+                        return Err(KclError::Semantic(KclErrorDetails::new(
-                            message: "Cannot return from outside a function.".to_owned(),
+                            "Cannot return from outside a function.".to_owned(),
-                            source_ranges: vec![metadata.source_range],
+                            vec![metadata.source_range],
-                        }));
+                        )));
                     }
 
                     let value = self
@@ -387,10 +384,10 @@ impl ExecutorContext {
                         .mut_stack()
                         .add(memory::RETURN_NAME.to_owned(), value, metadata.source_range)
                         .map_err(|_| {
-                            KclError::Semantic(KclErrorDetails {
+                            KclError::Semantic(KclErrorDetails::new(
-                                message: "Multiple returns from a single function.".to_owned(),
+                                "Multiple returns from a single function.".to_owned(),
-                                source_ranges: vec![metadata.source_range],
+                                vec![metadata.source_range],
-                            })
+                            ))
                         })?;
                     last_expr = None;
                 }
@@ -493,10 +490,10 @@ impl ExecutorContext {
                     *cache = Some((val, er, items.clone()));
                     (er, items)
                 }),
-            ModuleRepr::Foreign(geom, _) => Err(KclError::Semantic(KclErrorDetails {
+            ModuleRepr::Foreign(geom, _) => Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Cannot import items from foreign modules".to_owned(),
+                "Cannot import items from foreign modules".to_owned(),
-                source_ranges: vec![geom.source_range],
+                vec![geom.source_range],
-            })),
+            ))),
             ModuleRepr::Dummy => unreachable!("Looking up {}, but it is still being interpreted", path),
         };
 
@@ -572,13 +569,13 @@ impl ExecutorContext {
                 err.override_source_ranges(vec![source_range])
             } else {
                 // TODO would be great to have line/column for the underlying error here
-                KclError::Semantic(KclErrorDetails {
+                KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "Error loading imported file ({path}). Open it to view more details.\n  {}",
                         err.message()
                     ),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             }
         })
     }
@@ -639,11 +636,10 @@ impl ExecutorContext {
                             meta: vec![metadata.to_owned()],
                         }
                     } else {
-                        return Err(KclError::Semantic(KclErrorDetails {
+                        return Err(KclError::Semantic(KclErrorDetails::new(
-                            message: "Rust implementation of functions is restricted to the standard library"
+                            "Rust implementation of functions is restricted to the standard library".to_owned(),
-                                .to_owned(),
+                            vec![metadata.source_range],
-                            source_ranges: vec![metadata.source_range],
+                        )));
-                        }));
                     }
                 } else {
                     // Snapshotting memory here is crucial for semantics so that we close
@@ -667,18 +663,18 @@ impl ExecutorContext {
                         "you cannot declare variable {name} as %, because % can only be used in function calls"
                     );
 
-                    return Err(KclError::Semantic(KclErrorDetails {
+                    return Err(KclError::Semantic(KclErrorDetails::new(
                         message,
-                        source_ranges: vec![pipe_substitution.into()],
+                        vec![pipe_substitution.into()],
-                    }));
+                    )));
                 }
                 StatementKind::Expression => match exec_state.mod_local.pipe_value.clone() {
                     Some(x) => x,
                     None => {
-                        return Err(KclError::Semantic(KclErrorDetails {
+                        return Err(KclError::Semantic(KclErrorDetails::new(
-                            message: "cannot use % outside a pipe expression".to_owned(),
+                            "cannot use % outside a pipe expression".to_owned(),
-                            source_ranges: vec![pipe_substitution.into()],
+                            vec![pipe_substitution.into()],
-                        }));
+                        )));
                     }
                 },
             },
@@ -750,13 +746,13 @@ fn apply_ascription(
         } else {
             ""
         };
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "could not coerce {} value to type {ty}{suggestion}",
                 value.human_friendly_type()
             ),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        })
+        ))
     })
 }
 
@@ -783,10 +779,10 @@ impl Node<Name> {
         ctx: &ExecutorContext,
     ) -> Result<&'a KclValue, KclError> {
         if self.abs_path {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Absolute paths (names beginning with `::` are not yet supported)".to_owned(),
+                "Absolute paths (names beginning with `::` are not yet supported)".to_owned(),
-                source_ranges: self.as_source_ranges(),
+                self.as_source_ranges(),
-            }));
+            )));
         }
 
         if self.path.is_empty() {
@@ -798,10 +794,10 @@ impl Node<Name> {
             let value = match mem_spec {
                 Some((env, exports)) => {
                     if !exports.contains(&p.name) {
-                        return Err(KclError::Semantic(KclErrorDetails {
+                        return Err(KclError::Semantic(KclErrorDetails::new(
-                            message: format!("Item {} not found in module's exported items", p.name),
+                            format!("Item {} not found in module's exported items", p.name),
-                            source_ranges: p.as_source_ranges(),
+                            p.as_source_ranges(),
-                        }));
+                        )));
                     }
 
                     exec_state
@@ -813,13 +809,13 @@ impl Node<Name> {
             };
 
             let KclValue::Module { value: module_id, .. } = value else {
-                return Err(KclError::Semantic(KclErrorDetails {
+                return Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "Identifier in path must refer to a module, found {}",
                         value.human_friendly_type()
                     ),
-                    source_ranges: p.as_source_ranges(),
+                    p.as_source_ranges(),
-                }));
+                )));
             };
 
             mem_spec = Some(
@@ -830,10 +826,10 @@ impl Node<Name> {
 
         let (env, exports) = mem_spec.unwrap();
         if !exports.contains(&self.name.name) {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Item {} not found in module's exported items", self.name.name),
+                format!("Item {} not found in module's exported items", self.name.name),
-                source_ranges: self.name.as_source_ranges(),
+                self.name.as_source_ranges(),
-            }));
+            )));
         }
 
         exec_state
@@ -861,46 +857,44 @@ impl Node<MemberExpression> {
                 if let Some(value) = map.get(&property) {
                     Ok(value.to_owned())
                 } else {
-                    Err(KclError::UndefinedValue(KclErrorDetails {
+                    Err(KclError::UndefinedValue(KclErrorDetails::new(
-                        message: format!("Property '{property}' not found in object"),
+                        format!("Property '{property}' not found in object"),
-                        source_ranges: vec![self.clone().into()],
+                        vec![self.clone().into()],
-                    }))
+                    )))
                 }
             }
-            (KclValue::Object { .. }, Property::String(property), true) => Err(KclError::Semantic(KclErrorDetails {
+            (KclValue::Object { .. }, Property::String(property), true) => {
-                message: format!("Cannot index object with string; use dot notation instead, e.g. `obj.{property}`"),
+                Err(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.clone().into()],
+                    format!("Cannot index object with string; use dot notation instead, e.g. `obj.{property}`"),
-            })),
+                    vec![self.clone().into()],
+                )))
+            }
             (KclValue::Object { .. }, p, _) => {
                 let t = p.type_name();
                 let article = article_for(t);
-                Err(KclError::Semantic(KclErrorDetails {
+                Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!("Only strings can be used as the property of an object, but you're using {article} {t}",),
-                        "Only strings can be used as the property of an object, but you're using {article} {t}",
+                    vec![self.clone().into()],
-                    ),
+                )))
-                    source_ranges: vec![self.clone().into()],
-                }))
             }
             (KclValue::HomArray { value: arr, .. }, Property::UInt(index), _) => {
                 let value_of_arr = arr.get(index);
                 if let Some(value) = value_of_arr {
                     Ok(value.to_owned())
                 } else {
-                    Err(KclError::UndefinedValue(KclErrorDetails {
+                    Err(KclError::UndefinedValue(KclErrorDetails::new(
-                        message: format!("The array doesn't have any item at index {index}"),
+                        format!("The array doesn't have any item at index {index}"),
-                        source_ranges: vec![self.clone().into()],
+                        vec![self.clone().into()],
-                    }))
+                    )))
                 }
             }
             (KclValue::HomArray { .. }, p, _) => {
                 let t = p.type_name();
                 let article = article_for(t);
-                Err(KclError::Semantic(KclErrorDetails {
+                Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!("Only integers >= 0 can be used as the index of an array, but you're using {article} {t}",),
-                        "Only integers >= 0 can be used as the index of an array, but you're using {article} {t}",
+                    vec![self.clone().into()],
-                    ),
+                )))
-                    source_ranges: vec![self.clone().into()],
-                }))
             }
             (KclValue::Solid { value }, Property::String(prop), false) if prop == "sketch" => Ok(KclValue::Sketch {
                 value: Box::new(value.sketch),
@@ -918,10 +912,10 @@ impl Node<MemberExpression> {
             (being_indexed, _, _) => {
                 let t = being_indexed.human_friendly_type();
                 let article = article_for(&t);
-                Err(KclError::Semantic(KclErrorDetails {
+                Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!("Only arrays can be indexed, but you're trying to index {article} {t}"),
+                    format!("Only arrays can be indexed, but you're trying to index {article} {t}"),
-                    source_ranges: vec![self.clone().into()],
+                    vec![self.clone().into()],
-                }))
+                )))
             }
         }
     }
@@ -996,26 +990,26 @@ impl Node<BinaryExpression> {
                 meta: _,
             } = left_value
             else {
-                return Err(KclError::Semantic(KclErrorDetails {
+                return Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "Cannot apply logical operator to non-boolean value: {}",
                         left_value.human_friendly_type()
                     ),
-                    source_ranges: vec![self.left.clone().into()],
+                    vec![self.left.clone().into()],
-                }));
+                )));
             };
             let KclValue::Bool {
                 value: right_value,
                 meta: _,
             } = right_value
             else {
-                return Err(KclError::Semantic(KclErrorDetails {
+                return Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "Cannot apply logical operator to non-boolean value: {}",
                         right_value.human_friendly_type()
                     ),
-                    source_ranges: vec![self.right.clone().into()],
+                    vec![self.right.clone().into()],
-                }));
+                )));
             };
             let raw_value = match self.operator {
                 BinaryOperator::Or => left_value || right_value,
@@ -1115,13 +1109,13 @@ impl Node<UnaryExpression> {
                 meta: _,
             } = value
             else {
-                return Err(KclError::Semantic(KclErrorDetails {
+                return Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "Cannot apply unary operator ! to non-boolean value: {}",
                         value.human_friendly_type()
                     ),
-                    source_ranges: vec![self.into()],
+                    vec![self.into()],
-                }));
+                )));
             };
             let meta = vec![Metadata {
                 source_range: self.into(),
@@ -1136,13 +1130,13 @@ impl Node<UnaryExpression> {
 
         let value = &self.argument.get_result(exec_state, ctx).await?;
         let err = || {
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "You can only negate numbers, planes, or lines, but this is a {}",
                     value.human_friendly_type()
                 ),
-                source_ranges: vec![self.into()],
+                vec![self.into()],
-            })
+            ))
         };
         match value {
             KclValue::Number { value, ty, .. } => {
@@ -1239,10 +1233,10 @@ pub(crate) async fn execute_pipe_body(
     ctx: &ExecutorContext,
 ) -> Result<KclValue, KclError> {
     let Some((first, body)) = body.split_first() else {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: "Pipe expressions cannot be empty".to_owned(),
+            "Pipe expressions cannot be empty".to_owned(),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        }));
+        )));
     };
     // Evaluate the first element in the pipeline.
     // They use the pipe_value from some AST node above this, so that if pipe expression is nested in a larger pipe expression,
@@ -1277,10 +1271,10 @@ async fn inner_execute_pipe_body(
 ) -> Result<KclValue, KclError> {
     for expression in body {
         if let Expr::TagDeclarator(_) = expression {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("This cannot be in a PipeExpression: {:?}", expression),
+                format!("This cannot be in a PipeExpression: {:?}", expression),
-                source_ranges: vec![expression.into()],
+                vec![expression.into()],
-            }));
+            )));
         }
         let metadata = Metadata {
             source_range: SourceRange::from(expression),
@@ -1349,35 +1343,37 @@ impl Node<ArrayRangeExpression> {
                 StatementKind::Expression,
             )
             .await?;
-        let (start, start_ty) = start_val.as_int_with_ty().ok_or(KclError::Semantic(KclErrorDetails {
+        let (start, start_ty) = start_val
-            source_ranges: vec![self.into()],
+            .as_int_with_ty()
-            message: format!("Expected int but found {}", start_val.human_friendly_type()),
+            .ok_or(KclError::Semantic(KclErrorDetails::new(
-        }))?;
+                format!("Expected int but found {}", start_val.human_friendly_type()),
+                vec![self.into()],
+            )))?;
         let metadata = Metadata::from(&self.end_element);
         let end_val = ctx
             .execute_expr(&self.end_element, exec_state, &metadata, &[], StatementKind::Expression)
             .await?;
-        let (end, end_ty) = end_val.as_int_with_ty().ok_or(KclError::Semantic(KclErrorDetails {
+        let (end, end_ty) = end_val.as_int_with_ty().ok_or(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![self.into()],
+            format!("Expected int but found {}", end_val.human_friendly_type()),
-            message: format!("Expected int but found {}", end_val.human_friendly_type()),
+            vec![self.into()],
-        }))?;
+        )))?;
 
         if start_ty != end_ty {
             let start = start_val.as_ty_f64().unwrap_or(TyF64 { n: 0.0, ty: start_ty });
             let start = fmt::human_display_number(start.n, start.ty);
             let end = end_val.as_ty_f64().unwrap_or(TyF64 { n: 0.0, ty: end_ty });
             let end = fmt::human_display_number(end.n, end.ty);
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.into()],
+                format!("Range start and end must be of the same type, but found {start} and {end}"),
-                message: format!("Range start and end must be of the same type, but found {start} and {end}"),
+                vec![self.into()],
-            }));
+            )));
         }
 
         if end < start {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.into()],
+                format!("Range start is greater than range end: {start} .. {end}"),
-                message: format!("Range start is greater than range end: {start} .. {end}"),
+                vec![self.into()],
-            }));
+            )));
         }
 
         let range: Vec<_> = if self.end_inclusive {
@@ -1438,10 +1434,10 @@ fn article_for<S: AsRef<str>>(s: S) -> &'static str {
 fn number_as_f64(v: &KclValue, source_range: SourceRange) -> Result<TyF64, KclError> {
     v.as_ty_f64().ok_or_else(|| {
         let actual_type = v.human_friendly_type();
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![source_range],
+            format!("Expected a number, but found {actual_type}",),
-            message: format!("Expected a number, but found {actual_type}",),
+            vec![source_range],
-        })
+        ))
     })
 }
 
@@ -1530,16 +1526,16 @@ impl Property {
                         if let Some(x) = crate::try_f64_to_usize(value) {
                             Ok(Property::UInt(x))
                         } else {
-                            Err(KclError::Semantic(KclErrorDetails {
+                            Err(KclError::Semantic(KclErrorDetails::new(
-                                source_ranges: property_sr,
+                                format!("{value} is not a valid index, indices must be whole numbers >= 0"),
-                                message: format!("{value} is not a valid index, indices must be whole numbers >= 0"),
+                                property_sr,
-                            }))
+                            )))
                         }
                     }
-                    _ => Err(KclError::Semantic(KclErrorDetails {
+                    _ => Err(KclError::Semantic(KclErrorDetails::new(
-                        source_ranges: vec![sr],
+                        "Only numbers (>= 0) can be indexes".to_owned(),
-                        message: "Only numbers (>= 0) can be indexes".to_owned(),
+                        vec![sr],
-                    })),
+                    ))),
                 }
             }
         }
@@ -1547,12 +1543,7 @@ impl Property {
 }
 
 fn jvalue_to_prop(value: &KclValue, property_sr: Vec<SourceRange>, name: &str) -> Result<Property, KclError> {
-    let make_err = |message: String| {
+    let make_err = |message: String| Err::<Property, _>(KclError::Semantic(KclErrorDetails::new(message, property_sr)));
-        Err::<Property, _>(KclError::Semantic(KclErrorDetails {
-            source_ranges: property_sr,
-            message,
-        }))
-    };
     match value {
         KclValue::Number{value: num, .. } => {
             let num = *num;
@@ -1795,10 +1786,10 @@ d = b + c
                 crate::engine::conn_mock::EngineConnection::new()
                     .await
                     .map_err(|err| {
-                        KclError::Internal(crate::errors::KclErrorDetails {
+                        KclError::Internal(KclErrorDetails::new(
-                            message: format!("Failed to create mock engine connection: {}", err),
+                            format!("Failed to create mock engine connection: {}", err),
-                            source_ranges: vec![SourceRange::default()],
+                            vec![SourceRange::default()],
-                        })
+                        ))
                     })
                     .unwrap(),
             )),

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

@@ -1,13 +1,16 @@
 use async_recursion::async_recursion;
 use indexmap::IndexMap;
 
-use crate::execution::cad_op::{Group, OpArg, OpKclValue, Operation};
+use super::{types::ArrayLen, EnvironmentRef};
 use crate::{
     docs::StdLibFn,
     errors::{KclError, KclErrorDetails},
     execution::{
-        kcl_value::FunctionSource, memory, types::RuntimeType, BodyType, ExecState, ExecutorContext, KclValue,
+        cad_op::{Group, OpArg, OpKclValue, Operation},
-        Metadata, StatementKind, TagEngineInfo, TagIdentifier,
+        kcl_value::FunctionSource,
+        memory,
+        types::RuntimeType,
+        BodyType, ExecState, ExecutorContext, KclValue, Metadata, StatementKind, TagEngineInfo, TagIdentifier,
     },
     parsing::ast::types::{CallExpressionKw, DefaultParamVal, FunctionExpression, Node, Program, Type},
     source_range::SourceRange,
@@ -15,9 +18,6 @@ use crate::{
     CompilationError,
 };
 
-use super::types::ArrayLen;
-use super::EnvironmentRef;
-
 #[derive(Debug, Clone)]
 pub struct Args {
     /// Positional args.
@@ -281,6 +281,13 @@ impl Node<CallExpressionKw> {
                 def.call_kw(Some(func.name()), exec_state, ctx, args, callsite)
                     .await
                     .map(Option::unwrap)
+                    .map_err(|e| {
+                        // This is used for the backtrace display.  We don't add
+                        // another location the way we do for user-defined
+                        // functions because the error uses the Args, which
+                        // already points here.
+                        e.set_last_backtrace_fn_name(Some(func.name()))
+                    })
             }
             None => {
                 // Clone the function so that we can use a mutable reference to
@@ -288,10 +295,10 @@ impl Node<CallExpressionKw> {
                 let func = fn_name.get_result(exec_state, ctx).await?.clone();
 
                 let Some(fn_src) = func.as_fn() else {
-                    return Err(KclError::Semantic(KclErrorDetails {
+                    return Err(KclError::Semantic(KclErrorDetails::new(
-                        message: "cannot call this because it isn't a function".to_string(),
+                        "cannot call this because it isn't a function".to_string(),
-                        source_ranges: vec![callsite],
+                        vec![callsite],
-                    }));
+                    )));
                 };
 
                 let return_value = fn_src
@@ -299,7 +306,10 @@ impl Node<CallExpressionKw> {
                     .await
                     .map_err(|e| {
                         // Add the call expression to the source ranges.
-                        e.add_source_ranges(vec![callsite])
+                        //
+                        // TODO: Use the name that the function was defined
+                        // with, not the identifier it was used with.
+                        e.add_unwind_location(Some(fn_name.name.name.clone()), callsite)
                     })?;
 
                 let result = return_value.ok_or_else(move || {
@@ -308,10 +318,10 @@ impl Node<CallExpressionKw> {
                     if let KclValue::Function { meta, .. } = func {
                         source_ranges = meta.iter().map(|m| m.source_range).collect();
                     };
-                    KclError::UndefinedValue(KclErrorDetails {
+                    KclError::UndefinedValue(KclErrorDetails::new(
-                        message: format!("Result of user-defined function {} is undefined", fn_name),
+                        format!("Result of user-defined function {} is undefined", fn_name),
                         source_ranges,
-                    })
+                    ))
                 })?;
 
                 Ok(result)
@@ -490,10 +500,10 @@ fn update_memory_for_tags_of_geometry(result: &mut KclValue, exec_state: &mut Ex
                     let tag_id = if let Some(t) = value.sketch.tags.get(&tag.name) {
                         let mut t = t.clone();
                         let Some(info) = t.get_cur_info() else {
-                            return Err(KclError::Internal(KclErrorDetails {
+                            return Err(KclError::Internal(KclErrorDetails::new(
-                                message: format!("Tag {} does not have path info", tag.name),
+                                format!("Tag {} does not have path info", tag.name),
-                                source_ranges: vec![tag.into()],
+                                vec![tag.into()],
-                            }));
+                            )));
                         };
 
                         let mut info = info.clone();
@@ -608,10 +618,10 @@ fn type_check_params_kw(
                                 // TODO if we have access to the AST for the argument we could choose which example to suggest.
                                 message = format!("{message}\n\nYou may need to add information about the type of the argument, for example:\n  using a numeric suffix: `42{ty}`\n  or using type ascription: `foo(): number({ty})`");
                             }
-                            KclError::Semantic(KclErrorDetails {
+                            KclError::Semantic(KclErrorDetails::new(
                                 message,
-                                source_ranges: vec![arg.source_range],
+                                vec![arg.source_range],
-                            })
+                            ))
                         })?;
                 }
             }
@@ -673,8 +683,8 @@ fn type_check_params_kw(
                     exec_state,
                 )
                 .map_err(|_| {
-                    KclError::Semantic(KclErrorDetails {
+                    KclError::Semantic(KclErrorDetails::new(
-                        message: format!(
+                        format!(
                             "The input argument of {} requires a value with type `{}`, but found {}",
                             fn_name
                                 .map(|n| format!("`{}`", n))
@@ -682,8 +692,8 @@ fn type_check_params_kw(
                             ty,
                             arg.1.value.human_friendly_type()
                         ),
-                        source_ranges: vec![arg.1.source_range],
+                        vec![arg.1.source_range],
-                    })
+                    ))
                 })?;
         }
     } else if let Some((name, _)) = &fn_def.input_arg {
@@ -730,13 +740,13 @@ fn assign_args_to_params_kw(
                         .add(name.clone(), value, default_val.source_range())?;
                 }
                 None => {
-                    return Err(KclError::Semantic(KclErrorDetails {
+                    return Err(KclError::Semantic(KclErrorDetails::new(
-                        source_ranges,
+                        format!(
-                        message: format!(
                             "This function requires a parameter {}, but you haven't passed it one.",
                             name
                         ),
-                    }));
+                        source_ranges,
+                    )));
                 }
             },
         }
@@ -747,16 +757,15 @@ fn assign_args_to_params_kw(
 
         let Some(unlabeled) = unlabelled else {
             return Err(if args.kw_args.labeled.contains_key(param_name) {
-                KclError::Semantic(KclErrorDetails {
+                KclError::Semantic(KclErrorDetails::new(
+                    format!("The function does declare a parameter named '{param_name}', but this parameter doesn't use a label. Try removing the `{param_name}:`"),
                     source_ranges,
-                    message: format!("The function does declare a parameter named '{param_name}', but this parameter doesn't use a label. Try removing the `{param_name}:`"),
+                ))
-                })
             } else {
-                KclError::Semantic(KclErrorDetails {
+                KclError::Semantic(KclErrorDetails::new(
+                    "This function expects an unlabeled first parameter, but you haven't passed it one.".to_owned(),
                     source_ranges,
-                    message: "This function expects an unlabeled first parameter, but you haven't passed it one."
+                ))
-                        .to_owned(),
-                })
             });
         };
         exec_state.mut_stack().add(
@@ -789,14 +798,14 @@ fn coerce_result_type(
                 ty = RuntimeType::Union(vec![(**inner).clone(), ty]);
             }
             let val = val.coerce(&ty, exec_state).map_err(|_| {
-                KclError::Semantic(KclErrorDetails {
+                KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "This function requires its result to be of type `{}`, but found {}",
                         ty.human_friendly_type(),
                         val.human_friendly_type(),
                     ),
-                    source_ranges: ret_ty.as_source_ranges(),
+                    ret_ty.as_source_ranges(),
-                })
+                ))
             })?;
             Ok(Some(val))
         } else {
@@ -873,10 +882,10 @@ mod test {
                 "all params required, none given, should error",
                 vec![req_param("x")],
                 vec![],
-                Err(KclError::Semantic(KclErrorDetails {
+                Err(KclError::Semantic(KclErrorDetails::new(
-                    source_ranges: vec![SourceRange::default()],
+                    "This function requires a parameter x, but you haven't passed it one.".to_owned(),
-                    message: "This function requires a parameter x, but you haven't passed it one.".to_owned(),
+                    vec![SourceRange::default()],
-                })),
+                ))),
             ),
             (
                 "all params optional, none given, should be OK",
@@ -888,10 +897,10 @@ mod test {
                 "mixed params, too few given",
                 vec![req_param("x"), opt_param("y")],
                 vec![],
-                Err(KclError::Semantic(KclErrorDetails {
+                Err(KclError::Semantic(KclErrorDetails::new(
-                    source_ranges: vec![SourceRange::default()],
+                    "This function requires a parameter x, but you haven't passed it one.".to_owned(),
-                    message: "This function requires a parameter x, but you haven't passed it one.".to_owned(),
+                    vec![SourceRange::default()],
-                })),
+                ))),
             ),
             (
                 "mixed params, minimum given, should be OK",

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

@@ -469,18 +469,18 @@ impl TryFrom<PlaneData> for PlaneInfo {
             PlaneData::NegYZ => PlaneName::NegYz,
             PlaneData::Plane(_) => {
                 // We will never get here since we already checked for PlaneData::Plane.
-                return Err(KclError::Internal(KclErrorDetails {
+                return Err(KclError::Internal(KclErrorDetails::new(
-                    message: format!("PlaneData {:?} not found", value),
+                    format!("PlaneData {:?} not found", value),
-                    source_ranges: Default::default(),
+                    Default::default(),
-                }));
+                )));
             }
         };
 
         let info = DEFAULT_PLANE_INFO.get(&name).ok_or_else(|| {
-            KclError::Internal(KclErrorDetails {
+            KclError::Internal(KclErrorDetails::new(
-                message: format!("Plane {} not found", name),
+                format!("Plane {} not found", name),
-                source_ranges: Default::default(),
+                Default::default(),
-            })
+            ))
         })?;
 
         Ok(info.clone())

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

@@ -37,53 +37,43 @@ pub async fn import_foreign(
 ) -> Result<PreImportedGeometry, KclError> {
     // Make sure the file exists.
     if !ctxt.fs.exists(file_path, source_range).await? {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: format!("File `{}` does not exist.", file_path.display()),
+            format!("File `{}` does not exist.", file_path.display()),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        }));
+        )));
     }
 
     let ext_format = get_import_format_from_extension(file_path.extension().ok_or_else(|| {
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            message: format!("No file extension found for `{}`", file_path.display()),
+            format!("No file extension found for `{}`", file_path.display()),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        })
+        ))
     })?)
-    .map_err(|e| {
+    .map_err(|e| KclError::Semantic(KclErrorDetails::new(e.to_string(), vec![source_range])))?;
-        KclError::Semantic(KclErrorDetails {
-            message: e.to_string(),
-            source_ranges: vec![source_range],
-        })
-    })?;
 
     // Get the format type from the extension of the file.
     let format = if let Some(format) = format {
         // Validate the given format with the extension format.
-        validate_extension_format(ext_format, format.clone()).map_err(|e| {
+        validate_extension_format(ext_format, format.clone())
-            KclError::Semantic(KclErrorDetails {
+            .map_err(|e| KclError::Semantic(KclErrorDetails::new(e.to_string(), vec![source_range])))?;
-                message: e.to_string(),
-                source_ranges: vec![source_range],
-            })
-        })?;
         format
     } else {
         ext_format
     };
 
     // Get the file contents for each file path.
-    let file_contents = ctxt.fs.read(file_path, source_range).await.map_err(|e| {
+    let file_contents = ctxt
-        KclError::Semantic(KclErrorDetails {
+        .fs
-            message: e.to_string(),
+        .read(file_path, source_range)
-            source_ranges: vec![source_range],
+        .await
-        })
+        .map_err(|e| KclError::Semantic(KclErrorDetails::new(e.to_string(), vec![source_range])))?;
-    })?;
 
     // We want the file_path to be without the parent.
     let file_name = file_path.file_name().map(|p| p.to_string()).ok_or_else(|| {
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            message: format!("Could not get the file name from the path `{}`", file_path.display()),
+            format!("Could not get the file name from the path `{}`", file_path.display()),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        })
+        ))
     })?;
     let mut import_files = vec![kcmc::ImportFile {
         path: file_name.to_string(),
@@ -96,12 +86,8 @@ pub async fn import_foreign(
         // Check if the file is a binary gltf file, in that case we don't need to import the bin
         // file.
         if !file_contents.starts_with(b"glTF") {
-            let json = gltf_json::Root::from_slice(&file_contents).map_err(|e| {
+            let json = gltf_json::Root::from_slice(&file_contents)
-                KclError::Semantic(KclErrorDetails {
+                .map_err(|e| KclError::Semantic(KclErrorDetails::new(e.to_string(), vec![source_range])))?;
-                    message: e.to_string(),
-                    source_ranges: vec![source_range],
-                })
-            })?;
 
             // Read the gltf file and check if there is a bin file.
             for buffer in json.buffers.iter() {
@@ -109,18 +95,16 @@ pub async fn import_foreign(
                     if !uri.starts_with("data:") {
                         // We want this path relative to the file_path given.
                         let bin_path = file_path.parent().map(|p| p.join(uri)).ok_or_else(|| {
-                            KclError::Semantic(KclErrorDetails {
+                            KclError::Semantic(KclErrorDetails::new(
-                                message: format!("Could not get the parent path of the file `{}`", file_path.display()),
+                                format!("Could not get the parent path of the file `{}`", file_path.display()),
-                                source_ranges: vec![source_range],
+                                vec![source_range],
-                            })
+                            ))
                         })?;
 
-                        let bin_contents = ctxt.fs.read(&bin_path, source_range).await.map_err(|e| {
+                        let bin_contents =
-                            KclError::Semantic(KclErrorDetails {
+                            ctxt.fs.read(&bin_path, source_range).await.map_err(|e| {
-                                message: e.to_string(),
+                                KclError::Semantic(KclErrorDetails::new(e.to_string(), vec![source_range]))
-                                source_ranges: vec![source_range],
+                            })?;
-                            })
-                        })?;
 
                         import_files.push(ImportFile {
                             path: uri.to_string(),
@@ -157,13 +141,13 @@ pub(super) fn format_from_annotations(
         if p.key.name == annotations::IMPORT_FORMAT {
             result = Some(
                 get_import_format_from_extension(annotations::expect_ident(&p.value)?).map_err(|_| {
-                    KclError::Semantic(KclErrorDetails {
+                    KclError::Semantic(KclErrorDetails::new(
-                        message: format!(
+                        format!(
                             "Unknown format for import, expected one of: {}",
                             crate::IMPORT_FILE_EXTENSIONS.join(", ")
                         ),
-                        source_ranges: vec![p.as_source_range()],
+                        vec![p.as_source_range()],
-                    })
+                    ))
                 })?,
             );
             break;
@@ -175,10 +159,10 @@ pub(super) fn format_from_annotations(
             path.extension()
                 .and_then(|ext| get_import_format_from_extension(ext).ok())
         })
-        .ok_or(KclError::Semantic(KclErrorDetails {
+        .ok_or(KclError::Semantic(KclErrorDetails::new(
-            message: "Unknown or missing extension, and no specified format for imported file".to_owned(),
+            "Unknown or missing extension, and no specified format for imported file".to_owned(),
-            source_ranges: vec![import_source_range],
+            vec![import_source_range],
-        }))?;
+        )))?;
 
     for p in props {
         match p.key.name.as_str() {
@@ -190,15 +174,15 @@ pub(super) fn format_from_annotations(
             }
             annotations::IMPORT_FORMAT => {}
             _ => {
-                return Err(KclError::Semantic(KclErrorDetails {
+                return Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "Unexpected annotation for import, expected one of: {}, {}, {}",
                         annotations::IMPORT_FORMAT,
                         annotations::IMPORT_COORDS,
                         annotations::IMPORT_LENGTH_UNIT
                     ),
-                    source_ranges: vec![p.as_source_range()],
+                    vec![p.as_source_range()],
-                }))
+                )))
             }
         }
     }
@@ -215,8 +199,8 @@ fn set_coords(fmt: &mut InputFormat3d, coords_str: &str, source_range: SourceRan
     }
 
     let Some(coords) = coords else {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "Unknown coordinate system: {coords_str}, expected one of: {}",
                 annotations::IMPORT_COORDS_VALUES
                     .iter()
@@ -224,8 +208,8 @@ fn set_coords(fmt: &mut InputFormat3d, coords_str: &str, source_range: SourceRan
                     .collect::<Vec<_>>()
                     .join(", ")
             ),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        }));
+        )));
     };
 
     match fmt {
@@ -233,13 +217,13 @@ fn set_coords(fmt: &mut InputFormat3d, coords_str: &str, source_range: SourceRan
         InputFormat3d::Ply(opts) => opts.coords = coords,
         InputFormat3d::Stl(opts) => opts.coords = coords,
         _ => {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "`{}` option cannot be applied to the specified format",
                     annotations::IMPORT_COORDS
                 ),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            }))
+            )))
         }
     }
 
@@ -254,13 +238,13 @@ fn set_length_unit(fmt: &mut InputFormat3d, units_str: &str, source_range: Sourc
         InputFormat3d::Ply(opts) => opts.units = units.into(),
         InputFormat3d::Stl(opts) => opts.units = units.into(),
         _ => {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "`{}` option cannot be applied to the specified format",
                     annotations::IMPORT_LENGTH_UNIT
                 ),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            }))
+            )))
         }
     }
 

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

@@ -543,17 +543,13 @@ impl KclValue {
     /// If this value fits in a u32, return it.
     pub fn get_u32(&self, source_ranges: Vec<SourceRange>) -> Result<u32, KclError> {
         let u = self.as_int().and_then(|n| u64::try_from(n).ok()).ok_or_else(|| {
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(
-                message: "Expected an integer >= 0".to_owned(),
+                "Expected an integer >= 0".to_owned(),
-                source_ranges: source_ranges.clone(),
+                source_ranges.clone(),
-            })
+            ))
         })?;
-        u32::try_from(u).map_err(|_| {
+        u32::try_from(u)
-            KclError::Semantic(KclErrorDetails {
+            .map_err(|_| KclError::Semantic(KclErrorDetails::new("Number was too big".to_owned(), source_ranges)))
-                message: "Number was too big".to_owned(),
-                source_ranges,
-            })
-        })
     }
 
     /// If this value is of type function, return it.
@@ -568,10 +564,10 @@ impl KclValue {
     pub fn get_tag_identifier(&self) -> Result<TagIdentifier, KclError> {
         match self {
             KclValue::TagIdentifier(t) => Ok(*t.clone()),
-            _ => Err(KclError::Semantic(KclErrorDetails {
+            _ => Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Not a tag identifier: {:?}", self),
+                format!("Not a tag identifier: {:?}", self),
-                source_ranges: self.clone().into(),
+                self.clone().into(),
-            })),
+            ))),
         }
     }
 
@@ -579,20 +575,20 @@ impl KclValue {
     pub fn get_tag_declarator(&self) -> Result<TagNode, KclError> {
         match self {
             KclValue::TagDeclarator(t) => Ok((**t).clone()),
-            _ => Err(KclError::Semantic(KclErrorDetails {
+            _ => Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Not a tag declarator: {:?}", self),
+                format!("Not a tag declarator: {:?}", self),
-                source_ranges: self.clone().into(),
+                self.clone().into(),
-            })),
+            ))),
         }
     }
 
     /// If this KCL value is a bool, retrieve it.
     pub fn get_bool(&self) -> Result<bool, KclError> {
         let Self::Bool { value: b, .. } = self else {
-            return Err(KclError::Type(KclErrorDetails {
+            return Err(KclError::Type(KclErrorDetails::new(
-                source_ranges: self.into(),
+                format!("Expected bool, found {}", self.human_friendly_type()),
-                message: format!("Expected bool, found {}", self.human_friendly_type()),
+                self.into(),
-            }));
+            )));
         };
         Ok(*b)
     }

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

@@ -364,10 +364,10 @@ impl ProgramMemory {
             };
         }
 
-        Err(KclError::UndefinedValue(KclErrorDetails {
+        Err(KclError::UndefinedValue(KclErrorDetails::new(
-            message: format!("`{}` is not defined", var),
+            format!("`{}` is not defined", var),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        }))
+        )))
     }
 
     /// Iterate over all key/value pairs in the specified environment which satisfy the provided
@@ -485,10 +485,10 @@ impl ProgramMemory {
             };
         }
 
-        Err(KclError::UndefinedValue(KclErrorDetails {
+        Err(KclError::UndefinedValue(KclErrorDetails::new(
-            message: format!("`{}` is not defined", var),
+            format!("`{}` is not defined", var),
-            source_ranges: vec![],
+            vec![],
-        }))
+        )))
     }
 }
 
@@ -643,10 +643,10 @@ impl Stack {
     pub fn add(&mut self, key: String, value: KclValue, source_range: SourceRange) -> Result<(), KclError> {
         let env = self.memory.get_env(self.current_env.index());
         if env.contains_key(&key) {
-            return Err(KclError::ValueAlreadyDefined(KclErrorDetails {
+            return Err(KclError::ValueAlreadyDefined(KclErrorDetails::new(
-                message: format!("Cannot redefine `{}`", key),
+                format!("Cannot redefine `{}`", key),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            }));
+            )));
         }
 
         self.memory.stats.mutation_count.fetch_add(1, Ordering::Relaxed);

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

@@ -858,10 +858,9 @@ impl ExecutorContext {
 
             for module in modules {
                 let Some((import_stmt, module_id, module_path, repr)) = universe.get(&module) else {
-                    return Err(KclErrorWithOutputs::no_outputs(KclError::Internal(KclErrorDetails {
+                    return Err(KclErrorWithOutputs::no_outputs(KclError::Internal(
-                        message: format!("Module {module} not found in universe"),
+                        KclErrorDetails::new(format!("Module {module} not found in universe"), Default::default()),
-                        source_ranges: Default::default(),
+                    )));
-                    })));
                 };
                 let module_id = *module_id;
                 let module_path = module_path.clone();
@@ -921,10 +920,10 @@ impl ExecutorContext {
 
                             result.map(|val| ModuleRepr::Foreign(geom.clone(), val))
                         }
-                        ModuleRepr::Dummy | ModuleRepr::Root => Err(KclError::Internal(KclErrorDetails {
+                        ModuleRepr::Dummy | ModuleRepr::Root => Err(KclError::Internal(KclErrorDetails::new(
-                            message: format!("Module {module_path} not found in universe"),
+                            format!("Module {module_path} not found in universe"),
-                            source_ranges: vec![source_range],
+                            vec![source_range],
-                        })),
+                        ))),
                     }
                 };
 
@@ -1288,10 +1287,10 @@ impl ExecutorContext {
             .await?;
 
         let kittycad_modeling_cmds::websocket::OkWebSocketResponseData::Export { files } = resp else {
-            return Err(KclError::Internal(crate::errors::KclErrorDetails {
+            return Err(KclError::Internal(crate::errors::KclErrorDetails::new(
-                message: format!("Expected Export response, got {resp:?}",),
+                format!("Expected Export response, got {resp:?}",),
-                source_ranges: vec![SourceRange::default()],
+                vec![SourceRange::default()],
-            }));
+            )));
         };
 
         Ok(files)
@@ -1308,10 +1307,10 @@ impl ExecutorContext {
                     coords: *kittycad_modeling_cmds::coord::KITTYCAD,
                     created: if deterministic_time {
                         Some("2021-01-01T00:00:00Z".parse().map_err(|e| {
-                            KclError::Internal(crate::errors::KclErrorDetails {
+                            KclError::Internal(crate::errors::KclErrorDetails::new(
-                                message: format!("Failed to parse date: {}", e),
+                                format!("Failed to parse date: {}", e),
-                                source_ranges: vec![SourceRange::default()],
+                                vec![SourceRange::default()],
-                            })
+                            ))
                         })?)
                     } else {
                         None
@@ -1388,10 +1387,10 @@ pub(crate) async fn parse_execute_with_project_dir(
     let exec_ctxt = ExecutorContext {
         engine: Arc::new(Box::new(
             crate::engine::conn_mock::EngineConnection::new().await.map_err(|err| {
-                KclError::Internal(crate::errors::KclErrorDetails {
+                KclError::Internal(crate::errors::KclErrorDetails::new(
-                    message: format!("Failed to create mock engine connection: {}", err),
+                    format!("Failed to create mock engine connection: {}", err),
-                    source_ranges: vec![SourceRange::default()],
+                    vec![SourceRange::default()],
-                })
+                ))
             })?,
         )),
         fs: Arc::new(crate::fs::FileManager::new()),
@@ -1804,10 +1803,10 @@ foo
         let err = result.unwrap_err();
         assert_eq!(
             err,
-            KclError::Syntax(KclErrorDetails {
+            KclError::Syntax(KclErrorDetails::new(
-                message: "Unexpected token: #".to_owned(),
+                "Unexpected token: #".to_owned(),
-                source_ranges: vec![SourceRange::new(14, 15, ModuleId::default())],
+                vec![SourceRange::new(14, 15, ModuleId::default())],
-            }),
+            )),
         );
     }
 
@@ -2063,10 +2062,10 @@ notTagIdentifier = !myTag";
             // TODO: We don't currently parse this, but we should.  It should be
             // a runtime error instead.
             parse_execute(code10).await.unwrap_err(),
-            KclError::Syntax(KclErrorDetails {
+            KclError::Syntax(KclErrorDetails::new(
-                message: "Unexpected token: !".to_owned(),
+                "Unexpected token: !".to_owned(),
-                source_ranges: vec![SourceRange::new(10, 11, ModuleId::default())],
+                vec![SourceRange::new(10, 11, ModuleId::default())],
-            })
+            ))
         );
 
         let code11 = "
@@ -2076,10 +2075,10 @@ notPipeSub = 1 |> identity(!%))";
             // TODO: We don't currently parse this, but we should.  It should be
             // a runtime error instead.
             parse_execute(code11).await.unwrap_err(),
-            KclError::Syntax(KclErrorDetails {
+            KclError::Syntax(KclErrorDetails::new(
-                message: "Unexpected token: |>".to_owned(),
+                "Unexpected token: |>".to_owned(),
-                source_ranges: vec![SourceRange::new(44, 46, ModuleId::default())],
+                vec![SourceRange::new(44, 46, ModuleId::default())],
-            })
+            ))
         );
 
         // TODO: Add these tests when we support these types.

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

@@ -276,8 +276,8 @@ impl ExecState {
     }
 
     pub(super) fn circular_import_error(&self, path: &ModulePath, source_range: SourceRange) -> KclError {
-        KclError::ImportCycle(KclErrorDetails {
+        KclError::ImportCycle(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "circular import of modules is not allowed: {} -> {}",
                 self.global
                     .mod_loader
@@ -288,8 +288,8 @@ impl ExecState {
                     .join(" -> "),
                 path,
             ),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        })
+        ))
     }
 
     pub(crate) fn pipe_value(&self) -> Option<&KclValue> {
@@ -389,14 +389,14 @@ impl MetaSettings {
                     self.kcl_version = value;
                 }
                 name => {
-                    return Err(KclError::Semantic(KclErrorDetails {
+                    return Err(KclError::Semantic(KclErrorDetails::new(
-                        message: format!(
+                        format!(
                             "Unexpected settings key: `{name}`; expected one of `{}`, `{}`",
                             annotations::SETTINGS_UNIT_LENGTH,
                             annotations::SETTINGS_UNIT_ANGLE
                         ),
-                        source_ranges: vec![annotation.as_source_range()],
+                        vec![annotation.as_source_range()],
-                    }))
+                    )))
                 }
             }
         }

rust/kcl-lib/src/fs/local.rs

@@ -28,19 +28,19 @@ impl Default for FileManager {
 impl FileSystem for FileManager {
     async fn read(&self, path: &TypedPath, source_range: SourceRange) -> Result<Vec<u8>, KclError> {
         tokio::fs::read(&path.0).await.map_err(|e| {
-            KclError::Io(KclErrorDetails {
+            KclError::Io(KclErrorDetails::new(
-                message: format!("Failed to read file `{}`: {}", path.display(), e),
+                format!("Failed to read file `{}`: {}", path.display(), e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })
     }
 
     async fn read_to_string(&self, path: &TypedPath, source_range: SourceRange) -> Result<String, KclError> {
         tokio::fs::read_to_string(&path.0).await.map_err(|e| {
-            KclError::Io(KclErrorDetails {
+            KclError::Io(KclErrorDetails::new(
-                message: format!("Failed to read file `{}`: {}", path.display(), e),
+                format!("Failed to read file `{}`: {}", path.display(), e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })
     }
 
@@ -49,10 +49,10 @@ impl FileSystem for FileManager {
             if e.kind() == std::io::ErrorKind::NotFound {
                 Ok(false)
             } else {
-                Err(KclError::Io(KclErrorDetails {
+                Err(KclError::Io(KclErrorDetails::new(
-                    message: format!("Failed to check if file `{}` exists: {}", path.display(), e),
+                    format!("Failed to check if file `{}` exists: {}", path.display(), e),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                }))
+                )))
             }
         })
     }
@@ -71,10 +71,10 @@ impl FileSystem for FileManager {
             }
 
             let mut read_dir = tokio::fs::read_dir(&path).await.map_err(|e| {
-                KclError::Io(KclErrorDetails {
+                KclError::Io(KclErrorDetails::new(
-                    message: format!("Failed to read directory `{}`: {}", path.display(), e),
+                    format!("Failed to read directory `{}`: {}", path.display(), e),
-                    source_ranges: vec![source_range],
+                    vec![source_range],
-                })
+                ))
             })?;
 
             while let Ok(Some(entry)) = read_dir.next_entry().await {

rust/kcl-lib/src/fs/wasm.rs

@@ -46,18 +46,16 @@ unsafe impl Sync for FileManager {}
 #[async_trait::async_trait]
 impl FileSystem for FileManager {
     async fn read(&self, path: &TypedPath, source_range: SourceRange) -> Result<Vec<u8>, KclError> {
-        let promise = self.manager.read_file(path.to_string_lossy()).map_err(|e| {
+        let promise = self
-            KclError::Engine(KclErrorDetails {
+            .manager
-                message: e.to_string().into(),
+            .read_file(path.to_string_lossy())
-                source_ranges: vec![source_range],
+            .map_err(|e| KclError::Engine(KclErrorDetails::new(e.to_string().into(), vec![source_range])))?;
-            })
-        })?;
 
         let value = JsFuture::from(promise).await.map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to wait for promise from engine: {:?}", e),
+                format!("Failed to wait for promise from engine: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         let array = js_sys::Uint8Array::new(&value);
@@ -69,35 +67,33 @@ impl FileSystem for FileManager {
     async fn read_to_string(&self, path: &TypedPath, source_range: SourceRange) -> Result<String, KclError> {
         let bytes = self.read(path, source_range).await?;
         let string = String::from_utf8(bytes).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to convert bytes to string: {:?}", e),
+                format!("Failed to convert bytes to string: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         Ok(string)
     }
 
     async fn exists(&self, path: &TypedPath, source_range: SourceRange) -> Result<bool, crate::errors::KclError> {
-        let promise = self.manager.exists(path.to_string_lossy()).map_err(|e| {
+        let promise = self
-            KclError::Engine(KclErrorDetails {
+            .manager
-                message: e.to_string().into(),
+            .exists(path.to_string_lossy())
-                source_ranges: vec![source_range],
+            .map_err(|e| KclError::Engine(KclErrorDetails::new(e.to_string().into(), vec![source_range])))?;
-            })
-        })?;
 
         let value = JsFuture::from(promise).await.map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to wait for promise from engine: {:?}", e),
+                format!("Failed to wait for promise from engine: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         let it_exists = value.as_bool().ok_or_else(|| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: "Failed to convert value to bool".to_string(),
+                "Failed to convert value to bool".to_string(),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         Ok(it_exists)
@@ -108,32 +104,30 @@ impl FileSystem for FileManager {
         path: &TypedPath,
         source_range: SourceRange,
     ) -> Result<Vec<TypedPath>, crate::errors::KclError> {
-        let promise = self.manager.get_all_files(path.to_string_lossy()).map_err(|e| {
+        let promise = self
-            KclError::Engine(KclErrorDetails {
+            .manager
-                message: e.to_string().into(),
+            .get_all_files(path.to_string_lossy())
-                source_ranges: vec![source_range],
+            .map_err(|e| KclError::Engine(KclErrorDetails::new(e.to_string().into(), vec![source_range])))?;
-            })
-        })?;
 
         let value = JsFuture::from(promise).await.map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to wait for promise from javascript: {:?}", e),
+                format!("Failed to wait for promise from javascript: {:?}", e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         let s = value.as_string().ok_or_else(|| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to get string from response from javascript: `{:?}`", value),
+                format!("Failed to get string from response from javascript: `{:?}`", value),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         let files: Vec<String> = serde_json::from_str(&s).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
+            KclError::Engine(KclErrorDetails::new(
-                message: format!("Failed to parse json from javascript: `{}` `{:?}`", s, e),
+                format!("Failed to parse json from javascript: `{}` `{:?}`", s, e),
-                source_ranges: vec![source_range],
+                vec![source_range],
-            })
+            ))
         })?;
 
         Ok(files.into_iter().map(|s| TypedPath::from(&s)).collect())

rust/kcl-lib/src/lib.rs

@@ -86,7 +86,8 @@ mod wasm;
 pub use coredump::CoreDump;
 pub use engine::{AsyncTasks, EngineManager, EngineStats};
 pub use errors::{
-    CompilationError, ConnectionError, ExecError, KclError, KclErrorWithOutputs, Report, ReportWithOutputs,
+    BacktraceItem, CompilationError, ConnectionError, ExecError, KclError, KclErrorWithOutputs, Report,
+    ReportWithOutputs,
 };
 pub use execution::{
     bust_cache, clear_mem_cache,

rust/kcl-lib/src/modules.rs

@@ -58,8 +58,8 @@ impl ModuleLoader {
     }
 
     pub(crate) fn import_cycle_error(&self, path: &ModulePath, source_range: SourceRange) -> KclError {
-        KclError::ImportCycle(KclErrorDetails {
+        KclError::ImportCycle(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "circular import of modules is not allowed: {} -> {}",
                 self.import_stack
                     .iter()
@@ -68,8 +68,8 @@ impl ModuleLoader {
                     .join(" -> "),
                 path,
             ),
-            source_ranges: vec![source_range],
+            vec![source_range],
-        })
+        ))
     }
 
     pub(crate) fn enter_module(&mut self, path: &ModulePath) {
@@ -169,10 +169,10 @@ impl ModulePath {
             ModulePath::Std { value: name } => Ok(ModuleSource {
                 source: read_std(name)
                     .ok_or_else(|| {
-                        KclError::Semantic(KclErrorDetails {
+                        KclError::Semantic(KclErrorDetails::new(
-                            message: format!("Cannot find standard library module to import: std::{name}."),
+                            format!("Cannot find standard library module to import: std::{name}."),
-                            source_ranges: vec![source_range],
+                            vec![source_range],
-                        })
+                        ))
                     })
                     .map(str::to_owned)?,
                 path: self.clone(),

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

@@ -51,7 +51,7 @@ pub fn parse_tokens(mut tokens: TokenStream) -> ParseResult {
         } else {
             format!("found unknown tokens [{}]", token_list.join(", "))
         };
-        return KclError::Lexical(KclErrorDetails { source_ranges, message }).into();
+        return KclError::Lexical(KclErrorDetails::new(message, source_ranges)).into();
     }
 
     // Important, to not call this before the unknown tokens check.

rust/kcl-lib/src/parsing/token/mod.rs

@@ -578,10 +578,10 @@ impl From<ParseError<Input<'_>, winnow::error::ContextError>> for KclError {
             // This is an offset, not an index, and may point to
             // the end of input (input.len()) on eof errors.
 
-            return KclError::Lexical(crate::errors::KclErrorDetails {
+            return KclError::Lexical(crate::errors::KclErrorDetails::new(
-                source_ranges: vec![SourceRange::new(offset, offset, module_id)],
+                "unexpected EOF while parsing".to_owned(),
-                message: "unexpected EOF while parsing".to_string(),
+                vec![SourceRange::new(offset, offset, module_id)],
-            });
+            ));
         }
 
         // TODO: Add the Winnow tokenizer context to the error.
@@ -589,9 +589,9 @@ impl From<ParseError<Input<'_>, winnow::error::ContextError>> for KclError {
         let bad_token = &input[offset];
         // TODO: Add the Winnow parser context to the error.
         // See https://github.com/KittyCAD/modeling-app/issues/784
-        KclError::Lexical(crate::errors::KclErrorDetails {
+        KclError::Lexical(crate::errors::KclErrorDetails::new(
-            source_ranges: vec![SourceRange::new(offset, offset + 1, module_id)],
+            format!("found unknown token '{}'", bad_token),
-            message: format!("found unknown token '{}'", bad_token),
+            vec![SourceRange::new(offset, offset + 1, module_id)],
-        })
+        ))
     }
 }

rust/kcl-lib/src/std/appearance.rs

@@ -32,10 +32,10 @@ pub async fn appearance(exec_state: &mut ExecState, args: Args) -> Result<KclVal
 
     // Make sure the color if set is valid.
     if !HEX_REGEX.is_match(&color) {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: format!("Invalid hex color (`{}`), try something like `#fff000`", color),
+            format!("Invalid hex color (`{}`), try something like `#fff000`", color),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let result = inner_appearance(
@@ -282,10 +282,10 @@ async fn inner_appearance(
     for solid_id in solids.ids(&args.ctx).await? {
         // Set the material properties.
         let rgb = rgba_simple::RGB::<f32>::from_hex(&color).map_err(|err| {
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(
-                message: format!("Invalid hex color (`{color}`): {err}"),
+                format!("Invalid hex color (`{color}`): {err}"),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            })
+            ))
         })?;
 
         let color = Color {

rust/kcl-lib/src/std/args.rs

@@ -122,14 +122,14 @@ impl Args {
         }
 
         T::from_kcl_val(&arg.value).map(Some).ok_or_else(|| {
-            KclError::Type(KclErrorDetails {
+            KclError::Type(KclErrorDetails::new(
-                source_ranges: vec![self.source_range],
+                format!(
-                message: format!(
                     "The arg {label} was given, but it was the wrong type. It should be type {} but it was {}",
                     tynm::type_name::<T>(),
                     arg.value.human_friendly_type(),
                 ),
-            })
+                vec![self.source_range],
+            ))
         })
     }
 
@@ -155,10 +155,10 @@ impl Args {
         T: FromKclValue<'a>,
     {
         self.get_kw_arg_opt(label)?.ok_or_else(|| {
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.source_range],
+                format!("This function requires a keyword argument '{label}'"),
-                message: format!("This function requires a keyword argument '{label}'"),
+                vec![self.source_range],
-            })
+            ))
         })
     }
 
@@ -172,10 +172,10 @@ impl Args {
         T: for<'a> FromKclValue<'a>,
     {
         let Some(arg) = self.kw_args.labeled.get(label) else {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.source_range],
+                format!("This function requires a keyword argument '{label}'"),
-                message: format!("This function requires a keyword argument '{label}'"),
+                vec![self.source_range],
-            }));
+            )));
         };
 
         let arg = arg.value.coerce(ty, exec_state).map_err(|_| {
@@ -206,10 +206,7 @@ impl Args {
             if message.contains("one or more Solids or imported geometry but it's actually of type Sketch") {
                 message = format!("{message}. {ERROR_STRING_SKETCH_TO_SOLID_HELPER}");
             }
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(message, arg.source_ranges()))
-                source_ranges: arg.source_ranges(),
-                message,
-            })
         })?;
 
         // TODO unnecessary cloning
@@ -223,21 +220,21 @@ impl Args {
         T: FromKclValue<'a>,
     {
         let Some(arg) = self.kw_args.labeled.get(label) else {
-            let err = KclError::Semantic(KclErrorDetails {
+            let err = KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.source_range],
+                format!("This function requires a keyword argument '{label}'"),
-                message: format!("This function requires a keyword argument '{label}'"),
+                vec![self.source_range],
-            });
+            ));
             return Err(err);
         };
         let Some(array) = arg.value.as_array() else {
-            let err = KclError::Semantic(KclErrorDetails {
+            let err = KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![arg.source_range],
+                format!(
-                message: format!(
                     "Expected an array of {} but found {}",
                     tynm::type_name::<T>(),
                     arg.value.human_friendly_type()
                 ),
-            });
+                vec![arg.source_range],
+            ));
             return Err(err);
         };
         array
@@ -245,14 +242,14 @@ impl Args {
             .map(|item| {
                 let source = SourceRange::from(item);
                 let val = FromKclValue::from_kcl_val(item).ok_or_else(|| {
-                    KclError::Semantic(KclErrorDetails {
+                    KclError::Semantic(KclErrorDetails::new(
-                        source_ranges: arg.source_ranges(),
+                        format!(
-                        message: format!(
                             "Expected a {} but found {}",
                             tynm::type_name::<T>(),
                             arg.value.human_friendly_type()
                         ),
-                    })
+                        arg.source_ranges(),
+                    ))
                 })?;
                 Ok((val, source))
             })
@@ -267,19 +264,19 @@ impl Args {
     {
         let arg = self
             .unlabeled_kw_arg_unconverted()
-            .ok_or(KclError::Semantic(KclErrorDetails {
+            .ok_or(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.source_range],
+                format!("This function requires a value for the special unlabeled first parameter, '{label}'"),
-                message: format!("This function requires a value for the special unlabeled first parameter, '{label}'"),
+                vec![self.source_range],
-            }))?;
+            )))?;
 
         T::from_kcl_val(&arg.value).ok_or_else(|| {
             let expected_type_name = tynm::type_name::<T>();
             let actual_type_name = arg.value.human_friendly_type();
             let message = format!("This function expected the input argument to be of type {expected_type_name} but it's actually of type {actual_type_name}");
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(
-                source_ranges: arg.source_ranges(),
                 message,
-            })
+                arg.source_ranges(),
+            ))
         })
     }
 
@@ -296,10 +293,10 @@ impl Args {
     {
         let arg = self
             .unlabeled_kw_arg_unconverted()
-            .ok_or(KclError::Semantic(KclErrorDetails {
+            .ok_or(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![self.source_range],
+                format!("This function requires a value for the special unlabeled first parameter, '{label}'"),
-                message: format!("This function requires a value for the special unlabeled first parameter, '{label}'"),
+                vec![self.source_range],
-            }))?;
+            )))?;
 
         let arg = arg.value.coerce(ty, exec_state).map_err(|_| {
             let actual_type = arg.value.principal_type();
@@ -330,17 +327,14 @@ impl Args {
             if message.contains("one or more Solids or imported geometry but it's actually of type Sketch") {
                 message = format!("{message}. {ERROR_STRING_SKETCH_TO_SOLID_HELPER}");
             }
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(message, arg.source_ranges()))
-                source_ranges: arg.source_ranges(),
-                message,
-            })
         })?;
 
         T::from_kcl_val(&arg).ok_or_else(|| {
-            KclError::Internal(KclErrorDetails {
+            KclError::Internal(KclErrorDetails::new(
-                source_ranges: vec![self.source_range],
+                "Mismatch between type coercion and value extraction (this isn't your fault).\nTo assist in bug-reporting, expected type: {ty:?}; actual value: {arg:?}".to_owned(),
-                message: "Mismatch between type coercion and value extraction (this isn't your fault).\nTo assist in bug-reporting, expected type: {ty:?}; actual value: {arg:?}".to_owned(),
+                vec![self.source_range],
-           })
+           ))
         })
     }
 
@@ -383,17 +377,17 @@ impl Args {
             exec_state.stack().get_from_call_stack(&tag.value, self.source_range)?
         {
             let info = t.get_info(epoch).ok_or_else(|| {
-                KclError::Type(KclErrorDetails {
+                KclError::Type(KclErrorDetails::new(
-                    message: format!("Tag `{}` does not have engine info", tag.value),
+                    format!("Tag `{}` does not have engine info", tag.value),
-                    source_ranges: vec![self.source_range],
+                    vec![self.source_range],
-                })
+                ))
             })?;
             Ok(info)
         } else {
-            Err(KclError::Type(KclErrorDetails {
+            Err(KclError::Type(KclErrorDetails::new(
-                message: format!("Tag `{}` does not exist", tag.value),
+                format!("Tag `{}` does not exist", tag.value),
-                source_ranges: vec![self.source_range],
+                vec![self.source_range],
-            }))
+            )))
         }
     }
 
@@ -522,19 +516,19 @@ impl Args {
         must_be_planar: bool,
     ) -> Result<uuid::Uuid, KclError> {
         if tag.value.is_empty() {
-            return Err(KclError::Type(KclErrorDetails {
+            return Err(KclError::Type(KclErrorDetails::new(
-                message: "Expected a non-empty tag for the face".to_string(),
+                "Expected a non-empty tag for the face".to_string(),
-                source_ranges: vec![self.source_range],
+                vec![self.source_range],
-            }));
+            )));
         }
 
         let engine_info = self.get_tag_engine_info_check_surface(exec_state, tag)?;
 
         let surface = engine_info.surface.as_ref().ok_or_else(|| {
-            KclError::Type(KclErrorDetails {
+            KclError::Type(KclErrorDetails::new(
-                message: format!("Tag `{}` does not have a surface", tag.value),
+                format!("Tag `{}` does not have a surface", tag.value),
-                source_ranges: vec![self.source_range],
+                vec![self.source_range],
-            })
+            ))
         })?;
 
         if let Some(face_from_surface) = match surface {
@@ -550,10 +544,10 @@ impl Args {
                 }
             }
             // The must be planar check must be called before the arc check.
-            ExtrudeSurface::ExtrudeArc(_) if must_be_planar => Some(Err(KclError::Type(KclErrorDetails {
+            ExtrudeSurface::ExtrudeArc(_) if must_be_planar => Some(Err(KclError::Type(KclErrorDetails::new(
-                message: format!("Tag `{}` is a non-planar surface", tag.value),
+                format!("Tag `{}` is a non-planar surface", tag.value),
-                source_ranges: vec![self.source_range],
+                vec![self.source_range],
-            }))),
+            )))),
             ExtrudeSurface::ExtrudeArc(extrude_arc) => {
                 if let Some(arc_tag) = &extrude_arc.tag {
                     if arc_tag.name == tag.value {
@@ -577,10 +571,10 @@ impl Args {
                 }
             }
             // The must be planar check must be called before the fillet check.
-            ExtrudeSurface::Fillet(_) if must_be_planar => Some(Err(KclError::Type(KclErrorDetails {
+            ExtrudeSurface::Fillet(_) if must_be_planar => Some(Err(KclError::Type(KclErrorDetails::new(
-                message: format!("Tag `{}` is a non-planar surface", tag.value),
+                format!("Tag `{}` is a non-planar surface", tag.value),
-                source_ranges: vec![self.source_range],
+                vec![self.source_range],
-            }))),
+            )))),
             ExtrudeSurface::Fillet(fillet) => {
                 if let Some(fillet_tag) = &fillet.tag {
                     if fillet_tag.name == tag.value {
@@ -597,10 +591,10 @@ impl Args {
         }
 
         // If we still haven't found the face, return an error.
-        Err(KclError::Type(KclErrorDetails {
+        Err(KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a face with the tag `{}`", tag.value),
+            format!("Expected a face with the tag `{}`", tag.value),
-            source_ranges: vec![self.source_range],
+            vec![self.source_range],
-        }))
+        )))
     }
 }
 
@@ -622,20 +616,20 @@ where
 {
     fn from_args(args: &'a Args, i: usize) -> Result<Self, KclError> {
         let Some(arg) = args.args.get(i) else {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Expected an argument at index {i}"),
+                format!("Expected an argument at index {i}"),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         };
         let Some(val) = T::from_kcl_val(&arg.value) else {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Argument at index {i} was supposed to be type {} but found {}",
                     tynm::type_name::<T>(),
                     arg.value.human_friendly_type(),
                 ),
-                source_ranges: arg.source_ranges(),
+                arg.source_ranges(),
-            }));
+            )));
         };
         Ok(val)
     }
@@ -651,14 +645,14 @@ where
             return Ok(None);
         }
         let Some(val) = T::from_kcl_val(&arg.value) else {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Argument at index {i} was supposed to be type Option<{}> but found {}",
                     tynm::type_name::<T>(),
                     arg.value.human_friendly_type()
                 ),
-                source_ranges: arg.source_ranges(),
+                arg.source_ranges(),
-            }));
+            )));
         };
         Ok(Some(val))
     }

rust/kcl-lib/src/std/array.rs

@@ -58,10 +58,10 @@ async fn call_map_closure(
     let output = map_fn.call_kw(None, exec_state, ctxt, args, source_range).await?;
     let source_ranges = vec![source_range];
     let output = output.ok_or_else(|| {
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            message: "Map function must return a value".to_string(),
+            "Map function must return a value".to_owned(),
             source_ranges,
-        })
+        ))
     })?;
     Ok(output)
 }
@@ -118,10 +118,10 @@ async fn call_reduce_closure(
     // Unpack the returned transform object.
     let source_ranges = vec![source_range];
     let out = transform_fn_return.ok_or_else(|| {
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            message: "Reducer function must return a value".to_string(),
+            "Reducer function must return a value".to_string(),
-            source_ranges: source_ranges.clone(),
+            source_ranges.clone(),
-        })
+        ))
     })?;
     Ok(out)
 }
@@ -133,10 +133,10 @@ pub async fn push(_exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
     let KclValue::HomArray { value: values, ty } = array else {
         let meta = vec![args.source_range];
         let actual_type = array.human_friendly_type();
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: meta,
+            format!("You can't push to a value of type {actual_type}, only an array"),
-            message: format!("You can't push to a value of type {actual_type}, only an array"),
+            meta,
-        }));
+        )));
     };
     let ty = if item.has_type(&ty) {
         ty
@@ -161,10 +161,10 @@ pub async fn pop(_exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kc
     let KclValue::HomArray { value: values, ty } = array else {
         let meta = vec![args.source_range];
         let actual_type = array.human_friendly_type();
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: meta,
+            format!("You can't pop from a value of type {actual_type}, only an array"),
-            message: format!("You can't pop from a value of type {actual_type}, only an array"),
+            meta,
-        }));
+        )));
     };
 
     let new_array = inner_pop(values, &args)?;
@@ -173,10 +173,10 @@ pub async fn pop(_exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kc
 
 fn inner_pop(array: Vec<KclValue>, args: &Args) -> Result<Vec<KclValue>, KclError> {
     if array.is_empty() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: "Cannot pop from an empty array".to_string(),
+            "Cannot pop from an empty array".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Create a new array with all elements except the last one

rust/kcl-lib/src/std/assert.rs

@@ -12,10 +12,10 @@ use crate::{
 
 async fn _assert(value: bool, message: &str, args: &Args) -> Result<(), KclError> {
     if !value {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: format!("assert failed: {}", message),
+            format!("assert failed: {}", message),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
     Ok(())
 }
@@ -111,19 +111,18 @@ async fn inner_assert(
     .iter()
     .all(|cond| cond.is_none());
     if no_condition_given {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "You must provide at least one condition in this assert (for example, isEqualTo)".to_owned(),
+            "You must provide at least one condition in this assert (for example, isEqualTo)".to_owned(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     if tolerance.is_some() && is_equal_to.is_none() {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message:
+            "The `tolerance` arg is only used with `isEqualTo`. Either remove `tolerance` or add an `isEqualTo` arg."
-                "The `tolerance` arg is only used with `isEqualTo`. Either remove `tolerance` or add an `isEqualTo` arg."
+                .to_owned(),
-                    .to_owned(),
+            vec![args.source_range],
-            source_ranges: vec![args.source_range],
+        )));
-        }));
     }
 
     let suffix = if let Some(err_string) = error {

rust/kcl-lib/src/std/chamfer.rs

@@ -41,10 +41,10 @@ async fn inner_chamfer(
     // If you try and tag multiple edges with a tagged chamfer, we want to return an
     // error to the user that they can only tag one edge at a time.
     if tag.is_some() && tags.len() > 1 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "You can only tag one edge at a time with a tagged chamfer. Either delete the tag for the chamfer fn if you don't need it OR separate into individual chamfer functions for each tag.".to_string(),
+            "You can only tag one edge at a time with a tagged chamfer. Either delete the tag for the chamfer fn if you don't need it OR separate into individual chamfer functions for each tag.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let mut solid = solid.clone();

rust/kcl-lib/src/std/clone.rs

@@ -84,10 +84,10 @@ async fn inner_clone(
     fix_tags_and_references(&mut new_geometry, old_id, exec_state, &args)
         .await
         .map_err(|e| {
-            KclError::Internal(KclErrorDetails {
+            KclError::Internal(KclErrorDetails::new(
-                message: format!("failed to fix tags and references: {:?}", e),
+                format!("failed to fix tags and references: {:?}", e),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            })
+            ))
         })?;
 
     Ok(new_geometry)

rust/kcl-lib/src/std/csg.rs

@@ -24,10 +24,10 @@ pub async fn union(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
     let tolerance: Option<TyF64> = args.get_kw_arg_opt_typed("tolerance", &RuntimeType::length(), exec_state)?;
 
     if solids.len() < 2 {
-        return Err(KclError::UndefinedValue(KclErrorDetails {
+        return Err(KclError::UndefinedValue(KclErrorDetails::new(
-            message: "At least two solids are required for a union operation.".to_string(),
+            "At least two solids are required for a union operation.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let solids = inner_union(solids, tolerance, exec_state, args).await?;
@@ -147,10 +147,10 @@ pub(crate) async fn inner_union(
         modeling_response: OkModelingCmdResponse::BooleanUnion(BooleanUnion { extra_solid_ids }),
     } = result
     else {
-        return Err(KclError::Internal(KclErrorDetails {
+        return Err(KclError::Internal(KclErrorDetails::new(
-            message: "Failed to get the result of the union operation.".to_string(),
+            "Failed to get the result of the union operation.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     // If we have more solids, set those as well.
@@ -169,10 +169,10 @@ pub async fn intersect(exec_state: &mut ExecState, args: Args) -> Result<KclValu
     let tolerance: Option<TyF64> = args.get_kw_arg_opt_typed("tolerance", &RuntimeType::length(), exec_state)?;
 
     if solids.len() < 2 {
-        return Err(KclError::UndefinedValue(KclErrorDetails {
+        return Err(KclError::UndefinedValue(KclErrorDetails::new(
-            message: "At least two solids are required for an intersect operation.".to_string(),
+            "At least two solids are required for an intersect operation.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let solids = inner_intersect(solids, tolerance, exec_state, args).await?;
@@ -273,10 +273,10 @@ pub(crate) async fn inner_intersect(
         modeling_response: OkModelingCmdResponse::BooleanIntersection(BooleanIntersection { extra_solid_ids }),
     } = result
     else {
-        return Err(KclError::Internal(KclErrorDetails {
+        return Err(KclError::Internal(KclErrorDetails::new(
-            message: "Failed to get the result of the intersection operation.".to_string(),
+            "Failed to get the result of the intersection operation.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     // If we have more solids, set those as well.
@@ -397,10 +397,10 @@ pub(crate) async fn inner_subtract(
         modeling_response: OkModelingCmdResponse::BooleanSubtract(BooleanSubtract { extra_solid_ids }),
     } = result
     else {
-        return Err(KclError::Internal(KclErrorDetails {
+        return Err(KclError::Internal(KclErrorDetails::new(
-            message: "Failed to get the result of the subtract operation.".to_string(),
+            "Failed to get the result of the subtract operation.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     // If we have more solids, set those as well.

rust/kcl-lib/src/std/edge.rs

@@ -87,10 +87,10 @@ async fn inner_get_opposite_edge(
         modeling_response: OkModelingCmdResponse::Solid3dGetOppositeEdge(opposite_edge),
     } = &resp
     else {
-        return Err(KclError::Engine(KclErrorDetails {
+        return Err(KclError::Engine(KclErrorDetails::new(
-            message: format!("mcmd::Solid3dGetOppositeEdge response was not as expected: {:?}", resp),
+            format!("mcmd::Solid3dGetOppositeEdge response was not as expected: {:?}", resp),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     Ok(opposite_edge.edge)
@@ -172,20 +172,20 @@ async fn inner_get_next_adjacent_edge(
         modeling_response: OkModelingCmdResponse::Solid3dGetNextAdjacentEdge(adjacent_edge),
     } = &resp
     else {
-        return Err(KclError::Engine(KclErrorDetails {
+        return Err(KclError::Engine(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "mcmd::Solid3dGetNextAdjacentEdge response was not as expected: {:?}",
                 resp
             ),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     adjacent_edge.edge.ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("No edge found next adjacent to tag: `{}`", edge.value),
+            format!("No edge found next adjacent to tag: `{}`", edge.value),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })
 }
 
@@ -264,20 +264,20 @@ async fn inner_get_previous_adjacent_edge(
         modeling_response: OkModelingCmdResponse::Solid3dGetPrevAdjacentEdge(adjacent_edge),
     } = &resp
     else {
-        return Err(KclError::Engine(KclErrorDetails {
+        return Err(KclError::Engine(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "mcmd::Solid3dGetPrevAdjacentEdge response was not as expected: {:?}",
                 resp
             ),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     adjacent_edge.edge.ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("No edge found previous adjacent to tag: `{}`", edge.value),
+            format!("No edge found previous adjacent to tag: `{}`", edge.value),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })
 }
 
@@ -336,10 +336,10 @@ async fn inner_get_common_edge(
     }
 
     if faces.len() != 2 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "getCommonEdge requires exactly two tags for faces".to_string(),
+            "getCommonEdge requires exactly two tags for faces".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
     let first_face_id = args.get_adjacent_face_to_tag(exec_state, &faces[0], false).await?;
     let second_face_id = args.get_adjacent_face_to_tag(exec_state, &faces[1], false).await?;
@@ -348,10 +348,10 @@ async fn inner_get_common_edge(
     let second_tagged_path = args.get_tag_engine_info(exec_state, &faces[1])?;
 
     if first_tagged_path.sketch != second_tagged_path.sketch {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "getCommonEdge requires the faces to be in the same original sketch".to_string(),
+            "getCommonEdge requires the faces to be in the same original sketch".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Flush the batch for our fillets/chamfers if there are any.
@@ -377,19 +377,19 @@ async fn inner_get_common_edge(
         modeling_response: OkModelingCmdResponse::Solid3dGetCommonEdge(common_edge),
     } = &resp
     else {
-        return Err(KclError::Engine(KclErrorDetails {
+        return Err(KclError::Engine(KclErrorDetails::new(
-            message: format!("mcmd::Solid3dGetCommonEdge response was not as expected: {:?}", resp),
+            format!("mcmd::Solid3dGetCommonEdge response was not as expected: {:?}", resp),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     common_edge.edge.ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "No common edge was found between `{}` and `{}`",
                 faces[0].value, faces[1].value
             ),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })
 }

rust/kcl-lib/src/std/extrude.rs

@@ -175,11 +175,11 @@ async fn inner_extrude(
     let mut solids = Vec::new();
 
     if symmetric.unwrap_or(false) && bidirectional_length.is_some() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            "You cannot give both `symmetric` and `bidirectional` params, you have to choose one or the other"
-            message: "You cannot give both `symmetric` and `bidirectional` params, you have to choose one or the other"
                 .to_owned(),
-        }));
+            vec![args.source_range],
+        )));
     }
 
     let bidirection = bidirectional_length.map(|l| LengthUnit(l.to_mm()));
@@ -262,10 +262,10 @@ pub(crate) async fn do_post_extrude<'a>(
         // The "get extrusion face info" API call requires *any* edge on the sketch being extruded.
         // So, let's just use the first one.
         let Some(any_edge_id) = sketch.paths.first().map(|edge| edge.get_base().geo_meta.id) else {
-            return Err(KclError::Type(KclErrorDetails {
+            return Err(KclError::Type(KclErrorDetails::new(
-                message: "Expected a non-empty sketch".to_string(),
+                "Expected a non-empty sketch".to_owned(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         };
         any_edge_id
     };
@@ -387,13 +387,13 @@ pub(crate) async fn do_post_extrude<'a>(
     // Add the tags for the start or end caps.
     if let Some(tag_start) = named_cap_tags.start {
         let Some(start_cap_id) = start_cap_id else {
-            return Err(KclError::Type(KclErrorDetails {
+            return Err(KclError::Type(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Expected a start cap ID for tag `{}` for extrusion of sketch {:?}",
                     tag_start.name, sketch.id
                 ),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         };
 
         new_value.push(ExtrudeSurface::ExtrudePlane(crate::execution::ExtrudePlane {
@@ -407,13 +407,13 @@ pub(crate) async fn do_post_extrude<'a>(
     }
     if let Some(tag_end) = named_cap_tags.end {
         let Some(end_cap_id) = end_cap_id else {
-            return Err(KclError::Type(KclErrorDetails {
+            return Err(KclError::Type(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Expected an end cap ID for tag `{}` for extrusion of sketch {:?}",
                     tag_end.name, sketch.id
                 ),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         };
 
         new_value.push(ExtrudeSurface::ExtrudePlane(crate::execution::ExtrudePlane {

rust/kcl-lib/src/std/fillet.rs

@@ -49,10 +49,11 @@ pub(super) fn validate_unique<T: Eq + std::hash::Hash>(tags: &[(T, SourceRange)]
         }
     }
     if !duplicate_tags_source.is_empty() {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "The same edge ID is being referenced multiple times, which is not allowed. Please select a different edge".to_string(),
+            "The same edge ID is being referenced multiple times, which is not allowed. Please select a different edge"
-            source_ranges: duplicate_tags_source,
+                .to_string(),
-        }));
+            duplicate_tags_source,
+        )));
     }
     Ok(())
 }

rust/kcl-lib/src/std/helix.rs

@@ -6,7 +6,7 @@ use kittycad_modeling_cmds::{self as kcmc, shared::Point3d};
 
 use super::args::TyF64;
 use crate::{
-    errors::KclError,
+    errors::{KclError, KclErrorDetails},
     execution::{
         types::{PrimitiveType, RuntimeType},
         ExecState, Helix as HelixValue, KclValue, Solid,
@@ -33,50 +33,50 @@ pub async fn helix(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 
     // Make sure we have a radius if we don't have a cylinder.
     if radius.is_none() && cylinder.is_none() {
-        return Err(KclError::Semantic(crate::errors::KclErrorDetails {
+        return Err(KclError::Semantic(crate::errors::KclErrorDetails::new(
-            message: "Radius is required when creating a helix without a cylinder.".to_string(),
+            "Radius is required when creating a helix without a cylinder.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Make sure we don't have a radius if we have a cylinder.
     if radius.is_some() && cylinder.is_some() {
-        return Err(KclError::Semantic(crate::errors::KclErrorDetails {
+        return Err(KclError::Semantic(crate::errors::KclErrorDetails::new(
-            message: "Radius is not allowed when creating a helix with a cylinder.".to_string(),
+            "Radius is not allowed when creating a helix with a cylinder.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Make sure we have an axis if we don't have a cylinder.
     if axis.is_none() && cylinder.is_none() {
-        return Err(KclError::Semantic(crate::errors::KclErrorDetails {
+        return Err(KclError::Semantic(crate::errors::KclErrorDetails::new(
-            message: "Axis is required when creating a helix without a cylinder.".to_string(),
+            "Axis is required when creating a helix without a cylinder.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Make sure we don't have an axis if we have a cylinder.
     if axis.is_some() && cylinder.is_some() {
-        return Err(KclError::Semantic(crate::errors::KclErrorDetails {
+        return Err(KclError::Semantic(crate::errors::KclErrorDetails::new(
-            message: "Axis is not allowed when creating a helix with a cylinder.".to_string(),
+            "Axis is not allowed when creating a helix with a cylinder.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Make sure we have a radius if we have an axis.
     if radius.is_none() && axis.is_some() {
-        return Err(KclError::Semantic(crate::errors::KclErrorDetails {
+        return Err(KclError::Semantic(crate::errors::KclErrorDetails::new(
-            message: "Radius is required when creating a helix around an axis.".to_string(),
+            "Radius is required when creating a helix around an axis.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Make sure we have an axis if we have a radius.
     if axis.is_none() && radius.is_some() {
-        return Err(KclError::Semantic(crate::errors::KclErrorDetails {
+        return Err(KclError::Semantic(crate::errors::KclErrorDetails::new(
-            message: "Axis is required when creating a helix around an axis.".to_string(),
+            "Axis is required when creating a helix around an axis.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let value = inner_helix(
@@ -140,10 +140,10 @@ async fn inner_helix(
             Axis3dOrEdgeReference::Axis { direction, origin } => {
                 // Make sure they gave us a length.
                 let Some(length) = length else {
-                    return Err(KclError::Semantic(crate::errors::KclErrorDetails {
+                    return Err(KclError::Semantic(KclErrorDetails::new(
-                        message: "Length is required when creating a helix around an axis.".to_string(),
+                        "Length is required when creating a helix around an axis.".to_owned(),
-                        source_ranges: vec![args.source_range],
+                        vec![args.source_range],
-                    }));
+                    )));
                 };
 
                 args.batch_modeling_cmd(

rust/kcl-lib/src/std/loft.rs

@@ -148,13 +148,13 @@ async fn inner_loft(
 ) -> Result<Box<Solid>, KclError> {
     // Make sure we have at least two sketches.
     if sketches.len() < 2 {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: format!(
+            format!(
                 "Loft requires at least two sketches, but only {} were provided.",
                 sketches.len()
             ),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let id = exec_state.next_uuid();

rust/kcl-lib/src/std/math.rs

@@ -56,13 +56,13 @@ pub async fn sqrt(exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kc
     let input: TyF64 = args.get_unlabeled_kw_arg_typed("input", &RuntimeType::num_any(), exec_state)?;
 
     if input.n < 0.0 {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            format!(
-            message: format!(
                 "Attempt to take square root (`sqrt`) of a number less than zero ({})",
                 input.n
             ),
-        }));
+            vec![args.source_range],
+        )));
     }
 
     let result = input.n.sqrt();

rust/kcl-lib/src/std/mirror.rs

@@ -101,10 +101,10 @@ async fn inner_mirror_2d(
                 OkModelingCmdResponse::EntityGetAllChildUuids(EntityGetAllChildUuids { entity_ids: child_ids }),
         } = response
         else {
-            return Err(KclError::Internal(KclErrorDetails {
+            return Err(KclError::Internal(KclErrorDetails::new(
-                message: "Expected a successful response from EntityGetAllChildUuids".to_string(),
+                "Expected a successful response from EntityGetAllChildUuids".to_string(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         };
 
         if child_ids.len() >= 2 {
@@ -112,10 +112,10 @@ async fn inner_mirror_2d(
             let child_id = child_ids[1];
             sketch.mirror = Some(child_id);
         } else {
-            return Err(KclError::Type(KclErrorDetails {
+            return Err(KclError::Type(KclErrorDetails::new(
-                message: "Expected child uuids to be >= 2".to_string(),
+                "Expected child uuids to be >= 2".to_string(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
 

rust/kcl-lib/src/std/patterns.rs

@@ -264,10 +264,10 @@ async fn inner_pattern_transform<'a>(
     // Build the vec of transforms, one for each repetition.
     let mut transform_vec = Vec::with_capacity(usize::try_from(instances).unwrap());
     if instances < 1 {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            MUST_HAVE_ONE_INSTANCE.to_owned(),
-            message: MUST_HAVE_ONE_INSTANCE.to_owned(),
+            vec![args.source_range],
-        }));
+        )));
     }
     for i in 1..instances {
         let t = make_transform::<Solid>(i, transform, args.source_range, exec_state, &args.ctx).await?;
@@ -318,10 +318,10 @@ async fn inner_pattern_transform_2d<'a>(
     // Build the vec of transforms, one for each repetition.
     let mut transform_vec = Vec::with_capacity(usize::try_from(instances).unwrap());
     if instances < 1 {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            MUST_HAVE_ONE_INSTANCE.to_owned(),
-            message: MUST_HAVE_ONE_INSTANCE.to_owned(),
+            vec![args.source_range],
-        }));
+        )));
     }
     for i in 1..instances {
         let t = make_transform::<Sketch>(i, transform, args.source_range, exec_state, &args.ctx).await?;
@@ -398,10 +398,10 @@ async fn send_pattern_transform<T: GeometryTrait>(
         }
         &mock_ids
     } else {
-        return Err(KclError::Engine(KclErrorDetails {
+        return Err(KclError::Engine(KclErrorDetails::new(
-            message: format!("EntityLinearPattern response was not as expected: {:?}", resp),
+            format!("EntityLinearPattern response was not as expected: {:?}", resp),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     let mut geometries = vec![solid.clone()];
@@ -444,10 +444,10 @@ async fn make_transform<T: GeometryTrait>(
     // Unpack the returned transform object.
     let source_ranges = vec![source_range];
     let transform_fn_return = transform_fn_return.ok_or_else(|| {
-        KclError::Semantic(KclErrorDetails {
+        KclError::Semantic(KclErrorDetails::new(
-            message: "Transform function must return a value".to_string(),
+            "Transform function must return a value".to_string(),
-            source_ranges: source_ranges.clone(),
+            source_ranges.clone(),
-        })
+        ))
     })?;
     let transforms = match transform_fn_return {
         KclValue::Object { value, meta: _ } => vec![value],
@@ -455,19 +455,19 @@ async fn make_transform<T: GeometryTrait>(
             let transforms: Vec<_> = value
                 .into_iter()
                 .map(|val| {
-                    val.into_object().ok_or(KclError::Semantic(KclErrorDetails {
+                    val.into_object().ok_or(KclError::Semantic(KclErrorDetails::new(
-                        message: "Transform function must return a transform object".to_string(),
+                        "Transform function must return a transform object".to_string(),
-                        source_ranges: source_ranges.clone(),
+                        source_ranges.clone(),
-                    }))
+                    )))
                 })
                 .collect::<Result<_, _>>()?;
             transforms
         }
         _ => {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Transform function must return a transform object".to_string(),
+                "Transform function must return a transform object".to_string(),
-                source_ranges: source_ranges.clone(),
+                source_ranges.clone(),
-            }))
+            )))
         }
     };
 
@@ -487,10 +487,10 @@ fn transform_from_obj_fields<T: GeometryTrait>(
         Some(KclValue::Bool { value: true, .. }) => true,
         Some(KclValue::Bool { value: false, .. }) => false,
         Some(_) => {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "The 'replicate' key must be a bool".to_string(),
+                "The 'replicate' key must be a bool".to_string(),
-                source_ranges: source_ranges.clone(),
+                source_ranges.clone(),
-            }));
+            )));
         }
         None => true,
     };
@@ -519,11 +519,10 @@ fn transform_from_obj_fields<T: GeometryTrait>(
     let mut rotation = Rotation::default();
     if let Some(rot) = transform.get("rotation") {
         let KclValue::Object { value: rot, meta: _ } = rot else {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "The 'rotation' key must be an object (with optional fields 'angle', 'axis' and 'origin')"
+                "The 'rotation' key must be an object (with optional fields 'angle', 'axis' and 'origin')".to_owned(),
-                    .to_string(),
+                source_ranges.clone(),
-                source_ranges: source_ranges.clone(),
+            )));
-            }));
         };
         if let Some(axis) = rot.get("axis") {
             rotation.axis = point_3d_to_mm(T::array_to_point3d(axis, source_ranges.clone(), exec_state)?).into();
@@ -534,10 +533,10 @@ fn transform_from_obj_fields<T: GeometryTrait>(
                     rotation.angle = Angle::from_degrees(*number);
                 }
                 _ => {
-                    return Err(KclError::Semantic(KclErrorDetails {
+                    return Err(KclError::Semantic(KclErrorDetails::new(
-                        message: "The 'rotation.angle' key must be a number (of degrees)".to_string(),
+                        "The 'rotation.angle' key must be a number (of degrees)".to_owned(),
-                        source_ranges: source_ranges.clone(),
+                        source_ranges.clone(),
-                    }));
+                    )));
                 }
             }
         }
@@ -568,15 +567,15 @@ fn array_to_point3d(
 ) -> Result<[TyF64; 3], KclError> {
     val.coerce(&RuntimeType::point3d(), exec_state)
         .map_err(|e| {
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Expected an array of 3 numbers (i.e., a 3D point), found {}",
                     e.found
                         .map(|t| t.human_friendly_type())
                         .unwrap_or_else(|| val.human_friendly_type().to_owned())
                 ),
                 source_ranges,
-            })
+            ))
         })
         .map(|val| val.as_point3d().unwrap())
 }
@@ -588,15 +587,15 @@ fn array_to_point2d(
 ) -> Result<[TyF64; 2], KclError> {
     val.coerce(&RuntimeType::point2d(), exec_state)
         .map_err(|e| {
-            KclError::Semantic(KclErrorDetails {
+            KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Expected an array of 2 numbers (i.e., a 2D point), found {}",
                     e.found
                         .map(|t| t.human_friendly_type())
                         .unwrap_or_else(|| val.human_friendly_type().to_owned())
                 ),
                 source_ranges,
-            })
+            ))
         })
         .map(|val| val.as_point2d().unwrap())
 }
@@ -757,12 +756,11 @@ pub async fn pattern_linear_2d(exec_state: &mut ExecState, args: Args) -> Result
 
     let axis = axis.to_point2d();
     if axis[0].n == 0.0 && axis[1].n == 0.0 {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message:
+            "The axis of the linear pattern cannot be the zero vector. Otherwise they will just duplicate in place."
-                "The axis of the linear pattern cannot be the zero vector. Otherwise they will just duplicate in place."
+                .to_owned(),
-                    .to_string(),
+            vec![args.source_range],
-            source_ranges: vec![args.source_range],
+        )));
-        }));
     }
 
     let sketches = inner_pattern_linear_2d(sketches, instances, distance, axis, use_original, exec_state, args).await?;
@@ -860,12 +858,11 @@ pub async fn pattern_linear_3d(exec_state: &mut ExecState, args: Args) -> Result
 
     let axis = axis.to_point3d();
     if axis[0].n == 0.0 && axis[1].n == 0.0 && axis[2].n == 0.0 {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message:
+            "The axis of the linear pattern cannot be the zero vector. Otherwise they will just duplicate in place."
-                "The axis of the linear pattern cannot be the zero vector. Otherwise they will just duplicate in place."
+                .to_owned(),
-                    .to_string(),
+            vec![args.source_range],
-            source_ranges: vec![args.source_range],
+        )));
-        }));
     }
 
     let solids = inner_pattern_linear_3d(solids, instances, distance, axis, use_original, exec_state, args).await?;
@@ -1210,10 +1207,10 @@ async fn inner_pattern_circular_2d(
         .await?;
 
         let Geometries::Sketches(new_sketches) = geometries else {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Expected a vec of sketches".to_string(),
+                "Expected a vec of sketches".to_string(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         };
 
         sketches.extend(new_sketches);
@@ -1333,10 +1330,10 @@ async fn inner_pattern_circular_3d(
         .await?;
 
         let Geometries::Solids(new_solids) = geometries else {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Expected a vec of solids".to_string(),
+                "Expected a vec of solids".to_string(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         };
 
         solids.extend(new_solids);
@@ -1358,10 +1355,10 @@ async fn pattern_circular(
             return Ok(Geometries::from(geometry));
         }
         RepetitionsNeeded::Invalid => {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![args.source_range],
+                MUST_HAVE_ONE_INSTANCE.to_owned(),
-                message: MUST_HAVE_ONE_INSTANCE.to_owned(),
+                vec![args.source_range],
-            }));
+            )));
         }
     };
 
@@ -1403,10 +1400,10 @@ async fn pattern_circular(
         }
         &mock_ids
     } else {
-        return Err(KclError::Engine(KclErrorDetails {
+        return Err(KclError::Engine(KclErrorDetails::new(
-            message: format!("EntityCircularPattern response was not as expected: {:?}", resp),
+            format!("EntityCircularPattern response was not as expected: {:?}", resp),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     };
 
     let geometries = match geometry {

rust/kcl-lib/src/std/revolve.rs

@@ -75,10 +75,10 @@ async fn inner_revolve(
         // We don't use validate() here because we want to return a specific error message that is
         // nice and we use the other data in the docs, so we still need use the derive above for the json schema.
         if !(-360.0..=360.0).contains(&angle) || angle == 0.0 {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Expected angle to be between -360 and 360 and not 0, found `{}`", angle),
+                format!("Expected angle to be between -360 and 360 and not 0, found `{}`", angle),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
 
@@ -87,35 +87,35 @@ async fn inner_revolve(
         // We don't use validate() here because we want to return a specific error message that is
         // nice and we use the other data in the docs, so we still need use the derive above for the json schema.
         if !(-360.0..=360.0).contains(&bidirectional_angle) || bidirectional_angle == 0.0 {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!(
+                format!(
                     "Expected bidirectional angle to be between -360 and 360 and not 0, found `{}`",
                     bidirectional_angle
                 ),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
 
         if let Some(angle) = angle {
             let ang = angle.signum() * bidirectional_angle + angle;
             if !(-360.0..=360.0).contains(&ang) {
-                return Err(KclError::Semantic(KclErrorDetails {
+                return Err(KclError::Semantic(KclErrorDetails::new(
-                    message: format!(
+                    format!(
                         "Combined angle and bidirectional must be between -360 and 360, found '{}'",
                         ang
                     ),
-                    source_ranges: vec![args.source_range],
+                    vec![args.source_range],
-                }));
+                )));
             }
         }
     }
 
     if symmetric.unwrap_or(false) && bidirectional_angle.is_some() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            "You cannot give both `symmetric` and `bidirectional` params, you have to choose one or the other"
-            message: "You cannot give both `symmetric` and `bidirectional` params, you have to choose one or the other"
                 .to_owned(),
-        }));
+            vec![args.source_range],
+        )));
     }
 
     let angle = Angle::from_degrees(angle.unwrap_or(360.0));

rust/kcl-lib/src/std/segment.rs

@@ -59,10 +59,10 @@ pub async fn segment_end(exec_state: &mut ExecState, args: Args) -> Result<KclVa
 fn inner_segment_end(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<[TyF64; 2], KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
     let (p, ty) = path.end_point_components();
     // Docs generation isn't smart enough to handle ([f64; 2], NumericType).
@@ -104,10 +104,10 @@ pub async fn segment_end_x(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 fn inner_segment_end_x(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<TyF64, KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     Ok(TyF64::new(path.get_base().to[0], path.get_base().units.into()))
@@ -147,10 +147,10 @@ pub async fn segment_end_y(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 fn inner_segment_end_y(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<TyF64, KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     Ok(path.get_to()[1].clone())
@@ -201,10 +201,10 @@ pub async fn segment_start(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 fn inner_segment_start(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<[TyF64; 2], KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
     let (p, ty) = path.start_point_components();
     // Docs generation isn't smart enough to handle ([f64; 2], NumericType).
@@ -246,10 +246,10 @@ pub async fn segment_start_x(exec_state: &mut ExecState, args: Args) -> Result<K
 fn inner_segment_start_x(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<TyF64, KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     Ok(path.get_from()[0].clone())
@@ -289,10 +289,10 @@ pub async fn segment_start_y(exec_state: &mut ExecState, args: Args) -> Result<K
 fn inner_segment_start_y(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<TyF64, KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     Ok(path.get_from()[1].clone())
@@ -334,10 +334,10 @@ fn inner_last_segment_x(sketch: Sketch, args: Args) -> Result<TyF64, KclError> {
         .paths
         .last()
         .ok_or_else(|| {
-            KclError::Type(KclErrorDetails {
+            KclError::Type(KclErrorDetails::new(
-                message: format!("Expected a Sketch with at least one segment, found `{:?}`", sketch),
+                format!("Expected a Sketch with at least one segment, found `{:?}`", sketch),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            })
+            ))
         })?
         .get_base();
 
@@ -381,10 +381,10 @@ fn inner_last_segment_y(sketch: Sketch, args: Args) -> Result<TyF64, KclError> {
         .paths
         .last()
         .ok_or_else(|| {
-            KclError::Type(KclErrorDetails {
+            KclError::Type(KclErrorDetails::new(
-                message: format!("Expected a Sketch with at least one segment, found `{:?}`", sketch),
+                format!("Expected a Sketch with at least one segment, found `{:?}`", sketch),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            })
+            ))
         })?
         .get_base();
 
@@ -429,10 +429,10 @@ pub async fn segment_length(exec_state: &mut ExecState, args: Args) -> Result<Kc
 fn inner_segment_length(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<TyF64, KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     Ok(path.length())
@@ -473,10 +473,10 @@ pub async fn segment_angle(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 fn inner_segment_angle(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<f64, KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     let result = between(path.get_base().from, path.get_base().to);
@@ -575,10 +575,10 @@ pub async fn tangent_to_end(exec_state: &mut ExecState, args: Args) -> Result<Kc
 async fn inner_tangent_to_end(tag: &TagIdentifier, exec_state: &mut ExecState, args: Args) -> Result<f64, KclError> {
     let line = args.get_tag_engine_info(exec_state, tag)?;
     let path = line.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected a line segment with a path, found `{:?}`", line),
+            format!("Expected a line segment with a path, found `{:?}`", line),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     let from = untype_point(path.get_to()).0;

rust/kcl-lib/src/std/shapes.rs

@@ -325,17 +325,17 @@ async fn inner_polygon(
     args: Args,
 ) -> Result<Sketch, KclError> {
     if num_sides < 3 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Polygon must have at least 3 sides".to_string(),
+            "Polygon must have at least 3 sides".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     if radius.n <= 0.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Radius must be greater than 0".to_string(),
+            "Radius must be greater than 0".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let (sketch_surface, units) = match sketch_surface_or_group {

rust/kcl-lib/src/std/shell.rs

@@ -36,17 +36,17 @@ async fn inner_shell(
     args: Args,
 ) -> Result<Vec<Solid>, KclError> {
     if faces.is_empty() {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "You must shell at least one face".to_string(),
+            "You must shell at least one face".to_owned(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     if solids.is_empty() {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "You must shell at least one solid".to_string(),
+            "You must shell at least one solid".to_owned(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let mut face_ids = Vec::new();
@@ -63,20 +63,19 @@ async fn inner_shell(
     }
 
     if face_ids.is_empty() {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Expected at least one valid face".to_string(),
+            "Expected at least one valid face".to_owned(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // Make sure all the solids have the same id, as we are going to shell them all at
     // once.
     if !solids.iter().all(|eg| eg.id == solids[0].id) {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "All solids stem from the same root object, like multiple sketch on face extrusions, etc."
+            "All solids stem from the same root object, like multiple sketch on face extrusions, etc.".to_owned(),
-                .to_string(),
+            vec![args.source_range],
-            source_ranges: vec![args.source_range],
+        )));
-        }));
     }
 
     args.batch_modeling_cmd(

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

@@ -64,16 +64,16 @@ impl FaceTag {
         match self {
             FaceTag::Tag(ref t) => args.get_adjacent_face_to_tag(exec_state, t, must_be_planar).await,
             FaceTag::StartOrEnd(StartOrEnd::Start) => solid.start_cap_id.ok_or_else(|| {
-                KclError::Type(KclErrorDetails {
+                KclError::Type(KclErrorDetails::new(
-                    message: "Expected a start face".to_string(),
+                    "Expected a start face".to_string(),
-                    source_ranges: vec![args.source_range],
+                    vec![args.source_range],
-                })
+                ))
             }),
             FaceTag::StartOrEnd(StartOrEnd::End) => solid.end_cap_id.ok_or_else(|| {
-                KclError::Type(KclErrorDetails {
+                KclError::Type(KclErrorDetails::new(
-                    message: "Expected an end face".to_string(),
+                    "Expected an end face".to_string(),
-                    source_ranges: vec![args.source_range],
+                    vec![args.source_range],
-                })
+                ))
             }),
         }
     }
@@ -329,19 +329,18 @@ async fn straight_line(
     let from = sketch.current_pen_position()?;
     let (point, is_absolute) = match (end_absolute, end) {
         (Some(_), Some(_)) => {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![args.source_range],
+                "You cannot give both `end` and `endAbsolute` params, you have to choose one or the other".to_owned(),
-                message: "You cannot give both `end` and `endAbsolute` params, you have to choose one or the other"
+                vec![args.source_range],
-                    .to_owned(),
+            )));
-            }));
         }
         (Some(end_absolute), None) => (end_absolute, true),
         (None, Some(end)) => (end, false),
         (None, None) => {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                source_ranges: vec![args.source_range],
+                format!("You must supply either `{relative_name}` or `endAbsolute` arguments"),
-                message: format!("You must supply either `{relative_name}` or `endAbsolute` arguments"),
+                vec![args.source_range],
-            }));
+            )));
         }
     };
 
@@ -608,10 +607,10 @@ async fn inner_angled_line(
         .filter(|x| x.is_some())
         .count();
     if options_given > 1 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: " one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given".to_string(),
+            " one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
     if let Some(length_x) = length_x {
         return inner_angled_line_of_x_length(angle, length_x, sketch, tag, exec_state, args).await;
@@ -636,15 +635,14 @@ async fn inner_angled_line(
         (None, None, None, None, Some(end_absolute_y)) => {
             inner_angled_line_to_y(angle_degrees, end_absolute_y, sketch, tag, exec_state, args).await
         }
-        (None, None, None, None, None) => Err(KclError::Type(KclErrorDetails {
+        (None, None, None, None, None) => Err(KclError::Type(KclErrorDetails::new(
-            message: "One of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` must be given".to_string(),
+            "One of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` must be given".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })),
+        ))),
-        _ => Err(KclError::Type(KclErrorDetails {
+        _ => Err(KclError::Type(KclErrorDetails::new(
-            message: "Only One of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given"
+            "Only One of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given".to_owned(),
-                .to_string(),
+            vec![args.source_range],
-            source_ranges: vec![args.source_range],
+        ))),
-        })),
     }
 }
 
@@ -715,17 +713,17 @@ async fn inner_angled_line_of_x_length(
     args: Args,
 ) -> Result<Sketch, KclError> {
     if angle_degrees.abs() == 270.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have an x constrained angle of 270 degrees".to_string(),
+            "Cannot have an x constrained angle of 270 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     if angle_degrees.abs() == 90.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have an x constrained angle of 90 degrees".to_string(),
+            "Cannot have an x constrained angle of 90 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let to = get_y_component(Angle::from_degrees(angle_degrees), length.n);
@@ -747,17 +745,17 @@ async fn inner_angled_line_to_x(
     let from = sketch.current_pen_position()?;
 
     if angle_degrees.abs() == 270.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have an x constrained angle of 270 degrees".to_string(),
+            "Cannot have an x constrained angle of 270 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     if angle_degrees.abs() == 90.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have an x constrained angle of 90 degrees".to_string(),
+            "Cannot have an x constrained angle of 90 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let x_component = x_to.to_length_units(from.units) - from.x;
@@ -782,17 +780,17 @@ async fn inner_angled_line_of_y_length(
     args: Args,
 ) -> Result<Sketch, KclError> {
     if angle_degrees.abs() == 0.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have a y constrained angle of 0 degrees".to_string(),
+            "Cannot have a y constrained angle of 0 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     if angle_degrees.abs() == 180.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have a y constrained angle of 180 degrees".to_string(),
+            "Cannot have a y constrained angle of 180 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let to = get_x_component(Angle::from_degrees(angle_degrees), length.n);
@@ -814,17 +812,17 @@ async fn inner_angled_line_to_y(
     let from = sketch.current_pen_position()?;
 
     if angle_degrees.abs() == 0.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have a y constrained angle of 0 degrees".to_string(),
+            "Cannot have a y constrained angle of 0 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     if angle_degrees.abs() == 180.0 {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Cannot have a y constrained angle of 180 degrees".to_string(),
+            "Cannot have a y constrained angle of 180 degrees".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let y_component = y_to.to_length_units(from.units) - from.y;
@@ -898,10 +896,10 @@ pub async fn inner_angled_line_that_intersects(
 ) -> Result<Sketch, KclError> {
     let intersect_path = args.get_tag_engine_info(exec_state, &intersect_tag)?;
     let path = intersect_path.path.clone().ok_or_else(|| {
-        KclError::Type(KclErrorDetails {
+        KclError::Type(KclErrorDetails::new(
-            message: format!("Expected an intersect path with a path, found `{:?}`", intersect_path),
+            format!("Expected an intersect path with a path, found `{:?}`", intersect_path),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        })
+        ))
     })?;
 
     let from = sketch.current_pen_position()?;
@@ -1176,10 +1174,10 @@ async fn inner_start_sketch_on(
         SketchData::Plane(plane) => {
             if plane.value == crate::exec::PlaneType::Uninit {
                 if plane.info.origin.units == UnitLen::Unknown {
-                    return Err(KclError::Semantic(KclErrorDetails {
+                    return Err(KclError::Semantic(KclErrorDetails::new(
-                        message: "Origin of plane has unknown units".to_string(),
+                        "Origin of plane has unknown units".to_string(),
-                        source_ranges: vec![args.source_range],
+                        vec![args.source_range],
-                    }));
+                    )));
                 }
                 let plane = make_sketch_plane_from_orientation(plane.info.into_plane_data(), exec_state, args).await?;
                 Ok(SketchSurface::Plane(plane))
@@ -1200,10 +1198,10 @@ async fn inner_start_sketch_on(
         }
         SketchData::Solid(solid) => {
             let Some(tag) = face else {
-                return Err(KclError::Type(KclErrorDetails {
+                return Err(KclError::Type(KclErrorDetails::new(
-                    message: "Expected a tag for the face to sketch on".to_string(),
+                    "Expected a tag for the face to sketch on".to_string(),
-                    source_ranges: vec![args.source_range],
+                    vec![args.source_range],
-                }));
+                )));
             };
             let face = start_sketch_on_face(solid, tag, exec_state, args).await?;
 
@@ -1715,12 +1713,10 @@ pub(crate) async fn inner_arc(
             absolute_arc(&args, id, exec_state, sketch, from, interior_absolute, end_absolute, tag).await
         }
         _ => {
-            Err(KclError::Type(KclErrorDetails {
+            Err(KclError::Type(KclErrorDetails::new(
-                message:
+                "Invalid combination of arguments. Either provide (angleStart, angleEnd, radius) or (endAbsolute, interiorAbsolute)".to_owned(),
-                    "Invalid combination of arguments. Either provide (angleStart, angleEnd, radius) or (endAbsolute, interiorAbsolute)"
+                vec![args.source_range],
-                        .to_string(),
+            )))
-                source_ranges: vec![args.source_range],
-            }))
         }
     }
 }
@@ -1804,10 +1800,10 @@ pub async fn relative_arc(
     let radius = radius.to_length_units(from.units);
     let (center, end) = arc_center_and_end(from.ignore_units(), a_start, a_end, radius);
     if a_start == a_end {
-        return Err(KclError::Type(KclErrorDetails {
+        return Err(KclError::Type(KclErrorDetails::new(
-            message: "Arc start and end angles must be different".to_string(),
+            "Arc start and end angles must be different".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
     let ccw = a_start < a_end;
 
@@ -1958,19 +1954,18 @@ async fn inner_tangential_arc(
             let data = TangentialArcData::RadiusAndOffset { radius, offset: angle };
             inner_tangential_arc_radius_angle(data, sketch, tag, exec_state, args).await
         }
-        (Some(_), Some(_), None, None) => Err(KclError::Semantic(KclErrorDetails {
+        (Some(_), Some(_), None, None) => Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            "You cannot give both `end` and `endAbsolute` params, you have to choose one or the other".to_owned(),
-            message: "You cannot give both `end` and `endAbsolute` params, you have to choose one or the other"
+            vec![args.source_range],
-                .to_owned(),
+        ))),
-        })),
+        (None, None, Some(_), None) | (None, None, None, Some(_)) => Err(KclError::Semantic(KclErrorDetails::new(
-        (None, None, Some(_), None) | (None, None, None, Some(_)) => Err(KclError::Semantic(KclErrorDetails {
+            "You must supply both `radius` and `angle` arguments".to_owned(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-            message: "You must supply both `radius` and `angle` arguments".to_owned(),
+        ))),
-        })),
+        (_, _, _, _) => Err(KclError::Semantic(KclErrorDetails::new(
-        (_, _, _, _) => Err(KclError::Semantic(KclErrorDetails {
+            "You must supply `end`, `endAbsolute`, or both `radius` and `angle` arguments".to_owned(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-            message: "You must supply `end`, `endAbsolute`, or both `radius` and `angle` arguments".to_owned(),
+        ))),
-        })),
     }
 }
 
@@ -2121,19 +2116,17 @@ async fn inner_tangential_arc_to_point(
     });
 
     if result.center[0].is_infinite() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            "could not sketch tangential arc, because its center would be infinitely far away in the X direction"
-            message:
+                .to_owned(),
-                "could not sketch tangential arc, because its center would be infinitely far away in the X direction"
+            vec![args.source_range],
-                    .to_owned(),
+        )));
-        }));
     } else if result.center[1].is_infinite() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            source_ranges: vec![args.source_range],
+            "could not sketch tangential arc, because its center would be infinitely far away in the Y direction"
-            message:
+                .to_owned(),
-                "could not sketch tangential arc, because its center would be infinitely far away in the Y direction"
+            vec![args.source_range],
-                    .to_owned(),
+        )));
-        }));
     }
 
     let delta = if is_absolute {

rust/kcl-lib/src/std/sweep.rs

@@ -193,10 +193,10 @@ async fn inner_sweep(
         Some("sketchPlane") => RelativeTo::SketchPlane,
         Some("trajectoryCurve") | None => RelativeTo::TrajectoryCurve,
         Some(_) => {
-            return Err(KclError::Syntax(crate::errors::KclErrorDetails {
+            return Err(KclError::Syntax(crate::errors::KclErrorDetails::new(
-                source_ranges: vec![args.source_range],
+                "If you provide relativeTo, it must either be 'sketchPlane' or 'trajectoryCurve'".to_owned(),
-                message: "If you provide relativeTo, it must either be 'sketchPlane' or 'trajectoryCurve'".to_owned(),
+                vec![args.source_range],
-            }))
+            )))
         }
     };
 

rust/kcl-lib/src/std/transform.rs

@@ -36,10 +36,10 @@ pub async fn scale(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 
     // Ensure at least one scale value is provided.
     if scale_x.is_none() && scale_y.is_none() && scale_z.is_none() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: "Expected `x`, `y`, or `z` to be provided.".to_string(),
+            "Expected `x`, `y`, or `z` to be provided.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let objects = inner_scale(
@@ -219,10 +219,10 @@ pub async fn translate(exec_state: &mut ExecState, args: Args) -> Result<KclValu
 
     // Ensure at least one translation value is provided.
     if translate_x.is_none() && translate_y.is_none() && translate_z.is_none() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: "Expected `x`, `y`, or `z` to be provided.".to_string(),
+            "Expected `x`, `y`, or `z` to be provided.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     let objects = inner_translate(objects, translate_x, translate_y, translate_z, global, exec_state, args).await?;
@@ -452,82 +452,82 @@ pub async fn rotate(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 
     // Check if no rotation values are provided.
     if roll.is_none() && pitch.is_none() && yaw.is_none() && axis.is_none() && angle.is_none() {
-        return Err(KclError::Semantic(KclErrorDetails {
+        return Err(KclError::Semantic(KclErrorDetails::new(
-            message: "Expected `roll`, `pitch`, and `yaw` or `axis` and `angle` to be provided.".to_string(),
+            "Expected `roll`, `pitch`, and `yaw` or `axis` and `angle` to be provided.".to_string(),
-            source_ranges: vec![args.source_range],
+            vec![args.source_range],
-        }));
+        )));
     }
 
     // If they give us a roll, pitch, or yaw, they must give us at least one of them.
     if roll.is_some() || pitch.is_some() || yaw.is_some() {
         // Ensure they didn't also provide an axis or angle.
         if axis.is_some() || angle.is_some() {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Expected `axis` and `angle` to not be provided when `roll`, `pitch`, and `yaw` are provided."
+                "Expected `axis` and `angle` to not be provided when `roll`, `pitch`, and `yaw` are provided."
-                    .to_string(),
+                    .to_owned(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
 
     // If they give us an axis or angle, they must give us both.
     if axis.is_some() || angle.is_some() {
         if axis.is_none() {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Expected `axis` to be provided when `angle` is provided.".to_string(),
+                "Expected `axis` to be provided when `angle` is provided.".to_string(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
         if angle.is_none() {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Expected `angle` to be provided when `axis` is provided.".to_string(),
+                "Expected `angle` to be provided when `axis` is provided.".to_string(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
 
         // Ensure they didn't also provide a roll, pitch, or yaw.
         if roll.is_some() || pitch.is_some() || yaw.is_some() {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: "Expected `roll`, `pitch`, and `yaw` to not be provided when `axis` and `angle` are provided."
+                "Expected `roll`, `pitch`, and `yaw` to not be provided when `axis` and `angle` are provided."
-                    .to_string(),
+                    .to_owned(),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
 
     // Validate the roll, pitch, and yaw values.
     if let Some(roll) = &roll {
         if !(-360.0..=360.0).contains(&roll.n) {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Expected roll to be between -360 and 360, found `{}`", roll.n),
+                format!("Expected roll to be between -360 and 360, found `{}`", roll.n),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
     if let Some(pitch) = &pitch {
         if !(-360.0..=360.0).contains(&pitch.n) {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Expected pitch to be between -360 and 360, found `{}`", pitch.n),
+                format!("Expected pitch to be between -360 and 360, found `{}`", pitch.n),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
     if let Some(yaw) = &yaw {
         if !(-360.0..=360.0).contains(&yaw.n) {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Expected yaw to be between -360 and 360, found `{}`", yaw.n),
+                format!("Expected yaw to be between -360 and 360, found `{}`", yaw.n),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
 
     // Validate the axis and angle values.
     if let Some(angle) = &angle {
         if !(-360.0..=360.0).contains(&angle.n) {
-            return Err(KclError::Semantic(KclErrorDetails {
+            return Err(KclError::Semantic(KclErrorDetails::new(
-                message: format!("Expected angle to be between -360 and 360, found `{}`", angle.n),
+                format!("Expected angle to be between -360 and 360, found `{}`", angle.n),
-                source_ranges: vec![args.source_range],
+                vec![args.source_range],
-            }));
+            )));
         }
     }
 

rust/kcl-lib/src/unparser.rs

@@ -881,10 +881,10 @@ pub async fn walk_dir(dir: &std::path::PathBuf) -> Result<Vec<std::path::PathBuf
 #[cfg(not(target_arch = "wasm32"))]
 pub async fn recast_dir(dir: &std::path::Path, options: &crate::FormatOptions) -> Result<(), anyhow::Error> {
     let files = walk_dir(&dir.to_path_buf()).await.map_err(|err| {
-        crate::KclError::Internal(crate::errors::KclErrorDetails {
+        crate::KclError::Internal(crate::errors::KclErrorDetails::new(
-            message: format!("Failed to walk directory `{}`: {:?}", dir.display(), err),
+            format!("Failed to walk directory `{}`: {:?}", dir.display(), err),
-            source_ranges: vec![crate::SourceRange::default()],
+            vec![crate::SourceRange::default()],
-        })
+        ))
     })?;
 
     let futures = files

rust/kcl-lib/src/walk/import_graph.rs

@@ -96,11 +96,11 @@ fn topsort(all_modules: &[&str], graph: Graph) -> Result<Vec<Vec<String>>, KclEr
         if stage_modules.is_empty() {
             waiting_modules.sort();
 
-            return Err(KclError::ImportCycle(KclErrorDetails {
+            return Err(KclError::ImportCycle(KclErrorDetails::new(
-                message: format!("circular import of modules not allowed: {}", waiting_modules.join(", ")),
+                format!("circular import of modules not allowed: {}", waiting_modules.join(", ")),
                 // TODO: we can get the right import lines from the AST, but we don't
-                source_ranges: vec![SourceRange::default()],
+                vec![SourceRange::default()],
-            }));
+            )));
         }
 
         // not strictly needed here, but perhaps helpful to avoid thinking
@@ -137,20 +137,20 @@ pub(crate) fn import_dependencies(repr: &ModuleRepr, ctx: &ExecutorContext) -> R
                     // This is a bit of a hack, but it works for now.
                     ret.lock()
                         .map_err(|err| {
-                            KclError::Internal(KclErrorDetails {
+                            KclError::Internal(KclErrorDetails::new(
-                                message: format!("Failed to lock mutex: {}", err),
+                                format!("Failed to lock mutex: {}", err),
-                                source_ranges: Default::default(),
+                                Default::default(),
-                            })
+                            ))
                         })?
                         .push((filename.to_string(), is.clone(), resolved_path));
                 }
                 ImportPath::Foreign { path } => {
                     ret.lock()
                         .map_err(|err| {
-                            KclError::Internal(KclErrorDetails {
+                            KclError::Internal(KclErrorDetails::new(
-                                message: format!("Failed to lock mutex: {}", err),
+                                format!("Failed to lock mutex: {}", err),
-                                source_ranges: Default::default(),
+                                Default::default(),
-                            })
+                            ))
                         })?
                         .push((path.to_string(), is.clone(), resolved_path));
                 }
@@ -169,10 +169,10 @@ pub(crate) fn import_dependencies(repr: &ModuleRepr, ctx: &ExecutorContext) -> R
     walk(ret.clone(), prog.into(), ctx)?;
 
     let ret = ret.lock().map_err(|err| {
-        KclError::Internal(KclErrorDetails {
+        KclError::Internal(KclErrorDetails::new(
-            message: format!("Failed to lock mutex: {}", err),
+            format!("Failed to lock mutex: {}", err),
-            source_ranges: Default::default(),
+            Default::default(),
-        })
+        ))
     })?;
 
     Ok(ret.clone())
@@ -213,10 +213,10 @@ pub(crate) async fn import_universe(
 
         let repr = {
             let Some(module_info) = exec_state.get_module(module_id) else {
-                return Err(KclError::Internal(KclErrorDetails {
+                return Err(KclError::Internal(KclErrorDetails::new(
-                    message: format!("Module {} not found", module_id),
+                    format!("Module {} not found", module_id),
-                    source_ranges: vec![import_stmt.into()],
+                    vec![import_stmt.into()],
-                }));
+                )));
             };
             module_info.repr.clone()
         };

src/components/ModelingSidebar/ModelingPanes/index.tsx

@@ -118,7 +118,9 @@ export const sidebarPanes: SidebarPane[] = [
     keybinding: 'Shift + C',
     showBadge: {
       value: ({ kclContext }) => {
-        return kclContext.diagnostics.length
+        return kclContext.diagnostics.filter(
+          (diagnostic) => diagnostic.severity === 'error'
+        ).length
       },
       onClick: (e) => {
         e.preventDefault()

src/components/ShareButton.tsx

@@ -1,4 +1,4 @@
-import { err } from '@src/lib/trap'
+import { isErr } from '@src/lib/trap'
 import { CustomIcon } from '@src/components/CustomIcon'
 import Tooltip from '@src/components/Tooltip'
 import usePlatform from '@src/hooks/usePlatform'
@@ -17,7 +17,7 @@ const shareHotkey = 'mod+alt+s'
 const canPasswordProtectShareLinks = (
   subOrErr: undefined | SubscriptionsOrError
 ): boolean => {
-  if (subOrErr === undefined || typeof subOrErr === 'number' || err(subOrErr))
+  if (subOrErr === undefined || typeof subOrErr === 'number' || isErr(subOrErr))
     return false
   return subOrErr.modeling_app.share_links[0] === 'password_protected'
 }

src/lang/errors.test.ts

@@ -12,6 +12,7 @@ describe('test kclErrToDiagnostic', () => {
         kind: 'semantic',
         msg: 'Semantic error',
         sourceRange: topLevelRange(0, 1),
+        kclBacktrace: [],
         nonFatal: [],
         operations: [],
         artifactCommands: [],
@@ -25,6 +26,7 @@ describe('test kclErrToDiagnostic', () => {
         kind: 'type',
         msg: 'Type error',
         sourceRange: topLevelRange(4, 5),
+        kclBacktrace: [],
         nonFatal: [],
         operations: [],
         artifactCommands: [],

src/lang/errors.ts

@@ -18,12 +18,14 @@ import type { SourceRange } from '@rust/kcl-lib/bindings/SourceRange'
 import { defaultArtifactGraph } from '@src/lang/std/artifactGraph'
 import { isTopLevelModule } from '@src/lang/util'
 import type { ArtifactGraph } from '@src/lang/wasm'
+import type { BacktraceItem } from '@rust/kcl-lib/bindings/BacktraceItem'
 
 type ExtractKind<T> = T extends { kind: infer K } ? K : never
 export class KCLError extends Error {
   kind: ExtractKind<RustKclError> | 'name'
   sourceRange: SourceRange
   msg: string
+  kclBacktrace: BacktraceItem[]
   nonFatal: CompilationError[]
   operations: Operation[]
   artifactCommands: ArtifactCommand[]
@@ -35,7 +37,8 @@ export class KCLError extends Error {
     kind: ExtractKind<RustKclError> | 'name',
     msg: string,
     sourceRange: SourceRange,
-    nonFatal: CompilationError[] = [],
+    kclBacktrace: BacktraceItem[],
+    nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
     artifactGraph: ArtifactGraph,
@@ -46,6 +49,7 @@ export class KCLError extends Error {
     this.kind = kind
     this.msg = msg
     this.sourceRange = sourceRange
+    this.kclBacktrace = kclBacktrace
     this.nonFatal = nonFatal
     this.operations = operations
     this.artifactCommands = artifactCommands
@@ -60,6 +64,7 @@ export class KCLLexicalError extends KCLError {
   constructor(
     msg: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -71,6 +76,7 @@ export class KCLLexicalError extends KCLError {
       'lexical',
       msg,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -86,6 +92,7 @@ export class KCLInternalError extends KCLError {
   constructor(
     msg: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -97,6 +104,7 @@ export class KCLInternalError extends KCLError {
       'internal',
       msg,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -112,6 +120,7 @@ export class KCLSyntaxError extends KCLError {
   constructor(
     msg: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -123,6 +132,7 @@ export class KCLSyntaxError extends KCLError {
       'syntax',
       msg,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -138,6 +148,7 @@ export class KCLSemanticError extends KCLError {
   constructor(
     msg: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -149,6 +160,7 @@ export class KCLSemanticError extends KCLError {
       'semantic',
       msg,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -164,6 +176,7 @@ export class KCLTypeError extends KCLError {
   constructor(
     msg: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -175,6 +188,7 @@ export class KCLTypeError extends KCLError {
       'type',
       msg,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -190,6 +204,7 @@ export class KCLIoError extends KCLError {
   constructor(
     msg: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -201,6 +216,7 @@ export class KCLIoError extends KCLError {
       'io',
       msg,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -216,6 +232,7 @@ export class KCLUnexpectedError extends KCLError {
   constructor(
     msg: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -227,6 +244,7 @@ export class KCLUnexpectedError extends KCLError {
       'unexpected',
       msg,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -242,6 +260,7 @@ export class KCLValueAlreadyDefined extends KCLError {
   constructor(
     key: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -253,6 +272,7 @@ export class KCLValueAlreadyDefined extends KCLError {
       'name',
       `Key ${key} was already defined elsewhere`,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -268,6 +288,7 @@ export class KCLUndefinedValueError extends KCLError {
   constructor(
     key: string,
     sourceRange: SourceRange,
+    kclBacktrace: BacktraceItem[],
     nonFatal: CompilationError[],
     operations: Operation[],
     artifactCommands: ArtifactCommand[],
@@ -279,6 +300,7 @@ export class KCLUndefinedValueError extends KCLError {
       'name',
       `Key ${key} has not been defined`,
       sourceRange,
+      kclBacktrace,
       nonFatal,
       operations,
       artifactCommands,
@@ -308,6 +330,7 @@ export function lspDiagnosticsToKclErrors(
           [],
           [],
           [],
+          [],
           defaultArtifactGraph(),
           {},
           null
@@ -336,16 +359,44 @@ export function kclErrorsToDiagnostics(
   let nonFatal: CodeMirrorDiagnostic[] = []
   const errs = errors
     ?.filter((err) => isTopLevelModule(err.sourceRange))
-    .map((err): CodeMirrorDiagnostic => {
+    .flatMap((err) => {
+      const diagnostics: CodeMirrorDiagnostic[] = []
+      let message = err.msg
+      if (err.kclBacktrace.length > 0) {
+        // Show the backtrace in the error message.
+        for (let i = 0; i < err.kclBacktrace.length; i++) {
+          const item = err.kclBacktrace[i]
+          if (
+            i > 0 &&
+            isTopLevelModule(item.sourceRange) &&
+            item.sourceRange[0] !== err.sourceRange[0] &&
+            item.sourceRange[1] !== err.sourceRange[1]
+          ) {
+            diagnostics.push({
+              from: item.sourceRange[0],
+              to: item.sourceRange[1],
+              message: 'Part of the error backtrace',
+              severity: 'hint',
+            })
+          }
+          if (i === err.kclBacktrace.length - 1 && !item.fnName) {
+            // The top-level doesn't have a name.
+            break
+          }
+          const name = item.fnName ? `${item.fnName}()` : '(anonymous)'
+          message += `\n${name}`
+        }
+      }
       if (err.nonFatal.length > 0) {
         nonFatal = nonFatal.concat(compilationErrorsToDiagnostics(err.nonFatal))
       }
-      return {
+      diagnostics.push({
         from: err.sourceRange[0],
         to: err.sourceRange[1],
-        message: err.msg,
+        message,
         severity: 'error',
-      }
+      })
+      return diagnostics
     })
   return errs.concat(nonFatal)
 }

src/lang/executor.test.ts

@@ -464,6 +464,7 @@ theExtrude = startSketchOn(XY)
         expect.any(Object),
         expect.any(Object),
         expect.any(Object),
+        expect.any(Object),
         null
       )
     )

src/lang/wasm.test.ts

@@ -47,11 +47,11 @@ it('formats numbers with units', () => {
 describe('test errFromErrWithOutputs', () => {
   it('converts KclErrorWithOutputs to KclError', () => {
     const blob =
-      '{"error":{"kind":"internal","sourceRanges":[],"msg":"Cache busted"},"nonFatal":[],"operations":[],"artifactCommands":[],"artifactGraph":{"map":{}},"filenames":{},"sourceFiles":{},"defaultPlanes":null}'
+      '{"error":{"kind":"internal","sourceRanges":[],"backtrace":[],"msg":"Cache busted"},"nonFatal":[],"operations":[],"artifactCommands":[],"artifactGraph":{"map":{}},"filenames":{},"sourceFiles":{},"defaultPlanes":null}'
     const error = errFromErrWithOutputs(blob)
     const errorStr = JSON.stringify(error)
     expect(errorStr).toEqual(
-      '{"kind":"internal","sourceRange":[0,0,0],"msg":"Cache busted","nonFatal":[],"operations":[],"artifactCommands":[],"artifactGraph":{},"filenames":{},"defaultPlanes":null}'
+      '{"kind":"internal","sourceRange":[0,0,0],"msg":"Cache busted","kclBacktrace":[],"nonFatal":[],"operations":[],"artifactCommands":[],"artifactGraph":{},"filenames":{},"defaultPlanes":null}'
     )
   })
 })

src/lang/wasm.ts

@@ -164,17 +164,15 @@ function bestSourceRange(error: RustKclError): SourceRange {
   }
 
   // When there's an error, the call stack is unwound, and the locations are
-  // built up from deepest location to shallowest. So the shallowest call is
+  // built up from deepest location to shallowest. So the deepest call is first.
-  // last. That's the most useful to the user.
+  for (const range of error.sourceRanges) {
-  for (let i = error.sourceRanges.length - 1; i >= 0; i--) {
-    const range = error.sourceRanges[i]
     // Skip ranges pointing into files that aren't the top-level module.
     if (isTopLevelModule(range)) {
       return sourceRangeFromRust(range)
     }
   }
-  // We didn't find a top-level module range, so just use the last one.
+  // We didn't find a top-level module range, so just use the first one.
-  return sourceRangeFromRust(error.sourceRanges[error.sourceRanges.length - 1])
+  return sourceRangeFromRust(error.sourceRanges[0])
 }
 
 const splitErrors = (
@@ -248,6 +246,7 @@ export const parse = (code: string | Error): ParseResult | Error => {
       [],
       [],
       [],
+      [],
       defaultArtifactGraph(),
       {},
       null
@@ -402,6 +401,7 @@ export const errFromErrWithOutputs = (e: any): KCLError => {
     parsed.error.kind,
     parsed.error.msg,
     bestSourceRange(parsed.error),
+    parsed.error.backtrace,
     parsed.nonFatal,
     parsed.operations,
     parsed.artifactCommands,

src/lib/commandBarConfigs/applicationCommandConfig.ts

@@ -150,6 +150,7 @@ export function createApplicationCommands({
         required: (commandsContext) =>
           isDesktop() &&
           commandsContext.argumentsToSubmit.method === 'existingProject',
+        defaultValue: isDesktop() ? undefined : 'browser',
         skip: true,
         options: (_, _context) => {
           const { folders } = systemIOActor.getSnapshot().context

src/machines/billingMachine.ts

@@ -2,7 +2,9 @@ import type { Models } from '@kittycad/lib'
 import crossPlatformFetch from '@src/lib/crossPlatformFetch'
 import type { ActorRefFrom } from 'xstate'
 import { assign, fromPromise, setup } from 'xstate'
-import { err } from '@src/lib/trap'
+import { isErr } from '@src/lib/trap'
+
+const _TIME_1_SECOND = 1000
 
 export enum BillingState {
   Updating = 'updating',
@@ -42,6 +44,7 @@ export interface BillingContext {
   urlUserService: string
   tier: undefined | Tier
   subscriptionsOrError: undefined | SubscriptionsOrError
+  lastFetch: undefined | Date
 }
 
 export interface BillingUpdateEvent {
@@ -56,14 +59,15 @@ export const BILLING_CONTEXT_DEFAULTS: BillingContext = Object.freeze({
   tier: undefined,
   subscriptionsOrError: undefined,
   urlUserService: '',
+  lastFetch: undefined,
 })
 
 const toTierFrom = (args: TierBasedOn): Tier => {
-  if (typeof args.orgOrError !== 'number' && !err(args.orgOrError)) {
+  if (typeof args.orgOrError !== 'number' && !isErr(args.orgOrError)) {
     return Tier.Organization
   } else if (
     typeof args.subscriptionsOrError !== 'number' &&
-    !err(args.subscriptionsOrError)
+    !isErr(args.subscriptionsOrError)
   ) {
     const subscriptions: Models['ZooProductSubscriptions_type'] =
       args.subscriptionsOrError
@@ -88,6 +92,14 @@ export const billingMachine = setup({
       async ({
         input,
       }: { input: { context: BillingContext; event: BillingUpdateEvent } }) => {
+        // Rate limit on the client side to 1 request per second.
+        if (
+          input.context.lastFetch &&
+          Date.now() - input.context.lastFetch.getTime() < _TIME_1_SECOND
+        ) {
+          return input.context
+        }
+
         const billingOrError: Models['CustomerBalance_type'] | number | Error =
           await crossPlatformFetch(
             `${input.context.urlUserService}/user/payment/balance`,
@@ -95,7 +107,7 @@ export const billingMachine = setup({
             input.event.apiToken
           )
 
-        if (typeof billingOrError === 'number' || err(billingOrError)) {
+        if (typeof billingOrError === 'number' || isErr(billingOrError)) {
           return Promise.reject(billingOrError)
         }
         const billing: Models['CustomerBalance_type'] = billingOrError
@@ -135,7 +147,7 @@ export const billingMachine = setup({
             // TS too dumb Tier.Free has the same logic
             if (
               typeof subscriptionsOrError !== 'number' &&
-              !err(subscriptionsOrError)
+              !isErr(subscriptionsOrError)
             ) {
               allowance = Number(
                 subscriptionsOrError.modeling_app
@@ -157,6 +169,7 @@ export const billingMachine = setup({
           subscriptionsOrError,
           credits,
           allowance,
+          lastFetch: new Date(),
         }
       }
     ),