boa_parser 0.21.1

ECMAScript parser for the Boa JavaScript engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::parser::tests::check_script_parser;
use boa_ast::{
    Declaration, Expression, Span, Statement, StatementList, StatementListItem,
    declaration::{LexicalDeclaration, Variable},
    expression::{Identifier, Yield, literal::Literal},
    function::{FormalParameterList, FunctionBody, GeneratorExpression},
};
use boa_interner::Interner;
use boa_macros::utf16;
use indoc::indoc;

const PSEUDO_LINEAR_POS: boa_ast::LinearPosition = boa_ast::LinearPosition::new(0);
const EMPTY_LINEAR_SPAN: boa_ast::LinearSpan =
    boa_ast::LinearSpan::new(PSEUDO_LINEAR_POS, PSEUDO_LINEAR_POS);

#[test]
fn check_generator_function_expression() {
    let interner = &mut Interner::default();
    let r#gen = interner.get_or_intern_static("gen", utf16!("gen"));
    check_script_parser(
        indoc! {"
            const gen = function*() {
                yield 1;
            };
        "},
        vec![
            Declaration::Lexical(LexicalDeclaration::Const(
                vec![Variable::from_identifier(
                    Identifier::new(r#gen, Span::new((1, 7), (1, 10))),
                    Some(
                        GeneratorExpression::new(
                            Some(Identifier::new(r#gen, Span::new((1, 7), (1, 10)))),
                            FormalParameterList::default(),
                            FunctionBody::new(
                                StatementList::new(
                                    [StatementListItem::Statement(
                                        Statement::Expression(Expression::from(Yield::new(
                                            Some(
                                                Literal::new(1, Span::new((2, 11), (2, 12))).into(),
                                            ),
                                            false,
                                            Span::new((2, 5), (2, 12)),
                                        )))
                                        .into(),
                                    )],
                                    PSEUDO_LINEAR_POS,
                                    false,
                                ),
                                Span::new((1, 25), (3, 2)),
                            ),
                            EMPTY_LINEAR_SPAN,
                            false,
                            Span::new((1, 13), (3, 2)),
                        )
                        .into(),
                    ),
                )]
                .try_into()
                .unwrap(),
            ))
            .into(),
        ],
        interner,
    );
}

#[test]
fn check_generator_function_delegate_yield_expression() {
    let interner = &mut Interner::default();
    let r#gen = interner.get_or_intern_static("gen", utf16!("gen"));
    check_script_parser(
        indoc! {"
            const gen = function*() {
                yield* 1;
            };
        "},
        vec![
            Declaration::Lexical(LexicalDeclaration::Const(
                vec![Variable::from_identifier(
                    Identifier::new(r#gen, Span::new((1, 7), (1, 10))),
                    Some(
                        GeneratorExpression::new(
                            Some(Identifier::new(r#gen, Span::new((1, 7), (1, 10)))),
                            FormalParameterList::default(),
                            FunctionBody::new(
                                StatementList::new(
                                    [StatementListItem::Statement(
                                        Statement::Expression(Expression::from(Yield::new(
                                            Some(
                                                Literal::new(1, Span::new((2, 12), (2, 13))).into(),
                                            ),
                                            true,
                                            Span::new((2, 5), (2, 13)),
                                        )))
                                        .into(),
                                    )],
                                    PSEUDO_LINEAR_POS,
                                    false,
                                ),
                                Span::new((1, 25), (3, 2)),
                            ),
                            EMPTY_LINEAR_SPAN,
                            false,
                            Span::new((1, 13), (3, 2)),
                        )
                        .into(),
                    ),
                )]
                .try_into()
                .unwrap(),
            ))
            .into(),
        ],
        interner,
    );
}