fmt improvements

src/parser/ast.rs

@@ -447,9 +447,9 @@ impl ParserError {
             ParserError::InvalidSingleQuotedCharacter(..) => {
                 atom!("invalid_single_quoted_character")
             }
-	    ParserError::InfiniteFloat(..) => {
-		atom!("infinite_float")
-	    }
+            ParserError::InfiniteFloat(..) => {
+                atom!("infinite_float")
+            }
             ParserError::IO(e) if e.kind() == ErrorKind::UnexpectedEof => {
                 atom!("unexpected_end_of_file")
             }

src/parser/lexer.rs

@@ -665,10 +665,7 @@ impl<'a, R: CharRead> Lexer<'a, R> {
 
         let n = parse_float_lossy(&token)?;
 
-        Ok(Number::Float(float_alloc!(
-            n,
-            self.machine_st.arena
-        )))
+        Ok(Number::Float(float_alloc!(n, self.machine_st.arena)))
     }
 
     fn skip_underscore_in_number(&mut self) -> Result<char, ParserError> {
@@ -944,9 +941,10 @@ impl<'a, R: CharRead> Lexer<'a, R> {
                 Ok(n) => Ok(Token::Literal(n.to_literal())),
                 Err(_) => {
                     let n = parse_float_lossy(&token_string)?;
-                    Ok(Token::Literal(Literal::F64Offset(
-                        float_alloc!(n, self.machine_st.arena),
-                    )))
+                    Ok(Token::Literal(Literal::F64Offset(float_alloc!(
+                        n,
+                        self.machine_st.arena
+                    ))))
                 }
             },
             Ok(NumberToken::Number(n)) => return Ok(Token::Literal(n.to_literal())),

src/parser/parser.rs

@@ -962,12 +962,20 @@ impl<'a, R: CharRead> Parser<'a, R> {
             Token::Literal(Literal::Rational(n)) => {
                 self.negate_number(n, negate_rat_rc, |r, _| Literal::Rational(r))
             }
-	    Token::Literal(Literal::F64Offset(n)) if self.lexer.machine_st.arena.f64_tbl.get_entry(n).is_infinite() => {
-		return Err(ParserError::InfiniteFloat(
-		    self.lexer.line_num,
-		    self.lexer.col_num,
-		));
-	    }
+            Token::Literal(Literal::F64Offset(n))
+                if self
+                    .lexer
+                    .machine_st
+                    .arena
+                    .f64_tbl
+                    .get_entry(n)
+                    .is_infinite() =>
+            {
+                return Err(ParserError::InfiniteFloat(
+                    self.lexer.line_num,
+                    self.lexer.col_num,
+                ));
+            }
             Token::Literal(Literal::F64Offset(n)) => {
                 let n = self.lexer.machine_st.arena.f64_tbl.get_entry(n);