refactor: Make bi_tuple macro more expressive

Author: ngeor

rusty_basic/src/instruction_generator/instruction_generator.rs

@@ -338,7 +338,7 @@ impl InstructionGenerator {
 
     fn is_data_statement(statement: &Statement) -> bool {
         if let Statement::BuiltInSubCall(b) = statement {
-            *b.left() == BuiltInSub::Data
+            *b.built_in_sub() == BuiltInSub::Data
         } else {
             false
         }

rusty_parser/src/specific/core/macros.rs

@@ -1,37 +1,53 @@
+// `bi_tuple` creates a tuple of two items.
+//
+// Example: `bi_tuple!(Person(name: String, age: int))`
+//
+// It implements the `From` trait to break apart the tuple into the members
+// or take references to them.
+//
+// It does not implement `AsRef` (or any other trait) per item type, as it might be that the two types are the same.
 macro_rules! bi_tuple {
-    ($(#[$($attrss:tt)*])* $name: ident($left: ty, $right: ty)) => {
+    ($(#[$($attrss:tt)*])* $name: ident($left_name: tt: $left_type: ty, $right_name: tt: $right_type: ty)) => {
         $(#[$($attrss)*])*
         #[derive(Clone, Debug, PartialEq)]
-        pub struct $name($left, $right);
+        pub struct $name($left_type, $right_type);
 
         impl $name {
-            pub fn new(left: $left, right: $right) -> Self {
-                Self(left, right)
+            /// Creates a new instance of [$name].
+            pub fn new($left_name: $left_type, $right_name: $right_type) -> Self {
+                Self($left_name, $right_name)
             }
 
+            /// Tries to map the right side of the tuple with the given function.
             pub fn try_map_right<F, E>(self, f: F) -> Result<Self, E>
-            where F : FnOnce($right) -> Result<$right, E>
+            where F : FnOnce($right_type) -> Result<$right_type, E>
             {
-                let (left, right) = self.into();
-                f(right).map(|new_right| Self::new(left, new_right))
+                let ($left_name, $right_name) = self.into();
+                f($right_name).map(|new_right| Self::new($left_name, new_right))
             }
 
-            pub fn left(&self) -> &$left {
+            /// Gets a reference to the left side member of the tuple.
+            pub fn $left_name(&self) -> &$left_type {
                 &self.0
             }
 
-            pub fn right(&self) -> &$right {
+            /// Gets a reference to the right side member of the tuple.
+            pub fn $right_name(&self) -> &$right_type {
                 &self.1
             }
         }
 
-        impl From<$name> for ($left, $right) {
+        // Break apart the tuple
+
+        impl From<$name> for ($left_type, $right_type) {
             fn from(value: $name) -> Self {
                 (value.0, value.1)
             }
         }
 
-        impl<'a> From<&'a $name> for (&'a $left, &'a $right) {
+        // Get references to both members of the tuple
+
+        impl<'a> From<&'a $name> for (&'a $left_type, &'a $right_type) {
             fn from(value: &'a $name) -> Self {
                 (&value.0, &value.1)
             }

rusty_parser/src/specific/core/statement.rs

@@ -141,22 +141,22 @@ pub enum Statement {
 
 bi_tuple!(
     /// A constant declaration.
-    Constant(NamePos, ExpressionPos)
+    Constant(name: NamePos, value: ExpressionPos)
 );
 
 bi_tuple!(
     /// An assignment statement.
-    Assignment(Expression, ExpressionPos)
+    Assignment(lvalue: Expression, rvalue: ExpressionPos)
 );
 
 bi_tuple!(
     /// A call to a user defined SUB.
-    SubCall(BareName, Expressions)
+    SubCall(sub_name: BareName, args: Expressions)
 );
 
 bi_tuple!(
     /// A call to a built-in SUB.
-    BuiltInSubCall(BuiltInSub, Expressions)
+    BuiltInSubCall(built_in_sub: BuiltInSub, args: Expressions)
 );
 
 /// A list of variables defined in a DIM statement.
@@ -228,14 +228,10 @@ pub struct SelectCase {
 bi_tuple!(
     /// A case block can have one or more condition expressions and
     /// the statements to execute if the condition is met.
-    CaseBlock(Vec<CaseExpression>, Statements)
+    CaseBlock(conditions: Vec<CaseExpression>, statements: Statements)
 );
 
 impl CaseBlock {
-    pub fn conditions(&self) -> &Vec<CaseExpression> {
-        &self.0
-    }
-
     pub fn has_conditions(&self) -> bool {
         // the CASE ELSE block does not have conditions
         !self.conditions().is_empty()