Skip to main content

ct_regex_internal/codegen/convert_hir/
metadata.rs

1use std::collections::HashMap;
2use std::mem;
3
4use quote::format_ident;
5use syn::Ident;
6
7#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Group {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f, "Group", "name",
            &self.name, "required", &&self.required)
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for Group {
    #[inline]
    fn clone(&self) -> Group {
        Group {
            name: ::core::clone::Clone::clone(&self.name),
            required: ::core::clone::Clone::clone(&self.required),
        }
    }
}Clone, #[automatically_derived]
impl ::core::cmp::PartialEq for Group {
    #[inline]
    fn eq(&self, other: &Group) -> bool {
        self.required == other.required && self.name == other.name
    }
}PartialEq, #[automatically_derived]
impl ::core::cmp::Eq for Group {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<Option<Box<str>>>;
        let _: ::core::cmp::AssertParamIsEq<bool>;
    }
}Eq)]
8pub(crate) struct Group {
9    pub name: Option<Box<str>>,
10    pub required: bool,
11}
12
13#[derive(#[automatically_derived]
impl ::core::fmt::Debug for ExprMetadata {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field4_finish(f, "ExprMetadata",
            "name", &self.name, "groups", &self.groups, "required",
            &self.required, "literals", &&self.literals)
    }
}Debug, #[automatically_derived]
impl ::core::clone::Clone for ExprMetadata {
    #[inline]
    fn clone(&self) -> ExprMetadata {
        ExprMetadata {
            name: ::core::clone::Clone::clone(&self.name),
            groups: ::core::clone::Clone::clone(&self.groups),
            required: ::core::clone::Clone::clone(&self.required),
            literals: ::core::clone::Clone::clone(&self.literals),
        }
    }
}Clone, #[automatically_derived]
impl ::core::cmp::PartialEq for ExprMetadata {
    #[inline]
    fn eq(&self, other: &ExprMetadata) -> bool {
        self.required == other.required && self.name == other.name &&
                self.groups == other.groups && self.literals == other.literals
    }
}PartialEq, #[automatically_derived]
impl ::core::cmp::Eq for ExprMetadata {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<Ident>;
        let _: ::core::cmp::AssertParamIsEq<HashMap<u32, Group>>;
        let _: ::core::cmp::AssertParamIsEq<bool>;
        let _: ::core::cmp::AssertParamIsEq<Vec<Box<[u8]>>>;
    }
}Eq)]
14pub(crate) struct ExprMetadata {
15    pub name: Ident,
16    // Group ids are provided by regex_syntax as a u32, and not returned in the right order, so we
17    // store them in a map before checking them and creating a Vec later.
18    pub groups: HashMap<u32, Group>,
19    pub required: bool,
20    pub literals: Vec<Box<[u8]>>,
21}
22
23impl ExprMetadata {
24    pub fn new(name: Ident) -> ExprMetadata {
25        let mut groups = HashMap::new();
26        groups.insert(0, Group {
27            name: Some("whole_match".into()),
28            required: true,
29        });
30        ExprMetadata {
31            name,
32            groups,
33            required: true,
34            literals: Vec::new(),
35        }
36    }
37
38    pub fn insert_group(&mut self, index: u32, name: Option<Box<str>>) {
39        self.groups.insert(index, Group {
40            name,
41            required: self.required,
42        });
43    }
44
45    pub fn take_groups(&mut self) -> Vec<Group> {
46        let mut items: Vec<_> = mem::take(&mut self.groups).into_iter().collect();
47        items.sort_by_key(|(i, _)| *i);
48
49        if items
50            .iter()
51            .enumerate()
52            .any(|(num, (index, _))| num != *index as usize)
53        {
54            { ::core::panicking::panic_fmt(format_args!("missing a capture group")); };panic!("missing a capture group");
55        }
56
57        items.into_iter().map(|(_, item)| item).collect()
58    }
59
60    pub fn insert_literal(&mut self, literal: Box<[u8]>) -> Ident {
61        let index = self.literals.len();
62        self.literals.push(literal);
63        create_literal_id(&self.name, index)
64    }
65}
66
67pub fn create_literal_id(name: &Ident, num: usize) -> Ident {
68    match ::quote::__private::IdentFragmentAdapter(&name) {
    arg =>
        match ::quote::__private::IdentFragmentAdapter(&num) {
            arg =>
                ::quote::__private::mk_ident(&::alloc::__export::must_use({
                                ::alloc::fmt::format(format_args!("{0}Literal{1}", arg,
                                        arg))
                            }),
                    ::quote::__private::Option::None.or(arg.span()).or(arg.span())),
        },
}format_ident!("{}Literal{}", name, num)
69}