Replace lazy_static with std::sync::OnceLock, bump MSRV to 1.71

Author: ogoffart

.github/workflows/rust.yml

@@ -17,7 +17,7 @@ jobs:
         rust:
           - stable
           - nightly
-          - 1.65.0
+          - 1.71.0
         os:
           - ubuntu-latest
           - macos-11
@@ -27,14 +27,6 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Install old nightly for minimal-versions (produces v3 lockfile)
-      if: matrix.rust == '1.65.0'
-      uses: dtolnay/rust-toolchain@stable
-      with:
-          toolchain: nightly-2024-02-01
-    - name: Generate minimal-versions lockfile
-      if: matrix.rust == '1.65.0'
-      run: cargo +nightly-2024-02-01 -Z minimal-versions generate-lockfile
     - uses: dtolnay/rust-toolchain@stable
       with:
           toolchain: ${{ matrix.rust }}

cpp_build/Cargo.toml

@@ -18,7 +18,6 @@ docs-only = []
 parallel = ["cc/parallel"]
 
 [dependencies]
-lazy_static = "1.0"
 cc = "1.0.38"
 cpp_common = { path = "../cpp_common", version = "=0.5.10" }
 syn = { version = "2.0", features=["full", "visit"] }

cpp_build/src/lib.rs

@@ -9,12 +9,12 @@
 mod strnom;
 
 use cpp_common::*;
-use lazy_static::lazy_static;
 use std::collections::hash_map::{Entry, HashMap};
 use std::env;
 use std::fs::{create_dir, remove_dir_all, File};
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
 
 mod parser;
 
@@ -122,19 +122,27 @@ template<typename T> int compare_helper(const T &a, const T&b, int cmp) {
     }
 "#;
 
-lazy_static! {
-    static ref CPP_DIR: PathBuf = OUT_DIR.join("rust_cpp");
-    static ref CARGO_MANIFEST_DIR: PathBuf = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect(
-        r#"
+static CPP_DIR_LOCK: OnceLock<PathBuf> = OnceLock::new();
+static CARGO_MANIFEST_DIR_LOCK: OnceLock<PathBuf> = OnceLock::new();
+
+fn cpp_dir() -> &'static PathBuf {
+    CPP_DIR_LOCK.get_or_init(|| out_dir().join("rust_cpp"))
+}
+
+fn cargo_manifest_dir() -> &'static PathBuf {
+    CARGO_MANIFEST_DIR_LOCK.get_or_init(|| {
+        PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect(
+            r#"
 -- rust-cpp fatal error --
 
 The CARGO_MANIFEST_DIR environment variable was not set.
-NOTE: rust-cpp's build function must be run in a build script."#
-    ));
+NOTE: rust-cpp's build function must be run in a build script."#,
+        ))
+    })
 }
 
 fn gen_cpp_lib(visitor: &parser::Parser) -> PathBuf {
-    let result_path = CPP_DIR.join("cpp_closures.cpp");
+    let result_path = cpp_dir().join("cpp_closures.cpp");
     let mut output = File::create(&result_path).expect("Unable to generate temporary C++ file");
 
     write!(output, "{}", INTERNAL_CPP_STRUCTS).unwrap();
@@ -146,7 +154,7 @@ extern "C" {{
     void (*rust_cpp_callbacks{file_hash}[{callbacks_count}])() = {{}};
 }}
         "#,
-            file_hash = *FILE_HASH,
+            file_hash = file_hash(),
             callbacks_count = visitor.callbacks_count
         ).unwrap();
     }
@@ -348,7 +356,7 @@ MetaData metadata_{hash} = {{
 
 }} // namespace rustcpp
 "#,
-        hash = *FILE_HASH,
+        hash = file_hash(),
         data = sizealign.join(", "),
         length = sizealign.len(),
         magic = magic.join(", "),
