chore: replace bitmask with bitflags

The `bitmask` crate seems to be abandoned, with no changes since 6 years ago and very few crates rely on it. Also, it started raising warnings with Rust 1.81.

Cargo.toml

@@ -37,7 +37,7 @@ array-bytes = "9.1.2"
 ascii_tree = "0.1.1"
 base64 = "0.22.1"
 bincode = "1.3.3"
-bitmask = "0.5.0"
+bitflags = "2.8.0"
 bitvec = "1.0.1"
 bstr = "1.9.1"
 cbindgen = "0.27.0"

fmt/Cargo.toml

@@ -12,7 +12,7 @@ homepage.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-bitmask = { workspace = true }
+bitflags = { workspace = true }
 bstr = { workspace = true }
 lazy_static = { workspace = true }
 thiserror = { workspace = true }

fmt/src/tokens/mod.rs

@@ -22,87 +22,87 @@ mod tests;
 /// bits set to one, corresponding to the base categories contained in the
 /// super-category.
 pub(crate) mod categories {
-    use bitmask::bitmask;
+    use bitflags::bitflags;
     use lazy_static::lazy_static;
 
-    bitmask! {
-        #[derive(Debug)]
-        pub mask Category: u32 where flags BaseCategory  {
-            None                = 0b00000000000000000000000000000001,
-            Begin               = 0b00000000000000000000000000000010,
-            End                 = 0b00000000000000000000000000000100,
-            BlockBegin          = 0b00000000000000000000000000001000,
-            BlockEnd            = 0b00000000000000000000000000010000,
-            AlignmentBlockBegin = 0b00000000000000000000000000100000,
-            AlignmentBlockEnd   = 0b00000000000000000000000001000000,
-            AlignmentMarker     = 0b00000000000000000000000010000000,
-            Indentation         = 0b00000000000000000000000100000000,
-            Whitespace          = 0b00000000000000000000001000000000,
-            Comment             = 0b00000000000000000000010000000000,
-            Newline             = 0b00000000000000000000100000000000,
-            Punctuation         = 0b00000000000000000001000000000000,
-            Identifier          = 0b00000000000000000010000000000000,
-            Keyword             = 0b00000000000000000100000000000000,
-            Literal             = 0b00000000000000001000000000000000,
-            LGrouping           = 0b00000000000000010000000000000000,
-            RGrouping           = 0b00000000000000100000000000000000,
+    bitflags! {
+        #[derive(Debug, Clone, Copy)]
+        pub struct Category: u32 {
+            const None                = 0b00000000000000000000000000000001;
+            const Begin               = 0b00000000000000000000000000000010;
+            const End                 = 0b00000000000000000000000000000100;
+            const BlockBegin          = 0b00000000000000000000000000001000;
+            const BlockEnd            = 0b00000000000000000000000000010000;
+            const AlignmentBlockBegin = 0b00000000000000000000000000100000;
+            const AlignmentBlockEnd   = 0b00000000000000000000000001000000;
+            const AlignmentMarker     = 0b00000000000000000000000010000000;
+            const Indentation         = 0b00000000000000000000000100000000;
+            const Whitespace          = 0b00000000000000000000001000000000;
+            const Comment             = 0b00000000000000000000010000000000;
+            const Newline             = 0b00000000000000000000100000000000;
+            const Punctuation         = 0b00000000000000000001000000000000;
+            const Identifier          = 0b00000000000000000010000000000000;
+            const Keyword             = 0b00000000000000000100000000000000;
+            const Literal             = 0b00000000000000001000000000000000;
+            const LGrouping           = 0b00000000000000010000000000000000;
+            const RGrouping           = 0b00000000000000100000000000000000;
         }
     }
     lazy_static! {
         // These are the base categories (i.e: those that don't contain another category)
         pub static ref NONE: Category =
-            Category::from(BaseCategory::None);
+            Category::from(Category::None);
 
         pub static ref BEGIN: Category =
-            Category::from(BaseCategory::Begin);
+            Category::from(Category::Begin);
 
         pub static ref END: Category =
-            Category::from(BaseCategory::End);
+            Category::from(Category::End);
 
         pub static ref BLOCK_BEGIN: Category =
-            Category::from(BaseCategory::BlockBegin);
+            Category::from(Category::BlockBegin);
 
         pub static ref BLOCK_END: Category =
-            Category::from(BaseCategory::BlockEnd);
+            Category::from(Category::BlockEnd);
 
         pub static ref ALIGNMENT_BLOCK_BEGIN: Category =
-            Category::from(BaseCategory::AlignmentBlockBegin);
+            Category::from(Category::AlignmentBlockBegin);
 
         pub static ref ALIGNMENT_BLOCK_END: Category =
-            Category::from(BaseCategory::AlignmentBlockBegin);
+            Category::from(Category::AlignmentBlockBegin);
 
         pub static ref ALIGNMENT_MARKER: Category =
-            Category::from(BaseCategory::AlignmentMarker);
+            Category::from(Category::AlignmentMarker);
 
         pub static ref INDENTATION: Category =
-            Category::from(BaseCategory::Indentation);
+            Category::from(Category::Indentation);
 
         pub static ref WHITESPACE: Category =
-            Category::from(BaseCategory::Whitespace);
+            Category::from(Category::Whitespace);
 
         pub static ref COMMENT: Category =
-            Category::from(BaseCategory::Comment);
+            Category::from(Category::Comment);
 
         pub static ref NEWLINE: Category =
-            Category::from(BaseCategory::Newline);
+            Category::from(Category::Newline);
 
         pub static ref KEYWORD: Category =
-            Category::from(BaseCategory::Keyword);
+            Category::from(Category::Keyword);
 
         pub static ref PUNCTUATION: Category =
-            Category::from(BaseCategory::Punctuation);
+            Category::from(Category::Punctuation);
 
         pub static ref IDENTIFIER: Category =
-            Category::from(BaseCategory::Identifier);
+            Category::from(Category::Identifier);
 
         pub static ref LITERAL: Category =
-            Category::from(BaseCategory::Literal);
+            Category::from(Category::Literal);
 
         pub static ref LGROUPING: Category =
-            Category::from(BaseCategory::LGrouping);
+            Category::from(Category::LGrouping);
 
         pub static ref RGROUPING: Category =
-            Category::from(BaseCategory::RGrouping);
+            Category::from(Category::RGrouping);
 
         // These are super-categories that are composed of other categories.
         pub static ref CONTROL: Category =
@@ -236,37 +236,35 @@ pub(crate) enum Token<'a> {
 
 impl<'a> Token<'a> {
     /// Returns the category the token belongs to.
-    pub fn category(&'a self) -> categories::BaseCategory {
+    pub fn category(&'a self) -> categories::Category {
         match self {
-            Token::None => categories::BaseCategory::None,
-            Token::Begin(..) => categories::BaseCategory::Begin,
-            Token::End(..) => categories::BaseCategory::End,
-            Token::BlockBegin => categories::BaseCategory::BlockBegin,
-            Token::BlockEnd => categories::BaseCategory::BlockEnd,
+            Token::None => categories::Category::None,
+            Token::Begin(..) => categories::Category::Begin,
+            Token::End(..) => categories::Category::End,
+            Token::BlockBegin => categories::Category::BlockBegin,
+            Token::BlockEnd => categories::Category::BlockEnd,
             Token::AlignmentBlockBegin => {
-                categories::BaseCategory::AlignmentBlockBegin
+                categories::Category::AlignmentBlockBegin
             }
             Token::AlignmentBlockEnd => {
-                categories::BaseCategory::AlignmentBlockEnd
+                categories::Category::AlignmentBlockEnd
             }
-            Token::AlignmentMarker => {
-                categories::BaseCategory::AlignmentMarker
-            }
-            Token::Indentation(..) => categories::BaseCategory::Indentation,
-            Token::Whitespace => categories::BaseCategory::Whitespace,
-            Token::Tab => categories::BaseCategory::Whitespace,
+            Token::AlignmentMarker => categories::Category::AlignmentMarker,
+            Token::Indentation(..) => categories::Category::Indentation,
+            Token::Whitespace => categories::Category::Whitespace,
+            Token::Tab => categories::Category::Whitespace,
             Token::Comment(..)
             | Token::BlockComment(..)
             | Token::TailComment(..)
             | Token::HeadComment(..)
-            | Token::InlineComment(..) => categories::BaseCategory::Comment,
-            Token::Newline => categories::BaseCategory::Newline,
-            Token::Identifier(..) => categories::BaseCategory::Identifier,
-            Token::Keyword(..) => categories::BaseCategory::Keyword,
-            Token::LGrouping(..) => categories::BaseCategory::LGrouping,
-            Token::RGrouping(..) => categories::BaseCategory::RGrouping,
-            Token::Punctuation(..) => categories::BaseCategory::Punctuation,
-            Token::Literal(..) => categories::BaseCategory::Literal,
+            | Token::InlineComment(..) => categories::Category::Comment,
+            Token::Newline => categories::Category::Newline,
+            Token::Identifier(..) => categories::Category::Identifier,
+            Token::Keyword(..) => categories::Category::Keyword,
+            Token::LGrouping(..) => categories::Category::LGrouping,
+            Token::RGrouping(..) => categories::Category::RGrouping,
+            Token::Punctuation(..) => categories::Category::Punctuation,
+            Token::Literal(..) => categories::Category::Literal,
         }
     }
 

lib/Cargo.toml

@@ -210,7 +210,7 @@ array-bytes = { workspace = true }
 ascii_tree = { workspace = true }
 base64 = { workspace = true }
 bincode = { workspace = true }
-bitmask = { workspace = true }
+bitflags = { workspace = true, features = ["serde"] }
 bitvec = { workspace = true }
 bstr = { workspace = true, features = ["serde"] }
 const-oid = { workspace = true, optional = true, features = ["db"] }

lib/src/compiler/atoms/mod.rs

@@ -72,7 +72,7 @@ pub(crate) use crate::compiler::atoms::quality::best_range_in_bytes;
 pub(crate) use crate::compiler::atoms::quality::best_range_in_masked_bytes;
 pub(crate) use crate::compiler::atoms::quality::AtomsQuality;
 
-use crate::compiler::{SubPatternFlagSet, SubPatternFlags};
+use crate::compiler::SubPatternFlags;
 
 /// The number of bytes that every atom *should* have. Some atoms may be
 /// shorter than DESIRED_ATOM_SIZE when it's impossible to extract a longer,
@@ -288,7 +288,7 @@ impl Atom {
 /// case combinations for that atom if the `Nocase` flag is set.
 pub(crate) fn extract_atoms(
     literal_bytes: &[u8],
-    flags: SubPatternFlagSet,
+    flags: SubPatternFlags,
 ) -> Box<dyn Iterator<Item = Atom>> {
     let mut best_atom = best_atom_in_bytes(literal_bytes);
 
@@ -329,7 +329,7 @@ pub(super) fn make_wide(s: &[u8]) -> Vec<u8> {
 }
 
 /// Iterator that returns all the atoms resulting from masking an atom with
-/// with a mask.
+/// a mask.
 pub(crate) struct MaskCombinations {
     cartesian_product: MultiProduct<ByteMaskCombinator>,
     backtrack: u16,

lib/src/compiler/ir/ast2ir.rs

@@ -23,8 +23,7 @@ use crate::compiler::errors::{
 use crate::compiler::ir::hex2hir::hex_pattern_hir_from_ast;
 use crate::compiler::ir::{
     Error, Expr, ExprId, Iterable, LiteralPattern, MatchAnchor, Pattern,
-    PatternFlagSet, PatternFlags, PatternIdx, PatternInRule, Quantifier,
-    Range, RegexpPattern,
+    PatternFlags, PatternIdx, PatternInRule, Quantifier, Range, RegexpPattern,
 };
 use crate::compiler::report::ReportBuilder;
 use crate::compiler::{
@@ -128,22 +127,22 @@ pub(in crate::compiler) fn text_pattern_from_ast<'src>(
         };
     }
 
-    let mut flags = PatternFlagSet::none();
+    let mut flags = PatternFlags::empty();
 
     if ascii.is_some() || wide.is_none() {
-        flags.set(PatternFlags::Ascii);
+        flags.insert(PatternFlags::Ascii);
     }
 
     if wide.is_some() {
-        flags.set(PatternFlags::Wide);
+        flags.insert(PatternFlags::Wide);
     }
 
     if nocase.is_some() {
-        flags.set(PatternFlags::Nocase);
+        flags.insert(PatternFlags::Nocase);
     }
 
     if fullword.is_some() {
-        flags.set(PatternFlags::Fullword);
+        flags.insert(PatternFlags::Fullword);
     }
 
     let xor_range = match xor {
@@ -158,7 +157,7 @@ pub(in crate::compiler) fn text_pattern_from_ast<'src>(
                     modifier.span().into(),
                 ));
             }
-            flags.set(PatternFlags::Xor);
+            flags.insert(PatternFlags::Xor);
             Some(*start..=*end)
         }
         _ => None,
@@ -182,15 +181,15 @@ pub(in crate::compiler) fn text_pattern_from_ast<'src>(
 
     let base64_alphabet = match base64 {
         Some(ast::PatternModifier::Base64 { alphabet, .. }) => {
-            flags.set(PatternFlags::Base64);
+            flags.insert(PatternFlags::Base64);
             validate_alphabet(alphabet)?
         }
         _ => None,
     };
 
     let base64wide_alphabet = match base64wide {
         Some(ast::PatternModifier::Base64Wide { alphabet, .. }) => {
-            flags.set(PatternFlags::Base64Wide);
+            flags.insert(PatternFlags::Base64Wide);
             validate_alphabet(alphabet)?
         }
         _ => None,
@@ -288,7 +287,7 @@ pub(in crate::compiler) fn hex_pattern_from_ast<'src>(
         span: pattern.span(),
         pattern: Pattern::Hex(RegexpPattern {
             hir,
-            flags: PatternFlagSet::from(PatternFlags::Ascii),
+            flags: PatternFlags::Ascii,
             anchored_at: None,
         }),
     })
@@ -315,27 +314,27 @@ pub(in crate::compiler) fn regexp_pattern_from_ast<'src>(
         }
     }
 
-    let mut flags = PatternFlagSet::none();
+    let mut flags = PatternFlags::empty();
 
     if pattern.modifiers.ascii().is_some()
         || pattern.modifiers.wide().is_none()
     {
-        flags.set(PatternFlags::Ascii);
+        flags |= PatternFlags::Ascii;
     }
 
     if pattern.modifiers.wide().is_some() {
-        flags.set(PatternFlags::Wide);
+        flags |= PatternFlags::Wide;
     }
 
     if pattern.modifiers.fullword().is_some() {
-        flags.set(PatternFlags::Fullword);
+        flags |= PatternFlags::Fullword;
     }
 
     // A regexp pattern can use either the `nocase` modifier or the `/i`
     // modifier (e.g: /foobar/i). In both cases it means the same thing.
     if pattern.modifiers.nocase().is_some() || pattern.regexp.case_insensitive
     {
-        flags.set(PatternFlags::Nocase);
+        flags |= PatternFlags::Nocase;
     }
 
     // When both the `nocase` modifier and the `/i` modifier are used together,