unyt-org · jonasstrehle · Nov 11, 2025 · Nov 11, 2025 · Nov 11, 2025 · Nov 11, 2025
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -67,7 +67,7 @@ jobs:
                   files: target/nextest/ci/report.xml
     test-embedded:
         runs-on: macos-latest
-        name: Test
+        name: Test no-std/embedded build
         concurrency:
             group: ${{ github.workflow }}-${{ github.ref }}-test-embedded
             cancel-in-progress: true

diff --git a/Cargo.toml b/Cargo.toml
@@ -90,7 +90,7 @@ syntect = { version = "5.2.0", default-features = false, optional = true, featur
     "default-fancy",
 ] }
 pretty = { version = "0.12.5", optional = true }
-chumsky = { version = "0.10.1", optional = true, features = [
+chumsky = { version = "0.11.2", optional = true, features = [
     "std",
 ], default-features = false }
 logos = { version = "0.15.0", optional = true }

diff --git a/TROUBLESHOOTING.md b/TROUBLESHOOTING.md
@@ -0,0 +1,9 @@
+# Troubleshooting
+
+This document provides solutions to common issues you may encounter while working with this project.
+
+## Rust Compiler gets stuck during compilation without errors
+
+Possible Fixes:
+ * Check if you made any modifications to structs that derive BinRead/BinWrite from `binrw` (e.g. in `src/global/protocol_structures/instructions.rs`).
+   Some values are not supported by `binrw` per default, e.g. `bool` values without custom mapping. In this case, the compiler may get stuck without providing any error messages.
diff --git a/benches/json/mod.rs b/benches/json/mod.rs
@@ -40,10 +40,8 @@ pub fn json_to_json_syntax_value(json: &str) -> json_syntax::Value {
 pub fn json_to_datex_value(json: &str) -> ValueContainer {
     let (dxb, _) = compile_script(json, CompileOptions::default())
         .expect("Failed to parse JSON string");
-    let exec_input = ExecutionInput::new_with_dxb_and_options(
-        &dxb,
-        ExecutionOptions::default(),
-    );
+    let exec_input =
+        ExecutionInput::new(&dxb, ExecutionOptions::default(), None);
     execute_dxb_sync(exec_input).unwrap().unwrap()
 }
 
@@ -72,10 +70,8 @@ pub fn json_to_runtime_value_datex<'a>(
         },
     )
     .expect("Failed to parse JSON string");
-    let exec_input = ExecutionInput::new_with_dxb_and_options(
-        &dxb,
-        ExecutionOptions::default(),
-    );
+    let exec_input =
+        ExecutionInput::new(&dxb, ExecutionOptions::default(), None);
     let val = execute_dxb_sync(exec_input).unwrap().unwrap();
     assert!(val.to_value().borrow().is_map());
 }
@@ -123,10 +119,8 @@ pub fn json_to_dxb<'a>(
 
 // DXB -> value
 pub fn dxb_to_runtime_value(dxb: &[u8]) {
-    let exec_input = ExecutionInput::new_with_dxb_and_options(
-        dxb,
-        ExecutionOptions::default(),
-    );
+    let exec_input =
+        ExecutionInput::new(dxb, ExecutionOptions::default(), None);
     let json_value = execute_dxb_sync(exec_input).unwrap().unwrap();
     assert!(json_value.to_value().borrow().is_map());
 }

