ct_regex_internal/codegen/convert_hir/

into_matcher.rs

use std::any;

use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote};
use regex_syntax::hir::{
    Capture, Class, ClassBytesRange, ClassUnicodeRange, Hir, HirKind, Literal, Look, Repetition,
};

use crate::codegen::{CodegenItem, Group, Groups};
use crate::matcher::{Always as A, Or, Then};

pub fn type_name<T>() -> &'static str {
    any::type_name::<T>()
        .split('<').next().unwrap()
        .rsplit("::").next().unwrap()
}

pub fn type_ident<T>() -> Ident {
    format_ident!("{}", type_name::<T>())
}

pub trait HirExtension {
    fn into_matcher<I: CodegenItem>(self) -> (TokenStream, Vec<Group>);
}

impl HirExtension for Hir {
    fn into_matcher<I: CodegenItem>(self) -> (TokenStream, Vec<Group>) {
        let mut caps = Groups::new();
        let tokens = self.into_matcher_expr::<I>(&mut caps);
        (tokens, caps.into_vec())
    }
}

pub trait IntoMatcherExpr {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream;
}

impl IntoMatcherExpr for Hir {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        match self.into_kind() {
            HirKind::Empty              => Empty.into_matcher_expr::<I>(caps),
            HirKind::Literal(lit)       => lit.into_matcher_expr::<I>(caps),
            HirKind::Class(class)       => class.into_matcher_expr::<I>(caps),
            HirKind::Look(look)         => look.into_matcher_expr::<I>(caps),
            HirKind::Repetition(rep)    => rep.into_matcher_expr::<I>(caps),
            HirKind::Capture(cap)       => cap.into_matcher_expr::<I>(caps),
            HirKind::Concat(hirs)       => Concat(hirs).into_matcher_expr::<I>(caps),
            HirKind::Alternation(hirs)  => Alternation(hirs).into_matcher_expr::<I>(caps),
        }
    }
}

#[derive(Debug, Clone)]
struct Empty;

#[derive(Debug, Clone)]
struct Concat(pub Vec<Hir>);

#[derive(Debug, Clone)]
struct Alternation(pub Vec<Hir>);

impl IntoMatcherExpr for u8 {
    fn into_matcher_expr<I: CodegenItem>(self, _caps: &mut Groups) -> TokenStream {
        assert_eq!(type_name::<I>(), type_name::<u8>());
        quote!(::ct_regex::internal::matcher::Byte<#self>)
    }
}

impl IntoMatcherExpr for &ClassBytesRange {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        assert_eq!(type_name::<I>(), type_name::<u8>());
        if self.start() == self.end() {
            self.start().into_matcher_expr::<I>(caps)
        } else {
            let start = self.start();
            let end = self.end();
            quote!(::ct_regex::internal::matcher::ByteRange<#start, #end>)
        }
    }
}

impl IntoMatcherExpr for char {
    fn into_matcher_expr<I: CodegenItem>(self, _caps: &mut Groups) -> TokenStream {
        assert_eq!(type_name::<I>(), type_name::<char>());
        quote!(::ct_regex::internal::matcher::Scalar<#self>)
    }
}

impl IntoMatcherExpr for &ClassUnicodeRange {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        assert_eq!(type_name::<I>(), type_name::<char>(), "{:?}", self);
        if self.start() == self.end() {
            self.start().into_matcher_expr::<I>(caps)
        } else {
            let start = self.start();
            let end = self.end();
            quote!(::ct_regex::internal::matcher::ScalarRange<#start, #end>)
        }
    }
}

impl IntoMatcherExpr for Empty {
    fn into_matcher_expr<I: CodegenItem>(self, _caps: &mut Groups) -> TokenStream {
        quote!(::ct_regex::internal::matcher::Always)
    }
}

impl IntoMatcherExpr for Literal {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        write_chunked::<Then<u8, A, A>, I, _>(
            caps,
            I::collect_from_bytes(&self.0)
        )
    }
}

impl IntoMatcherExpr for Class {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        match I::normalize_class(self) {
            Class::Unicode(unicode) => write_chunked::<Or<u8, A, A>, I, _>(
                caps,
                unicode.ranges().iter().collect()
            ),
            Class::Bytes(bytes) => write_chunked::<Or<u8, A, A>, I, _>(
                caps,
                bytes.ranges().iter().collect()
            ),
        }
    }
}

