refactor: replace once_cell::sync::Lazy with std::sync::LazyLock

Cargo.lock

@@ -1312,7 +1312,6 @@ dependencies = [
  "num-derive",
  "num-traits",
  "num_cpus",
- "once_cell",
  "parking_lot",
  "percent-encoding",
  "pgp",
@@ -1362,7 +1361,6 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "chrono",
- "once_cell",
  "regex",
  "rusqlite",
 ]
@@ -1455,7 +1453,6 @@ dependencies = [
  "human-panic",
  "libc",
  "num-traits",
- "once_cell",
  "rand 0.8.5",
  "serde_json",
  "thiserror 2.0.12",

Cargo.toml

@@ -72,7 +72,6 @@ mime = "0.3.17"
 num_cpus = "1.16"
 num-derive = "0.4"
 num-traits = { workspace = true }
-once_cell = { workspace = true }
 parking_lot = "0.12"
 percent-encoding = "2.3"
 pgp = { version = "0.15.0", default-features = false }
@@ -185,7 +184,6 @@ log = "0.4"
 mailparse = "0.16.1"
 nu-ansi-term = "0.46"
 num-traits = "0.2"
-once_cell = "1.21.3"
 rand = "0.8"
 regex = "1.10"
 rusqlite = "0.32"

deltachat-contact-tools/Cargo.toml

@@ -9,7 +9,6 @@ license = "MPL-2.0"
 
 [dependencies]
 anyhow = { workspace = true }
-once_cell = { workspace = true }
 regex = { workspace = true }
 rusqlite = { workspace = true } # Needed in order to `impl rusqlite::types::ToSql for EmailAddress`. Could easily be put behind a feature.
 chrono = { workspace = true, features = ["alloc", "clock", "std"] }

deltachat-contact-tools/src/lib.rs

@@ -29,12 +29,12 @@
 
 use std::fmt;
 use std::ops::Deref;
+use std::sync::LazyLock;
 
 use anyhow::bail;
 use anyhow::Context as _;
 use anyhow::Result;
 use chrono::{DateTime, NaiveDateTime};
-use once_cell::sync::Lazy;
 use regex::Regex;
 
 #[derive(Debug)]
@@ -155,7 +155,8 @@ pub fn parse_vcard(vcard: &str) -> Vec<VcardContact> {
     }
 
     // Remove line folding, see https://datatracker.ietf.org/doc/html/rfc6350#section-3.2
-    static NEWLINE_AND_SPACE_OR_TAB: Lazy<Regex> = Lazy::new(|| Regex::new("\r?\n[\t ]").unwrap());
+    static NEWLINE_AND_SPACE_OR_TAB: LazyLock<Regex> =
+        LazyLock::new(|| Regex::new("\r?\n[\t ]").unwrap());
     let unfolded_lines = NEWLINE_AND_SPACE_OR_TAB.replace_all(vcard, "");
 
     let mut lines = unfolded_lines.lines().peekable();
@@ -276,7 +277,8 @@ impl rusqlite::types::ToSql for ContactAddress {
 /// - Removes special characters from the name, see [`sanitize_name()`]
 /// - Removes the name if it is equal to the address by setting it to ""
 pub fn sanitize_name_and_addr(name: &str, addr: &str) -> (String, String) {
-    static ADDR_WITH_NAME_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new("(.*)<(.*)>").unwrap());
+    static ADDR_WITH_NAME_REGEX: LazyLock<Regex> =
+        LazyLock::new(|| Regex::new("(.*)<(.*)>").unwrap());
     let (name, addr) = if let Some(captures) = ADDR_WITH_NAME_REGEX.captures(addr.as_ref()) {
         (
             if name.is_empty() {

deltachat-ffi/Cargo.toml

@@ -24,7 +24,6 @@ tokio = { workspace = true, features = ["rt-multi-thread"] }
 anyhow = { workspace = true }
 thiserror = { workspace = true }
 rand = { workspace = true }
-once_cell = { workspace = true }
 yerpc = { workspace = true, features = ["anyhow_expose"] }
 
 [features]

deltachat-ffi/src/lib.rs

@@ -18,7 +18,7 @@ use std::future::Future;
 use std::ops::Deref;
 use std::ptr;
 use std::str::FromStr;
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 use std::time::{Duration, SystemTime};
 
 use anyhow::Context as _;
@@ -38,7 +38,6 @@ use deltachat::{accounts::Accounts, log::LogExt};
 use deltachat_jsonrpc::api::CommandApi;
 use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcSession};
 use num_traits::{FromPrimitive, ToPrimitive};
-use once_cell::sync::Lazy;
 use rand::Rng;
 use tokio::runtime::Runtime;
 use tokio::sync::RwLock;
@@ -68,7 +67,8 @@ const DC_GCM_INFO_ONLY: u32 = 0x02;
 /// Struct representing the deltachat context.
 pub type dc_context_t = Context;
 
-static RT: Lazy<Runtime> = Lazy::new(|| Runtime::new().expect("unable to create tokio runtime"));
+static RT: LazyLock<Runtime> =
+    LazyLock::new(|| Runtime::new().expect("unable to create tokio runtime"));
 
 fn block_on<T>(fut: T) -> T::Output
 where

scripts/create-provider-data-rs.py

@@ -215,7 +215,7 @@ if __name__ == "__main__":
         "    Config, ConfigDefault, Oauth2Authorizer, Provider, ProviderOptions, Server, Status,\n"
         "};\n"
         "use std::collections::HashMap;\n\n"
-        "use once_cell::sync::Lazy;\n\n"
+        "use std::sync::LazyLock;\n\n"
     )
 
     process_dir(Path(sys.argv[1]))
@@ -224,7 +224,7 @@ if __name__ == "__main__":
     out_all += out_domains
     out_all += "];\n\n"
 
-    out_all += "pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> = Lazy::new(|| HashMap::from([\n"
+    out_all += "pub(crate) static PROVIDER_IDS: LazyLock<HashMap<&'static str, &'static Provider>> = LazyLock::new(|| HashMap::from([\n"
     out_all += out_ids
     out_all += "]));\n\n"
 
@@ -233,8 +233,8 @@ if __name__ == "__main__":
     else:
         now = datetime.datetime.fromisoformat(sys.argv[2])
     out_all += (
-        "pub static _PROVIDER_UPDATED: Lazy<chrono::NaiveDate> = "
+        "pub static _PROVIDER_UPDATED: LazyLock<chrono::NaiveDate> = "
-        "Lazy::new(|| chrono::NaiveDate::from_ymd_opt("
+        "LazyLock::new(|| chrono::NaiveDate::from_ymd_opt("
         + str(now.year)
         + ", "
         + str(now.month)

src/authres.rs

@@ -4,12 +4,12 @@
 use std::borrow::Cow;
 use std::collections::BTreeSet;
 use std::fmt;
+use std::sync::LazyLock;
 
 use anyhow::Result;
 use deltachat_contact_tools::EmailAddress;
 use mailparse::MailHeaderMap;
 use mailparse::ParsedMail;
-use once_cell::sync::Lazy;
 
 use crate::config::Config;
 use crate::context::Context;
@@ -107,7 +107,8 @@ fn remove_comments(header: &str) -> Cow<'_, str> {
     // In Pomsky, this is:
     //     "(" Codepoint* lazy ")"
     // See https://playground.pomsky-lang.org/?text=%22(%22%20Codepoint*%20lazy%20%22)%22
-    static RE: Lazy<regex::Regex> = Lazy::new(|| regex::Regex::new(r"\([\s\S]*?\)").unwrap());
+    static RE: LazyLock<regex::Regex> =
+        LazyLock::new(|| regex::Regex::new(r"\([\s\S]*?\)").unwrap());
 
     RE.replace_all(header, " ")
 }

src/chatlist.rs

@@ -1,7 +1,7 @@
 //! # Chat list module.
 
 use anyhow::{ensure, Context as _, Result};
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 use crate::chat::{update_special_chat_names, Chat, ChatId, ChatVisibility};
 use crate::constants::{
@@ -17,8 +17,8 @@ use crate::summary::Summary;
 use crate::tools::IsNoneOrEmpty;
 
 /// Regex to find out if a query should filter by unread messages.
-pub static IS_UNREAD_FILTER: Lazy<regex::Regex> =
+pub static IS_UNREAD_FILTER: LazyLock<regex::Regex> =
-    Lazy::new(|| regex::Regex::new(r"\bis:unread\b").unwrap());
+    LazyLock::new(|| regex::Regex::new(r"\bis:unread\b").unwrap());
 
 /// An object representing a single chatlist in memory.
 ///

src/constants.rs

@@ -2,14 +2,16 @@
 
 #![allow(missing_docs)]
 
+use std::sync::LazyLock;
+
 use deltachat_derive::{FromSql, ToSql};
-use once_cell::sync::Lazy;
 use percent_encoding::{AsciiSet, NON_ALPHANUMERIC};
 use serde::{Deserialize, Serialize};
 
 use crate::chat::ChatId;
 
-pub static DC_VERSION_STR: Lazy<String> = Lazy::new(|| env!("CARGO_PKG_VERSION").to_string());
+pub static DC_VERSION_STR: LazyLock<String> =
+    LazyLock::new(|| env!("CARGO_PKG_VERSION").to_string());
 
 /// Set of characters to percent-encode in email addresses and names.
 pub(crate) const NON_ALPHANUMERIC_WITHOUT_DOT: &AsciiSet = &NON_ALPHANUMERIC.remove(b'.');

src/dehtml.rs

@@ -3,8 +3,8 @@
 //! A module to remove HTML tags from the email text
 
 use std::io::BufRead;
+use std::sync::LazyLock;
 
-use once_cell::sync::Lazy;
 use quick_xml::{
     events::{BytesEnd, BytesStart, BytesText},
     Reader,
@@ -176,7 +176,8 @@ fn dehtml_quick_xml(buf: &str) -> (String, String) {
 }
 
 fn dehtml_text_cb(event: &BytesText, dehtml: &mut Dehtml) {
-    static LINE_RE: Lazy<regex::Regex> = Lazy::new(|| regex::Regex::new(r"(\r?\n)+").unwrap());
+    static LINE_RE: LazyLock<regex::Regex> =
+        LazyLock::new(|| regex::Regex::new(r"(\r?\n)+").unwrap());
 
     if dehtml.get_add_text() == AddText::YesPreserveLineEnds
         || dehtml.get_add_text() == AddText::YesRemoveLineEnds

src/key.rs

@@ -456,15 +456,13 @@ impl std::str::FromStr for Fingerprint {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
+    use std::sync::{Arc, LazyLock};
-
-    use once_cell::sync::Lazy;
 
     use super::*;
     use crate::config::Config;
     use crate::test_utils::{alice_keypair, TestContext};
 
-    static KEYPAIR: Lazy<KeyPair> = Lazy::new(alice_keypair);
+    static KEYPAIR: LazyLock<KeyPair> = LazyLock::new(alice_keypair);
 
     #[test]
     fn test_from_armored_string() {

src/net/dns.rs

@@ -44,13 +44,13 @@ use anyhow::{Context as _, Result};
 use std::collections::HashMap;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::str::FromStr;
+use std::sync::LazyLock;
 use tokio::net::lookup_host;
 use tokio::time::timeout;
 
 use super::load_connection_timestamp;
 use crate::context::Context;
 use crate::tools::time;
-use once_cell::sync::Lazy;
 
 /// Inserts entry into DNS cache
 /// or updates existing one with a new timestamp.
@@ -90,8 +90,8 @@ pub(crate) async fn prune_dns_cache(context: &Context) -> Result<()> {
 /// <https://docs.rs/tokio/1.40.0/tokio/sync/struct.Mutex.html#which-kind-of-mutex-should-you-use>
 /// and
 /// <https://stackoverflow.com/questions/63712823/why-do-i-get-a-deadlock-when-using-tokio-with-a-stdsyncmutex>.
-static LOOKUP_HOST_CACHE: Lazy<parking_lot::RwLock<HashMap<String, Vec<IpAddr>>>> =
+static LOOKUP_HOST_CACHE: LazyLock<parking_lot::RwLock<HashMap<String, Vec<IpAddr>>>> =
-    Lazy::new(Default::default);
+    LazyLock::new(Default::default);
 
 /// Wrapper for `lookup_host` that returns IP addresses.
 async fn lookup_ips(host: impl tokio::net::ToSocketAddrs) -> Result<impl Iterator<Item = IpAddr>> {
@@ -229,7 +229,7 @@ pub(crate) async fn update_connect_timestamp(
 ///
 /// See <https://support.delta.chat/t/no-dns-resolution-result/2778> and
 /// <https://github.com/deltachat/deltachat-core-rust/issues/4920> for reasons.
-static DNS_PRELOAD: Lazy<HashMap<&'static str, Vec<IpAddr>>> = Lazy::new(|| {
+static DNS_PRELOAD: LazyLock<HashMap<&'static str, Vec<IpAddr>>> = LazyLock::new(|| {
     HashMap::from([
         (
             "mail.sangham.net",

src/pgp.rs

@@ -424,7 +424,7 @@ pub async fn symm_decrypt<T: std::io::Read + std::io::Seek>(
 
 #[cfg(test)]
 mod tests {
-    use once_cell::sync::Lazy;
+    use std::sync::LazyLock;
     use tokio::sync::OnceCell;
 
     use super::*;
@@ -502,7 +502,7 @@ mod tests {
     static CLEARTEXT: &[u8] = b"This is a test";
 
     /// Initialised [TestKeys] for tests.
-    static KEYS: Lazy<TestKeys> = Lazy::new(TestKeys::new);
+    static KEYS: LazyLock<TestKeys> = LazyLock::new(TestKeys::new);
 
     static CTEXT_SIGNED: OnceCell<String> = OnceCell::const_new();
     static CTEXT_UNSIGNED: OnceCell<String> = OnceCell::const_new();

src/plaintext.rs

@@ -1,6 +1,6 @@
 //! Handle plain text together with some attributes.
 
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 use crate::simplify::remove_message_footer;
 
@@ -25,10 +25,10 @@ impl PlainText {
     /// Convert plain text to HTML.
     /// The function handles quotes, links, fixed and floating text paragraphs.
     pub fn to_html(&self) -> String {
-        static LINKIFY_MAIL_RE: Lazy<regex::Regex> =
+        static LINKIFY_MAIL_RE: LazyLock<regex::Regex> =
-            Lazy::new(|| regex::Regex::new(r"\b([\w.\-+]+@[\w.\-]+)\b").unwrap());
+            LazyLock::new(|| regex::Regex::new(r"\b([\w.\-+]+@[\w.\-]+)\b").unwrap());
 
-        static LINKIFY_URL_RE: Lazy<regex::Regex> = Lazy::new(|| {
+        static LINKIFY_URL_RE: LazyLock<regex::Regex> = LazyLock::new(|| {
             regex::Regex::new(r"\b((http|https|ftp|ftps):[\w.,:;$/@!?&%\-~=#+]+)").unwrap()
         });
 

src/provider/data.rs

@@ -8,7 +8,7 @@ use crate::provider::{
 };
 use std::collections::HashMap;
 
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 // 163.md: 163.com
 static P_163: Provider = Provider {
@@ -2406,7 +2406,8 @@ pub(crate) static PROVIDER_DATA: [(&str, &Provider); 533] = [
     ("zoho.com", &P_ZOHO),
 ];
 
-pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> = Lazy::new(|| {
+pub(crate) static PROVIDER_IDS: LazyLock<HashMap<&'static str, &'static Provider>> =
+    LazyLock::new(|| {
         HashMap::from([
             ("163", &P_163),
             ("aktivix.org", &P_AKTIVIX_ORG),
@@ -2483,7 +2484,7 @@ pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> =
             ("ziggo.nl", &P_ZIGGO_NL),
             ("zoho", &P_ZOHO),
         ])
-});
+    });
 
-pub static _PROVIDER_UPDATED: Lazy<chrono::NaiveDate> =
+pub static _PROVIDER_UPDATED: LazyLock<chrono::NaiveDate> =
-    Lazy::new(|| chrono::NaiveDate::from_ymd_opt(2024, 9, 13).unwrap());
+    LazyLock::new(|| chrono::NaiveDate::from_ymd_opt(2024, 9, 13).unwrap());

src/qr.rs

@@ -2,11 +2,11 @@
 
 mod dclogin_scheme;
 use std::collections::BTreeMap;
+use std::sync::LazyLock;
 
 use anyhow::{anyhow, bail, ensure, Context as _, Result};
 pub use dclogin_scheme::LoginOptions;
 use deltachat_contact_tools::{addr_normalize, may_be_valid_addr, ContactAddress};
-use once_cell::sync::Lazy;
 use percent_encoding::{percent_decode_str, percent_encode, NON_ALPHANUMERIC};
 use serde::Deserialize;
 
@@ -915,10 +915,10 @@ async fn decode_matmsg(context: &Context, qr: &str) -> Result<Qr> {
     Qr::from_address(context, name, &addr, None).await
 }
 
-static VCARD_NAME_RE: Lazy<regex::Regex> =
+static VCARD_NAME_RE: LazyLock<regex::Regex> =
-    Lazy::new(|| regex::Regex::new(r"(?m)^N:([^;]*);([^;\n]*)").unwrap());
+    LazyLock::new(|| regex::Regex::new(r"(?m)^N:([^;]*);([^;\n]*)").unwrap());
-static VCARD_EMAIL_RE: Lazy<regex::Regex> =
+static VCARD_EMAIL_RE: LazyLock<regex::Regex> =
-    Lazy::new(|| regex::Regex::new(r"(?m)^EMAIL([^:\n]*):([^;\n]*)").unwrap());
+    LazyLock::new(|| regex::Regex::new(r"(?m)^EMAIL([^:\n]*):([^;\n]*)").unwrap());
 
 /// Extract address for the vcard scheme.
 ///

src/receive_imf.rs

@@ -2,6 +2,7 @@
 
 use std::collections::HashSet;
 use std::iter;
+use std::sync::LazyLock;
 
 use anyhow::{Context as _, Result};
 use data_encoding::BASE32_NOPAD;
@@ -9,7 +10,6 @@ use deltachat_contact_tools::{addr_cmp, may_be_valid_addr, sanitize_single_line,
 use iroh_gossip::proto::TopicId;
 use mailparse::SingleInfo;
 use num_traits::FromPrimitive;
-use once_cell::sync::Lazy;
 use regex::Regex;
 
 use crate::aheader::EncryptPreference;
@@ -2717,7 +2717,7 @@ async fn group_changes_msgs(
     Ok(group_changes_msgs)
 }
 
-static LIST_ID_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"^(.+)<(.+)>$").unwrap());
+static LIST_ID_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(.+)<(.+)>$").unwrap());
 
 fn mailinglist_header_listid(list_id_header: &str) -> Result<String> {
     Ok(match LIST_ID_REGEX.captures(list_id_header) {
@@ -2825,8 +2825,8 @@ fn compute_mailinglist_name(
     // (as that part is much more visible, we assume, that names is shorter and comes more to the point,
     // than the sometimes longer part from ListId)
     let subject = mime_parser.get_subject().unwrap_or_default();
-    static SUBJECT: Lazy<Regex> =
+    static SUBJECT: LazyLock<Regex> =
-        Lazy::new(|| Regex::new(r"^.{0,5}\[(.+?)\](\s*\[.+\])?").unwrap()); // remove square brackets around first name
+        LazyLock::new(|| Regex::new(r"^.{0,5}\[(.+?)\](\s*\[.+\])?").unwrap()); // remove square brackets around first name
     if let Some(cap) = SUBJECT.captures(&subject) {
         name = cap[1].to_string() + cap.get(2).map_or("", |m| m.as_str());
     }
@@ -2853,8 +2853,8 @@ fn compute_mailinglist_name(
     // but strip some known, long hash prefixes
     if name.is_empty() {
         // 51231231231231231231231232869f58.xing.com -> xing.com
-        static PREFIX_32_CHARS_HEX: Lazy<Regex> =
+        static PREFIX_32_CHARS_HEX: LazyLock<Regex> =
-            Lazy::new(|| Regex::new(r"([0-9a-fA-F]{32})\.(.{6,})").unwrap());
+            LazyLock::new(|| Regex::new(r"([0-9a-fA-F]{32})\.(.{6,})").unwrap());
         if let Some(cap) = PREFIX_32_CHARS_HEX
             .captures(listid)
             .and_then(|caps| caps.get(2))

src/release.rs

@@ -1,10 +1,10 @@
 //! DC release info.
 
 use chrono::NaiveDate;
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 const DATE_STR: &str = include_str!("../release-date.in");
 
 /// Last release date.
-pub static DATE: Lazy<NaiveDate> =
+pub static DATE: LazyLock<NaiveDate> =
-    Lazy::new(|| NaiveDate::parse_from_str(DATE_STR, "%Y-%m-%d").unwrap());
+    LazyLock::new(|| NaiveDate::parse_from_str(DATE_STR, "%Y-%m-%d").unwrap());

src/test_utils.rs

@@ -6,14 +6,13 @@ use std::fmt::Write;
 use std::ops::{Deref, DerefMut};
 use std::panic;
 use std::path::Path;
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 use std::time::{Duration, Instant};
 
 use async_channel::{self as channel, Receiver, Sender};
 use chat::ChatItem;
 use deltachat_contact_tools::{ContactAddress, EmailAddress};
 use nu_ansi_term::Color;
-use once_cell::sync::Lazy;
 use pretty_assertions::assert_eq;
 use rand::Rng;
 use tempfile::{tempdir, TempDir};
@@ -47,8 +46,8 @@ use crate::tools::time;
 pub const AVATAR_900x900_BYTES: &[u8] = include_bytes!("../test-data/image/avatar900x900.png");
 
 /// Map of context IDs to names for [`TestContext`]s.
-static CONTEXT_NAMES: Lazy<std::sync::RwLock<BTreeMap<u32, String>>> =
+static CONTEXT_NAMES: LazyLock<std::sync::RwLock<BTreeMap<u32, String>>> =
-    Lazy::new(|| std::sync::RwLock::new(BTreeMap::new()));
+    LazyLock::new(|| std::sync::RwLock::new(BTreeMap::new()));
 
 /// Manage multiple [`TestContext`]s in one place.
 ///