Add ? token

This adds a new `parse_kcl!` macro which takes a string as input. It parses the string into KCL source code _at compile-time_. Invalid KCL will make your Rust project fail to compile.

src/wasm-lib/Cargo.lock

@@ -681,6 +681,30 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
 
+[[package]]
+name = "databake"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "959b676312ba1aaafb2219c475560082e6b20c3bc572ec1483f93cecd748cf3d"
+dependencies = [
+ "databake-derive",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "databake-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0694dfe255f1af0289d3d1b40787bb955e8603d96e96a6b14b225926e108fb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "synstructure",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.9"
@@ -1401,6 +1425,18 @@ dependencies = [
  "treediff",
 ]
 
+[[package]]
+name = "kcl-compile-macro"
+version = "0.1.0"
+dependencies = [
+ "databake",
+ "kcl-lib",
+ "pretty_assertions",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
 [[package]]
 name = "kcl-lib"
 version = "0.1.35"
@@ -1412,6 +1448,7 @@ dependencies = [
  "clap",
  "criterion",
  "dashmap",
+ "databake",
  "derive-docs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "expectorate",
  "futures",
@@ -2906,6 +2943,18 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "285ba80e733fac80aa4270fbcdf83772a79b80aa35c97075320abfee4a915b06"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "unicode-xid",
+]
+
 [[package]]
 name = "system-configuration"
 version = "0.5.1"
@@ -3455,6 +3504,12 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
 
+[[package]]
+name = "unicode-xid"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
 [[package]]
 name = "unsafe-libyaml"
 version = "0.2.9"

src/wasm-lib/Cargo.toml

@@ -53,6 +53,7 @@ debug = true
 members = [
 	"derive-docs",
 	"kcl",
+  "kcl-compile-macro",
 ]
 
 [workspace.dependencies]

src/wasm-lib/kcl-compile-macro/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "kcl-compile-macro"
+description = "Macro for compiling KCL to its AST during Rust compile-time"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/KittyCAD/modeling-app"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+proc-macro = true
+
+[dependencies]
+databake = "0.1.6"
+kcl-lib = { path = "../kcl" }
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "2.0.39", features = ["full"] }
+
+[dev-dependencies]
+pretty_assertions = "1.4.0"

src/wasm-lib/kcl-compile-macro/src/lib.rs

@@ -0,0 +1,22 @@
+use databake::*;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, LitStr};
+
+/// Parses KCL into its AST at compile-time.
+/// This macro takes exactly one argument: A string literal containing KCL.
+/// # Examples
+/// ```
+/// extern crate alloc;
+/// use kcl_compile_macro::parse_kcl;
+/// let ast: kcl_lib::ast::types::Program = parse_kcl!("const y = 4");
+/// ```
+#[proc_macro]
+pub fn parse_kcl(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as LitStr);
+    let kcl_src = input.value();
+    let tokens = kcl_lib::token::lexer(&kcl_src);
+    let ast = kcl_lib::parser::Parser::new(tokens).ast().unwrap();
+    let ast_struct = ast.bake(&Default::default());
+    quote!(#ast_struct).into()
+}

src/wasm-lib/kcl-compile-macro/tests/macro_test.rs

@@ -0,0 +1,38 @@
+extern crate alloc;
+use kcl_compile_macro::parse_kcl;
+use kcl_lib::ast::types::{
+    BodyItem, Identifier, Literal, LiteralValue, NonCodeMeta, Program, Value, VariableDeclaration, VariableDeclarator,
+    VariableKind,
+};
+use pretty_assertions::assert_eq;
+
+#[test]
+fn basic() {
+    let actual = parse_kcl!("const y = 4");
+    let expected = Program {
+        start: 0,
+        end: 11,
+        body: vec![BodyItem::VariableDeclaration(VariableDeclaration {
+            start: 0,
+            end: 11,
+            declarations: vec![VariableDeclarator {
+                start: 6,
+                end: 11,
+                id: Identifier {
+                    start: 6,
+                    end: 7,
+                    name: "y".to_owned(),
+                },
+                init: Value::Literal(Box::new(Literal {
+                    start: 10,
+                    end: 11,
+                    value: LiteralValue::IInteger(4),
+                    raw: "4".to_owned(),
+                })),
+            }],
+            kind: VariableKind::Const,
+        })],
+        non_code_meta: NonCodeMeta::default(),
+    };
+    assert_eq!(expected, actual);
+}

