solar_parse/parser/
stmt.rs

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

solar_parse/parser/
stmt.rs
