solar_parse/parser/
ty.rs

1use super::item::FunctionFlags;
2use crate::{PResult, Parser};
3use solar_ast::{token::*, *};
4use solar_interface::kw;
5use std::{fmt, ops::RangeInclusive};
6
7impl<'sess, 'ast, 'cb> Parser<'sess, 'ast, 'cb> {
8    /// Parses a type.
9    #[instrument(level = "trace", skip_all)]
10    pub fn parse_type(&mut self) -> PResult<'sess, Type<'ast>> {
11        let mut ty = self
12            .parse_spanned(Self::parse_basic_ty_kind)
13            .map(|(span, kind)| Type { span, kind })?;
14
15        // Parse suffixes.
16        while self.eat(TokenKind::OpenDelim(Delimiter::Bracket)) {
17            let size = if self.check_noexpect(TokenKind::CloseDelim(Delimiter::Bracket)) {
18                None
19            } else {
20                Some(self.parse_expr()?)
21            };
22            self.expect(TokenKind::CloseDelim(Delimiter::Bracket))?;
23            ty = Type {
24                span: ty.span.to(self.prev_token.span),
25                kind: TypeKind::Array(self.alloc(TypeArray { element: ty, size })),
26            };
27        }
28
29        Ok(ty)
30    }
31
32    /// Parses a type kind. Does not parse suffixes.
33    fn parse_basic_ty_kind(&mut self) -> PResult<'sess, TypeKind<'ast>> {
34        if self.check_elementary_type() {
35            self.parse_elementary_type().map(TypeKind::Elementary)
36        } else if self.eat_keyword(kw::Function) {
37            self.parse_function_header(FunctionFlags::FUNCTION_TY).map(|f| {
38                let FunctionHeader {
39                    span: _,
40                    name: _,
41                    parameters,
42                    visibility,
43                    state_mutability,
44                    modifiers: _,
45                    virtual_: _,
46                    override_: _,
47                    returns,
48                } = f;
49                TypeKind::Function(self.alloc(TypeFunction {
50                    parameters,
51                    visibility,
52                    state_mutability,
53                    returns,
54                }))
55            })
56        } else if self.eat_keyword(kw::Mapping) {
57            self.parse_mapping_type().map(|x| TypeKind::Mapping(self.alloc(x)))
58        } else if self.check_path() {
59            self.parse_path().map(TypeKind::Custom)
60        } else {
61            self.unexpected()
62        }
63    }
64
65    /// Parses an elementary type.
66    ///
67    /// Must be used after checking that the next token is an elementary type.
68    pub(super) fn parse_elementary_type(&mut self) -> PResult<'sess, ElementaryType> {
69        let id = self.parse_ident_any()?;
70        debug_assert!(id.is_elementary_type());
71        let mut ty = match id.name {
72            kw::Address => ElementaryType::Address(false),
73            kw::Bool => ElementaryType::Bool,
74            kw::String => ElementaryType::String,
75            kw::Bytes => ElementaryType::Bytes,
76            kw::Fixed => ElementaryType::Fixed(TypeSize::ZERO, TypeFixedSize::ZERO),
77            kw::UFixed => ElementaryType::UFixed(TypeSize::ZERO, TypeFixedSize::ZERO),
78            kw::Int => ElementaryType::Int(TypeSize::ZERO),
79            kw::UInt => ElementaryType::UInt(TypeSize::ZERO),
80            s if s >= kw::UInt8 && s <= kw::UInt256 => {
81                let bits = (s.as_u32() - kw::UInt8.as_u32() + 1) * 8;
82                ElementaryType::UInt(TypeSize::new_int_bits(bits as u16))
83            }
84            s if s >= kw::Int8 && s <= kw::Int256 => {
85                let bits = (s.as_u32() - kw::Int8.as_u32() + 1) * 8;
86                ElementaryType::Int(TypeSize::new_int_bits(bits as u16))
87            }
88            s if s >= kw::Bytes1 && s <= kw::Bytes32 => {
89                let bytes = s.as_u32() - kw::Bytes1.as_u32() + 1;
90                ElementaryType::FixedBytes(TypeSize::new_fb_bytes(bytes as u8))
91            }
92            s => unreachable!("unexpected elementary type: {s}"),
93        };
94
95        let sm = self.parse_state_mutability();
96        match (&mut ty, sm) {
97            (ElementaryType::Address(p), Some(StateMutability::Payable)) => *p = true,
98            (_, None) => {}
99            (_, Some(_)) => {
100                let msg = if matches!(ty, ElementaryType::Address(_)) {
101                    "address types can only be payable or non-payable"
102                } else {
103                    "only address types can have state mutability"
104                };
105                self.dcx().emit_err(id.span.to(self.prev_token.span), msg);
106            }
107        }
108
109        // TODO: Move to type checking.
110        // if matches!(ty, ElementaryType::Fixed(..) | ElementaryType::UFixed(..)) {
111        //     self.dcx().emit_err(id.span, "`fixed` types are not yet supported");
112        // }
113
114        Ok(ty)
115    }
116
117    /// Parses a mapping type.
118    fn parse_mapping_type(&mut self) -> PResult<'sess, TypeMapping<'ast>> {
119        self.expect(TokenKind::OpenDelim(Delimiter::Parenthesis))?;
120
121        let key = self.parse_type()?;
122        let key_name = self.parse_ident_opt()?;
123
124        self.expect(TokenKind::FatArrow)?;
125
126        let value = self.parse_type()?;
127        let value_name = self.parse_ident_opt()?;
128
129        self.expect(TokenKind::CloseDelim(Delimiter::Parenthesis))?;
130
131        Ok(TypeMapping { key, key_name, value, value_name })
132    }
133}
134
135#[derive(Debug, PartialEq)]
136enum ParseTySizeError {
137    Parse(std::num::ParseIntError),
138    TryFrom(std::num::TryFromIntError),
139    NotMultipleOf8,
140    OutOfRange(RangeInclusive<u16>),
141    FixedX,
142}
143
144impl fmt::Display for ParseTySizeError {
145    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
146        match self {
147            Self::Parse(e) => e.fmt(f),
148            Self::TryFrom(e) => e.fmt(f),
149            Self::NotMultipleOf8 => f.write_str("number must be a multiple of 8"),
150            Self::OutOfRange(range) => {
151                write!(f, "size is out of range of {}:{} (inclusive)", range.start(), range.end())
152            }
153            Self::FixedX => f.write_str("`fixed` sizes must be separated by exactly one 'x'"),
154        }
155    }
156}
157
158/// Parses `fixedMxN` or `ufixedMxN`.
159#[allow(dead_code)]
160fn parse_fixed_type(original: &str) -> Result<Option<ElementaryType>, ParseTySizeError> {
161    let s = original;
162    let tmp = s.strip_prefix('u');
163    let unsigned = tmp.is_some();
164    let s = tmp.unwrap_or(s);
165
166    if let Some(s) = s.strip_prefix("fixed") {
167        debug_assert!(!s.is_empty());
168        let (m, n) = parse_fixed_size(s)?;
169        return Ok(Some(if unsigned {
170            ElementaryType::UFixed(m, n)
171        } else {
172            ElementaryType::Fixed(m, n)
173        }));
174    }
175
176    Ok(None)
177}
178
179#[allow(dead_code)]
180fn parse_fb_size(s: &str) -> Result<TypeSize, ParseTySizeError> {
181    parse_ty_size_u8(s, 1..=32, false).map(|x| TypeSize::new_fb_bytes(x))
182}
183
184#[allow(dead_code)]
185fn parse_int_size(s: &str) -> Result<TypeSize, ParseTySizeError> {
186    parse_ty_size_u8(s, 1..=32, true).map(|x| TypeSize::new_int_bits(x as u16 * 8))
187}
188
189#[allow(dead_code)]
190fn parse_fixed_size(s: &str) -> Result<(TypeSize, TypeFixedSize), ParseTySizeError> {
191    let (m, n) = s.split_once('x').ok_or(ParseTySizeError::FixedX)?;
192    let m = parse_int_size(m)?;
193    let n = parse_ty_size_u8(n, 0..=80, false)?;
194    let n = TypeFixedSize::new(n).unwrap();
195    Ok((m, n))
196}
197
198/// Parses a type size.
199///
200/// If `to_bytes` is true, the size is checked to be a multiple of 8 and then converted from
201/// bits to bytes.
202///
203/// The final **converted** size must be in the range `range`. This means that if `to_bytes` is
204/// true, the range must be in bytes and not bits.
205fn parse_ty_size_u8(
206    s: &str,
207    real_range: RangeInclusive<u8>,
208    to_bytes: bool,
209) -> Result<u8, ParseTySizeError> {
210    let mut n = s.parse::<u16>().map_err(ParseTySizeError::Parse)?;
211
212    if to_bytes {
213        if !n.is_multiple_of(8) {
214            return Err(ParseTySizeError::NotMultipleOf8);
215        }
216        n /= 8;
217    }
218
219    let n = u8::try_from(n).map_err(ParseTySizeError::TryFrom)?;
220
221    if !real_range.contains(&n) {
222        let display_range = if to_bytes {
223            *real_range.start() as u16 * 8..=*real_range.end() as u16 * 8
224        } else {
225            *real_range.start() as u16..=*real_range.end() as u16
226        };
227        return Err(ParseTySizeError::OutOfRange(display_range));
228    }
229
230    Ok(n)
231}
232
233#[cfg(test)]
234mod tests {
235    use super::*;
236
237    #[test]
238    fn parse_size() {
239        use ParseTySizeError::*;
240
241        assert_eq!(parse_ty_size_u8("0", 0..=1, false), Ok(0));
242        assert_eq!(parse_ty_size_u8("1", 0..=1, false), Ok(1));
243        assert_eq!(parse_ty_size_u8("0", 0..=1, true), Ok(0));
244        assert_eq!(parse_ty_size_u8("1", 0..=1, true), Err(NotMultipleOf8));
245        assert_eq!(parse_ty_size_u8("8", 0..=1, true), Ok(1));
246
247        assert_eq!(parse_ty_size_u8("0", 1..=32, false), Err(OutOfRange(1..=32)));
248        assert_eq!(parse_ty_size_u8("0", 1..=32, true), Err(OutOfRange(8..=256)));
249        for n in 1..=32 {
250            assert_eq!(parse_ty_size_u8(&n.to_string(), 1..=32, false), Ok(n as u8));
251            for m in 1..=7u16 {
252                assert_eq!(
253                    parse_ty_size_u8(&((n - 1) * 8 + m).to_string(), 1..=32, true),
254                    Err(NotMultipleOf8)
255                );
256            }
257            assert_eq!(parse_ty_size_u8(&(n * 8).to_string(), 1..=32, true), Ok(n as u8));
258        }
259    }
260}
solar_parse/parser/ty.rs

solar_parse/parser/
ty.rs
