jetcrab\parser\expressions/
unary.rs

1use crate::ast::{CallExpression, MemberExpression, Node, UnaryExpression, UpdateExpression};
2use crate::lexer::TokenKind;
3use crate::parser::error::ParseResult;
4use crate::parser::Parser;
5
6impl Parser {
7    pub fn parse_unary_expression(&mut self) -> ParseResult<Node> {
8        if self.is_unary_operator() {
9            let operator = self.current_token_string();
10            let prefix = true;
11            self.advance();
12            let argument = Box::new(self.parse_unary_expression()?);
13
14            let span = self.create_span_from_tokens();
15            return Ok(Node::UnaryExpression(UnaryExpression {
16                operator,
17                argument,
18                prefix,
19                span: Some(span),
20            }));
21        }
22
23        self.parse_postfix_expression()
24    }
25
26    pub fn parse_postfix_expression(&mut self) -> ParseResult<Node> {
27        let mut expr = self.parse_primary_expression()?;
28
29        while let Some(token) = &self.current {
30            match &token.kind {
31                TokenKind::LeftBracket => {
32                    self.advance();
33                    let property = Box::new(self.parse_expression()?);
34                    self.expect(TokenKind::RightBracket)?;
35
36                    let span = self.create_span_from_tokens();
37                    expr = Node::MemberExpression(MemberExpression {
38                        object: Box::new(expr),
39                        property,
40                        computed: true,
41                        optional: false,
42                        span: Some(span),
43                    });
44                }
45
46                TokenKind::Dot => {
47                    self.advance();
48                    let property = Box::new(self.parse_identifier()?);
49
50                    let span = self.create_span_from_tokens();
51                    expr = Node::MemberExpression(MemberExpression {
52                        object: Box::new(expr),
53                        property,
54                        computed: false,
55                        optional: false,
56                        span: Some(span),
57                    });
58                }
59
60                TokenKind::LeftParen => {
61                    self.advance();
62                    let arguments = self.parse_arguments()?;
63                    self.expect(TokenKind::RightParen)?;
64
65                    let span = self.create_span_from_tokens();
66                    expr = Node::CallExpression(CallExpression {
67                        callee: Box::new(expr),
68                        arguments,
69                        span: Some(span),
70                    });
71                }
72
73                TokenKind::Increment | TokenKind::Decrement => {
74                    let operator = self.current_token_string();
75                    let prefix = false;
76                    self.advance();
77
78                    let span = self.create_span_from_tokens();
79                    expr = Node::UpdateExpression(UpdateExpression {
80                        operator,
81                        argument: Box::new(expr),
82                        prefix,
83                        span: Some(span),
84                    });
85                }
86
87                _ => break,
88            }
89        }
90
91        Ok(expr)
92    }
93}
jetcrab\parser\expressions/unary.rs

jetcrab\parser\expressions/
unary.rs
