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

solar_parse/parser/
stmt.rs
