WIP [GDEF] Use a bit-set for representing mark-filtering-sets

HB does this.

Author: behdad

src/hb/ot/mod.rs

@@ -1,5 +1,5 @@
 use super::ot_layout::TableIndex;
-use super::{common::TagExt, set_digest::hb_set_digest_t};
+use super::{common::TagExt};
 use crate::hb::hb_tag_t;
 use crate::hb::ot_layout_gsubgpos::MappingCache;
 use alloc::vec::Vec;
@@ -14,6 +14,7 @@ use read_fonts::{
         variations::{DeltaSetIndex, ItemVariationStore},
     },
     types::{BigEndian, F2Dot14, GlyphId, Offset32},
+    collections::int_set::BitSet,
     FontData, FontRef, ReadError, ResolveOffset, TableProvider,
 };
 
@@ -25,7 +26,7 @@ pub mod lookup;
 pub struct OtCache {
     pub gsub: LookupCache,
     pub gpos: LookupCache,
-    pub gdef_mark_set_digests: Vec<hb_set_digest_t>,
+    pub gdef_mark_sets: Vec<BitSet>,
 }
 
 impl OtCache {
@@ -46,20 +47,36 @@ impl OtCache {
                 cache
             })
             .unwrap_or_default();
-        let mut gdef_mark_set_digests = Vec::new();
+        let mut gdef_mark_sets = Vec::new();
         if let Ok(gdef) = font.gdef() {
             if let Some(Ok(mark_sets)) = gdef.mark_glyph_sets_def() {
-                gdef_mark_set_digests.extend(mark_sets.coverages().iter().map(|set| {
+                gdef_mark_sets.extend(mark_sets.coverages().iter().map(|set| {
                     set.ok()
-                        .map(|coverage| hb_set_digest_t::from_coverage(&coverage))
+                        .map(|coverage| {
+                            let mut set = BitSet::empty();
+
+                            match coverage {
+                                CoverageTable::Format1(table) => {
+                                    for glyph in table.glyph_array() {
+                                        set.insert(glyph.get().into());
+                                    }
+                                }
+                                CoverageTable::Format2(table) => {
+                                    for range in table.range_records() {
+                                        set.insert_range(range.start_glyph_id().into()..=range.end_glyph_id().into());
+                                    }
+                                }
+                            }
+                            set
+                        })
                         .unwrap_or_default()
                 }));
             }
         }
         Self {
             gsub,
             gpos,
-            gdef_mark_set_digests,
+            gdef_mark_sets,
         }
     }
 }
@@ -132,7 +149,7 @@ pub struct OtTables<'a> {
     pub gsub: Option<GsubTable<'a>>,
     pub gpos: Option<GposTable<'a>>,
     pub gdef: GdefTable<'a>,
-    pub gdef_mark_set_digests: &'a [hb_set_digest_t],
+    pub gdef_mark_sets: &'a [BitSet],
     pub coords: &'a [F2Dot14],
     pub var_store: Option<ItemVariationStore<'a>>,
 }
@@ -164,7 +181,7 @@ impl<'a> OtTables<'a> {
             gsub,
             gpos,
             gdef,
-            gdef_mark_set_digests: &cache.gdef_mark_set_digests,
+            gdef_mark_sets: &cache.gdef_mark_sets,
             var_store,
             coords,
         }
@@ -189,20 +206,10 @@ impl<'a> OtTables<'a> {
     }
 
     pub fn is_mark_glyph(&self, glyph_id: u32, set_index: u16) -> bool {
-        if self
-            .gdef_mark_set_digests
+        self
+            .gdef_mark_sets
             .get(set_index as usize)
-            .is_some_and(|digest| digest.may_have_glyph(glyph_id.into()))
-        {
-            self.gdef
-                .mark_sets
-                .as_ref()
-                .and_then(|(data, offsets)| Some((data, offsets.get(set_index as usize)?.get())))
-                .and_then(|(data, offset)| offset.resolve::<CoverageTable>(*data).ok())
-                .is_some_and(|coverage| coverage.get(glyph_id).is_some())
-        } else {
-            false
-        }
+            .is_some_and(|set| set.contains(glyph_id.into()))
     }
 
     pub fn table_data_and_lookups(