WIP - tremor-script VM

.vscode/settings.json

@@ -131,11 +131,5 @@
   ],
   "rust-analyzer.linkedProjects": [
     "./Cargo.toml",
-    "./tremor-connectors/Cargo.toml",
-    "./tremor-connectors/Cargo.toml",
-    "./tremor-connectors/Cargo.toml",
-    "./tremor-connectors-gcp/Cargo.toml",
-    "./tremor-connectors-gcp/Cargo.toml",
-    "./tremor-connectors-gcp/Cargo.toml"
   ]
 }

tremor-script/src/ast.rs

@@ -197,7 +197,7 @@ impl<'script> BytesPart<'script> {
 /// Binary semiliteral
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct Bytes<'script> {
-    mid: Box<NodeMeta>,
+    pub(crate) mid: Box<NodeMeta>,
     /// Bytes
     pub value: Vec<BytesPart<'script>>,
 }

tremor-script/src/ast/binary.rs

@@ -165,7 +165,7 @@ fn write_bits_le(
     }
 }
 
-fn write_bits(
+pub(crate) fn write_bits(
     bytes: &mut Vec<u8>,
     bits: u8,
     endianess: Endian,

tremor-script/src/ast/visitors/impls/const_folder.rs

@@ -17,8 +17,8 @@ use crate::ast::{BooleanBinExpr, BooleanBinOpKind};
 use crate::{
     ast::{base_expr::Ranged, binary::extend_bytes_from_value, NodeMeta},
     errors::{
-        err_generic, err_invalid_unary, err_need_int, error_array_out_of_bound, error_bad_key,
-        error_decreasing_range, error_need_arr, error_need_obj,
+        err_generic, err_need_int, error_array_out_of_bound, error_bad_key, error_decreasing_range,
+        error_need_arr, error_need_obj,
     },
     interpreter::{exec_binary, exec_unary, Env},
     lexer::Span,
@@ -160,13 +160,7 @@ impl<'run, 'script: 'run> ImutExprVisitor<'script> for ConstFolder<'run, 'script
                     mid,
                 } = b.as_ref()
                 {
-                    let value = exec_unary(*kind, value)
-                        .ok_or_else(|| {
-                            let inner = b.extent();
-                            let outer = b.extent();
-                            err_invalid_unary(&outer, &inner, *kind, value)
-                        })?
-                        .into_owned();
+                    let value = exec_unary(b.as_ref(), b.as_ref(), *kind, value)?.into_owned();
                     Lit(Literal {
                         mid: mid.clone(),
                         value,

tremor-script/src/errors.rs

@@ -247,11 +247,11 @@ impl ErrorKind {
             Msg, NoClauseHit, NoConstsAllowed, NoEventReferencesAllowed, NoLocalsAllowed,
             NoObjectError, NotConstant, NotFound, Oops, Overflow, ParseIntError, ParserError,
             PatchKeyExists, PipelineUnknownPort, QueryNodeDuplicateName, QueryNodeReservedName,
-            QueryStreamNotDefined, RecursionLimit, RuntimeError, TailingHereDoc, TypeConflict,
-            TypeError, UnexpectedCharacter, UnexpectedEndOfStream, UnexpectedEscapeCode,
-            UnknownLocal, UnrecognizedToken, UnterminatedExtractor, UnterminatedHereDoc,
-            UnterminatedIdentLiteral, UnterminatedInterpolation, UnterminatedStringLiteral,
-            UpdateKeyMissing, Utf8Error, ValueError, WithParamNoArg,
+            QueryStreamNotDefined, RecursionLimit, RuntimeError, TailingHereDoc, TryFromInt,
+            TypeConflict, TypeError, UnexpectedCharacter, UnexpectedEndOfStream,
+            UnexpectedEscapeCode, UnknownLocal, UnrecognizedToken, UnterminatedExtractor,
+            UnterminatedHereDoc, UnterminatedIdentLiteral, UnterminatedInterpolation,
+            UnterminatedStringLiteral, UpdateKeyMissing, Utf8Error, ValueError, WithParamNoArg,
         };
         match self {
             NoClauseHit(outer)
@@ -350,6 +350,7 @@ impl ErrorKind {
             | Self::__Nonexhaustive { .. }
             | Utf8Error(_)
             | FromUtf8Error(_)
+            | TryFromInt(_)
             | ValueError(_) => (Some(Span::yolo()), None),
         }
     }
@@ -567,6 +568,7 @@ error_chain! {
         AccessError(value_trait::AccessError);
         CodecError(tremor_codec::Error);
         Common(tremor_common::Error);
+        TryFromInt(std::num::TryFromIntError);
     }
     errors {
         /*
@@ -1211,15 +1213,6 @@ pub(crate) fn error_guard_not_bool<T, O: Ranged, I: Ranged>(
     error_type_conflict(outer, inner, got.value_type(), ValueType::Bool)
 }
 
-pub(crate) fn error_invalid_unary<T, O: Ranged, I: Ranged>(
-    outer: &O,
-    inner: &I,
-    op: ast::UnaryOpKind,
-    val: &Value,
-) -> Result<T> {
-    Err(err_invalid_unary(outer, inner, op, val))
-}
-
 pub(crate) fn err_invalid_unary<O: Ranged, I: Ranged>(
     outer: &O,
     inner: &I,

tremor-script/src/interpreter.rs

@@ -43,11 +43,12 @@
     },
     ctx::NO_CONTEXT,
     errors::{
-        err_need_obj, error_array_out_of_bound, error_bad_array_index, error_bad_key,
-        error_bad_key_err, error_decreasing_range, error_division_by_zero, error_guard_not_bool,
-        error_invalid_binary, error_invalid_bitshift, error_need_arr, error_need_int,
-        error_need_obj, error_need_str, error_oops, error_overflow, error_patch_key_exists,
-        error_patch_merge_type_conflict, error_patch_update_key_missing, unknown_local, Result,
+        err_invalid_unary, err_need_obj, error_array_out_of_bound, error_bad_array_index,
+        error_bad_key, error_bad_key_err, error_decreasing_range, error_division_by_zero,
+        error_guard_not_bool, error_invalid_binary, error_invalid_bitshift, error_need_arr,
+        error_need_int, error_need_obj, error_need_str, error_oops, error_overflow,
+        error_patch_key_exists, error_patch_merge_type_conflict, error_patch_update_key_missing,
+        unknown_local, Result,
     },
     prelude::*,
     stry, NO_AGGRS, NO_CONSTS,
@@ -385,16 +386,14 @@
     }
 }
 #[inline]
-pub(crate) fn exec_binary<'run, 'event, OuterExpr, InnerExpr>(
-    outer: &OuterExpr,
-    inner: &InnerExpr,
+pub(crate) fn exec_binary<'run, 'event>(
+    outer: &impl BaseExpr,
+    inner: &impl BaseExpr,
     op: BinOpKind,
     lhs: &Value<'event>,
     rhs: &Value<'event>,
 ) -> Result<Cow<'run, Value<'event>>>
 where
-    OuterExpr: BaseExpr,
-    InnerExpr: BaseExpr,
     'event: 'run,
 {
     // Lazy Heinz doesn't want to write that 10000 times
@@ -499,49 +498,56 @@
 
 #[inline]
 pub(crate) fn exec_unary<'run, 'event: 'run>(
+    outer: &impl BaseExpr,
+    inner: &impl BaseExpr,
     op: UnaryOpKind,
     val: &Value<'event>,
-) -> Option<Cow<'run, Value<'event>>> {
+) -> Result<Cow<'run, Value<'event>>> {
     // Lazy Heinz doesn't want to write that 10000 times
     // - snot badger - Darach
     use UnaryOpKind::{BitNot, Minus, Not, Plus};
     if let Some(x) = val.as_f64() {
         match &op {
-            Minus => Some(Cow::Owned(Value::from(-x))),
-            Plus => Some(Cow::Owned(Value::from(x))),
-            _ => None,
+            Minus => Ok(Cow::Owned(Value::from(-x))),
+            Plus => Ok(Cow::Owned(Value::from(x))),
+            _ => Err(err_invalid_unary(outer, inner, op, val)),
         }
     } else if let Some(x) = val.as_u64() {
         match &op {
             Minus => {
                 if x == 9_223_372_036_854_775_808 {
-                    Some(Cow::Owned(Value::from(i64::MIN)))
+                    Ok(Cow::Owned(Value::from(i64::MIN)))
                 } else {
                     x.try_into()
                         .ok()
                         .and_then(i64::checked_neg)
                         .map(Value::from)
                         .map(Cow::Owned)
+                        .ok_or_else(|| err_invalid_unary(outer, inner, op, val))
                 }
             }
-            Plus => Some(Cow::Owned(Value::from(x))),
-            BitNot => Some(Cow::Owned(Value::from(!x))),
-            Not => None,
+            Plus => Ok(Cow::Owned(Value::from(x))),
+            BitNot => Ok(Cow::Owned(Value::from(!x))),
+            Not => Err(err_invalid_unary(outer, inner, op, val)),
         }
     } else if let Some(x) = val.as_i64() {
         match &op {
-            Minus => x.checked_neg().map(Value::from).map(Cow::Owned),
-            Plus => Some(Cow::Owned(Value::from(x))),
-            BitNot => Some(Cow::Owned(Value::from(!x))),
-            Not => None,
+            Minus => x
+                .checked_neg()
+                .map(Value::from)
+                .map(Cow::Owned)
+                .ok_or_else(|| err_invalid_unary(outer, inner, op, val)),
+            Plus => Ok(Cow::Owned(Value::from(x))),
+            BitNot => Ok(Cow::Owned(Value::from(!x))),
+            Not => Err(err_invalid_unary(outer, inner, op, val)),
         }
     } else if let Some(x) = val.as_bool() {
         match &op {
-            BitNot | Not => Some(static_bool!(!x)),
-            _ => None,
+            BitNot | Not => Ok(static_bool!(!x)),
+            _ => Err(err_invalid_unary(outer, inner, op, val)),
         }
     } else {
-        None
+        Err(err_invalid_unary(outer, inner, op, val))
     }
 }
 
@@ -745,7 +751,10 @@
     ))
 }
 
-fn merge_values<'event>(value: &mut Value<'event>, replacement: &Value<'event>) -> Result<()> {
+pub(crate) fn merge_values<'event>(
+    value: &mut Value<'event>,
+    replacement: &Value<'event>,
+) -> Result<()> {
     if let Some((rep, map)) = replacement.as_object().zip(value.as_object_mut()) {
         for (k, v) in rep {
             if let Some(k) = map.get_mut(k) {

tremor-script/src/interpreter/imut_expr.rs

@@ -21,8 +21,7 @@ use crate::{
     errors::Kind as ErrorKind,
     errors::{
         err_invalid_fold, error_bad_key, error_decreasing_range, error_invalid_bool_op,
-        error_invalid_unary, error_need_obj, error_need_str, error_no_clause_hit, error_oops,
-        error_oops_err, Result,
+        error_need_obj, error_need_str, error_no_clause_hit, error_oops, error_oops_err, Result,
     },
     interpreter::{
         exec_binary, exec_unary, merge_values, patch_value, resolve, set_local_shadow, test_guard,
@@ -726,11 +725,8 @@ impl<'script> ImutExpr<'script> {
         'script: 'event,
     {
         let rhs = stry!(expr.expr.run(opts, env, event, state, meta, local));
-        // TODO align this implemenation to be similar to exec_binary?
-        match exec_unary(expr.kind, &rhs) {
-            Some(v) => Ok(v),
-            None => error_invalid_unary(self, &expr.expr, expr.kind, &rhs),
-        }
+        // TOO align this implemenation to be similar to exec_binary?
+        exec_unary(self, expr, expr.kind, &rhs)
     }
 
     // TODO: Quite some overlap with `interpreter::resolve` (and some with `expr::assign`)

tremor-script/src/lib.rs

@@ -71,7 +71,8 @@ pub mod srs;
 mod std_lib;
 /// Utility functions
 pub mod utils;
-pub use srs::{EventPayload, ValueAndMeta};
+
+mod vm;
 
 pub use crate::ast::deploy::raw::run_script;
 pub use crate::ast::module;
@@ -85,6 +86,8 @@ pub use crate::registry::{
     TremorAggrFnWrapper, TremorFn, TremorFnWrapper,
 };
 pub use crate::script::{Return, Script};
+pub use crate::srs::{EventPayload, ValueAndMeta};
+pub use crate::vm::compiler::Compiler;
 use ast::{Consts, InvokeAggrFn};
 pub use interpreter::{AggrType, FALSE, NULL, TRUE};
 use lazy_static::lazy_static;

tremor-script/src/script.rs

@@ -131,7 +131,6 @@ impl Script {
         // helper.consts.args = args.clone_static();
         let mut script = script_raw.up_script(&mut helper)?;
         Optimizer::new(&helper).walk_script(&mut script)?;
-        let script = script;
 
         Ok(Self {
             script,