Attempting to add bus constraints parsing, may need rework

Author: Leo-Besancon

air/src/passes/translate_from_ast.rs

@@ -297,7 +297,8 @@ impl<'a> AirBuilder<'a> {
                 }
                 ast::Statement::Enforce(_)
                 | ast::Statement::EnforceIf(_, _)
-                | ast::Statement::EnforceAll(_) => {
+                | ast::Statement::EnforceAll(_)
+                | ast::Statement::BusEnforce(_) => {
                     unreachable!()
                 }
             }
@@ -447,7 +448,9 @@ impl<'a> AirBuilder<'a> {
                     panic!("expected scalar expression to produce scalar value, got: {invalid:?}")
                 }
             },
-            ast::ScalarExpr::Call(_) | ast::ScalarExpr::BoundedSymbolAccess(_) => unreachable!(),
+            ast::ScalarExpr::Call(_)
+            | ast::ScalarExpr::BoundedSymbolAccess(_)
+            | ast::ScalarExpr::BusOperation(_) => unreachable!(),
         }
     }
 

mir/derive-ir/src/lib.rs

@@ -29,7 +29,7 @@ use syn::{parse_macro_input, DeriveInput};
 ///     f: Link<Vec<Link<Op>>>,
 /// }
 /// ```
-/// 
+///
 /// We now isolate the optional fields:
 /// - `a: BackLink<Owner>`
 /// - `b: Vec<BackLink<Owner>>`
@@ -38,13 +38,13 @@ use syn::{parse_macro_input, DeriveInput};
 ///   and the required fields:
 /// - `c: i32`
 /// - `d: Link<Op>`
-/// 
+///
 /// We generate an initial state `FooBuilder0` with no fields set,
 /// except for the optional fields which are set to their default values.
 /// ```ignore
 /// let initial_state = [true, true, false, false, true, true];
 /// ```
-/// 
+///
 /// We then generate a state with each of the required fields set,
 /// and every possible combination of those field states.
 /// We sort the states by the number of fields set, then by leftmost true bits.
@@ -58,7 +58,7 @@ use syn::{parse_macro_input, DeriveInput};
 ///     [true, true, true,  true,  true, true], // 3
 /// ];
 /// ```
-/// 
+///
 /// We generate a transition table for each state,
 /// which maps from the current state to the next state.
 /// rows are indexed by the current state,
@@ -71,7 +71,7 @@ use syn::{parse_macro_input, DeriveInput};
 ///     /* 3: */ [3, 3, 3, 3, 3, 3],
 /// ];
 /// ```
-/// 
+///
 /// We then generate an implementation for each state,
 /// with a method for each field., which transitions to the next state.
 ///
@@ -107,7 +107,7 @@ use syn::{parse_macro_input, DeriveInput};
 ///         f: Link::new(vec![f0, f1]),
 ///     });
 /// ```
-/// 
+///
 #[proc_macro_derive(Builder, attributes(enum_wrapper))]
 pub fn derive_builder(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);

mir/src/passes/translate.rs

@@ -374,6 +374,7 @@ impl<'a> MirBuilder<'a> {
             ast::Statement::Enforce(enf) => self.translate_enforce(enf),
             ast::Statement::EnforceIf(enf, cond) => self.translate_enforce_if(enf, cond),
             ast::Statement::EnforceAll(list_comp) => self.translate_enforce_all(list_comp),
+            ast::Statement::BusEnforce(_) => todo!(),
         }
     }
     fn translate_let(&mut self, let_stmt: &'a ast::Let) -> Result<Link<Op>, CompileError> {
@@ -808,6 +809,7 @@ impl<'a> MirBuilder<'a> {
             ast::ScalarExpr::Binary(b) => self.translate_binary_op(b),
             ast::ScalarExpr::Call(c) => self.translate_call(c),
             ast::ScalarExpr::Let(l) => self.translate_let(l),
+            ast::ScalarExpr::BusOperation(_) => todo!(),
         }
     }
 

parser/src/ast/declarations.rs

