KCL: Fix 'cryptic' error when referencing a variable in its own declaration

Previously, `x = cos(x)` would just say "`x` is undefined". Now it says
that `x` cannot be referenced in its own definition, try using a different
variable instead.

To do this, I've added a new `Option<String>` field to the mod-local
executor context, tracking the current variable declaration. This means
cloning some strings, implying a small performance hit. I think it's fine,
for the better diagnostics.

In the future we could refactor this to use a &str
or store variable labels in stack-allocated strings like docs.rs/compact_str
or something.

Closes https://github.com/KittyCAD/modeling-app/issues/6072#issuecomment-2923227477

rust/Cargo.lock

@@ -1815,7 +1815,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-bumper"
-version = "0.1.77"
+version = "0.1.78"
 dependencies = [
  "anyhow",
  "clap",
@@ -1826,7 +1826,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-derive-docs"
-version = "0.1.77"
+version = "0.1.78"
 dependencies = [
  "Inflector",
  "anyhow",
@@ -1845,7 +1845,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-directory-test-macro"
-version = "0.1.77"
+version = "0.1.78"
 dependencies = [
  "convert_case",
  "proc-macro2",
@@ -1855,7 +1855,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server"
-version = "0.2.77"
+version = "0.2.78"
 dependencies = [
  "anyhow",
  "clap",
@@ -1876,7 +1876,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server-release"
-version = "0.1.77"
+version = "0.1.78"
 dependencies = [
  "anyhow",
  "clap",
@@ -1896,7 +1896,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-lib"
-version = "0.2.77"
+version = "0.2.78"
 dependencies = [
  "anyhow",
  "approx 0.5.1",
@@ -1973,7 +1973,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-python-bindings"
-version = "0.3.77"
+version = "0.3.78"
 dependencies = [
  "anyhow",
  "kcl-lib",
@@ -1988,7 +1988,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-test-server"
-version = "0.1.77"
+version = "0.1.78"
 dependencies = [
  "anyhow",
  "hyper 0.14.32",
@@ -2001,7 +2001,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-to-core"
-version = "0.1.77"
+version = "0.1.78"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2015,7 +2015,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-wasm-lib"
-version = "0.1.77"
+version = "0.1.78"
 dependencies = [
  "anyhow",
  "bson",

rust/kcl-bumper/Cargo.toml

@@ -1,7 +1,7 @@
 
 [package]
 name = "kcl-bumper"
-version = "0.1.77"
+version = "0.1.78"
 edition = "2021"
 repository = "https://github.com/KittyCAD/modeling-api"
 rust-version = "1.76"

rust/kcl-derive-docs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-derive-docs"
 description = "A tool for generating documentation from Rust derive macros"
-version = "0.1.77"
+version = "0.1.78"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

rust/kcl-directory-test-macro/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-directory-test-macro"
 description = "A tool for generating tests from a directory of kcl files"
-version = "0.1.77"
+version = "0.1.78"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

rust/kcl-language-server-release/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-language-server-release"
-version = "0.1.77"
+version = "0.1.78"
 edition = "2021"
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
 publish = false

rust/kcl-language-server/Cargo.toml

@@ -2,7 +2,7 @@
 name = "kcl-language-server"
 description = "A language server for KCL."
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
-version = "0.2.77"
+version = "0.2.78"
 edition = "2021"
 license = "MIT"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

rust/kcl-lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-lib"
 description = "KittyCAD Language implementation and tools"
-version = "0.2.77"
+version = "0.2.78"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

rust/kcl-lib/src/errors.rs

@@ -107,8 +107,11 @@ pub enum KclError {
     Unexpected(KclErrorDetails),
     #[error("value already defined: {0:?}")]
     ValueAlreadyDefined(KclErrorDetails),
-    #[error("undefined value: {0:?}")]
+    #[error("undefined value: {details:?}")]
-    UndefinedValue(KclErrorDetails),
+    UndefinedValue {
+        details: KclErrorDetails,
+        undefined_name: Option<String>,
+    },
     #[error("invalid expression: {0:?}")]
     InvalidExpression(KclErrorDetails),
     #[error("engine: {0:?}")]
@@ -304,7 +307,7 @@ impl miette::Diagnostic for ReportWithOutputs {
             KclError::Io(_) => "I/O",
             KclError::Unexpected(_) => "Unexpected",
             KclError::ValueAlreadyDefined(_) => "ValueAlreadyDefined",
-            KclError::UndefinedValue(_) => "UndefinedValue",
+            KclError::UndefinedValue { .. } => "UndefinedValue",
             KclError::InvalidExpression(_) => "InvalidExpression",
             KclError::Engine(_) => "Engine",
             KclError::Internal(_) => "Internal",
@@ -354,7 +357,7 @@ impl miette::Diagnostic for Report {
             KclError::Io(_) => "I/O",
             KclError::Unexpected(_) => "Unexpected",
             KclError::ValueAlreadyDefined(_) => "ValueAlreadyDefined",
-            KclError::UndefinedValue(_) => "UndefinedValue",
+            KclError::UndefinedValue { .. } => "UndefinedValue",
             KclError::InvalidExpression(_) => "InvalidExpression",
             KclError::Engine(_) => "Engine",
             KclError::Internal(_) => "Internal",
@@ -432,7 +435,7 @@ impl KclError {
             KclError::Io(_) => "i/o",
             KclError::Unexpected(_) => "unexpected",
             KclError::ValueAlreadyDefined(_) => "value already defined",
-            KclError::UndefinedValue(_) => "undefined value",
+            KclError::UndefinedValue { .. } => "undefined value",
             KclError::InvalidExpression(_) => "invalid expression",
             KclError::Engine(_) => "engine",
             KclError::Internal(_) => "internal",
@@ -449,7 +452,7 @@ impl KclError {
             KclError::Io(e) => e.source_ranges.clone(),
             KclError::Unexpected(e) => e.source_ranges.clone(),
             KclError::ValueAlreadyDefined(e) => e.source_ranges.clone(),
-            KclError::UndefinedValue(e) => e.source_ranges.clone(),
+            KclError::UndefinedValue { details, .. } => details.source_ranges.clone(),
             KclError::InvalidExpression(e) => e.source_ranges.clone(),
             KclError::Engine(e) => e.source_ranges.clone(),
             KclError::Internal(e) => e.source_ranges.clone(),
@@ -467,7 +470,7 @@ impl KclError {
             KclError::Io(e) => &e.message,
             KclError::Unexpected(e) => &e.message,
             KclError::ValueAlreadyDefined(e) => &e.message,
-            KclError::UndefinedValue(e) => &e.message,
+            KclError::UndefinedValue { details, .. } => &details.message,
             KclError::InvalidExpression(e) => &e.message,
             KclError::Engine(e) => &e.message,
             KclError::Internal(e) => &e.message,
@@ -484,7 +487,7 @@ impl KclError {
             | KclError::Io(e)
             | KclError::Unexpected(e)
             | KclError::ValueAlreadyDefined(e)
-            | KclError::UndefinedValue(e)
+            | KclError::UndefinedValue { details: e, .. }
             | KclError::InvalidExpression(e)
             | KclError::Engine(e)
             | KclError::Internal(e) => e.backtrace.clone(),
@@ -502,7 +505,7 @@ impl KclError {
             | KclError::Io(e)
             | KclError::Unexpected(e)
             | KclError::ValueAlreadyDefined(e)
-            | KclError::UndefinedValue(e)
+            | KclError::UndefinedValue { details: e, .. }
             | KclError::InvalidExpression(e)
             | KclError::Engine(e)
             | KclError::Internal(e) => {
@@ -531,7 +534,7 @@ impl KclError {
             | KclError::Io(e)
             | KclError::Unexpected(e)
             | KclError::ValueAlreadyDefined(e)
-            | KclError::UndefinedValue(e)
+            | KclError::UndefinedValue { details: e, .. }
             | KclError::InvalidExpression(e)
             | KclError::Engine(e)
             | KclError::Internal(e) => {
@@ -555,7 +558,7 @@ impl KclError {
             | KclError::Io(e)
             | KclError::Unexpected(e)
             | KclError::ValueAlreadyDefined(e)
-            | KclError::UndefinedValue(e)
+            | KclError::UndefinedValue { details: e, .. }
             | KclError::InvalidExpression(e)
             | KclError::Engine(e)
             | KclError::Internal(e) => {

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

@@ -164,10 +164,13 @@ impl ExecutorContext {
                                 let mut mod_value = mem.get_from(&mod_name, env_ref, import_item.into(), 0).cloned();
 
                                 if value.is_err() && ty.is_err() && mod_value.is_err() {
-                                    return Err(KclError::UndefinedValue(KclErrorDetails::new(
+                                    return Err(KclError::UndefinedValue {
-                                        format!("{} is not defined in module", import_item.name.name),
+                                        undefined_name: None,
-                                        vec![SourceRange::from(&import_item.name)],
+                                        details: KclErrorDetails::new(
-                                    )));
+                                            format!("{} is not defined in module", import_item.name.name),
+                                            vec![SourceRange::from(&import_item.name)],
+                                        ),
+                                    });
                                 }
 
                                 // Check that the item is allowed to be imported (in at least one namespace).
@@ -301,6 +304,7 @@ impl ExecutorContext {
 
                     let annotations = &variable_declaration.outer_attrs;
 
+                    exec_state.mod_local.being_declared = Some(variable_declaration.inner.name().to_owned());
                     let value = self
                         .execute_expr(
                             &variable_declaration.declaration.init,
@@ -310,6 +314,7 @@ impl ExecutorContext {
                             StatementKind::Declaration { name: &var_name },
                         )
                         .await?;
+                    exec_state.mod_local.being_declared = None;
                     exec_state
                         .mut_stack()
                         .add(var_name.clone(), value.clone(), source_range)?;
@@ -635,7 +640,23 @@ impl ExecutorContext {
             Expr::Literal(literal) => KclValue::from_literal((**literal).clone(), exec_state),
             Expr::TagDeclarator(tag) => tag.execute(exec_state).await?,
             Expr::Name(name) => {
-                let value = name.get_result(exec_state, self).await?.clone();
+                let being_declared = exec_state.mod_local.being_declared.clone();
+                let value = name
+                    .get_result(exec_state, self)
+                    .await
+                    .map_err(|e| match e {
+                        KclError::UndefinedValue {
+                            undefined_name,
+                            mut details,
+                        } => {
+                            if let Some(being_declared) = &being_declared{
+                                details.message = format!("You can't use `{}` because you're currently trying to define it. Use a different variable here instead.", being_declared);
+                            }
+                            KclError::UndefinedValue { details, undefined_name}
+                        }
+                        e => e,
+                    })?
+                    .clone();
                 if let KclValue::Module { value: module_id, meta } = value {
                     self.exec_module_for_result(
                         module_id,
@@ -913,10 +934,13 @@ impl Node<MemberExpression> {
                 if let Some(value) = map.get(&property) {
                     Ok(value.to_owned())
                 } else {
-                    Err(KclError::UndefinedValue(KclErrorDetails::new(
+                    Err(KclError::UndefinedValue {
-                        format!("Property '{property}' not found in object"),
+                        undefined_name: None,
-                        vec![self.clone().into()],
+                        details: KclErrorDetails::new(
-                    )))
+                            format!("Property '{property}' not found in object"),
+                            vec![self.clone().into()],
+                        ),
+                    })
                 }
             }
             (KclValue::Object { .. }, Property::String(property), true) => {
@@ -938,10 +962,13 @@ impl Node<MemberExpression> {
                 if let Some(value) = value_of_arr {
                     Ok(value.to_owned())
                 } else {
-                    Err(KclError::UndefinedValue(KclErrorDetails::new(
+                    Err(KclError::UndefinedValue {
-                        format!("The array doesn't have any item at index {index}"),
+                        undefined_name: None,
-                        vec![self.clone().into()],
+                        details: KclErrorDetails::new(
-                    )))
+                            format!("The array doesn't have any item at index {index}"),
+                            vec![self.clone().into()],
+                        ),
+                    })
                 }
             }
             // Singletons and single-element arrays should be interchangeable, but only indexing by 0 should work.

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

@@ -318,10 +318,13 @@ impl Node<CallExpressionKw> {
                     if let KclValue::Function { meta, .. } = func {
                         source_ranges = meta.iter().map(|m| m.source_range).collect();
                     };
-                    KclError::UndefinedValue(KclErrorDetails::new(
+                    KclError::UndefinedValue {
-                        format!("Result of user-defined function {} is undefined", fn_name),
+                        undefined_name: None,
-                        source_ranges,
+                        details: KclErrorDetails::new(
-                    ))
+                            format!("Result of user-defined function {} is undefined", fn_name),
+                            source_ranges,
+                        ),
+                    }
                 })?;
 
                 Ok(result)

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

@@ -367,10 +367,10 @@ impl ProgramMemory {
 
         let name = var.trim_start_matches(TYPE_PREFIX).trim_start_matches(MODULE_PREFIX);
 
-        Err(KclError::UndefinedValue(KclErrorDetails::new(
+        Err(KclError::UndefinedValue {
-            format!("`{name}` is not defined"),
+            undefined_name: Some(name.to_owned()),
-            vec![source_range],
+            details: KclErrorDetails::new(format!("`{name}` is not defined"), vec![source_range]),
-        )))
+        })
     }
 
     /// Iterate over all key/value pairs in the specified environment which satisfy the provided
@@ -488,10 +488,10 @@ impl ProgramMemory {
             };
         }
 
-        Err(KclError::UndefinedValue(KclErrorDetails::new(
+        Err(KclError::UndefinedValue {
-            format!("`{}` is not defined", var),
+            undefined_name: Some(var.to_owned()),
-            vec![],
+            details: KclErrorDetails::new(format!("`{}` is not defined", var), vec![]),
-        )))
+        })
     }
 }
 

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

@@ -2072,8 +2072,8 @@ notPipeSub = 1 |> identity(!%))";
             // a runtime error instead.
             parse_execute(code11).await.unwrap_err(),
             KclError::Syntax(KclErrorDetails::new(
-                "Unexpected token: |>".to_owned(),
+                "There was an unexpected !. Try removing it.".to_owned(),
-                vec![SourceRange::new(44, 46, ModuleId::default())],
+                vec![SourceRange::new(56, 57, ModuleId::default())],
             ))
         );
 

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

@@ -80,6 +80,11 @@ pub(super) struct ModuleState {
     /// The current value of the pipe operator returned from the previous
     /// expression.  If we're not currently in a pipeline, this will be None.
     pub pipe_value: Option<KclValue>,
+    /// The closest variable declaration being executed in any parent node in the AST.
+    /// This is used to provide better error messages, e.g. noticing when the user is trying
+    /// to use the variable `length` inside the RHS of its own definition, like `length = tan(length)`.
+    /// TODO: Make this a reference.
+    pub being_declared: Option<String>,
     /// Identifiers that have been exported from the current module.
     pub module_exports: Vec<String>,
     /// Settings specified from annotations.
@@ -342,6 +347,7 @@ impl ModuleState {
             id_generator: IdGenerator::new(module_id),
             stack: memory.new_stack(),
             pipe_value: Default::default(),
+            being_declared: Default::default(),
             module_exports: Default::default(),
             explicit_length_units: false,
             path,

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

@@ -979,12 +979,18 @@ fn property_separator(i: &mut TokenSlice) -> ModalResult<()> {
 }
 
 /// Match something that separates the labeled arguments of a fn call.
-fn labeled_arg_separator(i: &mut TokenSlice) -> ModalResult<()> {
+/// Returns the source range of the erroneous separator, if any was found.
+fn labeled_arg_separator(i: &mut TokenSlice) -> ModalResult<Option<SourceRange>> {
     alt((
         // Normally you need a comma.
-        comma_sep,
+        comma_sep.map(|_| None),
         // But, if the argument list is ending, no need for a comma.
-        peek(preceded(opt(whitespace), close_paren)).void(),
+        peek(preceded(opt(whitespace), close_paren)).void().map(|_| None),
+        whitespace.map(|mut tokens| {
+            // Safe to unwrap here because `whitespace` is guaranteed to return at least 1 whitespace.
+            let first_token = tokens.pop().unwrap();
+            Some(SourceRange::from(&first_token))
+        }),
     ))
     .parse_next(i)
 }
@@ -3135,7 +3141,7 @@ fn binding_name(i: &mut TokenSlice) -> ModalResult<Node<Identifier>> {
 
 /// Either a positional or keyword function call.
 fn fn_call_pos_or_kw(i: &mut TokenSlice) -> ModalResult<Expr> {
-    alt((fn_call_kw.map(Box::new).map(Expr::CallExpressionKw),)).parse_next(i)
+    fn_call_kw.map(Box::new).map(Expr::CallExpressionKw).parse_next(i)
 }
 
 fn labelled_fn_call(i: &mut TokenSlice) -> ModalResult<Expr> {
@@ -3198,7 +3204,7 @@ fn fn_call_kw(i: &mut TokenSlice) -> ModalResult<Node<CallExpressionKw>> {
     #[allow(clippy::large_enum_variant)]
     enum ArgPlace {
         NonCode(Node<NonCodeNode>),
-        LabeledArg(LabeledArg),
+        LabeledArg((LabeledArg, Option<SourceRange>)),
         UnlabeledArg(Expr),
         Keyword(Token),
     }
@@ -3208,7 +3214,7 @@ fn fn_call_kw(i: &mut TokenSlice) -> ModalResult<Node<CallExpressionKw>> {
         alt((
             terminated(non_code_node.map(ArgPlace::NonCode), whitespace),
             terminated(any_keyword.map(ArgPlace::Keyword), whitespace),
-            terminated(labeled_argument, labeled_arg_separator).map(ArgPlace::LabeledArg),
+            (labeled_argument, labeled_arg_separator).map(ArgPlace::LabeledArg),
             expression.map(ArgPlace::UnlabeledArg),
         )),
     )
@@ -3220,7 +3226,16 @@ fn fn_call_kw(i: &mut TokenSlice) -> ModalResult<Node<CallExpressionKw>> {
                 ArgPlace::NonCode(x) => {
                     non_code_nodes.insert(index, vec![x]);
                 }
-                ArgPlace::LabeledArg(x) => {
+                ArgPlace::LabeledArg((x, bad_token_source_range)) => {
+                    if let Some(bad_token_source_range) = bad_token_source_range {
+                        return Err(ErrMode::Cut(
+                            CompilationError::fatal(
+                                bad_token_source_range,
+                                "Missing comma between arguments, try adding a comma in",
+                            )
+                            .into(),
+                        ));
+                    }
                     args.push(x);
                 }
                 ArgPlace::Keyword(kw) => {
@@ -3255,7 +3270,22 @@ fn fn_call_kw(i: &mut TokenSlice) -> ModalResult<Node<CallExpressionKw>> {
     )?;
     ignore_whitespace(i);
     opt(comma_sep).parse_next(i)?;
-    let end = close_paren.parse_next(i)?.end;
+    let end = match close_paren.parse_next(i) {
+        Ok(tok) => tok.end,
+        Err(e) => {
+            if let Some(tok) = i.next_token() {
+                return Err(ErrMode::Cut(
+                    CompilationError::fatal(
+                        SourceRange::from(&tok),
+                        format!("There was an unexpected {}. Try removing it.", tok.value),
+                    )
+                    .into(),
+                ));
+            } else {
+                return Err(e);
+            }
+        }
+    };
 
     // Validate there aren't any duplicate labels.
     let mut counted_labels = IndexMap::with_capacity(args.len());
@@ -3376,8 +3406,7 @@ mod tests {
     fn kw_call_as_operand() {
         let tokens = crate::parsing::token::lex("f(x = 1)", ModuleId::default()).unwrap();
         let tokens = tokens.as_slice();
-        let op = operand.parse(tokens).unwrap();
+        operand.parse(tokens).unwrap();
-        println!("{op:#?}");
     }
 
     #[test]
@@ -4417,8 +4446,8 @@ z(-[["#,
         assert_err(
             r#"z
 (--#"#,
-            "Unexpected token: (",
+            "There was an unexpected -. Try removing it.",
-            [2, 3],
+            [3, 4],
         );
     }
 
@@ -5133,6 +5162,27 @@ bar = 1
         assert_eq!(actual.operator, UnaryOperator::Not);
         crate::parsing::top_level_parse(some_program_string).unwrap(); // Updated import path
     }
+    #[test]
+    fn test_sensible_error_when_missing_comma_between_fn_args() {
+        let program_source = "startSketchOn(XY)
+|> arc(
+    endAbsolute = [0, 50]
+    interiorAbsolute = [-50, 0]
+)";
+        let expected_src_start = program_source.find("]").unwrap();
+        let tokens = crate::parsing::token::lex(program_source, ModuleId::default()).unwrap();
+        ParseContext::init();
+        let err = program
+            .parse(tokens.as_slice())
+            .expect_err("Program succeeded, but it should have failed");
+        let cause = err
+            .inner()
+            .cause
+            .as_ref()
+            .expect("Found an error, but there was no cause. Add a cause.");
+        assert_eq!(cause.message, "Missing comma between arguments, try adding a comma in",);
+        assert_eq!(cause.source_range.start() - 1, expected_src_start);
+    }
 
     #[test]
     fn test_sensible_error_when_missing_rhs_of_kw_arg() {
@@ -5152,14 +5202,32 @@ bar = 1
         }
     }
 
+    #[test]
+    fn test_sensible_error_when_unexpected_token_in_fn_call() {
+        let program_source = "1
+|> extrude(
+  length=depth,
+})";
+        let expected_src_start = program_source.find("}").expect("Program should have an extraneous }");
+        let tokens = crate::parsing::token::lex(program_source, ModuleId::default()).unwrap();
+        ParseContext::init();
+        let err = program.parse(tokens.as_slice()).unwrap_err();
+        let cause = err
+            .inner()
+            .cause
+            .as_ref()
+            .expect("Found an error, but there was no cause. Add a cause.");
+        assert_eq!(cause.message, "There was an unexpected }. Try removing it.",);
+        assert_eq!(cause.source_range.start(), expected_src_start);
+    }
+
     #[test]
     fn test_sensible_error_when_using_keyword_as_arg_label() {
         for (i, program) in ["pow(2, fn = 8)"].into_iter().enumerate() {
             let tokens = crate::parsing::token::lex(program, ModuleId::default()).unwrap();
             let err = match fn_call_kw.parse(tokens.as_slice()) {
                 Err(e) => e,
-                Ok(ast) => {
+                Ok(_ast) => {
-                    eprintln!("{ast:#?}");
                     panic!("Expected this to error but it didn't");
                 }
             };

rust/kcl-lib/src/simulation_tests.rs

@@ -3483,3 +3483,24 @@ mod spheres {
         super::execute(TEST_NAME, true).await
     }
 }
+mod var_ref_in_own_def {
+    const TEST_NAME: &str = "var_ref_in_own_def";
+
+    /// Test parsing KCL.
+    #[test]
+    fn parse() {
+        super::parse(TEST_NAME)
+    }
+
+    /// Test that parsing and unparsing KCL produces the original KCL input.
+    #[tokio::test(flavor = "multi_thread")]
+    async fn unparse() {
+        super::unparse(TEST_NAME).await
+    }
+
+    /// Test that KCL is executed correctly.
+    #[tokio::test(flavor = "multi_thread")]
+    async fn kcl_test_execute() {
+        super::execute(TEST_NAME, true).await
+    }
+}

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

@@ -23,7 +23,7 @@ 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::new(
+        return Err(KclError::Semantic(KclErrorDetails::new(
             "At least two solids are required for a union operation.".to_string(),
             vec![args.source_range],
         )));
@@ -88,7 +88,7 @@ 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::new(
+        return Err(KclError::Semantic(KclErrorDetails::new(
             "At least two solids are required for an intersect operation.".to_string(),
             vec![args.source_range],
         )));

rust/kcl-lib/tests/var_ref_in_own_def/artifact_commands.snap

@@ -0,0 +1,32 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Artifact commands var_ref_in_own_def.kcl
+---
+[
+  {
+    "cmdId": "[uuid]",
+    "range": [],
+    "command": {
+      "type": "edge_lines_visible",
+      "hidden": false
+    }
+  },
+  {
+    "cmdId": "[uuid]",
+    "range": [],
+    "command": {
+      "type": "object_visible",
+      "object_id": "[uuid]",
+      "hidden": true
+    }
+  },
+  {
+    "cmdId": "[uuid]",
+    "range": [],
+    "command": {
+      "type": "object_visible",
+      "object_id": "[uuid]",
+      "hidden": true
+    }
+  }
+]

rust/kcl-lib/tests/var_ref_in_own_def/artifact_graph_flowchart.snap

@@ -0,0 +1,6 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Artifact graph flowchart var_ref_in_own_def.kcl
+extension: md
+snapshot_kind: binary
+---

rust/kcl-lib/tests/var_ref_in_own_def/artifact_graph_flowchart.snap.md

@@ -0,0 +1,3 @@
+```mermaid
+flowchart LR
+```

rust/kcl-lib/tests/var_ref_in_own_def/ast.snap

@@ -0,0 +1,75 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Result of parsing var_ref_in_own_def.kcl
+---
+{
+  "Ok": {
+    "body": [
+      {
+        "commentStart": 0,
+        "declaration": {
+          "commentStart": 0,
+          "end": 0,
+          "id": {
+            "commentStart": 0,
+            "end": 0,
+            "name": "x",
+            "start": 0,
+            "type": "Identifier"
+          },
+          "init": {
+            "callee": {
+              "abs_path": false,
+              "commentStart": 0,
+              "end": 0,
+              "name": {
+                "commentStart": 0,
+                "end": 0,
+                "name": "cos",
+                "start": 0,
+                "type": "Identifier"
+              },
+              "path": [],
+              "start": 0,
+              "type": "Name"
+            },
+            "commentStart": 0,
+            "end": 0,
+            "start": 0,
+            "type": "CallExpressionKw",
+            "type": "CallExpressionKw",
+            "unlabeled": {
+              "abs_path": false,
+              "commentStart": 0,
+              "end": 0,
+              "name": {
+                "commentStart": 0,
+                "end": 0,
+                "name": "x",
+                "start": 0,
+                "type": "Identifier"
+              },
+              "path": [],
+              "start": 0,
+              "type": "Name",
+              "type": "Name"
+            }
+          },
+          "start": 0,
+          "type": "VariableDeclarator"
+        },
+        "end": 0,
+        "kind": "const",
+        "preComments": [
+          "// This won't work, because `x` is being referenced in its own definition."
+        ],
+        "start": 0,
+        "type": "VariableDeclaration",
+        "type": "VariableDeclaration"
+      }
+    ],
+    "commentStart": 0,
+    "end": 0,
+    "start": 0
+  }
+}

rust/kcl-lib/tests/var_ref_in_own_def/execution_error.snap

@@ -0,0 +1,14 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Error from executing var_ref_in_own_def.kcl
+---
+KCL UndefinedValue error
+
+  × undefined value: You can't use `x` because you're currently trying to
+  │ define it. Use a different variable here instead.
+   ╭─[2:9]
+ 1 │ // This won't work, because `x` is being referenced in its own definition.
+ 2 │ x = cos(x)
+   ·         ┬
+   ·         ╰── tests/var_ref_in_own_def/input.kcl
+   ╰────

rust/kcl-lib/tests/var_ref_in_own_def/input.kcl

@@ -0,0 +1,2 @@
+// This won't work, because `x` is being referenced in its own definition.
+x = cos(x)

rust/kcl-lib/tests/var_ref_in_own_def/ops.snap

@@ -0,0 +1,5 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Operations executed var_ref_in_own_def.kcl
+---
+[]

rust/kcl-lib/tests/var_ref_in_own_def/unparsed.snap

@@ -0,0 +1,6 @@
+---
+source: kcl-lib/src/simulation_tests.rs
+description: Result of unparsing var_ref_in_own_def.kcl
+---
+// This won't work, because `x` is being referenced in its own definition.
+x = cos(x)

rust/kcl-python-bindings/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-python-bindings"
-version = "0.3.77"
+version = "0.3.78"
 edition = "2021"
 repository = "https://github.com/kittycad/modeling-app"
 exclude = ["tests/*", "files/*", "venv/*"]

rust/kcl-test-server/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-test-server"
 description = "A test server for KCL"
-version = "0.1.77"
+version = "0.1.78"
 edition = "2021"
 license = "MIT"
 

rust/kcl-to-core/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-to-core"
 description = "Utility methods to convert kcl to engine core executable tests"
-version = "0.1.77"
+version = "0.1.78"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

rust/kcl-wasm-lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-wasm-lib"
-version = "0.1.77"
+version = "0.1.78"
 edition = "2021"
 repository = "https://github.com/KittyCAD/modeling-app"
 rust-version = "1.83"