impl IntoMatcherExpr for Look {
    fn into_matcher_expr<I: CodegenItem>(self, _caps: &mut Groups) -> TokenStream {
        match self {
            Look::Start => quote!(::ct_regex::internal::matcher::Start),
            Look::End => quote!(::ct_regex::internal::matcher::End),
            Look::StartLF => quote!(::ct_regex::internal::matcher::LineStart),
            Look::EndLF => quote!(::ct_regex::internal::matcher::LineEnd),
            Look::StartCRLF => quote!(::ct_regex::internal::matcher::CRLFStart),
            Look::EndCRLF => quote!(::ct_regex::internal::matcher::CRLFEnd),
            _ => unimplemented!("complex look arounds"),
        }
    }
}

impl IntoMatcherExpr for Repetition {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        let Repetition { min, max, greedy, sub } = self;

        let required = caps.required;
        if min == 0 {
            caps.required = false;
        }

        let item_type = type_ident::<I>();
        let sub_matcher = sub.into_matcher_expr::<I>(caps);
        // I need to document this somewhere, might as well be here: usize is used for all generic
        // parameters, even though Hir types use u32, because it is used for arrasy indexing during
        // the conversion process.
        let (min, max) = (min as usize, max.map(|m| m as usize));

        if min == 0 {
            caps.required = required;
        }

        let tokens = match max {
            None => {
                quote!(::ct_regex::internal::matcher::QuantifierNOrMore<#item_type, #sub_matcher, #min>)
            },
            Some(max) if min == max => {
                return quote!(::ct_regex::internal::matcher::QuantifierN<#item_type, #sub_matcher, #min>);
            },
            Some(max) => {
                quote!(::ct_regex::internal::matcher::QuantifierNToM<#item_type, #sub_matcher, #min, #max>)
            },
        };

        if greedy {
            tokens
        } else {
            quote!(::ct_regex::internal::matcher::Lazy<#item_type, #tokens>)
        }
    }
}

impl IntoMatcherExpr for Capture {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        caps.insert(self.index, self.name);
        let item_type = type_ident::<I>();
        let sub_matcher = self.sub.into_matcher_expr::<I>(caps);
        let index = self.index as usize;

        quote!(::ct_regex::internal::matcher::CaptureGroup<#item_type, #sub_matcher, #index>)
    }
}

impl IntoMatcherExpr for Alternation {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        let required = caps.required;
        caps.required = false;
        let tokens = write_chunked::<Or<u8, A, A>, I, _>(caps, self.0);
        caps.required = required;
        tokens
    }
}

impl IntoMatcherExpr for Concat {
    fn into_matcher_expr<I: CodegenItem>(self, caps: &mut Groups) -> TokenStream {
        write_chunked::<Then<u8, A, A>, I, _>(caps, self.0)
    }
}

fn write_chunked<T, I: CodegenItem, W: IntoMatcherExpr>(
    caps: &mut Groups,
    mut items: Vec<W>,
) -> TokenStream {
    let n = items.len();
    let base = format_ident!("{}", type_name::<T>());
    let item_type = type_ident::<I>();

    match n {
        0 => panic!("literal contains no items"),
        1 => items.pop().unwrap().into_matcher_expr::<I>(caps),
        2 => {
            let mut iter = items.into_iter();
            let first = iter.next().unwrap().into_matcher_expr::<I>(caps);
            let second = iter.next().unwrap().into_matcher_expr::<I>(caps);

            quote!(::ct_regex::internal::matcher::#base<#item_type, #first, #second>)
        },
        3 => {
            let mut iter = items.into_iter();
            let first = iter.next().unwrap().into_matcher_expr::<I>(caps);
            let chunked = write_chunked::<T, I, W>(caps, iter.collect());

            quote!(::ct_regex::internal::matcher::#base<#item_type, #first, #chunked>)
        },
        4 | 8 | 16 => write_n_items::<T, I, W>(caps, items, n),
        _ => {
            // Take largest chunk that fits, combine with remainder
            let chunk_size = if n > 16 {
                16
            } else if n > 8 {
                8
            } else {
                4
            };
            let remainder = items.split_off(chunk_size);
            let n_matcher = write_n_items::<T, I, W>(caps, items, chunk_size);
            let chunked = write_chunked::<T, I, W>(caps, remainder);

            quote!(::ct_regex::internal::matcher::#base<#item_type, #n_matcher, #chunked>)
        },
    }
}

fn write_n_items<T, I: CodegenItem, W: IntoMatcherExpr>(
    caps: &mut Groups,
    items: Vec<W>,
    n: usize,
) -> TokenStream {
    let name = format_ident!("{}{}", type_name::<T>(), n);
    let item_type = type_ident::<I>();

    let mut tokens = quote!(::ct_regex::internal::matcher::#name<#item_type);

    for item in items {
        tokens.extend(quote!(,));
        tokens.extend(item.into_matcher_expr::<I>(caps));
    }

    tokens.extend(quote!(>));
    tokens
}