feat(geth-eventql): support a record field as a first-class ast construct

geth-eventql/src/codegen.rs

@@ -1,6 +1,4 @@
-use crate::{
-    Expr, ExprVisitor, Literal, NodeAttributes, Operation, Query, QueryVisitor, Var, parser::Record,
-};
+use crate::{Expr, ExprVisitor, Literal, NodeAttributes, Operation, Query, QueryVisitor, Var};
 
 pub enum Instr {
     Push(Literal),
@@ -45,14 +43,8 @@ impl ExprVisitor for ExprCodegen<'_> {
         self.inner.instrs.push(Instr::LoadVar(var.clone()));
     }
 
-    fn enter_record_entry(&mut self, _attrs: &NodeAttributes, key: &str, _expr: &Expr) {
-        self.inner
-            .instrs
-            .push(Instr::Push(Literal::String(key.to_string())));
-    }
-
-    fn exit_record(&mut self, _attrs: &NodeAttributes, record: &Record) {
-        self.inner.instrs.push(Instr::Rec(record.fields.len()));
+    fn exit_record(&mut self, _attrs: &NodeAttributes, record: &[Expr]) {
+        self.inner.instrs.push(Instr::Rec(record.len()));
     }
 
     fn exit_array(&mut self, _attrs: &NodeAttributes, values: &[Expr]) {

geth-eventql/src/infer.rs

@@ -3,7 +3,7 @@ use std::{collections::HashMap, fmt::Display};
 use crate::{
     Expr, Literal, Operation, Pos, Query, Scopes, Var,
     error::InferError,
-    parser::{ExprVisitorMut, NodeAttributes, QueryVisitorMut, Record},
+    parser::{ExprVisitorMut, NodeAttributes, QueryVisitorMut},
 };
 
 pub struct InferedQuery {
@@ -238,7 +238,7 @@ impl ExprVisitorMut for TypecheckExpr<'_> {
     fn exit_record(
         &mut self,
         attrs: &mut NodeAttributes,
-        _record: &mut Record,
+        _record: &mut [Expr],
     ) -> crate::Result<()> {
         if attrs.tpe != Type::Unspecified && attrs.tpe != Type::Record {
             bail!(attrs.pos, InferError::TypeMismatch(attrs.tpe, Type::Record));

geth-eventql/src/parser/ast.rs

@@ -1,4 +1,4 @@
-use std::{collections::BTreeMap, fmt::Display, ptr::NonNull};
+use std::{fmt::Display, ptr::NonNull};
 
 use crate::{
     Pos, Type,
@@ -313,9 +313,9 @@ impl Expr {
         None
     }
 
-    pub fn as_record(&self) -> Option<&Record> {
-        if let Value::Record(r) = &self.value {
-            return Some(r);
+    pub fn as_record(&self) -> Option<Rec<'_>> {
+        if let Value::Record(inner) = &self.value {
+            return Some(Rec { inner });
         }
 
         None
@@ -344,6 +344,18 @@ impl Expr {
                     visitor.on_var(&mut node.attrs, var)?;
                 }
 
+                Value::Field { label, value } => {
+                    if item.visited {
+                        visitor.exit_field(&mut node.attrs, label.as_mut_str(), value.as_mut())?;
+                        continue;
+                    }
+
+                    item.visited = true;
+                    visitor.enter_field(&mut node.attrs, label.as_mut_str(), value.as_mut())?;
+                    stack.push(item);
+                    stack.push(ItemMut::new(value.as_mut()));
+                }
+
                 Value::Record(record) => {
                     if item.visited {
                         visitor.exit_record(&mut node.attrs, record)?;
@@ -354,8 +366,7 @@ impl Expr {
                     visitor.enter_record(&mut node.attrs, record)?;
                     stack.push(item);
 
-                    for (key, expr) in record.fields.iter_mut() {
-                        visitor.enter_record_entry(&mut node.attrs, key, expr)?;
+                    for expr in record.iter_mut().rev() {
                         stack.push(ItemMut::new(expr));
                     }
                 }
@@ -433,6 +444,18 @@ impl Expr {
                     visitor.on_var(&item.value.attrs, var);
                 }
 
+                Value::Field { label, value } => {
+                    if item.visited {
+                        visitor.exit_field(&item.value.attrs, label.as_str(), value);
+                        continue;
+                    }
+
+                    item.visited = true;
+                    visitor.enter_field(&item.value.attrs, label.as_str(), value);
+                    stack.push(item);
+                    stack.push(Item::new(value));
+                }
+
                 Value::Record(record) => {
                     if item.visited {
                         visitor.exit_record(&item.value.attrs, record);
@@ -441,11 +464,9 @@ impl Expr {
 
                     item.visited = true;
                     visitor.enter_record(&item.value.attrs, record);
-                    let attrs = &item.value.attrs;
                     stack.push(item);
 
-                    for (key, expr) in record.fields.iter() {
-                        visitor.enter_record_entry(attrs, key, expr);
+                    for expr in record.iter().rev() {
                         stack.push(Item::new(expr));
                     }
                 }
@@ -548,6 +569,24 @@ pub struct UnaryOp<'a> {
     pub expr: &'a Expr,
 }
 
+pub struct Rec<'a> {
+    inner: &'a Vec<Expr>,
+}
+
+impl Rec<'_> {
+    pub fn get(&self, id: &str) -> Option<&Expr> {
+        for expr in self.inner.iter() {
+            if let Value::Field { label, value } = &expr.value
+                && label == id
+            {
+                return Some(value);
+            }
+        }
+
+        None
+    }
+}
+
 pub struct ApplyFun<'a> {
     pub name: &'a String,
     pub params: &'a Vec<Expr>,
@@ -573,34 +612,35 @@ impl Display for Var {
 
 pub enum Value {
     Literal(Literal),
+
     Var(Var),
-    Record(Record),
+
+    Field {
+        label: String,
+        value: Box<Expr>,
+    },
+
+    Record(Vec<Expr>),
+
     Array(Vec<Expr>),
+
     App {
         fun: String,
         params: Vec<Expr>,
     },
+
     Binary {
         lhs: Box<Expr>,
         op: Operation,
         rhs: Box<Expr>,
     },
+
     Unary {
         op: Operation,
         expr: Box<Expr>,
     },
 }
 
-pub struct Record {
-    pub fields: BTreeMap<String, Expr>,
-}
-
-impl Record {
-    pub fn get(&self, id: &str) -> Option<&Expr> {
-        self.fields.get(id)
-    }
-}
-
 pub struct Sort {
     pub expr: Expr,
     pub order: Order,
@@ -746,24 +786,33 @@ pub trait ExprVisitorMut {
     fn enter_record(
         &mut self,
         attrs: &mut NodeAttributes,
-        record: &mut Record,
+        record: &mut [Expr],
     ) -> crate::Result<()> {
         Ok(())
     }
 
-    fn enter_record_entry(
+    fn enter_field(
         &mut self,
         attrs: &mut NodeAttributes,
-        key: &str,
-        expr: &mut Expr,
+        label: &mut str,
+        value: &mut Expr,
+    ) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn exit_field(
+        &mut self,
+        attrs: &mut NodeAttributes,
+        label: &mut str,
+        value: &mut Expr,
     ) -> crate::Result<()> {
         Ok(())
     }
 
     fn exit_record(
         &mut self,
         attrs: &mut NodeAttributes,
-        record: &mut Record,
+        record: &mut [Expr],
     ) -> crate::Result<()> {
         Ok(())
     }
@@ -872,9 +921,10 @@ pub trait QueryVisitor {
 pub trait ExprVisitor {
     fn on_literal(&mut self, attrs: &NodeAttributes, lit: &Literal) {}
     fn on_var(&mut self, attrs: &NodeAttributes, var: &Var) {}
-    fn enter_record(&mut self, attrs: &NodeAttributes, record: &Record) {}
-    fn enter_record_entry(&mut self, attrs: &NodeAttributes, key: &str, expr: &Expr) {}
-    fn exit_record(&mut self, attrs: &NodeAttributes, record: &Record) {}
+    fn enter_record(&mut self, attrs: &NodeAttributes, record: &[Expr]) {}
+    fn enter_field(&mut self, attrs: &NodeAttributes, label: &str, value: &Expr) {}
+    fn exit_field(&mut self, attrs: &NodeAttributes, label: &str, value: &Expr) {}
+    fn exit_record(&mut self, attrs: &NodeAttributes, record: &[Expr]) {}
     fn enter_array(&mut self, attrs: &NodeAttributes, values: &[Expr]) {}
     fn exit_array(&mut self, attrs: &NodeAttributes, values: &[Expr]) {}
     fn enter_app(&mut self, attrs: &NodeAttributes, name: &str, params: &[Expr]) {}

geth-eventql/src/parser/mod.rs

@@ -3,7 +3,6 @@ use crate::{
     sym::{Keyword, Literal, Sym},
     tokenizer::{Lexer, Pos},
 };
-use std::collections::BTreeMap;
 
 mod ast;
 mod state;
@@ -406,15 +405,22 @@ fn parse_expr_single(state: &mut ParserState<'_>) -> crate::Result<Expr> {
         Sym::LBrace => {
             state.skip_whitespace()?;
 
-            let mut fields = BTreeMap::new();
+            let mut fields = Vec::new();
 
             while let Some(Sym::Id(id)) = state.look_ahead()? {
-                let id = id.clone();
+                let label = id.clone();
+                let label_pos = state.pos();
                 state.shift()?;
                 state.skip_whitespace()?;
                 state.expect(Sym::Colon)?;
                 state.skip_whitespace()?;
-                fields.insert(id, parse_expr_single(state)?);
+                fields.push(Expr {
+                    attrs: NodeAttributes::new(label_pos),
+                    value: Value::Field {
+                        label,
+                        value: Box::new(parse_expr_single(state)?),
+                    },
+                });
                 state.skip_whitespace()?;
 
                 if let Some(Sym::Comma) = state.look_ahead()? {
@@ -430,7 +436,7 @@ fn parse_expr_single(state: &mut ParserState<'_>) -> crate::Result<Expr> {
 
             Ok(Expr {
                 attrs: NodeAttributes::new(pos),
-                value: Value::Record(Record { fields }),
+                value: Value::Record(fields),
             })
         }
 

geth-eventql/src/rename.rs

@@ -7,7 +7,7 @@ use std::{
 use crate::{
     Expr, Literal, Query, Value, Var,
     error::RenameError,
-    parser::{ExprVisitorMut, NodeAttributes, QueryVisitorMut, Record, parse_subject},
+    parser::{ExprVisitorMut, NodeAttributes, QueryVisitorMut, parse_subject},
 };
 
 pub fn rename(query: &mut Query) -> crate::Result<Scopes> {
@@ -160,10 +160,20 @@ impl ExprVisitorMut for RenameExpr<'_> {
         Ok(())
     }
 
+    fn exit_field(
+        &mut self,
+        attrs: &mut NodeAttributes,
+        _label: &mut str,
+        value: &mut Expr,
+    ) -> crate::Result<()> {
+        attrs.scope = value.attrs.scope;
+        Ok(())
+    }
+
     fn exit_record(
         &mut self,
         attrs: &mut NodeAttributes,
-        _record: &mut Record,
+        _record: &mut [Expr],
     ) -> crate::Result<()> {
         attrs.scope = self.inner.scope_id();