solar_parse/parser/
stmt.rs

1use super::item::VarFlags;
2use crate::{parser::SeqSep, PResult, Parser};
3use smallvec::SmallVec;
4use solar_ast::{token::*, *};
5use solar_data_structures::BumpExt;
6use solar_interface::{kw, sym, Ident, Span};
7
8impl<'sess, 'ast> Parser<'sess, 'ast> {
9    /// Parses a statement.
10    #[instrument(level = "debug", skip_all)]
11    pub fn parse_stmt(&mut self) -> PResult<'sess, Stmt<'ast>> {
12        let docs = self.parse_doc_comments();
13        self.parse_spanned(Self::parse_stmt_kind).map(|(span, kind)| Stmt { docs, kind, span })
14    }
15
16    /// Parses a statement into a new allocation.
17    pub fn parse_stmt_boxed(&mut self) -> PResult<'sess, Box<'ast, Stmt<'ast>>> {
18        self.parse_stmt().map(|stmt| self.alloc(stmt))
19    }
20
21    /// Parses a statement kind.
22    fn parse_stmt_kind(&mut self) -> PResult<'sess, StmtKind<'ast>> {
23        let mut semi = true;
24        let kind = if self.eat_keyword(kw::If) {
25            semi = false;
26            self.parse_stmt_if()
27        } else if self.eat_keyword(kw::While) {
28            semi = false;
29            self.parse_stmt_while()
30        } else if self.eat_keyword(kw::Do) {
31            self.parse_stmt_do_while()
32        } else if self.eat_keyword(kw::For) {
33            semi = false;
34            self.parse_stmt_for()
35        } else if self.eat_keyword(kw::Unchecked) {
36            semi = false;
37            self.parse_block().map(StmtKind::UncheckedBlock)
38        } else if self.check(TokenKind::OpenDelim(Delimiter::Brace)) {
39            semi = false;
40            self.parse_block().map(StmtKind::Block)
41        } else if self.eat_keyword(kw::Continue) {
42            Ok(StmtKind::Continue)
43        } else if self.eat_keyword(kw::Break) {
44            Ok(StmtKind::Break)
45        } else if self.eat_keyword(kw::Return) {
46            let expr = if self.check(TokenKind::Semi) { None } else { Some(self.parse_expr()?) };
47            Ok(StmtKind::Return(expr))
48        } else if self.eat_keyword(kw::Throw) {
49            let msg = "`throw` statements have been removed; use `revert`, `require`, or `assert` instead";
50            Err(self.dcx().err(msg).span(self.prev_token.span))
51        } else if self.eat_keyword(kw::Try) {
52            semi = false;
53            self.parse_stmt_try().map(|stmt| StmtKind::Try(self.alloc(stmt)))
54        } else if self.eat_keyword(kw::Assembly) {
55            semi = false;
56            self.parse_stmt_assembly().map(StmtKind::Assembly)
57        } else if self.eat_keyword(kw::Emit) {
58            self.parse_path_call().map(|(path, params)| StmtKind::Emit(path, params))
59        } else if self.check_keyword(kw::Revert) && self.look_ahead(1).is_ident() {
60            self.bump(); // `revert`
61            self.parse_path_call().map(|(path, params)| StmtKind::Revert(path, params))
62        } else if self.check_keyword(sym::underscore) && self.look_ahead(1).kind == TokenKind::Semi
63        {
64            self.bump(); // `_`
65            Ok(StmtKind::Placeholder)
66        } else {
67            self.parse_simple_stmt_kind()
68        };
69        if semi && kind.is_ok() {
70            self.expect_semi()?;
71        }
72        kind
73    }
74
75    /// Parses a block of statements.
76    pub(super) fn parse_block(&mut self) -> PResult<'sess, Block<'ast>> {
77        self.parse_delim_seq(Delimiter::Brace, SeqSep::none(), true, Self::parse_stmt)
78    }
79
80    /// Parses an if statement.
81    fn parse_stmt_if(&mut self) -> PResult<'sess, StmtKind<'ast>> {
82        self.expect(TokenKind::OpenDelim(Delimiter::Parenthesis))?;
83        let expr = self.parse_expr()?;
84        self.expect(TokenKind::CloseDelim(Delimiter::Parenthesis))?;
85        let true_stmt = self.parse_stmt()?;
86        let else_stmt =
87            if self.eat_keyword(kw::Else) { Some(self.parse_stmt_boxed()?) } else { None };
88        Ok(StmtKind::If(expr, self.alloc(true_stmt), else_stmt))
89    }
90
91    /// Parses a while statement.
92    fn parse_stmt_while(&mut self) -> PResult<'sess, StmtKind<'ast>> {
93        self.expect(TokenKind::OpenDelim(Delimiter::Parenthesis))?;
94        let expr = self.parse_expr()?;
95        self.expect(TokenKind::CloseDelim(Delimiter::Parenthesis))?;
96        let stmt = self.parse_stmt()?;
97        Ok(StmtKind::While(expr, self.alloc(stmt)))
98    }
99
100    /// Parses a do-while statement.
101    fn parse_stmt_do_while(&mut self) -> PResult<'sess, StmtKind<'ast>> {
102        let stmt = self.parse_stmt()?;
103        let stmt = self.alloc(stmt);
104        self.expect_keyword(kw::While)?;
105        self.expect(TokenKind::OpenDelim(Delimiter::Parenthesis))?;
106        let expr = self.parse_expr()?;
107        self.expect(TokenKind::CloseDelim(Delimiter::Parenthesis))?;
108        Ok(StmtKind::DoWhile(stmt, expr))
109    }
110
111    /// Parses a for statement.
112    fn parse_stmt_for(&mut self) -> PResult<'sess, StmtKind<'ast>> {
113        self.expect(TokenKind::OpenDelim(Delimiter::Parenthesis))?;
114
115        let init = if self.check(TokenKind::Semi) { None } else { Some(self.parse_simple_stmt()?) };
116        self.expect(TokenKind::Semi)?;
117
118        let cond = if self.check(TokenKind::Semi) { None } else { Some(self.parse_expr()?) };
119        self.expect_semi()?;
120
121        let next = if self.check_noexpect(TokenKind::CloseDelim(Delimiter::Parenthesis)) {
122            None
123        } else {
124            Some(self.parse_expr()?)
125        };
126        self.expect(TokenKind::CloseDelim(Delimiter::Parenthesis))?;
127        let body = self.parse_stmt_boxed()?;
128        Ok(StmtKind::For { init: init.map(|init| self.alloc(init)), cond, next, body })
129    }
130
131    /// Parses a try statement.
132    fn parse_stmt_try(&mut self) -> PResult<'sess, StmtTry<'ast>> {
133        let expr = self.parse_expr()?;
134
135        let mut clauses = SmallVec::<[_; 4]>::new();
136        let returns = if self.eat_keyword(kw::Returns) {
137            self.parse_parameter_list(false, VarFlags::FUNCTION)?
138        } else {
139            Default::default()
140        };
141        let block = self.parse_block()?;
142        clauses.push(TryCatchClause { name: None, args: returns, block });
143
144        self.expect_keyword(kw::Catch)?;
145        loop {
146            let name = self.parse_ident_opt()?;
147            let args = if self.check(TokenKind::OpenDelim(Delimiter::Parenthesis)) {
148                self.parse_parameter_list(false, VarFlags::FUNCTION)?
149            } else {
150                Default::default()
151            };
152            let block = self.parse_block()?;
153            clauses.push(TryCatchClause { name, args, block });
154            if !self.eat_keyword(kw::Catch) {
155                break;
156            }
157        }
158
159        let clauses = self.alloc_smallvec(clauses);
160        Ok(StmtTry { expr, clauses })
161    }
162
163    /// Parses an assembly block.
164    fn parse_stmt_assembly(&mut self) -> PResult<'sess, StmtAssembly<'ast>> {
165        let dialect = self.parse_str_lit_opt();
166        let flags = if self.check(TokenKind::OpenDelim(Delimiter::Parenthesis)) {
167            self.parse_paren_comma_seq(false, Self::parse_str_lit)?
168        } else {
169            Default::default()
170        };
171        let block = self.parse_yul_block()?;
172        Ok(StmtAssembly { dialect, flags, block })
173    }
174
175    /// Parses a simple statement. These are just variable declarations and expressions.
176    fn parse_simple_stmt(&mut self) -> PResult<'sess, Stmt<'ast>> {
177        let docs = self.parse_doc_comments();
178        self.parse_spanned(Self::parse_simple_stmt_kind).map(|(span, kind)| Stmt {
179            docs,
180            kind,
181            span,
182        })
183    }
184
185    /// Parses a simple statement kind. These are just variable declarations and expressions.
186    ///
187    /// Also used in the for loop initializer. Does not parse the trailing semicolon.
188    fn parse_simple_stmt_kind(&mut self) -> PResult<'sess, StmtKind<'ast>> {
189        let lo = self.token.span;
190        if self.eat(TokenKind::OpenDelim(Delimiter::Parenthesis)) {
191            let mut empty_components = 0usize;
192            while self.eat(TokenKind::Comma) {
193                empty_components += 1;
194            }
195
196            let (statement_type, iap) = self.try_parse_iap()?;
197            match statement_type {
198                LookAheadInfo::VariableDeclaration => {
199                    let mut variables = smallvec_repeat_none(empty_components);
200                    let ty = iap.into_ty(self);
201                    variables
202                        .push(Some(self.parse_variable_definition_with(VarFlags::FUNCTION, ty)?));
203                    self.parse_optional_items_seq_required(
204                        Delimiter::Parenthesis,
205                        &mut variables,
206                        |this| this.parse_variable_definition(VarFlags::FUNCTION),
207                    )?;
208                    self.expect(TokenKind::Eq)?;
209                    let expr = self.parse_expr()?;
210                    Ok(StmtKind::DeclMulti(self.alloc_smallvec(variables), expr))
211                }
212                LookAheadInfo::Expression => {
213                    let mut components = smallvec_repeat_none(empty_components);
214                    let expr = iap.into_expr(self);
215                    components.push(Some(self.parse_expr_with(expr)?));
216                    self.parse_optional_items_seq_required(
217                        Delimiter::Parenthesis,
218                        &mut components,
219                        Self::parse_expr,
220                    )?;
221                    let partially_parsed = Expr {
222                        span: lo.to(self.prev_token.span),
223                        kind: ExprKind::Tuple(self.alloc_smallvec(components)),
224                    };
225                    self.parse_expr_with(Some(self.alloc(partially_parsed))).map(StmtKind::Expr)
226                }
227                LookAheadInfo::IndexAccessStructure => unreachable!(),
228            }
229        } else {
230            let (statement_type, iap) = self.try_parse_iap()?;
231            match statement_type {
232                LookAheadInfo::VariableDeclaration => {
233                    let ty = iap.into_ty(self);
234                    self.parse_variable_definition_with(VarFlags::VAR, ty)
235                        .map(|var| StmtKind::DeclSingle(self.alloc(var)))
236                }
237                LookAheadInfo::Expression => {
238                    let expr = iap.into_expr(self);
239                    self.parse_expr_with(expr).map(StmtKind::Expr)
240                }
241                LookAheadInfo::IndexAccessStructure => unreachable!(),
242            }
243        }
244    }
245
246    /// Parses a `delim`-delimited, comma-separated list of maybe-optional items.
247    /// E.g. `(a, b) => [Some, Some]`, `(, a,, b,) => [None, Some, None, Some, None]`.
248    pub(super) fn parse_optional_items_seq<T>(
249        &mut self,
250        delim: Delimiter,
251        mut f: impl FnMut(&mut Self) -> PResult<'sess, T>,
252    ) -> PResult<'sess, Box<'ast, [Option<T>]>> {
253        self.expect(TokenKind::OpenDelim(delim))?;
254        let mut out = SmallVec::<[_; 8]>::new();
255        while self.eat(TokenKind::Comma) {
256            out.push(None);
257        }
258        if !self.check(TokenKind::CloseDelim(delim)) {
259            out.push(Some(f(self)?));
260        }
261        self.parse_optional_items_seq_required(delim, &mut out, f)
262            .map(|()| self.alloc_smallvec(out))
263    }
264
265    fn parse_optional_items_seq_required<T>(
266        &mut self,
267        delim: Delimiter,
268        out: &mut SmallVec<[Option<T>; 8]>,
269        mut f: impl FnMut(&mut Self) -> PResult<'sess, T>,
270    ) -> PResult<'sess, ()> {
271        let close = TokenKind::CloseDelim(delim);
272        while !self.eat(close) {
273            self.expect(TokenKind::Comma)?;
274            if self.check(TokenKind::Comma) || self.check(close) {
275                out.push(None);
276            } else {
277                out.push(Some(f(self)?));
278            }
279        }
280        Ok(())
281    }
282
283    /// Parses a path and a list of call arguments.
284    fn parse_path_call(&mut self) -> PResult<'sess, (AstPath<'ast>, CallArgs<'ast>)> {
285        let path = self.parse_path()?;
286        let params = self.parse_call_args()?;
287        Ok((path, params))
288    }
289
290    /// Never returns `LookAheadInfo::IndexAccessStructure`.
291    fn try_parse_iap(&mut self) -> PResult<'sess, (LookAheadInfo, IndexAccessedPath<'ast>)> {
292        // https://github.com/ethereum/solidity/blob/194b114664c7daebc2ff68af3c573272f5d28913/libsolidity/parsing/Parser.cpp#L1961
293        if let ty @ (LookAheadInfo::VariableDeclaration | LookAheadInfo::Expression) =
294            self.peek_statement_type()
295        {
296            return Ok((ty, IndexAccessedPath::default()));
297        }
298
299        let iap = self.parse_iap()?;
300        let ty = if self.token.is_non_reserved_ident(self.in_yul)
301            || self.token.is_location_specifier()
302        {
303            // `a.b memory`, `a[b] c`
304            LookAheadInfo::VariableDeclaration
305        } else {
306            LookAheadInfo::Expression
307        };
308        Ok((ty, iap))
309    }
310
311    fn peek_statement_type(&mut self) -> LookAheadInfo {
312        // https://github.com/ethereum/solidity/blob/194b114664c7daebc2ff68af3c573272f5d28913/libsolidity/parsing/Parser.cpp#L2528
313        if self.token.is_keyword_any(&[kw::Mapping, kw::Function]) {
314            return LookAheadInfo::VariableDeclaration;
315        }
316
317        if self.check_nr_ident() || self.check_elementary_type() {
318            let next = self.look_ahead(1);
319            if self.token.is_elementary_type() && next.is_ident_where(|id| id.name == kw::Payable) {
320                return LookAheadInfo::VariableDeclaration;
321            }
322            if next.is_non_reserved_ident(self.in_yul)
323                || next.is_location_specifier()
324                // These aren't valid but we include them for a better error message.
325                || next.is_mutability_specifier()
326                || next.is_visibility_specifier()
327            {
328                return LookAheadInfo::VariableDeclaration;
329            }
330            if matches!(next.kind, TokenKind::OpenDelim(Delimiter::Bracket) | TokenKind::Dot) {
331                return LookAheadInfo::IndexAccessStructure;
332            }
333        }
334        LookAheadInfo::Expression
335    }
336
337    fn parse_iap(&mut self) -> PResult<'sess, IndexAccessedPath<'ast>> {
338        // https://github.com/ethereum/solidity/blob/194b114664c7daebc2ff68af3c573272f5d28913/libsolidity/parsing/Parser.cpp#L2559
339        let mut path = SmallVec::<[_; 4]>::new();
340        if self.check_nr_ident() {
341            path.push(IapKind::Member(self.parse_ident()?));
342            while self.eat(TokenKind::Dot) {
343                let id = self.ident_or_err(true)?;
344                if id.name != kw::Address && id.is_reserved(self.in_yul) {
345                    self.expected_ident_found_err().emit();
346                }
347                self.bump(); // `id`
348                path.push(IapKind::Member(id));
349            }
350        } else if self.check_elementary_type() {
351            let (span, kind) = self.parse_spanned(Self::parse_elementary_type)?;
352            path.push(IapKind::MemberTy(span, kind));
353        } else {
354            return self.unexpected();
355        }
356        let n_idents = path.len();
357
358        while self.check(TokenKind::OpenDelim(Delimiter::Bracket)) {
359            let (span, kind) = self.parse_spanned(Self::parse_expr_index_kind)?;
360            path.push(IapKind::Index(span, kind));
361        }
362
363        Ok(IndexAccessedPath { path, n_idents })
364    }
365}
366
367#[derive(Debug)]
368enum LookAheadInfo {
369    /// `a.b`, `a[b]`
370    IndexAccessStructure,
371    VariableDeclaration,
372    Expression,
373}
374
375#[derive(Debug)]
376enum IapKind<'ast> {
377    /// `[...]`
378    Index(Span, IndexKind<'ast>),
379    /// `<ident>` or `.<ident>`
380    Member(Ident),
381    /// `<ty>`
382    MemberTy(Span, ElementaryType),
383}
384
385#[derive(Debug, Default)]
386struct IndexAccessedPath<'ast> {
387    path: SmallVec<[IapKind<'ast>; 4]>,
388    /// The number of elements in `path` that are `IapKind::Member[Ty]` at the start.
389    n_idents: usize,
390}
391
392impl<'ast> IndexAccessedPath<'ast> {
393    fn into_ty(self, parser: &mut Parser<'_, 'ast>) -> Option<Type<'ast>> {
394        // https://github.com/ethereum/solidity/blob/194b114664c7daebc2ff68af3c573272f5d28913/libsolidity/parsing/Parser.cpp#L2617
395        let mut path = self.path.into_iter();
396        let first = path.next()?;
397
398        let mut ty = if let IapKind::MemberTy(span, kind) = first {
399            debug_assert_eq!(self.n_idents, 1);
400            Type { span, kind: TypeKind::Elementary(kind) }
401        } else {
402            debug_assert!(self.n_idents >= 1);
403            let first = std::iter::once(&first);
404            let path = first
405                .chain(path.as_slice())
406                .map(|x| match x {
407                    IapKind::Member(id) => *id,
408                    kind => unreachable!("{kind:?}"),
409                })
410                .take(self.n_idents);
411            let path = PathSlice::from_mut_slice(parser.arena.alloc_from_iter(path));
412            Type { span: path.span(), kind: TypeKind::Custom(path) }
413        };
414
415        for index in path.skip(self.n_idents - 1) {
416            let IapKind::Index(span, kind) = index else { panic!("parsed too much") };
417            let size = match kind {
418                IndexKind::Index(expr) => expr,
419                IndexKind::Range(l, r) => {
420                    let msg = "expected array length, got range expression";
421                    parser.dcx().err(msg).span(span).emit();
422                    l.or(r)
423                }
424            };
425            let span = ty.span.to(span);
426            ty =
427                Type { span, kind: TypeKind::Array(parser.alloc(TypeArray { element: ty, size })) };
428        }
429
430        Some(ty)
431    }
432
433    fn into_expr(self, parser: &mut Parser<'_, 'ast>) -> Option<Box<'ast, Expr<'ast>>> {
434        // https://github.com/ethereum/solidity/blob/194b114664c7daebc2ff68af3c573272f5d28913/libsolidity/parsing/Parser.cpp#L2658
435        let mut path = self.path.into_iter();
436
437        let mut expr = parser.alloc(match path.next()? {
438            IapKind::Member(ident) => Expr::from_ident(ident),
439            IapKind::MemberTy(span, kind) => {
440                Expr { span, kind: ExprKind::Type(Type { span, kind: TypeKind::Elementary(kind) }) }
441            }
442            IapKind::Index(..) => panic!("should not happen"),
443        });
444        for index in path {
445            expr = parser.alloc(match index {
446                IapKind::Member(ident) => {
447                    Expr { span: expr.span.to(ident.span), kind: ExprKind::Member(expr, ident) }
448                }
449                IapKind::MemberTy(..) => panic!("should not happen"),
450                IapKind::Index(span, kind) => {
451                    Expr { span: expr.span.to(span), kind: ExprKind::Index(expr, kind) }
452                }
453            });
454        }
455        Some(expr)
456    }
457}
458
459/// `T: !Clone`
460fn smallvec_repeat_none<T>(n: usize) -> SmallVec<[Option<T>; 8]> {
461    let mut v = SmallVec::with_capacity(n);
462    v.extend(std::iter::repeat_with(|| None).take(n));
463    v
464}
465
466#[cfg(test)]
467mod tests {
468    use super::*;
469    use solar_interface::{source_map::FileName, Result, Session};
470
471    #[test]
472    fn optional_items_seq() {
473        fn check(tests: &[(&str, &[Option<&str>])]) {
474            solar_interface::enter(|| -> Result {
475                let sess = Session::builder().with_test_emitter().build();
476                for (i, &(s, results)) in tests.iter().enumerate() {
477                    let name = i.to_string();
478                    let arena = Arena::new();
479                    let mut parser =
480                        Parser::from_source_code(&sess, &arena, FileName::Custom(name), s)?;
481
482                    let list = parser
483                        .parse_optional_items_seq(Delimiter::Parenthesis, Parser::parse_ident)
484                        .map_err(|e| e.emit())
485                        .unwrap_or_else(|_| panic!("src: {s:?}"));
486                    sess.dcx.has_errors().unwrap();
487                    let formatted: Vec<_> =
488                        list.iter().map(|o| o.as_ref().map(|i| i.as_str())).collect();
489                    assert_eq!(formatted.as_slice(), results, "{s:?}");
490                }
491                Ok(())
492            })
493            .unwrap();
494        }
495
496        check(&[
497            ("()", &[]),
498            ("(a)", &[Some("a")]),
499            // ("(,)", &[None, None]),
500            ("(a,)", &[Some("a"), None]),
501            ("(,b)", &[None, Some("b")]),
502            ("(a,b)", &[Some("a"), Some("b")]),
503            ("(a,b,)", &[Some("a"), Some("b"), None]),
504            // ("(,,)", &[None, None, None]),
505            ("(a,,)", &[Some("a"), None, None]),
506            ("(a,b,)", &[Some("a"), Some("b"), None]),
507            ("(a,b,c)", &[Some("a"), Some("b"), Some("c")]),
508            ("(,b,c)", &[None, Some("b"), Some("c")]),
509            ("(,,c)", &[None, None, Some("c")]),
510            ("(a,,c)", &[Some("a"), None, Some("c")]),
511        ]);
512    }
513}
solar_parse/parser/stmt.rs

solar_parse/parser/
stmt.rs
