Add span to negate

numbat/src/ast.rs

@@ -36,7 +36,7 @@ pub enum Expression {
     Scalar(Span, Number),
     Identifier(Span, String),
     UnitIdentifier(Span, Prefix, String, String),
-    Negate(Box<Expression>),
+    Negate(Span, Box<Expression>),
     BinaryOperator {
         op: BinaryOperator,
         lhs: Box<Expression>,
@@ -63,7 +63,7 @@ macro_rules! identifier {
 #[cfg(test)]
 macro_rules! negate {
     ( $rhs:expr ) => {{
-        Expression::Negate(Box::new($rhs))
+        Expression::Negate(Span::dummy(), Box::new($rhs))
     }};
 }
 
@@ -255,7 +255,7 @@ impl PrettyPrint for Expression {
             UnitIdentifier(_, prefix, _name, full_name) => {
                 m::unit(format!("{}{}", prefix.as_string_long(), full_name))
             }
-            Negate(rhs) => m::operator("-") + with_parens(rhs),
+            Negate(_, rhs) => m::operator("-") + with_parens(rhs),
             BinaryOperator {
                 op,
                 lhs,
@@ -555,7 +555,9 @@ impl ReplaceSpans for Expression {
                 name.clone(),
                 full_name.clone(),
             ),
-            Expression::Negate(expr) => Expression::Negate(Box::new(expr.replace_spans())),
+            Expression::Negate(_, expr) => {
+                Expression::Negate(Span::dummy(), Box::new(expr.replace_spans()))
+            }
             Expression::BinaryOperator {
                 op,
                 lhs,

numbat/src/parser.rs

@@ -636,9 +636,10 @@ impl<'a> Parser<'a> {
 
     fn unary(&mut self) -> Result<Expression> {
         if self.match_exact(TokenKind::Minus).is_some() {
+            let span = self.last().unwrap().span;
             let rhs = self.unary()?;
 
-            Ok(Expression::Negate(Box::new(rhs)))
+            Ok(Expression::Negate(span, Box::new(rhs)))
         } else {
             self.ifactor()
         }

numbat/src/prefix_transformer.rs

@@ -45,8 +45,8 @@ impl Transformer {
             Expression::UnitIdentifier(_, _, _, _) => {
                 unreachable!("Prefixed identifiers should not exist prior to this stage")
             }
-            Expression::Negate(expr) => {
-                Expression::Negate(Box::new(self.transform_expression(*expr)))
+            Expression::Negate(span, expr) => {
+                Expression::Negate(span, Box::new(self.transform_expression(*expr)))
             }
             Expression::BinaryOperator {
                 op,

numbat/src/typechecker.rs

@@ -152,7 +152,7 @@ impl TypeChecker {
 
                 typed_ast::Expression::UnitIdentifier(prefix, name, full_name, type_)
             }
-            ast::Expression::Negate(expr) => {
+            ast::Expression::Negate(_, expr) => {
                 let checked_expr = self.check_expression(*expr)?;
                 let type_ = checked_expr.get_type();
                 typed_ast::Expression::Negate(Box::new(checked_expr), type_)