Add middleware PrimaryExpression-struct to make TokenRanges correct

reid/src/ast/parse.rs

@@ -28,31 +28,32 @@ impl Parse for Type {
 
 impl Parse for Expression {
     fn parse(mut stream: TokenStream) -> Result<Expression, Error> {
-        let lhs = parse_primary_expression(&mut stream)?;
+        let lhs = stream.parse::<PrimaryExpression>()?.0;
         parse_binop_rhs(&mut stream, lhs, None)
     }
 }
 
-fn parse_primary_expression(stream: &mut TokenStream) -> Result<Expression, Error> {
+#[derive(Debug)]
+pub struct PrimaryExpression(Expression);
+
+impl Parse for PrimaryExpression {
+    fn parse(mut stream: TokenStream) -> Result<Self, Error> {
         use ExpressionKind as Kind;
 
-    if let Ok(exp) = stream.parse() {
+        let expr = if let Ok(exp) = stream.parse() {
-        Ok(Expression(
+            Expression(
                 Kind::FunctionCall(Box::new(exp)),
                 stream.get_range().unwrap(),
-        ))
+            )
         } else if let Ok(block) = stream.parse() {
-        Ok(Expression(
+            Expression(
                 Kind::BlockExpr(Box::new(block)),
                 stream.get_range().unwrap(),
-        ))
+            )
         } else if let Ok(ifexpr) = stream.parse() {
-        Ok(Expression(
+            Expression(Kind::IfExpr(Box::new(ifexpr)), stream.get_range().unwrap())
-            Kind::IfExpr(Box::new(ifexpr)),
-            stream.get_range().unwrap(),
-        ))
         } else if let Some(token) = stream.next() {
-        Ok(match &token {
+            match &token {
                 Token::Identifier(v) => {
                     Expression(Kind::VariableName(v.clone()), stream.get_range().unwrap())
                 }
@@ -66,9 +67,11 @@ fn parse_primary_expression(stream: &mut TokenStream) -> Result<Expression, Erro
                     exp
                 }
                 _ => Err(stream.expected_err("identifier, constant or parentheses")?)?,
-        })
+            }
         } else {
             Err(stream.expected_err("expression")?)?
+        };
+        Ok(PrimaryExpression(expr))
     }
 }
 
@@ -95,7 +98,7 @@ fn parse_binop_rhs(
         stream.parse_if::<BinaryOperator, _>(|b| b.get_precedence() >= expr_precedence)
     {
         let curr_token_prec = op.get_precedence();
-        let mut rhs = parse_primary_expression(stream)?;
+        let mut rhs = stream.parse::<PrimaryExpression>()?.0;
 
         if let Ok(next_op) = stream.parse_peek::<BinaryOperator>() {
             let next_prec = next_op.get_precedence();