src/wasm-lib/kcl/Cargo.toml

@@ -15,6 +15,7 @@ async-recursion = "1.0.5"
 async-trait = "0.1.73"
 clap = { version = "4.4.7", features = ["cargo", "derive", "env", "unicode"], optional = true }
 dashmap = "5.5.3"
+databake = { version = "0.1.6", features = ["derive"] }
 derive-docs = { version = "0.1.4" }
 #derive-docs = { path = "../derive-docs" }
 kittycad = { workspace = true }

src/wasm-lib/kcl/src/ast/types.rs

@@ -3,6 +3,7 @@
 use std::{collections::HashMap, fmt::Write};
 
 use anyhow::Result;
+use databake::*;
 use parse_display::{Display, FromStr};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -20,7 +21,8 @@ use crate::{
 
 mod literal_value;
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "camelCase")]
 pub struct Program {
@@ -349,7 +351,8 @@ macro_rules! impl_value_meta {
 
 pub(crate) use impl_value_meta;
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum BodyItem {
@@ -388,7 +391,8 @@ impl From<&BodyItem> for SourceRange {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum Value {
@@ -551,7 +555,8 @@ impl From<&Value> for SourceRange {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum BinaryPart {
@@ -707,7 +712,8 @@ impl BinaryPart {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct NonCodeNode {
@@ -755,7 +761,8 @@ impl NonCodeNode {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "camelCase")]
 pub enum CommentStyle {
@@ -765,7 +772,8 @@ pub enum CommentStyle {
     Block,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type", rename_all = "camelCase")]
 pub enum NonCodeValue {
@@ -810,6 +818,19 @@ pub struct NonCodeMeta {
     pub start: Vec<NonCodeNode>,
 }
 
+impl Bake for NonCodeMeta {
+    fn bake(&self, env: &CrateEnv) -> TokenStream {
+        env.insert("kcl_lib::ast::types");
+        let start = self.start.bake(env);
+        databake::quote! {
+            kcl_lib::ast::types::NonCodeMeta {
+                non_code_nodes: std::collections::HashMap::new(),
+                start: #start,
+            }
+        }
+    }
+}
+
 // implement Deserialize manually because we to force the keys of non_code_nodes to be usize
 // and by default the ts type { [statementIndex: number]: NonCodeNode } serializes to a string i.e. "0", "1", etc.
 impl<'de> Deserialize<'de> for NonCodeMeta {
@@ -843,7 +864,8 @@ impl NonCodeMeta {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ExpressionStatement {
@@ -854,7 +876,8 @@ pub struct ExpressionStatement {
 
 impl_value_meta!(ExpressionStatement);
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct CallExpression {
@@ -1122,7 +1145,8 @@ impl PartialEq for Function {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct VariableDeclaration {
@@ -1272,7 +1296,8 @@ impl VariableDeclaration {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]
 #[display(style = "snake_case")]
@@ -1316,7 +1341,8 @@ impl VariableKind {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct VariableDeclarator {
@@ -1345,7 +1371,8 @@ impl VariableDeclarator {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct Literal {
@@ -1415,7 +1442,8 @@ impl From<&Box<Literal>> for MemoryItem {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct Identifier {
@@ -1451,7 +1479,8 @@ impl Identifier {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct PipeSubstitution {
@@ -1479,7 +1508,8 @@ impl From<PipeSubstitution> for Value {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ArrayExpression {
@@ -1639,7 +1669,8 @@ impl ArrayExpression {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ObjectExpression {
@@ -1796,7 +1827,8 @@ impl ObjectExpression {
 
 impl_value_meta!(ObjectExpression);
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ObjectProperty {
@@ -1838,7 +1870,8 @@ impl ObjectProperty {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum MemberObject {
@@ -1884,7 +1917,8 @@ impl From<&MemberObject> for SourceRange {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum LiteralIdentifier {
@@ -1920,7 +1954,8 @@ impl From<&LiteralIdentifier> for SourceRange {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct MemberExpression {
@@ -2083,7 +2118,8 @@ pub struct ObjectKeyInfo {
     pub computed: bool,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct BinaryExpression {
@@ -2262,7 +2298,8 @@ pub fn parse_json_value_as_string(j: &serde_json::Value) -> Option<String> {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]
 #[display(style = "snake_case")]
@@ -2330,7 +2367,8 @@ impl BinaryOperator {
         }
     }
 }
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct UnaryExpression {
@@ -2408,7 +2446,8 @@ impl UnaryExpression {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]
 #[display(style = "snake_case")]
@@ -2423,7 +2462,8 @@ pub enum UnaryOperator {
     Not,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "camelCase", tag = "type")]
 pub struct PipeExpression {
@@ -2581,7 +2621,8 @@ async fn execute_pipe_body(
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct FunctionExpression {
@@ -2631,7 +2672,8 @@ impl FunctionExpression {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ReturnStatement {

src/wasm-lib/kcl/src/ast/types/literal_value.rs

@@ -1,10 +1,12 @@
+use databake::*;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JValue;
 
 use super::{Literal, Value};
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(untagged, rename_all = "snake_case")]
 pub enum LiteralValue {

src/wasm-lib/kcl/src/executor.rs

@@ -795,7 +795,9 @@ pub async fn execute(
     for statement in &program.body {
         match statement {
             BodyItem::ExpressionStatement(expression_statement) => {
-                if let Value::CallExpression(call_expr) = &expression_statement.expression {
+                if let Value::PipeExpression(pipe_expr) = &expression_statement.expression {
+                    pipe_expr.get_result(memory, &mut pipe_info, ctx).await?;
+                } else if let Value::CallExpression(call_expr) = &expression_statement.expression {
                     let fn_name = call_expr.callee.name.to_string();
                     let mut args: Vec<MemoryItem> = Vec::new();
                     for arg in &call_expr.arguments {

src/wasm-lib/kcl/src/parser/parser_impl.rs

@@ -2801,4 +2801,5 @@ mod snapshot_tests {
     snapshot_test!(ar, r#"5 + "a""#);
     snapshot_test!(at, "line([0, l], %)");
     snapshot_test!(au, include_str!("../../../tests/executor/inputs/cylinder.kcl"));
+    snapshot_test!(av, "fn f = (angle) => { return default(angle, 360) }");
 }

src/wasm-lib/kcl/src/parser/snapshots/kcl_lib__parser__parser_impl__snapshot_tests__av.snap

@@ -0,0 +1,94 @@
+---
+source: kcl/src/parser/parser_impl.rs
+expression: actual
+---
+{
+  "start": 0,
+  "end": 48,
+  "body": [
+    {
+      "type": "VariableDeclaration",
+      "type": "VariableDeclaration",
+      "start": 0,
+      "end": 48,
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "start": 3,
+          "end": 48,
+          "id": {
+            "type": "Identifier",
+            "start": 3,
+            "end": 4,
+            "name": "f"
+          },
+          "init": {
+            "type": "FunctionExpression",
+            "type": "FunctionExpression",
+            "start": 7,
+            "end": 48,
+            "params": [
+              {
+                "type": "Identifier",
+                "start": 8,
+                "end": 13,
+                "name": "angle"
+              }
+            ],
+            "body": {
+              "start": 18,
+              "end": 48,
+              "body": [
+                {
+                  "type": "ReturnStatement",
+                  "type": "ReturnStatement",
+                  "start": 20,
+                  "end": 46,
+                  "argument": {
+                    "type": "CallExpression",
+                    "type": "CallExpression",
+                    "start": 27,
+                    "end": 46,
+                    "callee": {
+                      "type": "Identifier",
+                      "start": 27,
+                      "end": 34,
+                      "name": "default"
+                    },
+                    "arguments": [
+                      {
+                        "type": "Identifier",
+                        "type": "Identifier",
+                        "start": 35,
+                        "end": 40,
+                        "name": "angle"
+                      },
+                      {
+                        "type": "Literal",
+                        "type": "Literal",
+                        "start": 42,
+                        "end": 45,
+                        "value": 360,
+                        "raw": "360"
+                      }
+                    ],
+                    "optional": false
+                  }
+                }
+              ],
+              "nonCodeMeta": {
+                "nonCodeNodes": {},
+                "start": []
+              }
+            }
+          }
+        }
+      ],
+      "kind": "fn"
+    }
+  ],
+  "nonCodeMeta": {
+    "nonCodeNodes": {},
+    "start": []
+  }
+}

src/wasm-lib/kcl/src/token.rs

@@ -47,6 +47,8 @@ pub enum TokenType {
     Function,
     /// Unknown lexemes.
     Unknown,
+    /// The ? symbol, used for optional values.
+    QuestionMark,
 }
 
 /// Most KCL tokens correspond to LSP semantic tokens (but not all).
@@ -58,6 +60,7 @@ impl TryFrom<TokenType> for SemanticTokenType {
             TokenType::Word => Self::VARIABLE,
             TokenType::Keyword => Self::KEYWORD,
             TokenType::Operator => Self::OPERATOR,
+            TokenType::QuestionMark => Self::OPERATOR,
             TokenType::String => Self::STRING,
             TokenType::LineComment => Self::COMMENT,
             TokenType::BlockComment => Self::COMMENT,

src/wasm-lib/kcl/src/token/tokeniser.rs

@@ -21,6 +21,7 @@ pub fn token(i: &mut Located<&str>) -> PResult<Token> {
         '{' | '(' | '[' => brace_start,
         '}' | ')' | ']' => brace_end,
         ',' => comma,
+        '?' => question_mark,
         '0'..='9' => number,
         ':' => colon,
         '.' => alt((number, double_period, period)),
@@ -108,6 +109,11 @@ fn comma(i: &mut Located<&str>) -> PResult<Token> {
     Ok(Token::from_range(range, TokenType::Comma, value.to_string()))
 }
 
+fn question_mark(i: &mut Located<&str>) -> PResult<Token> {
+    let (value, range) = '?'.with_span().parse_next(i)?;
+    Ok(Token::from_range(range, TokenType::QuestionMark, value.to_string()))
+}
+
 fn colon(i: &mut Located<&str>) -> PResult<Token> {
     let (value, range) = ':'.with_span().parse_next(i)?;
     Ok(Token::from_range(range, TokenType::Colon, value.to_string()))

src/wasm-lib/tests/executor/main.rs

@@ -518,3 +518,23 @@ show(part)"#;
     let result = execute_and_snapshot(code).await.unwrap();
     twenty_twenty::assert_image("tests/executor/outputs/rounded_with_holes.png", &result, 0.999);
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn serial_test_top_level_expression() {
+    let code = r#"fn circle = (pos, radius) => {
+  const sg = startSketchOn('XY')
+    |> startProfileAt([pos[0] + radius, pos[1]], %)
+    |> arc({
+       angle_end: 360,
+       angle_start: 0,
+       radius: radius
+     }, %)
+    |> close(%)
+  return sg
+}
+
+circle([0,0], 22) |> extrude(14, %)"#;
+
+    let result = execute_and_snapshot(code).await.unwrap();
+    twenty_twenty::assert_image("tests/executor/outputs/top_level_expression.png", &result, 0.999);
+}