@@ -364,16 +372,16 @@ MetaData metadata_{hash} = {{
 }
 
 fn clean_artifacts() {
-    if CPP_DIR.is_dir() {
-        remove_dir_all(&*CPP_DIR).expect(
+    if cpp_dir().is_dir() {
+        remove_dir_all(cpp_dir()).expect(
             r#"
 -- rust-cpp fatal error --
 
 Failed to remove existing build artifacts from output directory."#,
         );
     }
 
-    create_dir(&*CPP_DIR).expect(
+    create_dir(cpp_dir()).expect(
         r#"
 -- rust-cpp fatal error --
 
@@ -405,7 +413,7 @@ impl Default for Config {
 /// directories to work with `cpp`.
 impl From<cc::Build> for Config {
     fn from(mut cc: cc::Build) -> Self {
-        cc.cpp(true).include(&*CARGO_MANIFEST_DIR);
+        cc.cpp(true).include(cargo_manifest_dir());
         Self { cc, std_flag_set: false }
     }
 }

cpp_build/src/parser.rs

@@ -1,11 +1,11 @@
 use cpp_common::{Class, Closure, Macro, RustInvocation};
-use lazy_static::lazy_static;
 use regex::Regex;
 use std::fmt;
 use std::fs::File;
 use std::io::Read;
 use std::mem::swap;
 use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
 use syn::visit::Visit;
 
 #[allow(clippy::enum_variant_names)]
@@ -114,11 +114,11 @@ fn expand_sub_rust_macro(input: String, mut t: ExpandSubMacroType) -> Result<Str
                 rust_invocation.id.clone().to_string()
             }
             ExpandSubMacroType::Closure(ref mut offset) => {
-                use cpp_common::FILE_HASH;
+                use cpp_common::file_hash;
                 **offset += 1;
                 format!(
                     "rust_cpp_callbacks{file_hash}[{offset}]",
-                    file_hash = *FILE_HASH,
+                    file_hash = file_hash(),
                     offset = **offset - 1
                 )
             }
@@ -214,10 +214,9 @@ fn skip_literal(mut input: Cursor) -> PResult<bool> {
         }
         return Ok((input.advance(1), true));
     }
-    lazy_static! {
-        static ref RAW: Regex = Regex::new(r##"^b?r#*""##).unwrap();
-    }
-    if RAW.is_match(input.rest) {
+    static RAW: OnceLock<Regex> = OnceLock::new();
+    let raw = RAW.get_or_init(|| Regex::new(r##"^b?r#*""##).unwrap());
+    if raw.is_match(input.rest) {
         let q = input.rest.find('r').unwrap();
         input = input.advance(q + 1);
         return raw_string(input).map(|x| (x.0, true));

cpp_common/Cargo.toml

@@ -13,5 +13,4 @@ documentation = "https://docs.rs/cpp_common"
 
 [dependencies]
 syn = { version = "2.0", features = ["full", "extra-traits"] }
-lazy_static = "1.0"
 proc-macro2 = "1.0"

cpp_common/src/lib.rs

@@ -7,13 +7,11 @@
 extern crate syn;
 extern crate proc_macro2;
 
-#[macro_use]
-extern crate lazy_static;
-
 use std::collections::hash_map::DefaultHasher;
 use std::env;
 use std::hash::{Hash, Hasher};
 use std::path::PathBuf;
+use std::sync::OnceLock;
 
 use proc_macro2::{Span, TokenStream, TokenTree};
 use syn::ext::IdentExt;
@@ -58,19 +56,27 @@ pub const STRUCT_METADATA_MAGIC: [u8; 128] = [
     134, 183, 212, 227, 31,  217, 12,  5,   65,  221, 150, 59,  230, 96,  73,  62,
 ];
 
-lazy_static! {
-    pub static ref OUT_DIR: PathBuf = PathBuf::from(env::var("OUT_DIR").expect(
-        r#"
+static OUT_DIR_LOCK: OnceLock<PathBuf> = OnceLock::new();
+static FILE_HASH_LOCK: OnceLock<u64> = OnceLock::new();
+
+pub fn out_dir() -> &'static PathBuf {
+    OUT_DIR_LOCK.get_or_init(|| {
+        PathBuf::from(env::var("OUT_DIR").expect(
+            r#"
 -- rust-cpp fatal error --
 
 The OUT_DIR environment variable was not set.
-NOTE: rustc must be run by Cargo."#
-    ));
-    pub static ref FILE_HASH: u64 = {
-        let mut hasher = std::collections::hash_map::DefaultHasher::new();
-        OUT_DIR.hash(&mut hasher);
+NOTE: rustc must be run by Cargo."#,
+        ))
+    })
+}
+
+pub fn file_hash() -> u64 {
+    *FILE_HASH_LOCK.get_or_init(|| {
+        let mut hasher = DefaultHasher::new();
+        out_dir().hash(&mut hasher);
         hasher.finish()
-    };
+    })
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]

cpp_macros/Cargo.toml

@@ -20,7 +20,6 @@ docs-only = []
 proc-macro = true
 
 [dependencies]
-lazy_static = "1.0"
 cpp_common = { path = "../cpp_common", version = "=0.5.10" }
 syn = { version = "2.0", features=["full", "visit"] }
 quote = "1.0"

cpp_macros/src/lib.rs

@@ -10,14 +10,14 @@ extern crate syn;
 extern crate proc_macro;
 use proc_macro2::Span;
 
-use cpp_common::{flags, kw, RustInvocation, FILE_HASH, LIB_NAME, MSVC_LIB_NAME, OUT_DIR, VERSION};
+use cpp_common::{file_hash, flags, kw, out_dir, RustInvocation, LIB_NAME, MSVC_LIB_NAME, VERSION};
 use std::collections::HashMap;
 use std::iter::FromIterator;
+use std::sync::OnceLock;
 use syn::parse::Parser;
 use syn::Ident;
 
 use byteorder::{BigEndian, ByteOrder, LittleEndian, ReadBytesExt};
-use lazy_static::lazy_static;
 use quote::{quote, quote_spanned};
 use std::fs::File;
 use std::io::{self, BufReader, Read, Seek, SeekFrom};
@@ -33,8 +33,10 @@ impl MetaData {
     }
 }
 
-lazy_static! {
-    static ref METADATA: HashMap<u64, Vec<MetaData>> = {
+static METADATA_LOCK: OnceLock<HashMap<u64, Vec<MetaData>>> = OnceLock::new();
+
+fn metadata() -> &'static HashMap<u64, Vec<MetaData>> {
+    METADATA_LOCK.get_or_init(|| {
         let file = match open_lib_file() {
             Ok(x) => x,
             Err(e) => {
@@ -62,7 +64,7 @@ NOTE: Did you make sure to add the rust-cpp build script?
 
 I/O error while reading metadata from target library file."#,
         )
-    };
+    })
 }
 
 /// NOTE: This panics when it can produce a better error message
@@ -126,10 +128,10 @@ fn read_metadata_rest<E: ByteOrder>(
 /// metadata. We check both `MSVC_LIB_NAME` and `LIB_NAME`, in case we are on
 /// or are targeting Windows.
 fn open_lib_file() -> io::Result<File> {
-    if let Ok(file) = File::open(OUT_DIR.join(MSVC_LIB_NAME)) {
+    if let Ok(file) = File::open(out_dir().join(MSVC_LIB_NAME)) {
         Ok(file)
     } else {
-        File::open(OUT_DIR.join(LIB_NAME))
+        File::open(out_dir().join(LIB_NAME))
     }
 }
 
@@ -195,7 +197,7 @@ pub fn expand_internal(input: proc_macro::TokenStream) -> proc_macro::TokenStrea
     };
 
     // Get the size data compiled by the build macro
-    let size_data = match METADATA.get(&closure.sig.name_hash()) {
+    let size_data = match metadata().get(&closure.sig.name_hash()) {
         Some(x) => x,
         None => {
             #[cfg(not(feature = "docs-only"))]
@@ -314,7 +316,7 @@ NOTE: They cannot be generated by macro expansion."#})
     let rust_invocations = find_all_rust_macro.parse2(input).expect("rust! macro");
     let init_callbacks = if !rust_invocations.is_empty() {
         let rust_cpp_callbacks =
-            Ident::new(&format!("rust_cpp_callbacks{}", *FILE_HASH), Span::call_site());
+            Ident::new(&format!("rust_cpp_callbacks{}", file_hash()), Span::call_site());
         let offset = (flags >> 32) as isize;
         let callbacks: Vec<Ident> = rust_invocations.iter().map(|x| x.id.clone()).collect();
         quote! {
@@ -370,7 +372,7 @@ pub fn expand_wrap_class(input: proc_macro::TokenStream) -> proc_macro::TokenStr
     let class_name = class.name.clone();
 
     // Get the size data compiled by the build macro
-    let size_data = match METADATA.get(&hash) {
+    let size_data = match metadata().get(&hash) {
         Some(x) => x,
         None => {
             #[cfg(not(feature = "docs-only"))]