Add no-alloc test, make litemap no-alloc (#6077)

Discovered that litemap had an `alloc` feature that partially worked,
made it fully work.

Author: Manishearth

Cargo.lock

@@ -95,6 +95,7 @@ members = [
     "tools/make/diplomat-gen",
     "tools/make/download-repo-sources",
     "tools/md-tests",
+    "tools/noalloctest",
 ]
 # Note: Workspaces in subdirectories, such as tutorials/crates, are
 # implicitly excluded from the main workspace.

Cargo.toml

@@ -144,6 +144,7 @@ env = { ICU4X_DATA_DIR = "../stubdata" }
 category = "CI"
 dependencies = [
     "check-nostd",
+    "check-noalloc",
     "check-freertos-wearos",
 ]
 

Makefile.toml

@@ -74,6 +74,17 @@ args = ["check", "--package", "icu_freertos",
         "--no-default-features", "--features=wearos",
         "-Zbuild-std=core,alloc", "-Zbuild-std-features=panic_immediate_abort"]
 
+[tasks.check-noalloc]
+description = "Build crates that are expected to work in no-alloc mode"
+category = "ICU4X FFI"
+dependencies = ["install-unknown-linux-nightly"]
+toolchain = "${PINNED_CI_NIGHTLY}"
+command = "cargo"
+args = ["rustc", "-p", "noalloctest",
+        "--target", "x86_64-unknown-linux-gnu",
+        "--",
+        "-Clink-arg=-nostartfiles", "-Cpanic=abort",
+        "--cfg", "icu4x_nostdtest"]
 
 # Diplomat gen
 

tools/make/ffi.toml

@@ -0,0 +1,31 @@
+# This file is part of ICU4X. For terms of use, please see the file
+# called LICENSE at the top level of the ICU4X source tree
+# (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+[package]
+name = "noalloctest"
+version.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+edition.workspace = true
+repository.workspace = true
+homepage.workspace = true
+license.workspace = true
+categories.workspace = true
+include.workspace = true
+publish = false
+
+# Testing: Build this crate with
+# cargo +nightly rustc -Zbuild-std=core,panic_abort -- -C link-arg=-nostartfiles  -Cpanic=abort --cfg icu4x_noalloctest
+
+[dependencies]
+# Dependencies that should be no-alloc should go here
+tinystr = {workspace = true, default-features = false}
+zerofrom = {workspace = true, default-features = false}
+yoke = {workspace = true, default-features = false}
+zerotrie = {workspace = true, default-features = false}
+potential_utf = {workspace = true, default-features = false}
+litemap = {workspace = true, default-features = false}
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(icu4x_noalloctest)'] }

tools/noalloctest/Cargo.toml

@@ -0,0 +1,46 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 2020-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0
+
+—
+
+Portions of ICU4X may have been adapted from ICU4C and/or ICU4J.
+ICU 1.8.1 to ICU 57.1 © 1995-2016 International Business Machines Corporation and others.

tools/noalloctest/LICENSE

@@ -0,0 +1,25 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+// We have icu4x_noalloctest so that this crate does not trip up our all-crates CI
+#![cfg_attr(icu4x_noalloctest, no_std)]
+#![cfg_attr(icu4x_noalloctest, no_main)]
+
+#[cfg(icu4x_noalloctest)]
+mod real {
+    #[panic_handler]
+    fn panic(_info: &core::panic::PanicInfo) -> ! {
+        // don't care
+        loop {}
+    }
+
+    #[no_mangle]
+    pub extern "C" fn _start() -> ! {
+        // don't care
+        loop {}
+    }
+}
+
+#[cfg(not(icu4x_noalloctest))]
+fn main() {}

tools/noalloctest/README.md

@@ -50,6 +50,7 @@
 #[cfg(doc)]
 extern crate std;
 
+#[cfg(feature = "alloc")]
 extern crate alloc;
 
 #[cfg(feature = "databake")]

tools/noalloctest/src/main.rs

@@ -3,30 +3,43 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 use crate::store::*;
-use alloc::borrow::Borrow;
+#[cfg(feature = "alloc")]
 use alloc::boxed::Box;
+#[cfg(feature = "alloc")]
 use alloc::vec::Vec;
+use core::borrow::Borrow;
 use core::cmp::Ordering;
 use core::iter::FromIterator;
 use core::marker::PhantomData;
 use core::mem;
 use core::ops::{Index, IndexMut, Range};
 
-/// A simple "flat" map based on a sorted vector
-///
-/// See the [module level documentation][super] for why one should use this.
-///
-/// The API is roughly similar to that of [`std::collections::BTreeMap`].
-#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
-pub struct LiteMap<K: ?Sized, V: ?Sized, S = alloc::vec::Vec<(K, V)>> {
-    pub(crate) values: S,
-    pub(crate) _key_type: PhantomData<K>,
-    pub(crate) _value_type: PhantomData<V>,
-}
+macro_rules! litemap_impl(
+    ($cfg:meta, $store:ident $(=$defaultty:ty)?) => {
+        /// A simple "flat" map based on a sorted vector
+        ///
+        /// See the [module level documentation][super] for why one should use this.
+        ///
+        /// The API is roughly similar to that of [`std::collections::BTreeMap`].
+        #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+        #[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
+        #[cfg($cfg)]
+        pub struct LiteMap<K: ?Sized, V: ?Sized, $store $(= $defaultty)?> {
+            pub(crate) values: $store,
+            pub(crate) _key_type: PhantomData<K>,
+            pub(crate) _value_type: PhantomData<V>,
+        }
+    };
+
+);
+// You can't `cfg()` a default generic parameter, and we don't want to write this type twice
+// and keep them in sync so we use a small macro
+litemap_impl!(feature = "alloc", S = alloc::vec::Vec<(K, V)>);
+litemap_impl!(not(feature = "alloc"), S);
 
+#[cfg(feature = "alloc")]
 impl<K, V> LiteMap<K, V> {
-    /// Construct a new [`LiteMap`] backed by Vec
+    /// Construct a new [`LiteMap`] backed by Vec    
     pub const fn new_vec() -> Self {
         Self {
             values: alloc::vec::Vec::new(),
@@ -49,6 +62,7 @@ impl<K, V, S> LiteMap<K, V, S> {
     }
 }
 
+#[cfg(feature = "alloc")]
 impl<K, V> LiteMap<K, V, Vec<(K, V)>> {
     /// Convert a [`LiteMap`] into a sorted `Vec<(K, V)>`.
     #[inline]
@@ -144,6 +158,7 @@ where
     ///
     /// assert_eq!(boxed_map.get("one"), Some(&Box::from("uno")));
     /// ```
+    #[cfg(feature = "alloc")]
     pub fn to_boxed_keys_values<KB: ?Sized, VB: ?Sized, SB>(&self) -> LiteMap<Box<KB>, Box<VB>, SB>
     where
         SB: StoreMut<Box<KB>, Box<VB>>,
@@ -182,6 +197,7 @@ where
     ///
     /// assert_eq!(boxed_map.get("one"), Some(&11));
     /// ```
+    #[cfg(feature = "alloc")]
     pub fn to_boxed_keys<KB: ?Sized, SB>(&self) -> LiteMap<Box<KB>, V, SB>
     where
         V: Clone,
@@ -219,6 +235,7 @@ where
     ///
     /// assert_eq!(boxed_map.get(&11), Some(&Box::from("uno")));
     /// ```
+    #[cfg(feature = "alloc")]
     pub fn to_boxed_values<VB: ?Sized, SB>(&self) -> LiteMap<K, Box<VB>, SB>
     where
         K: Clone,