vize_oxc_parser 0.492.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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Direct, original-source template parameter goals. 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> {
        self.parse_template_parameters(false)
    }

    /// Parse a Vue v-for alias list from its original source, without the
    /// enclosing tuple parentheses or `in`/`of` iterable. Unlike a slot's
    /// parameter list, this goal permits omitted alias positions. Elisions
    /// contribute no items; every retained binding keeps its authored span.
    /// Rest-last and trailing-comma restrictions remain in force.
    pub fn parse_v_for_parameters(self) -> Result<FormalParameters<'a>, Diagnostics> {
        self.parse_template_parameters(true)
    }

    fn parse_template_parameters(
        self,
        allow_elisions: bool,
    ) -> 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,
                allow_elisions,
            )
        } else if config.is::<TokensParserConfig>() {
            parse_tokens(
                self.allocator,
                self.source_text,
                self.source_type,
                self.options,
                allow_elisions,
            )
        } else if let Some(&config) = config.downcast_ref::<RuntimeParserConfig>() {
            parse_runtime(
                self.allocator,
                self.source_text,
                self.source_type,
                self.options,
                config,
                allow_elisions,
            )
        } else {
            ParserImpl::<C>::new(
                self.allocator,
                self.source_text,
                self.source_type,
                self.options,
                self.config,
                UniquePromise::new(),
            )
            .parse_template_parameters(allow_elisions)
        }
    }
}

// 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,
            allow_elisions: bool,
        ) -> Result<FormalParameters<'a>, Diagnostics> {
            ParserImpl::<$config>::new(
                allocator,
                source,
                source_type,
                options,
                $config,
                UniquePromise::new(),
            )
            .parse_template_parameters(allow_elisions)
        }
    };
}
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,
    allow_elisions: bool,
) -> Result<FormalParameters<'a>, Diagnostics> {
    ParserImpl::<RuntimeParserConfig>::new(
        allocator,
        source,
        source_type,
        options,
        config,
        UniquePromise::new(),
    )
    .parse_template_parameters(allow_elisions)
}

impl<'a, C: ParserConfig> ParserImpl<'a, C> {
    fn parse_template_parameters(
        mut self,
        allow_elisions: bool,
    ) -> Result<FormalParameters<'a>, Diagnostics> {
        self.bump_any();
        let parameters = self.parse_template_parameter_items(allow_elisions);
        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;