leo_ast/expressions/
literal.rs

1// Copyright (C) 2019-2025 Provable Inc.
2// This file is part of the Leo library.
3
4// The Leo library is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8
9// The Leo library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12// GNU General Public License for more details.
13
14// You should have received a copy of the GNU General Public License
15// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
16
17use crate::IntegerType;
18
19use super::*;
20
21/// A literal.
22#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
23pub struct Literal {
24    pub span: Span,
25    pub id: NodeID,
26    pub variant: LiteralVariant,
27}
28
29#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, Serialize, Deserialize)]
30pub enum LiteralVariant {
31    /// An address literal, e.g., `aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8s7pyjh9` or `hello.aleo`.
32    Address(String),
33    /// A boolean literal, either `true` or `false`.
34    Boolean(bool),
35    /// A field literal, e.g., `42field`.
36    /// A signed number followed by the keyword `field`.
37    Field(String),
38    /// A group literal, eg `42group`.
39    Group(String),
40    /// An integer literal, e.g., `42u32`.
41    Integer(IntegerType, String),
42    /// A literal `None` for optional types.
43    None,
44    /// A scalar literal, e.g. `1scalar`.
45    /// An unsigned number followed by the keyword `scalar`.
46    Scalar(String),
47    /// An unsuffixed literal, e.g. `42` (without a type suffix)
48    Unsuffixed(String),
49    /// A string literal, e.g., `"foobar"`.
50    String(String),
51}
52
53impl fmt::Display for LiteralVariant {
54    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
55        match &self {
56            Self::Address(address) => write!(f, "{address}"),
57            Self::Boolean(boolean) => write!(f, "{boolean}"),
58            Self::Field(field) => write!(f, "{field}field"),
59            Self::Group(group) => write!(f, "{group}group"),
60            Self::Integer(type_, value) => write!(f, "{value}{type_}"),
61            Self::None => write!(f, "none"),
62            Self::Scalar(scalar) => write!(f, "{scalar}scalar"),
63            Self::Unsuffixed(value) => write!(f, "{value}"),
64            Self::String(string) => write!(f, "\"{string}\""),
65        }
66    }
67}
68
69impl fmt::Display for Literal {
70    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
71        self.variant.fmt(f)
72    }
73}
74
75crate::simple_node_impl!(Literal);
76
77impl Literal {
78    pub fn string(s: String, span: Span, id: NodeID) -> Self {
79        Literal { variant: LiteralVariant::String(s), span, id }
80    }
81
82    pub fn field(s: String, span: Span, id: NodeID) -> Self {
83        Literal { variant: LiteralVariant::Field(s), span, id }
84    }
85
86    pub fn group(s: String, span: Span, id: NodeID) -> Self {
87        Literal { variant: LiteralVariant::Group(s), span, id }
88    }
89
90    pub fn address(s: String, span: Span, id: NodeID) -> Self {
91        Literal { variant: LiteralVariant::Address(s), span, id }
92    }
93
94    pub fn scalar(s: String, span: Span, id: NodeID) -> Self {
95        Literal { variant: LiteralVariant::Scalar(s), span, id }
96    }
97
98    pub fn boolean(s: bool, span: Span, id: NodeID) -> Self {
99        Literal { variant: LiteralVariant::Boolean(s), span, id }
100    }
101
102    pub fn integer(integer_type: IntegerType, s: String, span: Span, id: NodeID) -> Self {
103        Literal { variant: LiteralVariant::Integer(integer_type, s), span, id }
104    }
105
106    pub fn unsuffixed(s: String, span: Span, id: NodeID) -> Self {
107        Literal { variant: LiteralVariant::Unsuffixed(s), span, id }
108    }
109
110    pub fn none(span: Span, id: NodeID) -> Self {
111        Literal { variant: LiteralVariant::None, span, id }
112    }
113
114    /// For an integer literal, parse it and cast it to a u32.
115    pub fn as_u32(&self) -> Option<u32> {
116        if let LiteralVariant::Integer(_, s) = &self.variant {
117            u32::from_str_by_radix(&s.replace("_", "")).ok()
118        } else {
119            None
120        }
121    }
122}
123
124impl From<Literal> for Expression {
125    fn from(value: Literal) -> Self {
126        Expression::Literal(value)
127    }
128}
129
130/// This trait allows to parse integer literals of any type generically.
131///
132/// The literal may optionally start with a `-` and/or `0x` or `0o` or 0b`.
133pub trait FromStrRadix: Sized {
134    fn from_str_by_radix(src: &str) -> Result<Self, std::num::ParseIntError>;
135}
136
137macro_rules! implement_from_str_radix {
138    ($($ty:ident)*) => {
139        $(
140            impl FromStrRadix for $ty {
141                fn from_str_by_radix(src: &str) -> Result<Self, std::num::ParseIntError> {
142                    if let Some(stripped) = src.strip_prefix("0x") {
143                        Self::from_str_radix(stripped, 16)
144                    } else if let Some(stripped) = src.strip_prefix("0o") {
145                        Self::from_str_radix(stripped, 8)
146                    } else if let Some(stripped) = src.strip_prefix("0b") {
147                        Self::from_str_radix(stripped, 2)
148                    } else if let Some(stripped) = src.strip_prefix("-0x") {
149                        // We have to remove the 0x prefix and put back in a - to use
150                        // std's parsing. Alternatively we could jump through
151                        // a few hoops to avoid allocating.
152                        let mut s = String::new();
153                        s.push('-');
154                        s.push_str(stripped);
155                        Self::from_str_radix(&s, 16)
156                    } else if let Some(stripped) = src.strip_prefix("-0o") {
157                        // Ditto.
158                        let mut s = String::new();
159                        s.push('-');
160                        s.push_str(stripped);
161                        Self::from_str_radix(&s, 8)
162                    } else if let Some(stripped) = src.strip_prefix("-0b") {
163                        // Ditto.
164                        let mut s = String::new();
165                        s.push('-');
166                        s.push_str(stripped);
167                        Self::from_str_radix(&s, 2)
168                    } else {
169                        Self::from_str_radix(src, 10)
170                    }
171                }
172            }
173        )*
174    };
175}
176
177implement_from_str_radix! { u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 }
leo_ast/expressions/literal.rs

leo_ast/expressions/
literal.rs
