Some (?i) case found by Claude

Author: Keats

src/grammars/prefilter.rs

@@ -1,5 +1,5 @@
 use fancy_regex::{Expr, LookAround};
-use regex_syntax::hir::{Class, Hir, HirKind};
+use regex_syntax::hir::{Class, ClassUnicode, ClassUnicodeRange, Hir, HirKind};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct ByteSet([bool; 256]);
@@ -147,36 +147,37 @@ fn regex_syntax_start(expr: &Hir) -> Start {
     }
 }
 
+#[inline]
+fn first_utf8_byte(c: char) -> u8 {
+    let mut buf = [0u8; 4];
+    c.encode_utf8(&mut buf).as_bytes()[0]
+}
+
 /// TODO: what to do with low selective things like `\S+` or anything negated like `[^a]` that can match pretty much any chars?
 fn fancy_start(expr: &Expr) -> Start {
     match expr {
         Expr::Empty | Expr::Assertion(_) | Expr::KeepOut | Expr::ContinueFromPreviousMatchEnd => {
             Start::MaybeEmpty(ByteSet::new())
         }
         Expr::Literal { val, casei } => {
-            let bytes = val.as_bytes();
-            if let Some(first) = bytes.first() {
-                let mut set = ByteSet::new();
-                if first.is_ascii() {
-                    if *casei {
-                        set.insert(first.to_ascii_uppercase());
-                        set.insert(first.to_ascii_lowercase());
-                    } else {
-                        set.insert(*first);
-                    }
-                    Start::Definite(set)
-                } else {
-                    // utf-8, we ignore if casei is true since we can't represent it i think?
-                    if *casei {
-                        Start::Bail
-                    } else {
-                        set.insert(*first);
-                        Start::Definite(set)
+            let Some(first) = val.chars().next() else {
+                return Start::MaybeEmpty(ByteSet::new());
+            };
+            let mut set = ByteSet::new();
+            if *casei {
+                let mut class = ClassUnicode::new([ClassUnicodeRange::new(first, first)]);
+                class
+                    .try_case_fold_simple()
+                    .expect("regex-syntax missing unicode case?");
+                for range in class.ranges() {
+                    for c in range.start()..=range.end() {
+                        set.insert(first_utf8_byte(c));
                     }
                 }
             } else {
-                Start::MaybeEmpty(ByteSet::new())
+                set.insert(first_utf8_byte(first));
             }
+            Start::Definite(set)
         }
         // We parse those with regex-syntax
         Expr::Delegate { inner, casei } => {
@@ -395,8 +396,16 @@ mod tests {
             (r".", None),
             (r".*x", None),
             (r"\R", None),
-            (r"(?i)é", None),
             (r"(", None),
+            // Cases generated by Claude for (?i)
+            // Unicode simple folding: (?i)s also matches ſ (U+017F, lead 0xC5)
+            (r"(?i)sort", Some(vec![b'S', b's', 0xC5])),
+            // and (?i)k also matches K (U+212A KELVIN SIGN, lead 0xE2)
+            (r"(?i)kind", Some(vec![b'K', b'k', 0xE2])),
+            // the closure works from the non-ASCII side too
+            (r"(?i)ſ", Some(vec![b'S', b's', 0xC5])),
+            // é folds to {é, É}, both with starting with 0xC3
+            (r"(?i)é", Some(vec![0xC3])),
         ];
 
         for (input, expected) in inputs {