feat: implement bus declaration parsing

Author: Leo-Besancon

parser/src/ast/declarations.rs

@@ -35,6 +35,8 @@ use super::*;
 pub enum Declaration {
     /// Import one or more items from the specified AirScript module to the current module
     Import(Span<Import>),
+    /// A Bus section declaration
+    Buses(Span<Vec<Bus>>),
     /// A constant value declaration
     Constant(Constant),
     /// An evaluator function definition
@@ -76,6 +78,39 @@ pub enum Declaration {
     IntegrityConstraints(Span<Vec<Statement>>),
 }
 
+/// Represents a bus declaration in an AirScript module.
+#[derive(Debug, Clone, Spanned)]
+pub struct Bus {
+    #[span]
+    pub span: SourceSpan,
+    pub name: Identifier,
+    pub bus_type: BusType,
+}
+impl Bus {
+    /// Creates a new bus declaration
+    pub const fn new(span: SourceSpan, name: Identifier, bus_type: BusType) -> Self {
+        Self {
+            span,
+            name,
+            bus_type,
+        }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BusType {
+    /// A multiset bus
+    Unit,
+    /// A logup bus
+    Mult,
+}
+
+impl Eq for Bus {}
+impl PartialEq for Bus {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name && self.bus_type == other.bus_type
+    }
+}
+
 /// Stores a constant's name and value. There are three types of constants:
 ///
 /// * Scalar: 123

parser/src/ast/expression.rs

@@ -90,28 +90,31 @@ impl From<ResolvableIdentifier> for Identifier {
 
 /// Represents an identifier qualified with its namespace.
 ///
-/// Identifiers in AirScript are separated into two namespaces: one for functions,
-/// and one for bindings. This is because functions cannot be bound, and bindings
-/// cannot be called, so we can always disambiguate identifiers based on its usage.
+/// Identifiers in AirScript are separated into three namespaces: one for functions,
+/// one for buses and one for bindings. This is because functions cannot be bound,
+/// added to / remove from, buses cannot be bound or called, and bindings
+/// cannot be called added to / remove from.
+/// So we can always disambiguate identifiers based on its usage.
 ///
 /// It is still probably best practice to avoid having name conflicts between functions
 /// and bindings, but that is a matter of style rather than one of necessity.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Spanned)]
 pub enum NamespacedIdentifier {
     Function(#[span] Identifier),
     Binding(#[span] Identifier),
+    Bus(#[span] Identifier),
 }
 impl NamespacedIdentifier {
     pub fn id(&self) -> Identifier {
         match self {
-            Self::Function(ident) | Self::Binding(ident) => *ident,
+            Self::Function(ident) | Self::Binding(ident) | Self::Bus(ident) => *ident,
         }
     }
 }
 impl AsRef<Identifier> for NamespacedIdentifier {
     fn as_ref(&self) -> &Identifier {
         match self {
-            Self::Function(ref ident) | Self::Binding(ref ident) => ident,
+            Self::Function(ref ident) | Self::Binding(ref ident) | Self::Bus(ref ident) => ident,
         }
     }
 }

parser/src/ast/module.rs

@@ -59,6 +59,7 @@ pub struct Module {
     pub public_inputs: BTreeMap<Identifier, PublicInput>,
     pub random_values: Option<RandomValues>,
     pub trace_columns: Vec<TraceSegment>,
+    pub buses: BTreeMap<Identifier, Bus>,
     pub boundary_constraints: Option<Span<Vec<Statement>>>,
     pub integrity_constraints: Option<Span<Vec<Statement>>>,
 }
@@ -81,6 +82,7 @@ impl Module {
             constants: Default::default(),
             evaluators: Default::default(),
             functions: Default::default(),
+            buses: Default::default(),
             periodic_columns: Default::default(),
             public_inputs: Default::default(),
             random_values: None,
@@ -152,6 +154,11 @@ impl Module {
                 Declaration::IntegrityConstraints(statements) => {
                     module.declare_integrity_constraints(diagnostics, statements)?;
                 }
+                Declaration::Buses(mut buses) => {
+                    for bus in buses.drain(..) {
+                        module.declare_bus(diagnostics, &mut names, bus)?;
+                    }
+                }
             }
         }
 
@@ -416,6 +423,22 @@ impl Module {
         Ok(())
     }
 
+    fn declare_bus(
+        &mut self,
+        diagnostics: &DiagnosticsHandler,
+        names: &mut HashSet<NamespacedIdentifier>,
+        bus: Bus,
+    ) -> Result<(), SemanticAnalysisError> {
+        if let Some(prev) = names.replace(NamespacedIdentifier::Bus(bus.name)) {
+            conflicting_declaration(diagnostics, "bus", prev.span(), bus.name.span());
+            return Err(SemanticAnalysisError::NameConflict(bus.name.span()));
+        }
+
+        self.buses.insert(bus.name, bus);
+
+        Ok(())
+    }
+
     fn declare_periodic_column(
         &mut self,
         diagnostics: &DiagnosticsHandler,

parser/src/lexer/mod.rs

@@ -116,6 +116,15 @@ pub enum Token {
     /// Keyword to declare the function section in the AIR constraints module.
     Fn,
 
+    // BUSES KEYWORDS
+    // --------------------------------------------------------------------------------------------
+    /// Marks the beginning of buses section in the constraints file.
+    Buses,
+    /// Used to represent a multiset bus declaration.
+    Unit,
+    /// Used to represent a logup  bus declaration.
+    Mult,
+
     // BOUNDARY CONSTRAINT KEYWORDS
     // --------------------------------------------------------------------------------------------
     /// Marks the beginning of boundary constraints section in the constraints file.
@@ -187,6 +196,9 @@ impl Token {
             "ev" => Self::Ev,
             "fn" => Self::Fn,
             "felt" => Self::Felt,
+            "buses" => Self::Buses,
+            "unit" => Self::Unit,
+            "mult" => Self::Mult,
             "boundary_constraints" => Self::BoundaryConstraints,
             "integrity_constraints" => Self::IntegrityConstraints,
             "first" => Self::First,
@@ -260,6 +272,9 @@ impl fmt::Display for Token {
             Self::Ev => write!(f, "ev"),
             Self::Fn => write!(f, "fn"),
             Self::Felt => write!(f, "felt"),
+            Self::Buses => write!(f, "buses"),
+            Self::Unit => write!(f, "unit"),
+            Self::Mult => write!(f, "mult"),
             Self::BoundaryConstraints => write!(f, "boundary_constraints"),
             Self::First => write!(f, "first"),
             Self::Last => write!(f, "last"),

parser/src/parser/grammar.lalrpop

@@ -76,6 +76,7 @@ Declaration: Declaration = {
     RandomValues => Declaration::RandomValues(<>),
     EvaluatorFunction => Declaration::EvaluatorFunction(<>),
     Function => Declaration::Function(<>),
+    Buses => Declaration::Buses(<>),
     <l:@L> <trace:Trace> <r:@R> => Declaration::Trace(Span::new(span!(l, r), trace)),
     <PublicInputs> => Declaration::PublicInputs(<>),
     <BoundaryConstraints> => Declaration::BoundaryConstraints(<>),
@@ -180,6 +181,26 @@ PeriodicColumn: PeriodicColumn = {
         => PeriodicColumn::new(span!(l, r), name, values),
 }
 
+
+// BUSES
+// ================================================================================================
+
+// Buses are not required, and there is no limit to the number that can be provided.
+Buses: Span<Vec<Bus>> = {
+    <l:@L> "buses" "{" <bus:Bus*> "}" <r:@R>
+        => Span::new(span!(l, r), bus)
+}
+
+Bus: Bus = {
+    <l:@L> <bus_type: BusType> <name: Identifier> "," <r:@R>
+        => Bus::new(span!(l, r), name, bus_type),
+}
+
+BusType: BusType = {
+    "unit" => BusType::Unit,
+    "mult" => BusType::Mult,
+}
+
 // RANDOM VALUES
 // ================================================================================================
 
@@ -646,6 +667,9 @@ extern {
         "public_inputs" => Token::PublicInputs,
         "periodic_columns" => Token::PeriodicColumns,
         "random_values" => Token::RandomValues,
+        "buses" => Token::Buses,
+        "unit" => Token::Unit,
+        "mult" => Token::Mult,
         "boundary_constraints" => Token::BoundaryConstraints,
         "first" => Token::First,
         "last" => Token::Last,

parser/src/parser/tests/buses.rs

@@ -0,0 +1,38 @@
+use miden_diagnostics::SourceSpan;
+
+use crate::ast::*;
+
+use super::ParseTest;
+
+#[test]
+fn buses() {
+    let source = "
+    mod test
+
+    buses {
+        unit p,
+        mult q,
+    }";
+
+    let mut expected = Module::new(ModuleType::Library, SourceSpan::UNKNOWN, ident!(test));
+    expected.buses.insert(
+        ident!(p),
+        Bus::new(SourceSpan::UNKNOWN, ident!(p), BusType::Unit),
+    );
+    expected.buses.insert(
+        ident!(q),
+        Bus::new(SourceSpan::UNKNOWN, ident!(q), BusType::Mult),
+    );
+    ParseTest::new().expect_module_ast(source, expected);
+}
+
+#[test]
+fn empty_buses() {
+    let source = "
+    mod test
+
+    buses{}";
+
+    let expected = Module::new(ModuleType::Library, SourceSpan::UNKNOWN, ident!(test));
+    ParseTest::new().expect_module_ast(source, expected);
+}

parser/src/parser/tests/mod.rs

@@ -627,6 +627,7 @@ macro_rules! import {
 
 mod arithmetic_ops;
 mod boundary_constraints;
+mod buses;
 mod calls;
 mod constant_propagation;
 mod constants;

parser/src/sema/semantic_analysis.rs

@@ -1045,6 +1045,13 @@ impl<'a> VisitMut<SemanticAnalysisError> for SemanticAnalysis<'a> {
                             )
                             .emit();
                     }
+                    NamespacedIdentifier::Bus(_) => {
+                        self.diagnostics
+                            .diagnostic(Severity::Error)
+                            .with_message("reference to undefined bus")
+                            .with_primary_label(namespaced_id.span(), "this bus is not defined")
+                            .emit();
+                    }
                 }
 
                 ControlFlow::Continue(())