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/src/passes/translate.rs

@@ -373,6 +373,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> {
@@ -807,6 +808,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"),

parser/src/parser/grammar.lalrpop

@@ -361,6 +361,7 @@ ConstraintStatements: Vec<Statement> = {
 ConstraintStatement: Vec<Statement> = {
     "enf" "match" "{" <MatchArm+> "}" ";" => <>,
     "enf" <ConstraintExpr> ";" => vec![<>],
+    <BusConstraintExpr> ";" => vec![<>],
 }
 
 ReturnStatement: Expr = {
@@ -426,15 +427,60 @@ ConstraintExpr: Statement = {
     }
 }
 
+// 1. `p.add(a, b) when s`
+// 2. `q.add(a, b) for m`
+BusConstraintExpr: Statement = {
+    <l:@L> <expr: ScalarBusConstraintExpr> <selector: WithSelector> <r:@R> => {
+        let generated_name = format!("%{}", *next_var);
+        *next_var += 1;
+        let generated_binding = Identifier::new(SourceSpan::UNKNOWN, Symbol::intern(generated_name));
+        let context = vec![(generated_binding, Expr::Range(RangeExpr::from(0..1)))];
+        Statement::BusEnforce(ListComprehension::new(span!(l, r), expr, context, Some(selector)))
+    },
+    <l:@L> <expr: ScalarBusConstraintExpr> <multiplicity: WithMultiplicity> <r:@R> => {
+        let generated_name = format!("%{}", *next_var);
+        *next_var += 1;
+        let generated_binding = Identifier::new(SourceSpan::UNKNOWN, Symbol::intern(generated_name));
+        let context = vec![(generated_binding, Expr::Range(RangeExpr::from(0..1)))];
+        Statement::BusEnforce(ListComprehension::new(span!(l, r), expr, context, Some(multiplicity)))
+    }
+}
+
+// 1. `p.first = null`
+// 2. `q.first = ???` To define
+BoundaryBusConstraintExpr: Statement = {
+    <l:@L> <expr: ScalarBusConstraintExpr> <r:@R> => {
+                let generated_name = format!("%{}", *next_var);
+        *next_var += 1;
+        let generated_binding = Identifier::new(SourceSpan::UNKNOWN, Symbol::intern(generated_name));
+        let context = vec![(generated_binding, Expr::Range(RangeExpr::from(0..1)))];
+        Statement::BusEnforce(ListComprehension::new(span!(l, r), expr, context, None))
+    }
+}
+
 ScalarConstraintExpr: ScalarExpr = {
     FunctionCall,
     <l:@L> <lhs: ScalarExpr> "=" <rhs: ScalarExpr> <r:@R>
         => ScalarExpr::Binary(BinaryExpr::new(span!(l, r), BinaryOp::Eq, lhs, rhs)),
 }
 
+ScalarBusConstraintExpr: ScalarExpr = {
+    <l:@L> <bus: BusIdentifier> "." <bus_operation: BusOperator> "(" <args: Comma<Expr>> ")" <r:@R> => {
+        ScalarExpr::BusOperation(BusOperation::new(span!(l, r), bus, bus_operation, args))
+    }
+}
+
+BusOperator: BusOperator = {
+    "add" => BusOperator::Add,
+    "rem" => BusOperator::Rem
+}
+
 WithSelector: ScalarExpr = {
     "when" <ScalarExpr>,
 }
+WithMultiplicity: ScalarExpr = {
+    "for" <ScalarExpr>,
+}
 
 Expr: Expr = {
     <ScalarExpr> =>? {
@@ -634,6 +680,10 @@ FunctionIdentifier: Identifier = {
     <l:@L> <name:function_identifier> <r:@R> => Identifier::new(span!(l, r), name)
 }
 
+BusIdentifier: Identifier = {
+    <l:@L> <name:bus_identifier> <r:@R> => Identifier::new(span!(l, r), name)
+}
+
 Int: Span<u64> = {
    <l:@L> <i:Num_u64> <r:@R> => Span::new(span!(l, r), i),
 }
@@ -653,6 +703,7 @@ extern {
         identifier => Token::Ident(<Symbol>),
         decl_ident_ref => Token::DeclIdentRef(<Symbol>),
         function_identifier => Token::FunctionIdent(<Symbol>),
+        bus_identifier => Token::BusIdent(<Symbol>),
         int => Token::Num(<u64>),
         "def" => Token::Def,
         "mod" => Token::Mod,
@@ -670,6 +721,9 @@ extern {
         "buses" => Token::Buses,
         "unit" => Token::Unit,
         "mult" => Token::Mult,
+        "null" => Token::Null,
+        "add" => Token::Add,
+        "rem" => Token::Rem,
         "boundary_constraints" => Token::BoundaryConstraints,
         "first" => Token::First,
         "last" => Token::Last,

parser/src/transforms/constant_propagation.rs

@@ -275,12 +275,14 @@ impl<'a> VisitMut<SemanticAnalysisError> for ConstantPropagation<'a> {
                         }
                         Statement::Enforce(_)
                         | Statement::EnforceIf(_, _)
-                        | Statement::EnforceAll(_) => unreachable!(),
+                        | Statement::EnforceAll(_)
+                        | Statement::BusEnforce(_) => unreachable!(),
                     },
                     Err(err) => return ControlFlow::Break(err),
                 }
                 ControlFlow::Continue(())
             }
+            ScalarExpr::BusOperation(_) => todo!(),
         }
     }
 
@@ -591,7 +593,8 @@ impl<'a> VisitMut<SemanticAnalysisError> for ConstantPropagation<'a> {
                         }
                         Statement::Enforce(_)
                         | Statement::EnforceIf(_, _)
-                        | Statement::EnforceAll(_) => unreachable!(),
+                        | Statement::EnforceAll(_)
+                        | Statement::BusEnforce(_) => unreachable!(),
                     },
                     Err(err) => return ControlFlow::Break(err),
                 }
@@ -642,6 +645,7 @@ impl<'a> VisitMut<SemanticAnalysisError> for ConstantPropagation<'a> {
                 }
                 // This statement type is only present in the AST after inlining
                 Statement::EnforceIf(_, _) => unreachable!(),
+                Statement::BusEnforce(_) => todo!(),
             }
 
             // If we have a non-empty buffer, then we are collapsing a let into the current block,