@@ -104,6 +104,22 @@ pub enum BusType {
     Mult,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BusOperator {
+    /// Add a tuple to the bus
+    Add,
+    /// Remove a tuple from the bus
+    Rem,
+}
+impl std::fmt::Display for BusOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::Add => write!(f, "add"),
+            Self::Rem => write!(f, "rem"),
+        }
+    }
+}
+
 impl Eq for Bus {}
 impl PartialEq for Bus {
     fn eq(&self, other: &Self) -> bool {

parser/src/ast/display.rs

@@ -111,6 +111,7 @@ impl<'a> fmt::Display for DisplayStatement<'a> {
                 write!(f, "enf {}", expr)
             }
             Statement::Expr(ref expr) => write!(f, "return {}", expr),
+            Statement::BusEnforce(ref expr) => write!(f, "bus_enf {}", expr),
         }
     }
 }

parser/src/ast/expression.rs

@@ -441,6 +441,7 @@ impl TryFrom<ScalarExpr> for Expr {
                 Err(InvalidExprError::BoundedSymbolAccess(expr.span()))
             }
             ScalarExpr::Let(expr) => Ok(Self::Let(expr)),
+            ScalarExpr::BusOperation(_) => todo!(),
         }
     }
 }
@@ -489,6 +490,8 @@ pub enum ScalarExpr {
     /// binary expressions or function calls to a block of statements, and only when the result
     /// of evaluating the `let` produces a valid scalar expression.
     Let(Box<Let>),
+    /// A bus operation
+    BusOperation(BusOperation),
 }
 impl ScalarExpr {
     /// Returns true if this is a constant value
@@ -523,6 +526,7 @@ impl ScalarExpr {
             },
             Self::Call(ref expr) => Ok(expr.ty),
             Self::Let(ref expr) => Ok(expr.ty()),
+            Self::BusOperation(_) => todo!(),
         }
     }
 }
@@ -579,6 +583,7 @@ impl fmt::Debug for ScalarExpr {
             Self::Binary(ref expr) => f.debug_tuple("Binary").field(expr).finish(),
             Self::Call(ref expr) => f.debug_tuple("Call").field(expr).finish(),
             Self::Let(ref expr) => write!(f, "{:#?}", expr),
+            Self::BusOperation(ref expr) => f.debug_tuple("BusOp").field(expr).finish(),
         }
     }
 }
@@ -598,6 +603,7 @@ impl fmt::Display for ScalarExpr {
                 };
                 write!(f, "{display}")
             }
+            Self::BusOperation(ref expr) => write!(f, "{}", expr),
         }
     }
 }
@@ -1256,6 +1262,53 @@ impl fmt::Display for ListComprehension {
     }
 }
 
+#[derive(Clone, Spanned)]
+pub struct BusOperation {
+    #[span]
+    pub span: SourceSpan,
+    pub bus: ResolvableIdentifier,
+    pub op: BusOperator,
+    pub args: Vec<Expr>,
+}
+
+impl BusOperation {
+    pub fn new(span: SourceSpan, bus: Identifier, op: BusOperator, args: Vec<Expr>) -> Self {
+        Self {
+            span,
+            bus: ResolvableIdentifier::Unresolved(NamespacedIdentifier::Bus(bus)),
+            op,
+            args,
+        }
+    }
+}
+
+impl Eq for BusOperation {}
+impl PartialEq for BusOperation {
+    fn eq(&self, other: &Self) -> bool {
+        self.bus == other.bus && self.args == other.args && self.op == other.op
+    }
+}
+impl fmt::Debug for BusOperation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("BusOperation")
+            .field("bus", &self.bus)
+            .field("op", &self.op)
+            .field("args", &self.args)
+            .finish()
+    }
+}
+impl fmt::Display for BusOperation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}{}{}",
+            self.bus,
+            self.op,
+            DisplayTuple(self.args.as_slice())
+        )
+    }
+}
+
 /// Represents a function call (either a pure function or an evaluator).
 ///
 /// Calls are permitted in a scalar expression context, but arguments to the

parser/src/ast/statement.rs

