finally got the right codegen for the stack interpreter

Author: YoEight

geth-eventql/src/codegen.rs

@@ -1,6 +1,4 @@
-use crate::{
-    Expr, ExprVisitor, Literal, NodeAttributes, Operation, Query, QueryVisitor, Subject, Var,
-};
+use crate::{Expr, ExprVisitor, Literal, NodeAttributes, Operation, Var, Where};
 
 pub trait IntoLiteral {
     fn into_literal(self) -> Literal;
@@ -42,13 +40,19 @@ impl IntoLiteral for usize {
     }
 }
 
+impl IntoLiteral for Literal {
+    fn into_literal(self) -> Literal {
+        self
+    }
+}
+
 pub enum Instr {
     Push(Literal),
     LoadVar(Var),
     Operation(Operation),
     Array(usize),
     Rec(usize),
-    Call(String, usize),
+    Call(String),
 }
 
 impl Instr {
@@ -62,7 +66,7 @@ pub fn codegen_where_clause(where_clause: &Where) -> Vec<Instr> {
 
     where_clause.expr.dfs_post_order(&mut state);
 
-    state.emit
+    state.emit.inner
 }
 
 #[derive(Default)]
@@ -71,7 +75,10 @@ struct Emit {
 }
 
 impl Emit {
-    fn push(&mut self, lit: impl IntoLiteral) {
+    fn push<L>(&mut self, lit: L)
+    where
+        L: IntoLiteral,
+    {
         self.inner.push(Instr::lit(lit));
     }
 
@@ -82,6 +89,18 @@ impl Emit {
     fn rec(&mut self, siz: usize) {
         self.inner.push(Instr::Rec(siz));
     }
+
+    fn array(&mut self, siz: usize) {
+        self.inner.push(Instr::Array(siz));
+    }
+
+    fn call(&mut self, name: &str) {
+        self.inner.push(Instr::Call(name.to_string()));
+    }
+
+    fn op(&mut self, op: Operation) {
+        self.inner.push(Instr::Operation(op));
+    }
 }
 
 #[derive(Default)]
@@ -99,13 +118,19 @@ impl ExprVisitor for ExprCodegen {
     }
 
     fn exit_array(&mut self, _attrs: &NodeAttributes, values: &[Expr]) {
-        self.emit.push(Instr::lit(values.len()));
-        self.emit.push(Instr::Array);
+        self.emit.array(values.len());
+    }
+
+    fn exit_field(&mut self, _attrs: &NodeAttributes, label: &str, _value: &Expr) {
+        self.emit.push(label);
+    }
+
+    fn exit_record(&mut self, _attrs: &NodeAttributes, record: &[Expr]) {
+        self.emit.rec(record.len());
     }
 
     fn exit_app(&mut self, _attrs: &NodeAttributes, name: &str, _params: &[Expr]) {
-        self.emit.push(Instr::lit(name));
-        self.emit.push(Instr::Call);
+        self.emit.call(name);
     }
 
     fn exit_binary_op(
@@ -115,10 +140,10 @@ impl ExprVisitor for ExprCodegen {
         _lhs: &Expr,
         _rhs: &Expr,
     ) {
-        self.emit.push(Instr::Operation(*op));
+        self.emit.op(*op);
     }
 
     fn exit_unary_op(&mut self, _attrs: &NodeAttributes, op: &Operation, _expr: &Expr) {
-        self.emit.push(Instr::Operation(*op));
+        self.emit.op(*op);
     }
 }

geth-eventql/src/eval.rs

@@ -74,14 +74,6 @@ impl Stack {
         }
     }
 
-    fn pop_as_integral_or_bail(&mut self) -> Result<i64> {
-        if let Either::Left(int) = self.pop_as_number_or_bail()? {
-            return Ok(int);
-        }
-
-        Err(EvalError::UnexpectedRuntimeError)
-    }
-
     fn pop_as_bool_or_bail(&mut self) -> Result<bool> {
         match self.pop_as_literal_or_bail()? {
             Literal::Bool(b) => Ok(b),
@@ -97,22 +89,6 @@ impl Stack {
         Err(EvalError::UnexpectedRuntimeError)
     }
 
-    fn pop_as_array_of_strings_or_bail(&mut self) -> Result<Vec<String>> {
-        let vec_of_items = self.pop_as_array_or_bail()?;
-        let mut result = Vec::with_capacity(vec_of_items.len());
-
-        for item in vec_of_items {
-            if let Item::Literal(Literal::String(s)) = item {
-                result.push(s);
-                continue;
-            }
-
-            return Err(EvalError::UnexpectedRuntimeError);
-        }
-
-        Ok(result)
-    }
-
     fn push_literal(&mut self, lit: Literal) {
         self.inner.push(Item::Literal(lit));
     }
@@ -133,11 +109,7 @@ pub fn eval_where_clause(dict: &Dictionary, instrs: Vec<Instr>) -> Result<bool>
         match instr {
             Instr::Push(lit) => stack.push_literal(lit),
 
-            Instr::LoadVar => {
-                let name = stack.pop_as_string_or_bail()?;
-                let path = stack.pop_as_array_of_strings_or_bail()?;
-                let var = Var { name, path };
-
+            Instr::LoadVar(var) => {
                 stack.push_literal(dict.lookup(&var)?);
             }
 
@@ -469,8 +441,7 @@ pub fn eval_where_clause(dict: &Dictionary, instrs: Vec<Instr>) -> Result<bool>
                 }
             },
 
-            Instr::Array => {
-                let siz = stack.pop_as_integral_or_bail()? as usize;
+            Instr::Array(siz) => {
                 let mut array = Vec::with_capacity(siz);
 
                 for _ in 0..siz {
@@ -480,58 +451,52 @@ pub fn eval_where_clause(dict: &Dictionary, instrs: Vec<Instr>) -> Result<bool>
                 stack.push_array(array);
             }
 
-            Instr::Rec => {
-                let siz = stack.pop_as_integral_or_bail()? as usize;
+            Instr::Rec(siz) => {
                 let mut fields = HashMap::with_capacity(siz);
 
-                todo!("the keys come first now, then the values");
                 for _ in 0..siz {
-                    let value = stack.pop_or_bail()?;
                     let key = stack.pop_as_string_or_bail()?;
+                    let value = stack.pop_or_bail()?;
 
                     fields.insert(key, value);
                 }
 
                 stack.push_record(Rec { fields });
             }
 
-            Instr::Call => {
-                let fun_name = stack.pop_as_string_or_bail()?;
-
-                match fun_name.as_str() {
-                    "abs" => match stack.pop_as_number_or_bail()? {
-                        Either::Left(i) => stack.push_literal(Literal::Integral(i.abs())),
-                        Either::Right(f) => stack.push_literal(Literal::Float(f.abs())),
-                    },
-
-                    "ceil" => match stack.pop_as_number_or_bail()? {
-                        Either::Left(i) => stack.push_literal(Literal::Integral(i)),
-                        Either::Right(f) => stack.push_literal(Literal::Float(f.ceil())),
-                    },
-
-                    "floor" => match stack.pop_as_number_or_bail()? {
-                        Either::Left(i) => stack.push_literal(Literal::Integral(i)),
-                        Either::Right(f) => stack.push_literal(Literal::Float(f.floor())),
-                    },
-
-                    "sin" => match stack.pop_as_number_or_bail()? {
-                        Either::Left(i) => stack.push_literal(Literal::Float((i as f64).sin())),
-                        Either::Right(f) => stack.push_literal(Literal::Float(f.sin())),
-                    },
-
-                    "cos" => match stack.pop_as_number_or_bail()? {
-                        Either::Left(i) => stack.push_literal(Literal::Float((i as f64).cos())),
-                        Either::Right(f) => stack.push_literal(Literal::Float(f.cos())),
-                    },
-
-                    "tan" => match stack.pop_as_number_or_bail()? {
-                        Either::Left(i) => stack.push_literal(Literal::Float((i as f64).tan())),
-                        Either::Right(f) => stack.push_literal(Literal::Float(f.tan())),
-                    },
-
-                    _ => return Err(EvalError::UnexpectedRuntimeError),
-                }
-            }
+            Instr::Call(fun_name) => match fun_name.as_str() {
+                "abs" => match stack.pop_as_number_or_bail()? {
+                    Either::Left(i) => stack.push_literal(Literal::Integral(i.abs())),
+                    Either::Right(f) => stack.push_literal(Literal::Float(f.abs())),
+                },
+
+                "ceil" => match stack.pop_as_number_or_bail()? {
+                    Either::Left(i) => stack.push_literal(Literal::Integral(i)),
+                    Either::Right(f) => stack.push_literal(Literal::Float(f.ceil())),
+                },
+
+                "floor" => match stack.pop_as_number_or_bail()? {
+                    Either::Left(i) => stack.push_literal(Literal::Integral(i)),
+                    Either::Right(f) => stack.push_literal(Literal::Float(f.floor())),
+                },
+
+                "sin" => match stack.pop_as_number_or_bail()? {
+                    Either::Left(i) => stack.push_literal(Literal::Float((i as f64).sin())),
+                    Either::Right(f) => stack.push_literal(Literal::Float(f.sin())),
+                },
+
+                "cos" => match stack.pop_as_number_or_bail()? {
+                    Either::Left(i) => stack.push_literal(Literal::Float((i as f64).cos())),
+                    Either::Right(f) => stack.push_literal(Literal::Float(f.cos())),
+                },
+
+                "tan" => match stack.pop_as_number_or_bail()? {
+                    Either::Left(i) => stack.push_literal(Literal::Float((i as f64).tan())),
+                    Either::Right(f) => stack.push_literal(Literal::Float(f.tan())),
+                },
+
+                _ => return Err(EvalError::UnexpectedRuntimeError),
+            },
         }
     }