nixfmt_rs 0.5.1

Rust implementation of nixfmt with exact Haskell compatibility
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//! Number literal parsing
//!
//! This module handles parsing of Nix numeric literals:
//! - Integers: `42`, `0`, `123`
//! - Floats: `3.14`, `1.`, `.5`, `1.5e10`, `2e-5`
//!
//! Special cases:
//! - Numbers with leading zeros (e.g., `01`) cannot have decimal points
//! - Trailing dots are allowed for non-zero integers (e.g., `1.`)
//! - Leading dots are allowed (e.g., `.5`)
//! - Scientific notation with optional sign (e.g., `1e10`, `2e-5`)

use super::Lexer;
use crate::ast::Token;
use crate::error::{self, ParseError};

impl Lexer {
    /// Parse a number literal (integer or float)
    pub(super) fn parse_number(&mut self) -> error::Result<Token> {
        let start = self.current_pos();
        let mut num = self.consume_digits();
        let mut is_float = false;

        if self.peek() == Some('.') {
            let next = self.peek_ahead(1);
            let has_leading_zero = num.starts_with('0');
            let has_multiple_leading_zeroes = has_leading_zero && num.len() > 1;

            if next.is_some_and(|c| c.is_ascii_digit()) && !has_multiple_leading_zeroes {
                is_float = true;
                num.push('.');
                self.advance();
                num.push_str(&self.consume_digits());
            } else if next.is_none_or(|c| !c.is_ascii_digit()) && !num.is_empty() && num != "0" {
                // Allow trailing '.' for numbers starting with non-zero digit (e.g., 1.)
                is_float = true;
                num.push('.');
                self.advance();
            }
        }

        if is_float {
            if let Some(exp) = self.parse_exponent() {
                num.push_str(&exp);
            }
            return Ok(Token::Float(num.into()));
        }

        // Nix integers are signed 64-bit; reject literals that overflow.
        if num.parse::<i64>().is_err() {
            return Err(ParseError::invalid(
                start,
                format!("invalid integer '{num}'"),
                Some(format!(
                    "integer literals must fit in a signed 64-bit range (0 to {})",
                    i64::MAX
                )),
            ));
        }

        Ok(Token::Integer(num.into()))
    }

    /// Parse scientific notation exponent (e.g., `e10`, `E-5`, `e+3`)
    pub(super) fn parse_exponent(&mut self) -> Option<String> {
        if !matches!(self.peek(), Some('e' | 'E')) {
            return None;
        }

        self.try_with_cursor(|this| {
            let mut exponent = String::new();
            exponent.push(this.advance().unwrap());

            if matches!(this.peek(), Some('+' | '-')) {
                exponent.push(this.advance().unwrap());
            }

            if this.peek().is_some_and(|c| c.is_ascii_digit()) {
                exponent.push_str(&this.consume_digits());
                Some(exponent)
            } else {
                None
            }
        })
    }

    /// Consume consecutive ASCII digits and return as String
    pub(super) fn consume_digits(&mut self) -> String {
        self.take_ascii_while(|b| b.is_ascii_digit()).to_owned()
    }
}