Let work tell us dependencies and read/write needs

fontbe/src/avar.rs

@@ -5,15 +5,17 @@ use fontdrasil::orchestration::Work;
 use fontir::{
     coords::{CoordConverter, DesignCoord},
     ir::Axis,
+    orchestration::WorkId as FeWorkId,
 };
 use log::debug;
 use write_fonts::tables::avar::{Avar, AxisValueMap, SegmentMaps};
 
 use crate::{
     error::Error,
-    orchestration::{BeWork, Context, WorkId},
+    orchestration::{AnyWorkId, BeWork, Context, WorkId},
 };
 
+#[derive(Debug)]
 struct AvarWork {}
 
 pub fn create_avar_work() -> Box<BeWork> {
@@ -58,9 +60,13 @@ fn to_segment_map(axis: &Axis) -> SegmentMaps {
     SegmentMaps::new(mappings)
 }
 
-impl Work<Context, WorkId, Error> for AvarWork {
-    fn id(&self) -> WorkId {
-        WorkId::Avar
+impl Work<Context, AnyWorkId, Error> for AvarWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::Avar.into()
+    }
+
+    fn dependencies(&self) -> Vec<AnyWorkId> {
+        vec![FeWorkId::InitStaticMetadata.into()]
     }
 
     /// Generate [avar](https://learn.microsoft.com/en-us/typography/opentype/spec/avar)

fontbe/src/cmap.rs

@@ -1,23 +1,39 @@
 //! Generates a [cmap](https://learn.microsoft.com/en-us/typography/opentype/spec/cmap) table.
 
-use fontdrasil::orchestration::Work;
+use std::sync::Arc;
+
+use fontdrasil::orchestration::{Access, Work};
+use fontir::orchestration::WorkId as FeWorkId;
+
 use read_fonts::types::GlyphId;
 use write_fonts::tables::cmap::Cmap;
 
 use crate::{
     error::Error,
-    orchestration::{BeWork, Context, WorkId},
+    orchestration::{AnyWorkId, BeWork, Context, WorkId},
 };
 
+#[derive(Debug)]
 struct CmapWork {}
 
 pub fn create_cmap_work() -> Box<BeWork> {
     Box::new(CmapWork {})
 }
 
-impl Work<Context, WorkId, Error> for CmapWork {
-    fn id(&self) -> WorkId {
-        WorkId::Cmap
+impl Work<Context, AnyWorkId, Error> for CmapWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::Cmap.into()
+    }
+
+    fn dependencies(&self) -> Vec<AnyWorkId> {
+        vec![FeWorkId::FinalizeStaticMetadata.into()]
+    }
+
+    fn read_access(&self) -> Access<AnyWorkId> {
+        // We waited for final static metadata so it's safe to access all IR glyphs
+        Access::Custom(Arc::new(|id| {
+            matches!(id, AnyWorkId::Fe(FeWorkId::Glyph(..)))
+        }))
     }
 
     /// Generate [cmap](https://learn.microsoft.com/en-us/typography/opentype/spec/cmap)

fontbe/src/features.rs

@@ -12,16 +12,20 @@ use fea_rs::{
     parse::{SourceLoadError, SourceResolver},
     Compiler, GlyphMap, GlyphName as FeaRsGlyphName,
 };
-use fontir::{ir::Features, orchestration::Flags};
+use fontir::{
+    ir::Features,
+    orchestration::{Flags, WorkId as FeWorkId},
+};
 use log::{debug, error, warn};
 
 use fontdrasil::orchestration::Work;
 
 use crate::{
     error::Error,
-    orchestration::{BeWork, Context, WorkId},
+    orchestration::{AnyWorkId, BeWork, Context, WorkId},
 };
 
+#[derive(Debug)]
 pub struct FeatureWork {}
 
 // I did not want to make a struct
@@ -111,9 +115,20 @@ fn write_debug_fea(context: &Context, is_error: bool, why: &str, fea_content: &s
     };
 }
 
-impl Work<Context, WorkId, Error> for FeatureWork {
-    fn id(&self) -> WorkId {
-        WorkId::Features
+impl Work<Context, AnyWorkId, Error> for FeatureWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::Features.into()
+    }
+
+    fn dependencies(&self) -> Vec<AnyWorkId> {
+        vec![
+            FeWorkId::FinalizeStaticMetadata.into(),
+            FeWorkId::Features.into(),
+        ]
+    }
+
+    fn also_completes(&self) -> Vec<AnyWorkId> {
+        vec![WorkId::Gpos.into(), WorkId::Gsub.into()]
     }
 
     fn exec(&self, context: &Context) -> Result<(), Error> {

fontbe/src/font.rs

@@ -1,6 +1,7 @@
 //! Merge tables into a font
 
 use fontdrasil::orchestration::Work;
+use fontir::orchestration::WorkId as FeWorkId;
 use log::debug;
 use read_fonts::{
     tables::{
@@ -15,9 +16,10 @@ use write_fonts::FontBuilder;
 
 use crate::{
     error::Error,
-    orchestration::{to_bytes, BeWork, Bytes, Context, WorkId},
+    orchestration::{to_bytes, AnyWorkId, BeWork, Bytes, Context, WorkId},
 };
 
+#[derive(Debug)]
 struct FontWork {}
 
 pub fn create_font_work() -> Box<BeWork> {
@@ -93,9 +95,32 @@ fn bytes_for(context: &Context, id: WorkId) -> Result<Vec<u8>, Error> {
     Ok(bytes)
 }
 
-impl Work<Context, WorkId, Error> for FontWork {
-    fn id(&self) -> WorkId {
-        WorkId::Font
+impl Work<Context, AnyWorkId, Error> for FontWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::Font.into()
+    }
+
+    fn dependencies(&self) -> Vec<AnyWorkId> {
+        vec![
+            WorkId::Avar.into(),
+            WorkId::Cmap.into(),
+            WorkId::Fvar.into(),
+            WorkId::Head.into(),
+            WorkId::Hhea.into(),
+            WorkId::Hmtx.into(),
+            WorkId::Glyf.into(),
+            WorkId::Gpos.into(),
+            WorkId::Gsub.into(),
+            WorkId::Gvar.into(),
+            WorkId::Loca.into(),
+            WorkId::Maxp.into(),
+            WorkId::Name.into(),
+            WorkId::Os2.into(),
+            WorkId::Post.into(),
+            WorkId::Stat.into(),
+            FeWorkId::InitStaticMetadata.into(),
+            WorkId::LocaFormat.into(),
+        ]
     }
 
     /// Glue binary tables into a font

fontbe/src/fvar.rs

@@ -1,20 +1,20 @@
 //! Generates a [fvar](https://learn.microsoft.com/en-us/typography/opentype/spec/fvar) table.
 
-use std::collections::HashMap;
-
 use font_types::Fixed;
 use fontdrasil::orchestration::Work;
-use fontir::ir::StaticMetadata;
+use fontir::{ir::StaticMetadata, orchestration::WorkId as FeWorkId};
 use log::trace;
+use std::collections::HashMap;
 use write_fonts::tables::fvar::{AxisInstanceArrays, Fvar, InstanceRecord, VariationAxisRecord};
 
 use crate::{
     error::Error,
-    orchestration::{BeWork, Context, WorkId},
+    orchestration::{AnyWorkId, BeWork, Context, WorkId},
 };
 
 const HIDDEN_AXIS: u16 = 0x0001;
 
+#[derive(Debug)]
 struct FvarWork {}
 
 pub fn create_fvar_work() -> Box<BeWork> {
@@ -81,9 +81,13 @@ fn generate_fvar(static_metadata: &StaticMetadata) -> Option<Fvar> {
     Some(Fvar::new(axes_and_instances))
 }
 
-impl Work<Context, WorkId, Error> for FvarWork {
-    fn id(&self) -> WorkId {
-        WorkId::Fvar
+impl Work<Context, AnyWorkId, Error> for FvarWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::Fvar.into()
+    }
+
+    fn dependencies(&self) -> Vec<AnyWorkId> {
+        vec![FeWorkId::InitStaticMetadata.into()]
     }
 
     /// Generate [fvar](https://learn.microsoft.com/en-us/typography/opentype/spec/fvar)

fontbe/src/glyphs.rs

@@ -3,10 +3,16 @@
 //! Each glyph is built in isolation and then the fragments are collected
 //! and glued together to form a final table.
 
-use std::collections::{BTreeSet, HashMap, HashSet};
+use std::{
+    collections::{BTreeSet, HashMap, HashSet},
+    sync::Arc,
+};
 
-use fontdrasil::{orchestration::Work, types::GlyphName};
-use fontir::{coords::NormalizedLocation, ir};
+use fontdrasil::{
+    orchestration::{Access, Work},
+    types::GlyphName,
+};
+use fontir::{coords::NormalizedLocation, ir, orchestration::WorkId as FeWorkId};
 use kurbo::{cubics_to_quadratic_splines, Affine, BezPath, CubicBez, PathEl, Point, Rect};
 use log::{log_enabled, trace, warn};
 
@@ -26,9 +32,10 @@ use write_fonts::{
 
 use crate::{
     error::{Error, GlyphProblem},
-    orchestration::{BeWork, Context, GlyfLoca, Glyph, GvarFragment, WorkId},
+    orchestration::{AnyWorkId, BeWork, Context, GlyfLoca, Glyph, GvarFragment, WorkId},
 };
 
+#[derive(Debug)]
 struct GlyphWork {
     glyph_name: GlyphName,
 }
@@ -224,9 +231,35 @@ fn point_seqs_for_composite_glyph(ir_glyph: &ir::Glyph) -> HashMap<NormalizedLoc
         .collect()
 }
 
-impl Work<Context, WorkId, Error> for GlyphWork {
-    fn id(&self) -> WorkId {
-        WorkId::GlyfFragment(self.glyph_name.clone())
+impl Work<Context, AnyWorkId, Error> for GlyphWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::GlyfFragment(self.glyph_name.clone()).into()
+    }
+
+    fn dependencies(&self) -> Vec<AnyWorkId> {
+        // All IR glyphs should be done and thus safe to access; we need this for our components
+        vec![FeWorkId::FinalizeStaticMetadata.into()]
+    }
+
+    fn read_access(&self) -> Access<AnyWorkId> {
+        Access::Custom(Arc::new(|id| {
+            matches!(
+                id,
+                AnyWorkId::Fe(FeWorkId::FinalizeStaticMetadata)
+                    | AnyWorkId::Fe(FeWorkId::Glyph(..))
+            )
+        }))
+    }
+
+    fn write_access(&self) -> Access<AnyWorkId> {
+        Access::Set(HashSet::from([
+            WorkId::GlyfFragment(self.glyph_name.clone()).into(),
+            WorkId::GvarFragment(self.glyph_name.clone()).into(),
+        ]))
+    }
+
+    fn also_completes(&self) -> Vec<AnyWorkId> {
+        vec![WorkId::GvarFragment(self.glyph_name.clone()).into()]
     }
 
     fn exec(&self, context: &Context) -> Result<(), Error> {
@@ -599,6 +632,7 @@ fn bbox2rect(bbox: Bbox) -> Rect {
     }
 }
 
+#[derive(Debug)]
 struct GlyfLocaWork {}
 
 pub fn create_glyf_loca_work() -> Box<BeWork> {
@@ -695,9 +729,36 @@ fn compute_composite_bboxes(context: &Context) -> Result<(), Error> {
     Ok(())
 }
 
-impl Work<Context, WorkId, Error> for GlyfLocaWork {
-    fn id(&self) -> WorkId {
-        WorkId::Glyf
+impl Work<Context, AnyWorkId, Error> for GlyfLocaWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::Glyf.into()
+    }
+
+    fn read_access(&self) -> Access<AnyWorkId> {
+        Access::Custom(Arc::new(|id| {
+            matches!(
+                id,
+                AnyWorkId::Fe(FeWorkId::FinalizeStaticMetadata)
+                    | AnyWorkId::Be(WorkId::Loca)
+                    | AnyWorkId::Be(WorkId::GlyfFragment(..))
+            )
+        }))
+    }
+
+    fn write_access(&self) -> Access<AnyWorkId> {
+        Access::Custom(Arc::new(|id| {
+            matches!(
+                id,
+                AnyWorkId::Be(WorkId::Glyf)
+                    | AnyWorkId::Be(WorkId::Loca)
+                    | AnyWorkId::Be(WorkId::LocaFormat)
+                    | AnyWorkId::Be(WorkId::GlyfFragment(..))
+            )
+        }))
+    }
+
+    fn also_completes(&self) -> Vec<AnyWorkId> {
+        vec![WorkId::Loca.into(), WorkId::LocaFormat.into()]
     }
 
     /// Generate [glyf](https://learn.microsoft.com/en-us/typography/opentype/spec/glyf)

fontbe/src/gvar.rs

@@ -1,18 +1,24 @@
 //! Generates a [gvar](https://learn.microsoft.com/en-us/typography/opentype/spec/gvar) table.
 
+use std::sync::Arc;
+
 use font_types::GlyphId;
-use fontdrasil::{orchestration::Work, types::GlyphName};
-use fontir::ir::StaticMetadata;
+use fontdrasil::{
+    orchestration::{Access, Work},
+    types::GlyphName,
+};
+use fontir::{ir::StaticMetadata, orchestration::WorkId as FeWorkId};
 use write_fonts::{
     dump_table,
     tables::gvar::{GlyphDeltas, GlyphVariations, Gvar},
 };
 
 use crate::{
     error::Error,
-    orchestration::{BeWork, Bytes, Context, WorkId},
+    orchestration::{AnyWorkId, BeWork, Bytes, Context, WorkId},
 };
 
+#[derive(Debug)]
 struct GvarWork {}
 
 pub fn create_gvar_work() -> Box<BeWork> {
@@ -38,9 +44,19 @@ fn make_variations(
         .collect()
 }
 
-impl Work<Context, WorkId, Error> for GvarWork {
-    fn id(&self) -> WorkId {
-        WorkId::Gvar
+impl Work<Context, AnyWorkId, Error> for GvarWork {
+    fn id(&self) -> AnyWorkId {
+        WorkId::Gvar.into()
+    }
+
+    fn read_access(&self) -> Access<AnyWorkId> {
+        Access::Custom(Arc::new(|id| {
+            matches!(
+                id,
+                AnyWorkId::Fe(FeWorkId::FinalizeStaticMetadata)
+                    | AnyWorkId::Be(WorkId::GvarFragment(..))
+            )
+        }))
     }
 
     /// Generate [gvar](https://learn.microsoft.com/en-us/typography/opentype/spec/gvar)