diff --git a/src/ast/grammar/atom.rs b/src/ast/grammar/atom.rs
@@ -14,8 +14,8 @@ pub fn atom<'a>(
     choice((
         list,
         map,
-        literal(),
         decimal(),
+        literal(),
         integer(),
         text(),
         endpoint(),

diff --git a/src/ast/grammar/binding.rs b/src/ast/grammar/binding.rs
@@ -1,14 +1,17 @@
 use crate::ast::error::error::ParseError;
 use crate::ast::error::pattern::Pattern;
 use crate::ast::grammar::assignment_operation::assignment_operation;
+use crate::ast::grammar::chain::property_access;
 use crate::ast::grammar::r#type::{ty, type_declaration};
 use crate::ast::grammar::utils::whitespace;
 use crate::ast::lexer::Token;
 use crate::ast::spanned::Spanned;
-use crate::ast::structs::expression::VariableDeclaration;
 use crate::ast::structs::expression::{
     DerefAssignment, VariableAssignment, VariableKind,
 };
+use crate::ast::structs::expression::{
+    PropertyAssignment, VariableDeclaration,
+};
 use crate::ast::structs::r#type::TypeExpression;
 use crate::ast::{
     DatexExpression, DatexExpressionData, DatexParserTrait, ParserRecoverExt,
@@ -52,6 +55,28 @@ pub fn variable_assignment<'a>(
         .labelled(Pattern::Declaration)
         .as_context()
 }
+
+/// A variable assignment (e.g. `x.y.0 = 42` or `y.x += 1`)
+pub fn property_assignment<'a>(
+    property_access: impl DatexParserTrait<'a>,
+    expression: impl DatexParserTrait<'a>,
+) -> impl DatexParserTrait<'a> {
+    let assignment_op = assignment_operation();
+    property_access
+        .then(assignment_op)
+        .then(expression)
+        .map_with(|((access_expression, operator), expr), e| {
+            DatexExpressionData::PropertyAssignment(PropertyAssignment {
+                operator,
+                access_expression: Box::new(access_expression),
+                assigned_expression: Box::new(expr),
+            })
+            .with_span(e.span())
+        })
+        .labelled(Pattern::Declaration)
+        .as_context()
+}
+
 pub fn deref_assignment<'a>(
     expression: impl DatexParserTrait<'a>,
     unary: impl DatexParserTrait<'a>,
@@ -129,13 +154,18 @@ pub fn variable_declaration<'a>(
 
 /// A declaration or assignment, e.g. `var x = 42;`, `const x = 69`, `x = 43;`, or `type x = 42`
 pub fn declaration_or_assignment<'a>(
+    key: impl DatexParserTrait<'a>,
     expression: impl DatexParserTrait<'a>,
     unary: impl DatexParserTrait<'a>,
 ) -> impl DatexParserTrait<'a> {
     choice((
+        property_assignment(
+            property_access(unary.clone(), key, expression.clone()),
+            expression.clone(),
+        ),
         type_declaration(),
         variable_declaration(expression.clone()),
         deref_assignment(expression.clone(), unary),
-        variable_assignment(expression),
+        variable_assignment(expression.clone()),
     ))
 }
diff --git a/src/ast/grammar/chain.rs b/src/ast/grammar/chain.rs
@@ -79,6 +79,55 @@ pub fn indexed_parameters<'a>(
         })
 }
 
+/// A property access chain, e.g. `a.b[c].d[e,f].5.g`
+pub fn property_access<'a>(
+    unary: impl DatexParserTrait<'a>,
+    key: impl DatexParserTrait<'a>,
+    expression: impl DatexParserTrait<'a>,
+) -> impl DatexParserTrait<'a> {
+    let dot_key = just(Token::Dot)
+        .ignore_then(key.clone())
+        .map(ApplyOperation::PropertyAccess);
+    let index = indexed_parameters(expression.clone())
+        .map(ApplyOperation::PropertyAccess);
+
+    // .key [expr]*
+    let dot_access = dot_key
+        .clone()
+        .then(index.clone().repeated().collect::<Vec<_>>())
+        .map(|(first, rest)| {
+            let mut ops = Vec::with_capacity(1 + rest.len());
+            ops.push(first);
+            ops.extend(rest);
+            ops
+        });
+
+    // [expr]+ index many1
+    let index_access = index
+        .clone()
+        .then(index.clone().repeated().collect::<Vec<_>>())
+        .map(|(first, rest)| {
+            let mut ops = Vec::with_capacity(1 + rest.len());
+            ops.push(first);
+            ops.extend(rest);
+            ops
+        });
+
+    let segment = choice((dot_access, index_access));
+
+    unary
+        .clone()
+        .then(segment.repeated().at_least(1).collect::<Vec<_>>())
+        .map_with(|(base, segs), e| {
+            let operations = segs.into_iter().flatten().collect::<Vec<_>>();
+            DatexExpressionData::ApplyChain(ApplyChain {
+                base: Box::new(base),
+                operations,
+            })
+            .with_span(e.span())
+        })
+}
+
 pub fn chain<'a>(
     unary: impl DatexParserTrait<'a>,
     key: impl DatexParserTrait<'a>,