(main) ref: remove unnecessary options

Author: t-webber

src/parser/keyword/types/attributes.rs

@@ -26,14 +26,6 @@ macro_rules! define_attribute_keywords {
             }
         }
 
-        // impl PushInNode for AttributeKeyword {
-        //     fn push_in_node(self, node: &mut Ast) -> Result<(), String> {
-        //         match self {
-        //             $(Self::$name(val) => val.push_in_node(node),)*
-        //         }
-        //     }
-        // }
-
         pub enum UnsortedAttributeKeyword {
             $($($variant,)*)*
         }
@@ -78,8 +70,7 @@ impl PushInNode for AttributeKeyword {
             Ast::Empty => *node = self.into_node(),
             Ast::Leaf(Literal::Variable(var)) => var.push_attr(self),
             Ast::ParensBlock(_) | Ast::Leaf(_) => return Err(format!("invalid attribute. Attribute keywords can only be applied to variables, but found {node}")),
-            Ast::Unary(Unary{arg: Some(arg), ..}) | Ast::Binary(Binary {arg_r: Some(arg), ..}) | Ast::Ternary(Ternary { failure: Some(arg), ..} | Ternary { success: arg, .. }) => return self.push_in_node(arg),
-            Ast::Unary(Unary{arg: None, ..}) | Ast::Binary(Binary {arg_r: None, ..}) => return node.push_block_as_leaf(self.into_node()),
+            Ast::Unary(Unary{arg, ..}) | Ast::Binary(Binary {arg_r: arg, ..}) | Ast::Ternary(Ternary { failure: Some(arg), ..} | Ternary { success: arg, .. }) => return self.push_in_node(arg),
             Ast::ListInitialiser(ListInitialiser{ full: true, ..}) | Ast::FunctionCall(FunctionCall{full: true, .. })  => return Err("Attributes can only be placed before variables.".to_owned())
             ,Ast::ListInitialiser(ListInitialiser{elts , ..}) | Ast::FunctionCall(FunctionCall{args: elts,  ..}) | Ast::Block(Block{elts, ..}) => match elts.last_mut()  {
                 Some(last) => return self.push_in_node(last),

src/parser/tree/binary.rs

@@ -2,7 +2,7 @@
 
 use core::fmt;
 
-use super::{repr_option_node, Associativity, Ast, Operator};
+use super::{Associativity, Ast, Operator};
 
 macro_rules! define_binary_operator {
     ($($name_left:ident $precedence_left:expr, $repr_left:expr)*; $($name_right:ident $precedence_right:expr, $repr_right:expr)*) => {
@@ -45,27 +45,16 @@ macro_rules! define_binary_operator {
 pub struct Binary {
     pub op: BinaryOperator,
     pub arg_l: Box<Ast>,
-    pub arg_r: Option<Box<Ast>>,
+    pub arg_r: Box<Ast>,
 }
 
 #[expect(clippy::min_ident_chars)]
 impl fmt::Display for Binary {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.op == BinaryOperator::ArraySubscript {
-            write!(
-                f,
-                "({}[{}])",
-                self.arg_l,
-                repr_option_node(self.arg_r.as_ref())
-            )
+            write!(f, "({}[{}])", self.arg_l, self.arg_r)
         } else {
-            write!(
-                f,
-                "({} {} {})",
-                self.arg_l,
-                self.op,
-                repr_option_node(self.arg_r.as_ref())
-            )
+            write!(f, "({} {} {})", self.arg_l, self.op, self.arg_r)
         }
     }
 }

src/parser/tree/conversions.rs

@@ -16,7 +16,7 @@ impl OperatorConversions for BinaryOperator {
         Ok(Ast::Binary(Binary {
             op: self,
             arg_l: Box::new(arg),
-            arg_r: None,
+            arg_r: Box::new(Ast::Empty),
         }))
     }
 }
@@ -60,14 +60,14 @@ impl OperatorConversions for UnaryOperator {
     fn try_to_node(self) -> Result<Ast, String> {
         Ok(Ast::Unary(Unary {
             op: self,
-            arg: None,
+            arg: Box::new(Ast::Empty),
         }))
     }
 
     fn try_to_node_with_arg(self, arg: Ast) -> Result<Ast, String> {
         Ok(Ast::Unary(Unary {
             op: self,
-            arg: Some(Box::from(arg)),
+            arg: Box::from(arg),
         }))
     }
 }