@@ -60,6 +60,8 @@ pub enum Statement {
     /// Just like `Enforce`, except the constraint is contained in the body of a list comprehension,
     /// and must be enforced on every value produced by that comprehension.
     EnforceAll(ListComprehension),
+    /// Declares a bus related constraint
+    BusEnforce(ListComprehension),
 }
 impl Statement {
     /// Checks this statement to see if it contains any constraints
@@ -69,7 +71,10 @@ impl Statement {
     /// one or more constraints in its body.
     pub fn has_constraints(&self) -> bool {
         match self {
-            Self::Enforce(_) | Self::EnforceIf(_, _) | Self::EnforceAll(_) => true,
+            Self::Enforce(_)
+            | Self::EnforceIf(_, _)
+            | Self::EnforceAll(_)
+            | Self::BusEnforce(_) => true,
             Self::Let(Let { body, .. }) => body.iter().any(|s| s.has_constraints()),
             Self::Expr(_) => false,
         }
@@ -161,9 +166,10 @@ impl Let {
                     last = let_expr.body.last();
                 }
                 Statement::Expr(ref expr) => return expr.ty(),
-                Statement::Enforce(_) | Statement::EnforceIf(_, _) | Statement::EnforceAll(_) => {
-                    break
-                }
+                Statement::Enforce(_)
+                | Statement::EnforceIf(_, _)
+                | Statement::EnforceAll(_)
+                | Statement::BusEnforce(_) => break,
             }
         }
 

parser/src/ast/visit.rs

@@ -586,6 +586,7 @@ where
         }
         ast::Statement::EnforceAll(ref mut expr) => visitor.visit_mut_enforce_all(expr),
         ast::Statement::Expr(ref mut expr) => visitor.visit_mut_expr(expr),
+        ast::Statement::BusEnforce(ref mut _expr) => todo!(),
     }
 }
 
@@ -647,6 +648,7 @@ where
         ast::ScalarExpr::Binary(ref mut expr) => visitor.visit_mut_binary_expr(expr),
         ast::ScalarExpr::Call(ref mut expr) => visitor.visit_mut_call(expr),
         ast::ScalarExpr::Let(ref mut expr) => visitor.visit_mut_let(expr),
+        ast::ScalarExpr::BusOperation(ref mut _expr) => todo!(),
     }
 }
 

parser/src/lexer/mod.rs

@@ -84,6 +84,8 @@ pub enum Token {
     DeclIdentRef(Symbol),
     /// A function identifier
     FunctionIdent(Symbol),
+    /// A bus identifier
+    BusIdent(Symbol),
     /// Integers should only contain numeric characters.
     Num(u64),
 
@@ -122,8 +124,14 @@ pub enum Token {
     Buses,
     /// Used to represent a multiset bus declaration.
     Unit,
-    /// Used to represent a logup  bus declaration.
+    /// Used to represent a logup bus declaration.
     Mult,
+    /// Used to represent an empty bus
+    Null,
+    /// Used to represent the addition of a given tuple to a bus
+    Add,
+    /// Used to represent the removal of a given tuple to a bus
+    Rem,
 
     // BOUNDARY CONSTRAINT KEYWORDS
     // --------------------------------------------------------------------------------------------
@@ -199,6 +207,9 @@ impl Token {
             "buses" => Self::Buses,
             "unit" => Self::Unit,
             "mult" => Self::Mult,
+            "null" => Self::Null,
+            "add" => Self::Add,
+            "rem" => Self::Rem,
             "boundary_constraints" => Self::BoundaryConstraints,
             "integrity_constraints" => Self::IntegrityConstraints,
             "first" => Self::First,
@@ -257,6 +268,7 @@ impl fmt::Display for Token {
             Self::Ident(ref id) => write!(f, "{}", id),
             Self::DeclIdentRef(ref id) => write!(f, "{}", id),
             Self::FunctionIdent(ref id) => write!(f, "{}", id),
+            Self::BusIdent(ref id) => write!(f, "{}", id),
             Self::Num(ref i) => write!(f, "{}", i),
             Self::Def => write!(f, "def"),
             Self::Mod => write!(f, "mod"),
@@ -275,6 +287,9 @@ impl fmt::Display for Token {
             Self::Buses => write!(f, "buses"),
             Self::Unit => write!(f, "unit"),
             Self::Mult => write!(f, "mult"),
+            Self::Null => write!(f, "null"),
+            Self::Add => write!(f, "add"),
+            Self::Rem => write!(f, "rem"),
             Self::BoundaryConstraints => write!(f, "boundary_constraints"),
             Self::First => write!(f, "first"),
             Self::Last => write!(f, "last"),