Feat/pointer sync

.gitattributes

@@ -0,0 +1,6 @@
+* text=auto
+
+*.rs text eol=lf
+*.toml text eol=lf
+*.lock text eol=lf
+*.md text eol=lf

.github/workflows/test-datex-core.yml

@@ -59,6 +59,8 @@ jobs:
             features: default,allow_unsigned_blocks
           - profile: std
             features: target_native
+          - profile: lsp
+            features: target_native,lsp_tokio
     steps:
       - uses: actions/checkout@v5
 

.vscode/settings.json

@@ -5,6 +5,7 @@
     "rust-analyzer.procMacro.enable": true,
     "rust-analyzer.check.command": "clippy",
     "rust-analyzer.check.workspace": false,
+    "rust-analyzer.imports.preferNoStd": true,
     "rust-analyzer.linkedProjects": [
         "crates/datex-core/Cargo.toml",
         "crates/datex-crypto-facade/Cargo.toml",

crates/datex-core/Cargo.toml

@@ -85,7 +85,7 @@ foldhash = { version = "0.2.0", default-features = false }
 cfg-if = "1.0.1"
 async-trait = "0.1.87"
 strum_macros = { version = "0.27.1" }
-datex-macros-internal = { path = "../datex-macros-internal", version = "0.0.1" }
+datex-macros-internal = { path = "../datex-macros-internal", version = "0.0.2" }
 
 # nostd-only dependencies (optional)
 hashbrown = { version = "0.16.0", features = ["serde"], optional = true }
@@ -106,6 +106,7 @@ internment = { version = "0.8.6", optional = true }
 # lsp dependencies (optional)
 realhydroper-lsp = { version = "0.22.0", default-features = false, features = [
     "proposed",
+    "runtime-agnostic",
 ], optional = true }
 
 
@@ -166,6 +167,8 @@ json-syntax = "0.12.5"
 lazy_static = "1.4.0"
 ntest_timeout = "0.9.3"
 indoc = "2.0.6"
+test-case = "3.3.1"
+
 # enable native crypto for tests
 datex-crypto-native = { path = "../datex-crypto-native" }
 # enable tokio for tests
@@ -183,7 +186,7 @@ flexi_logger = { version = "0.31.8" }
 
 # When using the "std" feature, the "default" feature should not be enabled since
 # it includes no_std-specific dependencies
-default = ["no_std", "dep:async-timer"]
+default = ["no_std", "dep:async-timer", "disassembler"]
 
 no_std = ["dep:hashbrown", "dep:async-unsync", "dep:spin"]
 
@@ -280,14 +283,13 @@ compiler = ["ast", "parser", "dep:ariadne", "dep:pretty"]
 
 decompiler = ["ast"]
 
+disassembler = []
 
 ### LSP-related features ######################################################
 
-lsp = ["dep:realhydroper-lsp"]
-# lsp support
-lsp_tokio = ["lsp", "realhydroper-lsp/runtime-tokio"]
-# enable runtime-agnostic feature for realhydroper-lsp in wasm
-lsp_wasm = ["lsp", "realhydroper-lsp/runtime-agnostic"]
+lsp = ["dep:realhydroper-lsp", "compiler"]
+lsp_tokio = ["lsp"]
+lsp_wasm = ["lsp"]
 
 
 ### Utils for creating macros #################################################

crates/datex-core/benches/json/mod.rs

@@ -4,13 +4,17 @@ use core::hint::black_box;
 use criterion::{BenchmarkId, Criterion, criterion_group};
 
 use crate::{json, json::utils::*};
-use datex_core::compiler::{CompileOptions, compile_script};
+use datex_core::{
+    compiler::{CompileOptions, compile_script},
+    runtime::Runtime,
+};
 
 fn bench_json_file(c: &mut Criterion, file_path: &str) {
+    let runtime = Runtime::stub();
     // JSON benchmarks
     // JSON string to runtime value
     let json = get_json_test_string(file_path);
-    let (dxb, _) = compile_script(&json, CompileOptions::default())
+    let (dxb, _) = compile_script(&json, CompileOptions::default(), runtime)
         .expect("Failed to parse JSON string");
 
     // DATEX

crates/datex-core/benches/json/utils.rs

@@ -7,14 +7,17 @@ use datex_core::{
     core_compiler::value_compiler::compile_value_container,
     decompiler::{DecompileOptions, decompile_body},
     runtime::{
-        RuntimeInternal,
-        execution::{ExecutionInput, ExecutionOptions, execute_dxb_sync},
+        Runtime,
+        execution::{
+            ExecutionInput, ExecutionOptions, execute_dxb_sync,
+            execution_input::ExecutionCallerMetadata,
+        },
     },
     values::value_container::ValueContainer,
 };
 use json_syntax::Parse;
 use serde_json::Value;
-use std::{io::Read, rc::Rc};
+use std::io::Read;
 
 pub fn get_json_test_string(file_path: &str) -> String {
     // read json from test file
@@ -41,12 +44,15 @@ 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 runtime = Runtime::stub();
+    let (dxb, _) =
+        compile_script(json, CompileOptions::default(), runtime.clone())
+            .expect("Failed to parse JSON string");
     let exec_input = ExecutionInput::new(
         &dxb,
+        ExecutionCallerMetadata::local_default(),
         ExecutionOptions::default(),
-        Rc::new(RuntimeInternal::stub()),
+        runtime,
     );
     execute_dxb_sync(exec_input).unwrap().unwrap()
 }
@@ -65,20 +71,24 @@ pub fn json_to_runtime_value_baseline_json_syntax(json: &str) {
 }
 
 pub fn json_to_runtime_value_datex<'a>(json: &'a str) {
+    let runtime = Runtime::stub();
+
     let (dxb, _) = compile_script(
         json,
         CompileOptions {
             ..CompileOptions::default()
         },
+        runtime.clone(),
     )
     .expect("Failed to parse JSON string");
     let exec_input = ExecutionInput::new(
         &dxb,
+        ExecutionCallerMetadata::local_default(),
         ExecutionOptions::default(),
-        Rc::new(RuntimeInternal::stub()),
+        runtime,
     );
     let val = execute_dxb_sync(exec_input).unwrap().unwrap();
-    assert!(val.to_value().borrow().is_map());
+    val.with_collapsed_value(|val| assert!(val.is_map()));
 }
 
 pub fn json_to_runtime_value_datex_auto_static_detection(
@@ -89,6 +99,7 @@ pub fn json_to_runtime_value_datex_auto_static_detection(
         CompileOptions {
             ..CompileOptions::default()
         },
+        Runtime::stub(),
     )
     .unwrap();
     if let StaticValueOrDXB::StaticValue(value) = dxb {
@@ -111,6 +122,7 @@ pub fn json_to_dxb<'a>(json: &'a str) {
         CompileOptions {
             ..CompileOptions::default()
         },
+        Runtime::stub(),
     )
     .expect("Failed to parse JSON string");
     assert!(!dxb.is_empty(), "Expected DXB to be non-empty");
@@ -120,11 +132,12 @@ pub fn json_to_dxb<'a>(json: &'a str) {
 pub fn dxb_to_runtime_value(dxb: &[u8]) {
     let exec_input = ExecutionInput::new(
         dxb,
+        ExecutionCallerMetadata::local_default(),
         ExecutionOptions::default(),
-        Rc::new(RuntimeInternal::stub()),
+        Runtime::stub(),
     );
     let json_value = execute_dxb_sync(exec_input).unwrap().unwrap();
-    assert!(json_value.to_value().borrow().is_map());
+    json_value.with_collapsed_value(|val| assert!(val.is_map()));
 }
 
 // value -> JSON
@@ -143,13 +156,13 @@ pub fn runtime_value_to_json_baseline_json_syntax(value: &json_syntax::Value) {
 }
 
 pub fn runtime_value_to_json_datex(value: &ValueContainer) {
-    let dxb = compile_value_container(value);
+    let dxb = compile_value_container(value).unwrap();
     let string = decompile_body(&dxb, DecompileOptions::json_compat()).unwrap();
     assert!(!string.is_empty(), "Expected DATEX string to be non-empty");
 }
 
 pub fn runtime_value_to_dxb(value: &ValueContainer) {
-    let dxb = compile_value_container(value);
+    let dxb = compile_value_container(value).unwrap();
     assert!(!dxb.is_empty(), "Expected DXB to be non-empty");
 }