ron2 0.3.0

RON parser with full AST access, perfect round-trip fidelity, and formatting tools
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Number parsing helpers for `FromRon` implementations.

use crate::{
    ast::NumberKind,
    error::{Error, ErrorKind, Result},
};

/// Result of parsing an integer from its raw string representation.
#[derive(Debug, Clone, Copy)]
pub struct ParsedInt {
    /// The absolute value of the parsed integer.
    pub magnitude: u128,
    /// Whether the integer was negative.
    pub negative: bool,
}

/// Determine base and strip prefix from a numeric string.
/// Returns `(base, digits_str)`.
fn determine_base_and_digits(s: &str) -> (u32, &str) {
    if let Some(d) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
        (16, d)
    } else if let Some(d) = s.strip_prefix("0b").or_else(|| s.strip_prefix("0B")) {
        (2, d)
    } else if let Some(d) = s.strip_prefix("0o").or_else(|| s.strip_prefix("0O")) {
        (8, d)
    } else {
        (10, s)
    }
}

/// Parse an integer from its raw string representation.
///
/// Handles decimal, hex (0x), binary (0b), octal (0o), and underscores.
/// Returns the magnitude and sign separately for flexible fitting into target types.
pub fn parse_int_raw(raw: &str) -> Result<ParsedInt> {
    let raw = raw.trim();
    let (negative, unsigned_raw) = match raw.strip_prefix('-') {
        Some(r) => (true, r),
        None => (false, raw),
    };

    let magnitude = if unsigned_raw.contains('_') {
        // Slow path: filter underscores
        let cleaned: alloc::string::String = unsigned_raw.chars().filter(|&c| c != '_').collect();
        let (base, digits) = determine_base_and_digits(&cleaned);
        u128::from_str_radix(digits, base)
    } else {
        // Fast path: no underscores (common case)
        let (base, digits) = determine_base_and_digits(unsigned_raw);
        u128::from_str_radix(digits, base)
    }
    .map_err(|_| {
        Error::new(ErrorKind::IntegerOutOfBounds {
            value: raw.to_string().into(),
            target_type: "u128",
        })
    })?;

    Ok(ParsedInt {
        magnitude,
        negative,
    })
}

/// Parse an integer from a raw string representation into a specific type.
pub(crate) fn parse_integer_from_raw<T>(
    raw: &str,
    kind: &NumberKind,
    target_type: &'static str,
) -> Result<T>
where
    T: TryFrom<i128> + TryFrom<u128>,
{
    let raw_trimmed = raw.trim();
    match kind {
        NumberKind::Integer => {
            let parsed = parse_int_raw(raw)?;
            T::try_from(parsed.magnitude).map_err(|_| {
                Error::new(ErrorKind::IntegerOutOfBounds {
                    value: raw_trimmed.to_string().into(),
                    target_type,
                })
            })
        }
        NumberKind::NegativeInteger => {
            let parsed = parse_int_raw(raw)?;
            // Convert magnitude to signed and negate
            let val = i128::try_from(parsed.magnitude).map_err(|_| {
                Error::new(ErrorKind::IntegerOutOfBounds {
                    value: raw_trimmed.to_string().into(),
                    target_type,
                })
            })?;
            let val = -val;
            T::try_from(val).map_err(|_| {
                Error::new(ErrorKind::IntegerOutOfBounds {
                    value: raw_trimmed.to_string().into(),
                    target_type,
                })
            })
        }
        NumberKind::Float | NumberKind::SpecialFloat => Err(Error::new(ErrorKind::TypeMismatch {
            expected: "integer".into(),
            found: "float".into(),
        })),
    }
}

/// Parse a float from a raw string representation.
pub(crate) fn parse_float_from_raw(raw: &str, kind: &NumberKind) -> Result<f64> {
    let raw = raw.trim();
    match kind {
        NumberKind::SpecialFloat => match raw {
            "inf" => Ok(f64::INFINITY),
            "-inf" => Ok(f64::NEG_INFINITY),
            "NaN" => Ok(f64::NAN),
            _ => Err(Error::new(ErrorKind::TypeMismatch {
                expected: "float".into(),
                found: raw.into(),
            })),
        },
        NumberKind::Float | NumberKind::Integer | NumberKind::NegativeInteger => {
            if raw.contains('_') {
                // Slow path: filter underscores
                let cleaned: alloc::string::String = raw.chars().filter(|&c| c != '_').collect();
                cleaned.parse().map_err(|_| {
                    Error::new(ErrorKind::TypeMismatch {
                        expected: "float".into(),
                        found: raw.into(),
                    })
                })
            } else {
                // Fast path: no underscores (common case)
                raw.parse().map_err(|_| {
                    Error::new(ErrorKind::TypeMismatch {
                        expected: "float".into(),
                        found: raw.into(),
                    })
                })
            }
        }
    }
}