Get as close as possible to full no_std support (linebender#160)

To really get no-std support in parley, we need to land dfrg/swash#63.
But I believe I've done everything else that's necessary, in both parley
and fontique. One can test the build by patching Cargo.toml to use the
working branch for that swash PR, and modifying parley/Cargo.toml to
specify swash/std or swash/libm as appropriate. If we decide to land
dfrg/swash#63 before landing this one, then I can make the latter
modification to parley/Cargo.toml before merging this PR.

Some of my changes, e.g. unconditionally using `alloc::vec::Vec`, are
designed to minimize the amount of noise when searching the whole source
tree for "std".

fontique/src/attributes.rs

@@ -3,10 +3,7 @@
 
 //! Properties for specifying font weight, stretch and style.
 
-// This is unused due to an issue in CI and the fact that our
-// no_std support doesn't really work correctly yet.
-// See https://github.com/linebender/parley/issues/86
-#[cfg(not(feature = "std"))]
+#[cfg(feature = "libm")]
 #[allow(unused_imports)]
 use core_maths::*;
 

fontique/src/collection/mod.rs

@@ -7,7 +7,6 @@ mod query;
 
 pub use query::{Query, QueryFamily, QueryFont, QueryStatus};
 
-#[cfg(feature = "std")]
 use super::SourceCache;
 
 use super::{
@@ -166,7 +165,6 @@ impl Collection {
     }
 
     /// Returns an object for selecting fonts from this collection.
-    #[cfg(feature = "std")]
     pub fn query<'a>(&'a mut self, source_cache: &'a mut SourceCache) -> Query<'a> {
         Query::new(self, source_cache)
     }

fontique/src/collection/query.rs

@@ -3,10 +3,8 @@
 
 //! Query support.
 
-#[cfg(feature = "std")]
 use super::super::{Collection, SourceCache};
 
-#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 use super::{
@@ -33,14 +31,12 @@ impl QueryState {
 pub struct Query<'a> {
     collection: &'a mut Inner,
     state: &'a mut QueryState,
-    #[cfg(feature = "std")]
     source_cache: &'a mut SourceCache,
     attributes: Attributes,
     fallbacks: Option<FallbackKey>,
 }
 
 impl<'a> Query<'a> {
-    #[cfg(feature = "std")]
     pub(super) fn new(collection: &'a mut Collection, source_cache: &'a mut SourceCache) -> Self {
         collection.query_state.clear();
         Self {
@@ -108,7 +104,6 @@ impl<'a> Query<'a> {
     ///
     /// Return [`QueryStatus::Stop`] to end iterating over the matching
     /// fonts or [`QueryStatus::Continue`] to continue iterating.
-    #[cfg(feature = "std")]
     pub fn matches_with(&mut self, mut f: impl FnMut(&QueryFont) -> QueryStatus) {
         for family in self
             .state
@@ -226,7 +221,6 @@ pub struct QueryFont {
     pub synthesis: Synthesis,
 }
 
-#[cfg(feature = "std")]
 fn load_font<'a>(
     family: &FamilyInfo,
     attributes: Attributes,

fontique/src/font.rs

@@ -5,7 +5,6 @@
 
 use super::attributes::{Stretch, Style, Weight};
 use super::source::{SourceInfo, SourceKind};
-#[cfg(feature = "std")]
 use super::{source_cache::SourceCache, Blob};
 use skrifa::raw::{types::Tag, FontRef, TableProvider as _};
 use smallvec::SmallVec;
@@ -54,13 +53,13 @@ impl FontInfo {
     }
 
     /// Attempts to load the font, optionally from a source cache.
-    #[cfg(feature = "std")]
     pub fn load(&self, source_cache: Option<&mut SourceCache>) -> Option<Blob<u8>> {
         if let Some(source_cache) = source_cache {
             source_cache.get(&self.source)
         } else {
             match &self.source.kind {
                 SourceKind::Memory(blob) => Some(blob.clone()),
+                #[cfg(feature = "std")]
                 SourceKind::Path(path) => super::source_cache::load_blob(path),
             }
         }

fontique/src/lib.rs

@@ -4,9 +4,7 @@
 //! Font enumeration and fallback.
 
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
-// TODO: Remove this dead code allowance and hide the offending code behind the std feature gate.
-#![cfg_attr(not(feature = "std"), allow(dead_code))]
-#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
+#![cfg_attr(not(feature = "std"), no_std)]
 
 #[cfg(not(any(feature = "std", feature = "libm")))]
 compile_error!("fontique requires either the `std` or `libm` feature to be enabled");
@@ -26,7 +24,6 @@ mod scan;
 mod script;
 mod source;
 
-#[cfg(feature = "std")]
 mod source_cache;
 
 pub use icu_locid::LanguageIdentifier as Language;
@@ -41,5 +38,4 @@ pub use generic::GenericFamily;
 pub use script::Script;
 pub use source::{SourceId, SourceInfo, SourceKind};
 
-#[cfg(feature = "std")]
 pub use source_cache::{SourceCache, SourceCacheOptions};

fontique/src/scan.rs

@@ -17,7 +17,6 @@ use smallvec::SmallVec;
 #[cfg(feature = "std")]
 use {super::source::SourcePathMap, std::path::Path};
 
-#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 #[cfg(feature = "std")]

fontique/src/source_cache.rs

@@ -3,9 +3,15 @@
 
 //! Cache for font data.
 
-use super::source::{SourceId, SourceInfo, SourceKind};
+#[cfg(feature = "std")]
+use super::source::SourceId;
+use super::source::{SourceInfo, SourceKind};
+#[cfg(feature = "std")]
 use hashbrown::HashMap;
-use peniko::{Blob, WeakBlob};
+use peniko::Blob;
+#[cfg(feature = "std")]
+use peniko::WeakBlob;
+#[cfg(feature = "std")]
 use std::{
     path::Path,
     sync::{Arc, Mutex},
@@ -16,6 +22,7 @@ use std::{
 /// [source cache]: SourceCache
 #[derive(Copy, Clone, Default, Debug)]
 pub struct SourceCacheOptions {
+    #[cfg(feature = "std")]
     /// If true, the source cache will use a secondary shared cache
     /// guaranteeing that all clones will use the same backing store.
     ///
@@ -29,25 +36,29 @@ pub struct SourceCacheOptions {
 /// Cache for font data loaded from the file system.
 #[derive(Clone, Default)]
 pub struct SourceCache {
+    #[cfg(feature = "std")]
     cache: HashMap<SourceId, Entry<Blob<u8>>>,
+    #[cfg(feature = "std")]
     serial: u64,
+    #[cfg(feature = "std")]
     shared: Option<Arc<Mutex<Shared>>>,
 }
 
 impl SourceCache {
     /// Creates an empty cache with the given [options].
     ///
     /// [options]: SourceCacheOptions
+    #[cfg_attr(not(feature = "std"), allow(unused))]
     pub fn new(options: SourceCacheOptions) -> Self {
+        #[cfg(feature = "std")]
         if options.shared {
-            Self {
+            return Self {
                 cache: Default::default(),
                 serial: 0,
                 shared: Some(Arc::new(Mutex::new(Shared::default()))),
-            }
-        } else {
-            Self::default()
+            };
         }
+        Self::default()
     }
 
     /// Creates an empty cache that is suitable for multi-threaded use.
@@ -57,6 +68,7 @@ impl SourceCache {
     ///
     /// This is the same as calling [`SourceCache::new`] with an options
     /// struct where `shared = true`.
+    #[cfg(feature = "std")]
     pub fn new_shared() -> Self {
         Self {
             cache: Default::default(),
@@ -72,71 +84,80 @@ impl SourceCache {
     ///
     /// [blob]: Blob
     pub fn get(&mut self, source: &SourceInfo) -> Option<Blob<u8>> {
-        let path = match &source.kind {
-            SourceKind::Memory(memory) => return Some(memory.clone()),
-            SourceKind::Path(path) => &**path,
-        };
-        use hashbrown::hash_map::Entry as HashEntry;
-        match self.cache.entry(source.id()) {
-            HashEntry::Vacant(vacant) => {
-                if let Some(mut shared) = self.shared.as_ref().and_then(|shared| shared.lock().ok())
-                {
-                    // If we have a backing cache, try to load it there first
-                    // and then propagate the result here.
-                    if let Some(blob) = shared.get(source.id(), path) {
-                        vacant.insert(Entry::Loaded(EntryData {
-                            font_data: blob.clone(),
-                            serial: self.serial,
-                        }));
-                        Some(blob)
-                    } else {
-                        vacant.insert(Entry::Failed);
-                        None
-                    }
-                } else {
-                    // Otherwise, load it ourselves.
-                    if let Some(blob) = load_blob(path) {
-                        vacant.insert(Entry::Loaded(EntryData {
-                            font_data: blob.clone(),
-                            serial: self.serial,
-                        }));
-                        Some(blob)
-                    } else {
-                        vacant.insert(Entry::Failed);
-                        None
+        match &source.kind {
+            SourceKind::Memory(memory) => Some(memory.clone()),
+            #[cfg(feature = "std")]
+            SourceKind::Path(path) => {
+                use hashbrown::hash_map::Entry as HashEntry;
+                match self.cache.entry(source.id()) {
+                    HashEntry::Vacant(vacant) => {
+                        if let Some(mut shared) =
+                            self.shared.as_ref().and_then(|shared| shared.lock().ok())
+                        {
+                            // If we have a backing cache, try to load it there first
+                            // and then propagate the result here.
+                            if let Some(blob) = shared.get(source.id(), path) {
+                                vacant.insert(Entry::Loaded(EntryData {
+                                    font_data: blob.clone(),
+                                    serial: self.serial,
+                                }));
+                                Some(blob)
+                            } else {
+                                vacant.insert(Entry::Failed);
+                                None
+                            }
+                        } else {
+                            // Otherwise, load it ourselves.
+                            if let Some(blob) = load_blob(path) {
+                                vacant.insert(Entry::Loaded(EntryData {
+                                    font_data: blob.clone(),
+                                    serial: self.serial,
+                                }));
+                                Some(blob)
+                            } else {
+                                vacant.insert(Entry::Failed);
+                                None
+                            }
+                        }
                     }
-                }
-            }
-            HashEntry::Occupied(mut occupied) => {
-                let entry = occupied.get_mut();
-                match entry {
-                    Entry::Loaded(data) => {
-                        data.serial = self.serial;
-                        Some(data.font_data.clone())
+                    HashEntry::Occupied(mut occupied) => {
+                        let entry = occupied.get_mut();
+                        match entry {
+                            Entry::Loaded(data) => {
+                                data.serial = self.serial;
+                                Some(data.font_data.clone())
+                            }
+                            Entry::Failed => None,
+                        }
                     }
-                    Entry::Failed => None,
                 }
             }
         }
     }
 
     /// Removes all cached blobs that have not been accessed in the last
     /// `max_age` times `prune` has been called.
+    #[cfg_attr(not(feature = "std"), allow(unused))]
     pub fn prune(&mut self, max_age: u64, prune_failed: bool) {
-        self.cache.retain(|_, entry| match entry {
-            Entry::Failed => !prune_failed,
-            Entry::Loaded(data) => self.serial.saturating_sub(data.serial) < max_age,
-        });
-        self.serial = self.serial.saturating_add(1);
+        #[cfg(feature = "std")]
+        {
+            self.cache.retain(|_, entry| match entry {
+                Entry::Failed => !prune_failed,
+                Entry::Loaded(data) => self.serial.saturating_sub(data.serial) < max_age,
+            });
+            self.serial = self.serial.saturating_add(1);
+        }
     }
 }
 
 /// Shared backing store for a font data cache.
+#[cfg(feature = "std")]
 #[derive(Default)]
 struct Shared {
     cache: HashMap<SourceId, Entry<WeakBlob<u8>>>,
 }
 
+#[cfg(feature = "std")]
 impl Shared {
     pub fn get(&mut self, id: SourceId, path: &Path) -> Option<Blob<u8>> {
         use hashbrown::hash_map::Entry as HashEntry;
@@ -177,19 +198,22 @@ impl Shared {
     }
 }
 
+#[cfg(feature = "std")]
 #[derive(Clone, Default)]
 enum Entry<T> {
     Loaded(EntryData<T>),
     #[default]
     Failed,
 }
 
+#[cfg(feature = "std")]
 #[derive(Clone)]
 struct EntryData<T> {
     font_data: T,
     serial: u64,
 }
 
+#[cfg(feature = "std")]
 pub(crate) fn load_blob(path: &Path) -> Option<Blob<u8>> {
     let file = std::fs::File::open(path).ok()?;
     let mapped = unsafe { memmap2::Mmap::map(&file).ok()? };

parley/Cargo.toml

@@ -18,7 +18,7 @@ workspace = true
 [features]
 default = ["system"]
 std = ["fontique/std", "skrifa/std", "peniko/std"]
-libm = ["fontique/libm", "skrifa/libm", "peniko/libm"]
+libm = ["fontique/libm", "skrifa/libm", "peniko/libm", "dep:core_maths"]
 # Enables support for system font backends
 system = ["std", "fontique/system"]
 
@@ -27,3 +27,4 @@ swash = { workspace = true }
 skrifa = { workspace = true }
 peniko = { workspace = true }
 fontique = { workspace = true }
+core_maths = { version = "0.1.0", optional = true }

parley/src/bidi.rs

@@ -3,7 +3,6 @@
 
 //! Unicode bidirectional algorithm.
 
-#[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
 use swash::text::{BidiClass, BracketType, Codepoint as _};