zoo-kcl 0.3.103__tar.gz → 0.3.104__tar.gz

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/Cargo.lock

@@ -2231,7 +2231,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-api"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "indexmap 2.11.4",
  "kcl-error",
@@ -2242,7 +2242,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-bumper"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "anyhow",
  "clap",
@@ -2253,7 +2253,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-derive-docs"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2262,7 +2262,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-directory-test-macro"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "convert_case",
  "proc-macro2",
@@ -2272,7 +2272,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-error"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "miette",
  "serde",
@@ -2297,7 +2297,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "clap",
@@ -2318,7 +2318,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server-release"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "anyhow",
  "clap",
@@ -2338,7 +2338,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-lib"
-version = "0.2.103"
+version = "0.2.104"
 dependencies = [
  "anyhow",
  "approx 0.5.1",
@@ -2420,7 +2420,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-python-bindings"
-version = "0.3.103"
+version = "0.3.104"
 dependencies = [
  "anyhow",
  "kcl-lib",
@@ -2436,7 +2436,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-test-server"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "anyhow",
  "hyper 0.14.32",
@@ -2449,7 +2449,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-to-core"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2463,7 +2463,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-wasm-lib"
-version = "0.1.103"
+version = "0.1.104"
 dependencies = [
  "anyhow",
  "bson",
@@ -2532,9 +2532,9 @@ dependencies = [
 
 [[package]]
 name = "kittycad-modeling-cmds"
-version = "0.2.144"
+version = "0.2.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58c575ffec0c363c3cfcffcfcce8891dc365f9cbe7fe79404ed2087e7664f10c"
+checksum = "dfc08235cb273fb7b317f8f072dadfe523d809e4fca4dfcfee80490ef5965d74"
 dependencies = [
  "anyhow",
  "chrono",

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/Cargo.toml

@@ -16,7 +16,7 @@ kittycad = { version = "0.4.2", default-features = false, features = [
   "js",
   "requests",
 ] }
-kittycad-modeling-cmds = { version = "0.2.144", features = [
+kittycad-modeling-cmds = { version = "0.2.145", features = [
   "ts-rs",
   "websocket",
 ] }
@@ -70,6 +70,7 @@ insta = { opt-level = 3 }
 debug = "line-tables-only"
 
 #Example: how to point modeling-app at a different repo (e.g. a branch or a local clone)
-#[patch.crates-io]
-#kittycad-modeling-cmds = { path = "../../modeling-api/modeling-cmds" }
-#kittycad-modeling-session = { path = "../../modeling-api/modeling-session" }
+# [patch.crates-io]
+# kittycad-modeling-cmds = { git = "https://github.com/KittyCAD/modeling-api.git", branch = "ben/chamfer_angle" }
+# kittycad-modeling-session = { git = "https://github.com/KittyCAD/modeling-api.git", branch = "ben/chamfer_angle" }
+# #kittycad-modeling-session = { path = "../../modeling-api/modeling-session" }

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zoo-kcl
-Version: 0.3.103
+Version: 0.3.104
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-api"
-version = "0.1.103"
+version = "0.1.104"
 edition = "2024"
 description = "KCL interpreter API"
 license = "MIT"

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/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.103"
+version = "0.1.104"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-derive-docs/src/example_tests.rs

@@ -213,6 +213,7 @@ pub const TEST_NAMES: &[&str] = &[
     "std-solid-appearance-9",
     "std-solid-chamfer-0",
     "std-solid-chamfer-1",
+    "std-solid-chamfer-2",
     "std-solid-fillet-0",
     "std-solid-fillet-1",
     "std-solid-hollow-0",

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/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.103"
+version = "0.1.104"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-error"
-version = "0.1.103"
+version = "0.1.104"
 edition = "2024"
 description = "KCL error definitions"
 license = "MIT"

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-error/src/lib.rs

@@ -100,3 +100,15 @@ pub struct Suggestion {
     pub insert: String,
     pub source_range: SourceRange,
 }
+
+impl Suggestion {
+    /// Apply the suggestion to the source code.
+    pub fn apply(&self, src: &str) -> String {
+        format!(
+            "{}{}{}",
+            &src[0..self.source_range.start()],
+            self.insert,
+            &src[self.source_range.end()..]
+        )
+    }
+}

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-lib/Cargo.toml

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

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-lib/src/execution/annotations.rs

@@ -23,6 +23,7 @@ pub(crate) const SETTINGS_EXPERIMENTAL_FEATURES: &str = "experimentalFeatures";
 pub(super) const NO_PRELUDE: &str = "no_std";
 pub(crate) const DEPRECATED: &str = "deprecated";
 pub(crate) const EXPERIMENTAL: &str = "experimental";
+pub(crate) const INCLUDE_IN_FEATURE_TREE: &str = "feature_tree";
 
 pub(super) const IMPORT_FORMAT: &str = "format";
 pub(super) const IMPORT_COORDS: &str = "coords";
@@ -63,6 +64,8 @@ pub(super) const WARN_VALUES: [&str; 8] = [
 ];
 
 #[derive(Clone, Copy, Eq, PartialEq, Debug, Deserialize, Serialize, ts_rs::TS)]
+#[ts(export)]
+#[serde(tag = "type")]
 pub enum WarningLevel {
     Allow,
     Warn,
@@ -77,6 +80,14 @@ impl WarningLevel {
             WarningLevel::Deny => Some(Severity::Error),
         }
     }
+
+    pub(crate) fn as_str(self) -> &'static str {
+        match self {
+            WarningLevel::Allow => WARN_ALLOW,
+            WarningLevel::Warn => WARN_WARN,
+            WarningLevel::Deny => WARN_DENY,
+        }
+    }
 }
 
 impl FromStr for WarningLevel {
@@ -226,11 +237,23 @@ pub(super) fn expect_number(expr: &Expr) -> Result<String, KclError> {
     )))
 }
 
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct FnAttrs {
     pub impl_: Impl,
     pub deprecated: bool,
     pub experimental: bool,
+    pub include_in_feature_tree: bool,
+}
+
+impl Default for FnAttrs {
+    fn default() -> Self {
+        Self {
+            impl_: Impl::default(),
+            deprecated: false,
+            experimental: false,
+            include_in_feature_tree: true,
+        }
+    }
 }
 
 pub(super) fn get_fn_attrs(
@@ -283,9 +306,19 @@ pub(super) fn get_fn_attrs(
                 continue;
             }
 
+            if &*p.key.name == INCLUDE_IN_FEATURE_TREE
+                && let Some(b) = p.value.literal_bool()
+            {
+                if result.is_none() {
+                    result = Some(FnAttrs::default());
+                }
+                result.as_mut().unwrap().include_in_feature_tree = b;
+                continue;
+            }
+
             return Err(KclError::new_semantic(KclErrorDetails::new(
                 format!(
-                    "Invalid attribute, expected one of: {IMPL}, {DEPRECATED}, {EXPERIMENTAL}, found `{}`",
+                    "Invalid attribute, expected one of: {IMPL}, {DEPRECATED}, {EXPERIMENTAL}, {INCLUDE_IN_FEATURE_TREE}, found `{}`",
                     &*p.key.name,
                 ),
                 vec![source_range],

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-lib/src/execution/artifact.rs

@@ -294,6 +294,7 @@ pub struct EdgeCut {
 pub enum EdgeCutSubType {
     Fillet,
     Chamfer,
+    Custom,
 }
 
 impl From<kcmc::shared::CutType> for EdgeCutSubType {
@@ -305,6 +306,16 @@ impl From<kcmc::shared::CutType> for EdgeCutSubType {
     }
 }
 
+impl From<kcmc::shared::CutTypeV2> for EdgeCutSubType {
+    fn from(cut_type: kcmc::shared::CutTypeV2) -> Self {
+        match cut_type {
+            kcmc::shared::CutTypeV2::Fillet { .. } => EdgeCutSubType::Fillet,
+            kcmc::shared::CutTypeV2::Chamfer { .. } => EdgeCutSubType::Chamfer,
+            kcmc::shared::CutTypeV2::Custom { .. } => EdgeCutSubType::Custom,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Artifact.ts")]
 #[serde(rename_all = "camelCase")]
@@ -1301,6 +1312,31 @@ fn artifacts_to_update(
             }
             return Ok(return_arr);
         }
+        ModelingCmd::Solid3dCutEdges(cmd) => {
+            let mut return_arr = Vec::new();
+            let edge_id = if let Some(edge_id) = cmd.edge_ids.first() {
+                edge_id.into()
+            } else {
+                internal_error!(range, "Solid3dCutEdges command has no edge ID: id={id:?}, cmd={cmd:?}");
+            };
+            return_arr.push(Artifact::EdgeCut(EdgeCut {
+                id,
+                sub_type: cmd.cut_type.into(),
+                consumed_edge_id: edge_id,
+                edge_ids: Vec::new(),
+                surface_id: None,
+                code_ref,
+            }));
+            let consumed_edge = artifacts.get(&edge_id);
+            if let Some(Artifact::Segment(consumed_edge)) = consumed_edge {
+                let mut new_segment = consumed_edge.clone();
+                new_segment.edge_cut_id = Some(id);
+                return_arr.push(Artifact::Segment(new_segment));
+            } else {
+                // TODO: Handle other types like SweepEdge.
+            }
+            return Ok(return_arr);
+        }
         ModelingCmd::EntityMakeHelixFromParams(_) => {
             let return_arr = vec![Artifact::Helix(Helix {
                 id,

{zoo_kcl-0.3.103 → zoo_kcl-0.3.104}/kcl-lib/src/execution/exec_ast.rs

@@ -14,7 +14,7 @@ use crate::{
         Operation, PlaneType, StatementKind, TagIdentifier, annotations,
         cad_op::OpKclValue,
         fn_call::Args,
-        kcl_value::{FunctionSource, TypeDef},
+        kcl_value::{FunctionSource, KclFunctionSourceParams, TypeDef},
         memory,
         state::{ModuleState, SketchBlockState},
         types::{NumericType, PrimitiveType, RuntimeType},
@@ -396,7 +396,12 @@ impl ExecutorContext {
                         .mut_stack()
                         .add(var_name.clone(), rhs.clone(), source_range)?;
 
-                    if rhs.show_variable_in_feature_tree() {
+                    // Track operations, for the feature tree.
+                    // Don't track these operations if the KCL code being executed is in the stdlib,
+                    // because users shouldn't know about stdlib internals -- it's useless noise, to them.
+                    let should_show_in_feature_tree =
+                        !exec_state.mod_local.inside_stdlib && rhs.show_variable_in_feature_tree();
+                    if should_show_in_feature_tree {
                         exec_state.push_op(Operation::VariableDeclaration {
                             name: var_name.clone(),
                             value: OpKclValue::from(&rhs),
@@ -766,6 +771,10 @@ impl ExecutorContext {
             Expr::FunctionExpression(function_expression) => {
                 let attrs = annotations::get_fn_attrs(annotations, metadata.source_range)?;
                 let experimental = attrs.map(|a| a.experimental).unwrap_or_default();
+                let is_std = matches!(&exec_state.mod_local.path, ModulePath::Std { .. });
+
+                // Check the KCL @(feature_tree = ) annotation.
+                let include_in_feature_tree = attrs.unwrap_or_default().include_in_feature_tree;
                 if let Some(attrs) = attrs
                     && (attrs.impl_ == annotations::Impl::Rust || attrs.impl_ == annotations::Impl::RustConstraint)
                 {
@@ -789,8 +798,11 @@ impl ExecutorContext {
                         value: Box::new(FunctionSource::kcl(
                             function_expression.clone(),
                             exec_state.mut_stack().snapshot(),
-                            matches!(&exec_state.mod_local.path, ModulePath::Std { .. }),
-                            experimental,
+                            KclFunctionSourceParams {
+                                is_std,
+                                experimental,
+                                include_in_feature_tree,
+                            },
                         )),
                         meta: vec![metadata.to_owned()],
                     }
@@ -1461,16 +1473,86 @@ impl Node<MemberExpression> {
 }
 
 impl Node<BinaryExpression> {
-    #[async_recursion]
     pub async fn get_result(&self, exec_state: &mut ExecState, ctx: &ExecutorContext) -> Result<KclValue, KclError> {
-        let left_value = self.left.get_result(exec_state, ctx).await?;
-        let right_value = self.right.get_result(exec_state, ctx).await?;
+        enum State {
+            EvaluateLeft(Node<BinaryExpression>),
+            FromLeft {
+                node: Node<BinaryExpression>,
+            },
+            EvaluateRight {
+                node: Node<BinaryExpression>,
+                left: KclValue,
+            },
+            FromRight {
+                node: Node<BinaryExpression>,
+                left: KclValue,
+            },
+        }
+
+        let mut stack = vec![State::EvaluateLeft(self.clone())];
+        let mut last_result: Option<KclValue> = None;
+
+        while let Some(state) = stack.pop() {
+            match state {
+                State::EvaluateLeft(node) => {
+                    let left_part = node.left.clone();
+                    match left_part {
+                        BinaryPart::BinaryExpression(child) => {
+                            stack.push(State::FromLeft { node });
+                            stack.push(State::EvaluateLeft(*child));
+                        }
+                        part => {
+                            let left_value = part.get_result(exec_state, ctx).await?;
+                            stack.push(State::EvaluateRight { node, left: left_value });
+                        }
+                    }
+                }
+                State::FromLeft { node } => {
+                    let Some(left_value) = last_result.take() else {
+                        return Err(Self::missing_result_error(&node));
+                    };
+                    stack.push(State::EvaluateRight { node, left: left_value });
+                }
+                State::EvaluateRight { node, left } => {
+                    let right_part = node.right.clone();
+                    match right_part {
+                        BinaryPart::BinaryExpression(child) => {
+                            stack.push(State::FromRight { node, left });
+                            stack.push(State::EvaluateLeft(*child));
+                        }
+                        part => {
+                            let right_value = part.get_result(exec_state, ctx).await?;
+                            let result = node.apply_operator(exec_state, ctx, left, right_value).await?;
+                            last_result = Some(result);
+                        }
+                    }
+                }
+                State::FromRight { node, left } => {
+                    let Some(right_value) = last_result.take() else {
+                        return Err(Self::missing_result_error(&node));
+                    };
+                    let result = node.apply_operator(exec_state, ctx, left, right_value).await?;
+                    last_result = Some(result);
+                }
+            }
+        }
+
+        last_result.ok_or_else(|| Self::missing_result_error(self))
+    }
+
+    async fn apply_operator(
+        &self,
+        exec_state: &mut ExecState,
+        ctx: &ExecutorContext,
+        left_value: KclValue,
+        right_value: KclValue,
+    ) -> Result<KclValue, KclError> {
         let mut meta = left_value.metadata();
         meta.extend(right_value.metadata());
 
         // First check if we are doing string concatenation.
         if self.operator == BinaryOperator::Add
-            && let (KclValue::String { value: left, meta: _ }, KclValue::String { value: right, meta: _ }) =
+            && let (KclValue::String { value: left, .. }, KclValue::String { value: right, .. }) =
                 (&left_value, &right_value)
         {
             return Ok(KclValue::String {
@@ -1506,28 +1588,24 @@ impl Node<BinaryExpression> {
                 .await?;
                 return Ok(result.into());
             }
-        } else if self.operator == BinaryOperator::And {
+        } else if self.operator == BinaryOperator::And
+            && let (KclValue::Solid { value: left }, KclValue::Solid { value: right }) = (&left_value, &right_value)
+        {
             // Check if we have solids.
-            if let (KclValue::Solid { value: left }, KclValue::Solid { value: right }) = (&left_value, &right_value) {
-                let args = Args::new_no_args(self.into(), ctx.clone());
-                let result = crate::std::csg::inner_intersect(
-                    vec![*left.clone(), *right.clone()],
-                    Default::default(),
-                    exec_state,
-                    args,
-                )
-                .await?;
-                return Ok(result.into());
-            }
+            let args = Args::new_no_args(self.into(), ctx.clone());
+            let result = crate::std::csg::inner_intersect(
+                vec![*left.clone(), *right.clone()],
+                Default::default(),
+                exec_state,
+                args,
+            )
+            .await?;
+            return Ok(result.into());
         }
 
         // Check if we are doing logical operations on booleans.
         if self.operator == BinaryOperator::Or || self.operator == BinaryOperator::And {
-            let KclValue::Bool {
-                value: left_value,
-                meta: _,
-            } = left_value
-            else {
+            let KclValue::Bool { value: left_value, .. } = left_value else {
                 return Err(KclError::new_semantic(KclErrorDetails::new(
                     format!(
                         "Cannot apply logical operator to non-boolean value: {}",
@@ -1536,11 +1614,7 @@ impl Node<BinaryExpression> {
                     vec![self.left.clone().into()],
                 )));
             };
-            let KclValue::Bool {
-                value: right_value,
-                meta: _,
-            } = right_value
-            else {
+            let KclValue::Bool { value: right_value, .. } = right_value else {
                 return Err(KclError::new_semantic(KclErrorDetails::new(
                     format!(
                         "Cannot apply logical operator to non-boolean value: {}",
@@ -1687,6 +1761,13 @@ impl Node<BinaryExpression> {
         Ok(value)
     }
 
+    fn missing_result_error(node: &Node<BinaryExpression>) -> KclError {
+        KclError::new_internal(KclErrorDetails::new(
+            "missing result while evaluating binary expression".to_owned(),
+            vec![SourceRange::from(node)],
+        ))
+    }
+
     fn warn_on_unknown(&self, ty: &NumericType, verb: &str, exec_state: &mut ExecState) {
         if ty == &NumericType::Unknown {
             let sr = self.as_source_range();
@@ -2659,12 +2740,77 @@ y = x[0mm + 1]
 
     #[tokio::test(flavor = "multi_thread")]
     async fn getting_property_of_plane() {
-        // let ast = include_str!("../../tests/inputs/planestuff.kcl");
         let ast = std::fs::read_to_string("tests/inputs/planestuff.kcl").unwrap();
-
         parse_execute(&ast).await.unwrap();
     }
 
+    #[cfg(feature = "artifact-graph")]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn no_artifacts_from_within_hole_call() {
+        // Test that executing stdlib KCL, like the `hole` function
+        // (which is actually implemented in KCL not Rust)
+        // does not generate artifacts from within the stdlib code,
+        // only from the user code.
+        let ast = std::fs::read_to_string("tests/inputs/sample_hole.kcl").unwrap();
+        let out = parse_execute(&ast).await.unwrap();
+
+        // Get all the operations that occurred.
+        let actual_operations = out.exec_state.global.root_module_artifacts.operations;
+
+        // There should be 5, for sketching the cube and applying the hole.
+        // If the stdlib internal calls are being tracked, that's a bug,
+        // and the actual number of operations will be something like 35.
+        let expected = 5;
+        assert_eq!(
+            actual_operations.len(),
+            expected,
+            "expected {expected} operations, received {}:\n{actual_operations:#?}",
+            actual_operations.len(),
+        );
+    }
+
+    #[cfg(feature = "artifact-graph")]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn feature_tree_annotation_on_user_defined_kcl() {
+        // The call to foo() should not generate an operation,
+        // because its 'feature_tree' attribute has been set to false.
+        let ast = std::fs::read_to_string("tests/inputs/feature_tree_annotation_on_user_defined_kcl.kcl").unwrap();
+        let out = parse_execute(&ast).await.unwrap();
+
+        // Get all the operations that occurred.
+        let actual_operations = out.exec_state.global.root_module_artifacts.operations;
+
+        let expected = 0;
+        assert_eq!(
+            actual_operations.len(),
+            expected,
+            "expected {expected} operations, received {}:\n{actual_operations:#?}",
+            actual_operations.len(),
+        );
+    }
+
+    #[cfg(feature = "artifact-graph")]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn no_feature_tree_annotation_on_user_defined_kcl() {
+        // The call to foo() should generate an operation,
+        // because @(feature_tree) defaults to true.
+        let ast = std::fs::read_to_string("tests/inputs/no_feature_tree_annotation_on_user_defined_kcl.kcl").unwrap();
+        let out = parse_execute(&ast).await.unwrap();
+
+        // Get all the operations that occurred.
+        let actual_operations = out.exec_state.global.root_module_artifacts.operations;
+
+        let expected = 2;
+        assert_eq!(
+            actual_operations.len(),
+            expected,
+            "expected {expected} operations, received {}:\n{actual_operations:#?}",
+            actual_operations.len(),
+        );
+        assert!(matches!(actual_operations[0], Operation::GroupBegin { .. }));
+        assert!(matches!(actual_operations[1], Operation::GroupEnd));
+    }
+
     #[tokio::test(flavor = "multi_thread")]
     async fn custom_warning() {
         let warn = r#"