vize_oxc_parser 0.457.0

Vize's fork of the Oxc parser with admission and observation APIs.
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

//! Direct, original-source slot parameter grammar. No wrapper or retry.

use std::any::Any;

use oxc_ast::ast::FormalParameters;
use oxc_diagnostics::Diagnostics;

use crate::{
    Parser, ParserConfig, ParserDiagnostic, ParserImpl, UniquePromise,
    config::{NoTokensParserConfig, RuntimeParserConfig, TokensParserConfig},
    diagnostics,
    lexer::Kind,
};

impl<'a, C: ParserConfig> Parser<'a, C> {
    /// Parse the entire original source as an arrow-function parameter list,
    /// retaining original spans, binding defaults, rest and TS annotations.
    /// This goal has an EOF delimiter; it adds no synthetic source or AST.
    pub fn parse_slot_parameters(self) -> Result<FormalParameters<'a>, Diagnostics> {
        let config: &dyn Any = &self.config;
        if config.is::<NoTokensParserConfig>() {
            parse_no_tokens(self.allocator, self.source_text, self.source_type, self.options)
        } else if config.is::<TokensParserConfig>() {
            parse_tokens(self.allocator, self.source_text, self.source_type, self.options)
        } else if let Some(&config) = config.downcast_ref::<RuntimeParserConfig>() {
            parse_runtime(self.allocator, self.source_text, self.source_type, self.options, config)
        } else {
            ParserImpl::<C>::new(
                self.allocator,
                self.source_text,
                self.source_type,
                self.options,
                self.config,
                UniquePromise::new(),
            )
            .parse_slot_parameters()
        }
    }
}

// Stock goals remain provider-instantiated, as the ordinary expression entry.
macro_rules! stock_goal {
    ($name:ident, $config:ident) => {
        #[inline(never)]
        fn $name<'a>(
            allocator: &'a oxc_allocator::Allocator,
            source: &'a str,
            source_type: oxc_span::SourceType,
            options: crate::ParseOptions,
        ) -> Result<FormalParameters<'a>, Diagnostics> {
            ParserImpl::<$config>::new(
                allocator,
                source,
                source_type,
                options,
                $config,
                UniquePromise::new(),
            )
            .parse_slot_parameters()
        }
    };
}
stock_goal!(parse_no_tokens, NoTokensParserConfig);
stock_goal!(parse_tokens, TokensParserConfig);

#[inline(never)]
fn parse_runtime<'a>(
    allocator: &'a oxc_allocator::Allocator,
    source: &'a str,
    source_type: oxc_span::SourceType,
    options: crate::ParseOptions,
    config: RuntimeParserConfig,
) -> Result<FormalParameters<'a>, Diagnostics> {
    ParserImpl::<RuntimeParserConfig>::new(
        allocator,
        source,
        source_type,
        options,
        config,
        UniquePromise::new(),
    )
    .parse_slot_parameters()
}

impl<'a, C: ParserConfig> ParserImpl<'a, C> {
    fn parse_slot_parameters(mut self) -> Result<FormalParameters<'a>, Diagnostics> {
        self.bump_any();
        let parameters = self.parse_slot_parameter_items();
        if self.fatal_error.is_none() && !self.at(Kind::Eof) {
            self.error(diagnostics::unexpected_token(self.cur_token().span()));
        }
        if let Some(fatal) = self.fatal_error.take() {
            return Err(fatal.error.into_diagnostic().into());
        }
        self.check_unfinished_errors();
        let errors = self
            .lexer
            .errors
            .into_iter()
            .chain(self.errors)
            .map(ParserDiagnostic::into_diagnostic)
            .collect::<Diagnostics>();
        if errors.is_empty() { Ok(parameters) } else { Err(errors) }
    }
}

#[cfg(test)]
mod tests;