Enum RegexCompileError 

#[non_exhaustive]
pub enum RegexCompileError {
    Parse {
        pattern_index: usize,
        message: String,
    },
    Unsupported {
        pattern_index: usize,
        feature: &'static str,
    },
    TooManyStates {
        states: usize,
        cap: usize,
    },
    PatternCountOverflow {
        count: usize,
    },
    MatchLengthOverflow {
        pattern_index: usize,
        len: usize,
    },
    TableWordCountOverflow {
        table: &'static str,
    },
    StorageReserveFailed {
        field: &'static str,
        requested: usize,
        message: String,
    },
}

Failure modes for compile_regex_set. Variants are non-exhaustive so future regex features can be added without a breaking change.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Parse

regex-syntax rejected the pattern. Carries the parser’s own diagnostic so callers can forward it.

Fields

pattern_index: usize

Index into the input slice that failed to parse.

message: String

regex-syntax’s error message.

Unsupported

The pattern uses a regex feature this GPU NFA frontend does not support. Callers must reject or rewrite the detector into supported GPU-NFA rule data.

Fields

pattern_index: usize

Index into the input slice that uses the unsupported feature.

feature: &'static str

One-line description of what isn’t supported (e.g. “anchors”).

TooManyStates

The compiled NFA exceeds LANES * 32 states (the lane-major transition table addresses states with one bit per lane). Mitigation: split the pattern set across multiple pipelines.

Fields

states: usize

Number of states the AST would have produced.

cap: usize

Per-pipeline maximum.

PatternCountOverflow

Pattern count does not fit the GPU ABI’s u32 pattern id field.

Fields

count: usize

Number of patterns supplied by the caller.

MatchLengthOverflow

A compiled regex match length does not fit the u32 match ABI.

Fields

pattern_index: usize

Index into the input slice that produced the oversized match.

len: usize

Longest matched byte length for the pattern.

TableWordCountOverflow

Transition or epsilon table word count overflowed host usize.

Fields

table: &'static str

Table being built.

StorageReserveFailed

Compiler staging allocation failed.

Fields

field: &'static str

Scratch vector being reserved.

requested: usize

Requested target capacity.

message: String

Allocator failure details.

Implementations

impl RegexCompileError

pub fn diagnostic_code(&self) -> Option<&'static str>

The canonical REGEX_UNSUPPORTED_DIAGNOSTICS.toml diagnostic code for this error, or None when the error does not correspond to a tracked unsupported-construct in that registry.

A consumer routes on this code, e.g. a *_REQUIRES_VERIFIER code means “send this detector to the scalar verifier”, while a *_UNSUPPORTED_* code means “reject or rewrite”. It returns Some only for constructs the GPU-NFA frontend can distinctly identify AND that have a registry code today (ASCII lookaround assertions and over-budget Unicode classes); it invents no codes. Parse errors, state-budget overflow, and ABI-sizing failures return None: they are not registry constructs. As the frontend learns to distinguish more constructs (backreferences, captures, huge alternations, nested repeats), map them here against their registry codes.

The feature strings matched below are this crate’s own construction-site constants (not upstream parser text), so the mapping is stable; the regex_compile_diagnostic_codes test locks the real compile path to them.

Trait Implementations

impl Clone for RegexCompileError

fn clone(&self) -> RegexCompileError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RegexCompileError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for RegexCompileError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for RegexCompileError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<RegexCompileError> for RegexDfaError

fn from(error: RegexCompileError) -> Self

Converts to this type from the input type.