Tree search pattern matcher

Signed-off-by: Heinz N. Gies <[email protected]>

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,

tremor-script/src/vm.rs

@@ -341,6 +341,42 @@ impl<'run, 'event> Scope<'run, 'event> {
                 Op::TestArrayIsEmpty => {
                     self.reg.b1 = self.reg.v1.as_array().map_or(true, Vec::is_empty);
                 }
+                Op::TestEq => {
+                    let rhs = last(&stack, *pc, *cc)?;
+                    self.reg.b1 =
+                        exec_binary(mid, mid, crate::ast::BinOpKind::Eq, &self.reg.v1, rhs)?
+                            .try_as_bool()?;
+                }
+                Op::TestNeq => {
+                    let rhs = last(&stack, *pc, *cc)?;
+                    self.reg.b1 =
+                        exec_binary(mid, mid, crate::ast::BinOpKind::NotEq, &self.reg.v1, rhs)?
+                            .try_as_bool()?;
+                }
+                Op::TestGt => {
+                    let rhs = last(&stack, *pc, *cc)?;
+                    self.reg.b1 =
+                        exec_binary(mid, mid, crate::ast::BinOpKind::Gt, &self.reg.v1, rhs)?
+                            .try_as_bool()?;
+                }
+                Op::TestLt => {
+                    let rhs = last(&stack, *pc, *cc)?;
+                    self.reg.b1 =
+                        exec_binary(mid, mid, crate::ast::BinOpKind::Lt, &self.reg.v1, rhs)?
+                            .try_as_bool()?;
+                }
+                Op::TestGte => {
+                    let rhs = last(&stack, *pc, *cc)?;
+                    self.reg.b1 =
+                        exec_binary(mid, mid, crate::ast::BinOpKind::Gte, &self.reg.v1, rhs)?
+                            .try_as_bool()?;
+                }
+                Op::TestLte => {
+                    let rhs = last(&stack, *pc, *cc)?;
+                    self.reg.b1 =
+                        exec_binary(mid, mid, crate::ast::BinOpKind::Gte, &self.reg.v1, rhs)?
+                            .try_as_bool()?;
+                }
                 Op::TestRecordIsEmpty => {
                     self.reg.b1 = self
                         .reg
@@ -350,10 +386,9 @@ impl<'run, 'event> Scope<'run, 'event> {
                 }
                 // Inspect
                 Op::InspectLen => {
-                    let v = last(&stack, *pc, *cc)?;
-                    let len = if let Some(v) = v.as_array() {
+                    let len = if let Some(v) = self.reg.v1.as_array() {
                         v.len()
-                    } else if let Some(v) = v.as_object() {
+                    } else if let Some(v) = self.reg.v1.as_object() {
                         v.len()
                     } else {
                         return Err("Not an array or object".into());

tremor-script/src/vm/compiler/impls.rs

@@ -1,6 +1,8 @@
 mod imut_expr;
 mod mut_expr;
 
+use tremor_value::Value;
+
 use crate::{
     ast::{
         ClauseGroup, Comprehension, DefaultCase, Expression, IfElse, Match, Path, PredicateClause,
@@ -37,7 +39,6 @@ where
         let end_dst = compiler.end_dst()?;
         let dst = compiler.new_jump_point();
         compiler.comment("Predicate Clause");
-        compiler.emit(Op::CopyV1, &mid);
         pattern.compile_to_b(compiler)?;
         compiler.comment("Jump to the next pattern");
         compiler.emit(Op::JumpFalse { dst }, &mid);
@@ -106,20 +107,26 @@ where
             }
             ClauseGroup::SearchTree {
                 precondition,
-                tree: _,
+                tree,
                 rest,
             } => {
                 if let Some(precondition) = precondition {
                     compiler.comment("Match Tree Preconditions");
                     precondition.compile_to_b(compiler)?;
                     compiler.comment("Jump to next case if precondition is false");
                     compiler.emit(Op::JumpFalse { dst: next }, &NodeMeta::dummy());
-                    // FIXME
+                }
+                compiler.comment("Encode binary search tree");
+
+                let tree = tree.into_iter().collect::<Vec<_>>();
+                traverse_tree(compiler, &tree)?;
+
+                if !rest.is_empty() {
+                    compiler.comment("Test remaining matches");
                 }
                 for r in rest {
                     r.compile(compiler)?;
                 }
-                todo!("the tree has to go before therest!");
             }
             ClauseGroup::Combined {
                 precondition,
@@ -154,6 +161,54 @@ where
     }
 }
 
+fn traverse_tree<'script, Ex>(
+    compiler: &mut Compiler<'script>,
+    tree: &[(Value<'script>, (Vec<Ex>, Ex))],
+) -> Result<()>
+where
+    Ex: Compilable<'script> + Expression,
+{
+    let mid = NodeMeta::dummy();
+    let (lower, upper) = tree.split_at(tree.len() / 2);
+
+    assert!(lower.len() <= upper.len());
+    let Some(((val, (exprs, last)), upper_rest)) = upper.split_first() else {
+        // we know that in the case of a odd number the upper half is always larger or equal to the lower half
+        // so if it is empty we have nothing left to do in the tree
+        return Ok(());
+    };
+    let gt = compiler.new_jump_point();
+    let lt = compiler.new_jump_point();
+    compiler.comment("Binary search tree node");
+    compiler.emit_const(val.clone(), &mid);
+    compiler.comment("Test if value is greater than the current node");
+    compiler.emit(Op::TestGt, &mid);
+    compiler.emit(Op::JumpTrue { dst: gt }, &mid);
+    compiler.comment("Test if value is lesser than the current node");
+    compiler.emit(Op::TestLt, &mid);
+    compiler.emit(Op::JumpTrue { dst: lt }, &mid);
+    compiler.comment("Value is equal to the current node");
+    for e in exprs {
+        // FIXME: kins of annoying to clone but eh
+        e.clone().compile(compiler)?;
+    } // FIXME: kins of annoying to clone but eh
+
+    last.clone().compile(compiler)?;
+    compiler.comment("We found and executed a match, jump to the end of the match statement");
+    compiler.emit(
+        Op::Jump {
+            dst: compiler.end_dst()?,
+        },
+        &mid,
+    );
+    compiler.comment("Llesser half of the tree");
+    compiler.set_jump_target(lt);
+    traverse_tree(compiler, lower)?;
+    compiler.set_jump_target(gt);
+    traverse_tree(compiler, upper_rest)?;
+    Ok(())
+}
+
 impl<'script, Ex> Compilable<'script> for Match<'script, Ex>
 where
     Ex: Compilable<'script> + Expression,

tremor-script/src/vm/compiler/impls/imut_expr.rs

@@ -421,8 +421,7 @@ impl<'script> Compilable<'script> for Pattern<'script> {
             Pattern::Expr(e) => {
                 let mid = e.meta().clone();
                 e.compile(compiler)?;
-                compiler.emit(Op::Binary { op: BinOpKind::Eq }, &mid);
-                compiler.emit(Op::LoadRB, &NodeMeta::dummy());
+                compiler.emit(Op::TestEq, &mid);
             }
 
             Pattern::Assign(_) => todo!(),
@@ -444,7 +443,7 @@ impl<'script> Compilable<'script> for Pattern<'script> {
                 compiler.emit(Op::LoadRB, &mid);
                 let end_and_pop = compiler.new_jump_point();
 
-                compiler.emit(Op::JumpFalse { dst: end_and_pop }, &mid);
+                compiler.emit(Op::JumpFalse { dst: dst_next }, &mid);
 
                 compiler.comment("Save array for itteration and reverse it");
                 compiler.emit(Op::CopyV1, &mid);

tremor-script/src/vm/op.rs

@@ -113,6 +113,17 @@ pub(crate) enum Op {
     TestIsU64,
     TestIsI64,
     TestIsBytes,
+    #[allow(dead_code)]
+    TestEq,
+    #[allow(dead_code)]
+    TestNeq,
+    TestGt,
+    #[allow(dead_code)]
+    TestGte,
+    TestLt,
+    #[allow(dead_code)]
+    TestLte,
+
     #[allow(dead_code)]
     TestArrayIsEmpty,
     TestRecordIsEmpty,
@@ -190,6 +201,12 @@ impl Display for Op {
             Op::TestIsArray => write!(f, "test_is_array"),
             Op::TestArrayIsEmpty => write!(f, "test_array_is_empty"),
             Op::TestRecordIsEmpty => write!(f, "test_record_is_empty"),
+            Op::TestEq => write!(f, "test_eq"),
+            Op::TestNeq => write!(f, "test_neq"),
+            Op::TestGt => write!(f, "test_gt"),
+            Op::TestGte => write!(f, "test_gte"),
+            Op::TestLt => write!(f, "test_lt"),
+            Op::TestLte => write!(f, "test_lte"),
 
             Op::InspectLen => write!(f, "inspect_len"),