oxc_regular_expression 0.52.0

A collection of JavaScript tools written in Rust.
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

use oxc_allocator::Allocator;
use oxc_diagnostics::Result;
use oxc_span::Span;

use crate::{
    ast, diagnostics,
    options::Options,
    parser::{flags_parser::FlagsParser, pattern_parser::PatternParser, reader::Reader},
};

/// Regular expression parser for `/literal/` usage.
/// - `pattern_text`: the text between `/` and `/`
/// - `flags_text`: the text after the second `/`
pub struct LiteralParser<'a> {
    allocator: &'a Allocator,
    pattern_text: &'a str,
    flags_text: Option<&'a str>,
    options: Options,
}

impl<'a> LiteralParser<'a> {
    pub fn new(
        allocator: &'a Allocator,
        pattern_text: &'a str,
        flags_text: Option<&'a str>,
        options: Options,
    ) -> Self {
        Self { allocator, pattern_text, flags_text, options }
    }

    pub fn parse(self) -> Result<ast::Pattern<'a>> {
        let parse_string_literal = false;
        let Options { pattern_span_offset, flags_span_offset } = self.options;

        let (unicode_mode, unicode_sets_mode) = if let Some(flags_text) = self.flags_text {
            let reader = Reader::initialize(flags_text, true, parse_string_literal)?; // For literal, never expect to throw

            FlagsParser::new(reader, flags_span_offset).parse()?
        } else {
            (false, false)
        };

        let pattern_text = if self.pattern_text.is_empty() { "(?:)" } else { self.pattern_text };
        let reader = Reader::initialize(pattern_text, unicode_mode, parse_string_literal)?; // For literal, never expect to throw

        PatternParser::new(
            self.allocator,
            reader,
            (unicode_mode, unicode_sets_mode),
            pattern_span_offset,
        )
        .parse()
    }
}

/// Regular expression parser for `new RegExp("constrocutor")` usage.
/// - `pattern_text`: the string literal text as 1st argument of `RegExp` constructor
/// - `flags_text`: the string literal text as 2nd argument of `RegExp` constructor
///
/// String literal text should be in the form of `'...'` or `"..."` and may contain escape sequences.
pub struct ConstructorParser<'a> {
    allocator: &'a Allocator,
    pattern_text: &'a str,
    flags_text: Option<&'a str>,
    options: Options,
}

impl<'a> ConstructorParser<'a> {
    pub fn new(
        allocator: &'a Allocator,
        pattern_text: &'a str,
        flags_text: Option<&'a str>,
        options: Options,
    ) -> Self {
        Self { allocator, pattern_text, flags_text, options }
    }

    pub fn parse(self) -> Result<ast::Pattern<'a>> {
        let parse_string_literal = true;
        let Options { pattern_span_offset, flags_span_offset } = self.options;

        let (unicode_mode, unicode_sets_mode) = if let Some(flags_text) = self.flags_text {
            let reader =
                Reader::initialize(flags_text, true, parse_string_literal).map_err(|_| {
                    let span_start = flags_span_offset;
                    #[expect(clippy::cast_possible_truncation)]
                    let span_end = flags_span_offset + flags_text.len() as u32;
                    diagnostics::invalid_input(Span::new(span_start, span_end))
                })?;

            FlagsParser::new(reader, self.options.flags_span_offset).parse()?
        } else {
            (false, false)
        };

        let pattern_text = if matches!(self.pattern_text, r#""""# | "''") {
            r#""(?:)""#
        } else {
            self.pattern_text
        };
        let reader =
            Reader::initialize(pattern_text, unicode_mode, parse_string_literal).map_err(|_| {
                let span_start = pattern_span_offset;
                #[expect(clippy::cast_possible_truncation)]
                let span_end = pattern_span_offset + pattern_text.len() as u32;
                diagnostics::invalid_input(Span::new(span_start, span_end))
            })?;

        PatternParser::new(
            self.allocator,
            reader,
            (unicode_mode, unicode_sets_mode),
            pattern_span_offset,
        )
        .parse()
    }
}