Merge pull request #550 from Expyron/master

Use `const Mutex::new()` whenever possible

.cirrus.yml

@@ -14,7 +14,7 @@ common: &COMMON
 task:
   name: MSRV
   container:
-    image: rust:1.64.0
+    image: rust:1.70.0
   cargo_lock_script:
     - cp Cargo.lock.msrv Cargo.lock
   << : *COMMON

CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [ Unreleased ] - ReleaseDate
+
+### Changed
+
+- Raised MSRV to 1.70.0 to remove `lazy_static` dependency
+  ([#550](https://github.com/asomers/mockall/pull/550))
 
 ## [ 0.12.1 ] - 2023-12-21
 

README.md

@@ -62,7 +62,7 @@ See the [API docs](https://docs.rs/mockall) for more information.
 
 # Minimum Supported Rust Version (MSRV)
 
-Mockall is supported on Rust 1.64.0 and higher.  Mockall's MSRV will not be
+Mockall is supported on Rust 1.70.0 and higher.  Mockall's MSRV will not be
 changed in the future without bumping the major or minor version.
 
 # License

mockall/Cargo.toml

@@ -9,7 +9,7 @@ categories = ["development-tools::testing"]
 keywords = ["mock", "mocking", "testing"]
 documentation = "https://docs.rs/mockall"
 edition = "2021"
-rust-version = "1.60"
+rust-version = "1.70"
 description = """
 A powerful mock object library for Rust.
 """
@@ -41,7 +41,6 @@ nightly = [
 cfg-if = "1.0"
 downcast = "0.11"
 fragile = "2.0"
-lazy_static = "1.1"
 predicates = { version = "3.0.0", default-features = false }
 predicates-tree = "1.0"
 mockall_derive = { version = "=0.12.1", path = "../mockall_derive" }
@@ -53,7 +52,7 @@ mockall_double = { version = "^0.3.1", path = "../mockall_double" }
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
-tracing = "0.1.32"
+tracing = "0.1.35"
 
 [[example]]
 name = "serde"

mockall/examples/synchronization.rs

@@ -6,7 +6,7 @@
 //! overwrites the mock that another test is depending on. The solution to this
 //! is to add some form of synchronization so that tests that depend on a
 //! specific mock will not run in parallel. This is easily achieved using a
-//! Mutex and the lazy_static crate.
+//! Mutex.
 #![deny(warnings)]
 
 use mockall_double::double;
@@ -34,12 +34,9 @@ fn main() {
 #[cfg(test)]
 mod test {
     use crate::my_mock::MockThing;
-    use lazy_static::lazy_static;
     use std::sync::Mutex;
 
-    lazy_static! {
-        static ref MTX: Mutex<()> = Mutex::new(());
-    }
+    static MTX: Mutex<()> = Mutex::new(());
 
     #[test]
     fn test_1() {

mockall/src/lib.rs

@@ -1162,10 +1162,6 @@ pub use downcast::{Any, Downcast};
 #[doc(hidden)]
 pub use fragile::Fragile;
 
-/// For mocking static methods
-#[doc(hidden)]
-pub use lazy_static::lazy_static;
-
 pub use predicates::{
     boolean::PredicateBooleanExt,
     prelude::{

mockall/tests/automock_foreign_c.rs

@@ -11,9 +11,7 @@ mod ffi {
     }
 }
 
-lazy_static! {
-    static ref FOO_MTX: Mutex<()> = Mutex::new(());
-}
+static FOO_MTX: Mutex<()> = Mutex::new(());
 
 // Ensure we can still use the original mocked function
 pub fn normal_usage() {

mockall/tests/automock_generic_static_method.rs

@@ -5,9 +5,7 @@
 use mockall::*;
 use std::sync::Mutex;
 
-lazy_static! {
-    static ref A_MTX: Mutex<()> = Mutex::new(());
-}
+static A_MTX: Mutex<()> = Mutex::new(());
 
 #[automock]
 trait A {

mockall/tests/automock_module.rs

@@ -8,9 +8,7 @@ pub mod m {
     use mockall::*;
     type T = u32;
 
-    lazy_static! {
-        static ref BAR_MTX: Mutex<()> = Mutex::new(());
-    }
+    static BAR_MTX: Mutex<()> = Mutex::new(());
 
     #[automock]
     pub mod foo {

mockall/tests/automock_nonsend.rs

@@ -95,11 +95,9 @@ pub mod static_method {
     use super::*;
     use std::sync::Mutex;
 
-    lazy_static! {
-        static ref FOO_MTX: Mutex<()> = Mutex::new(());
-        static ref BAR_MTX: Mutex<()> = Mutex::new(());
-        static ref BAZ_MTX: Mutex<()> = Mutex::new(());
-    }
+    static FOO_MTX: Mutex<()> = Mutex::new(());
+    static BAR_MTX: Mutex<()> = Mutex::new(());
+    static BAZ_MTX: Mutex<()> = Mutex::new(());
 
     #[automock]
     trait Foo {

mockall/tests/mock_generic_struct_with_generic_static_method.rs

@@ -11,9 +11,7 @@ mock! {
     }
 }
 
-lazy_static! {
-    static ref FOO_MTX: Mutex<()> = Mutex::new(());
-}
+static FOO_MTX: Mutex<()> = Mutex::new(());
 
 // Checkpointing the mock object should not checkpoint static methods too
 #[test]

mockall/tests/mock_static_method_with_lifetime_parameters.rs

@@ -20,9 +20,7 @@ mock!{
     }
 }
 
-lazy_static! {
-    static ref FOO_MTX: Mutex<()> = Mutex::new(());
-}
+static FOO_MTX: Mutex<()> = Mutex::new(());
 
 #[test]
 fn return_const() {

mockall/tests/mock_struct_with_static_method.rs

@@ -10,9 +10,7 @@ mock!{
     }
 }
 
-lazy_static! {
-    static ref BAR_MTX: Mutex<()> = Mutex::new(());
-}
+static BAR_MTX: Mutex<()> = Mutex::new(());
 
 // Checkpointing the mock object should not checkpoint static methods
 #[test]

mockall_derive/src/mock_function.rs

@@ -518,7 +518,7 @@ impl MockFunction {
                     use ::mockall::{ViaDebug, ViaNothing};
                     let no_match_msg = #no_match_msg;
                     #deref {
-                        let __mockall_guard = #outer_mod_path::EXPECTATIONS
+                        let __mockall_guard = #outer_mod_path::get_expectations()
                             .lock().unwrap();
                         /*
                          * TODO: catch panics, then gracefully release the mutex
@@ -558,7 +558,7 @@ impl MockFunction {
             quote!(
                 #(#attrs)*
                 {
-                    let __mockall_timeses = #inner_mod_ident::EXPECTATIONS.lock()
+                    let __mockall_timeses = #inner_mod_ident::get_expectations().lock()
                         .unwrap()
                         .checkpoint()
                         .collect::<Vec<_>>();
@@ -1188,14 +1188,14 @@ impl<'a> ToTokens for CommonExpectationsMethods<'a> {
                     &mut self.0[__mockall_l - 1]
                 }
 
-                #v fn new() -> Self {
-                    Self::default()
+                #v const fn new() -> Self {
+                    Self(Vec::new())
                 }
             }
             impl #ig Default for Expectations #tg #wc
             {
                 fn default() -> Self {
-                    Expectations(Vec::new())
+                    Expectations::new()
                 }
             }
         ).to_tokens(tokens);
@@ -1397,12 +1397,14 @@ impl<'a> ToTokens for ConcreteExpectationGuard<'a> {
         let (ei_ig, _, _) = e_generics.split_for_impl();
         let v = &self.f.privmod_vis;
         quote!(
-            ::mockall::lazy_static! {
-                #[doc(hidden)]
-                #v static ref EXPECTATIONS:
+            #[doc(hidden)]
+            #v fn get_expectations() -> &'static ::std::sync::Mutex<Expectations> {
+                static EXPECTATIONS:
                     ::std::sync::Mutex<Expectations #tg> =
                     ::std::sync::Mutex::new(Expectations::new());
+                &EXPECTATIONS
             }
+
             /// Like an [`&Expectation`](struct.Expectation.html) but
             /// protected by a Mutex guard.  Useful for mocking static
             /// methods.  Forwards accesses to an `Expectation` object.
@@ -1466,11 +1468,12 @@ impl<'a> ToTokens for GenericExpectationGuard<'a> {
         let tbf = tg.as_turbofish();
         let v = &self.f.privmod_vis;
         quote!(
-            ::mockall::lazy_static! {
-                #v static ref EXPECTATIONS:
-                    ::std::sync::Mutex<GenericExpectations> =
-                    ::std::sync::Mutex::new(GenericExpectations::new());
+            #[doc(hidden)]
+            #v fn get_expectations() -> &'static ::std::sync::Mutex<GenericExpectations> {
+                static CELL: ::std::sync::OnceLock<::std::sync::Mutex<GenericExpectations>> = ::std::sync::OnceLock::new();
+                CELL.get_or_init(|| ::std::sync::Mutex::new(GenericExpectations::new()))
             }
+
             /// Like an [`&Expectation`](struct.Expectation.html) but
             /// protected by a Mutex guard.  Useful for mocking static
             /// methods.  Forwards accesses to an `Expectation` object.
@@ -1571,7 +1574,7 @@ impl<'a> ToTokens for Context<'a> {
                 }
                 #[doc(hidden)]
                 #v fn do_checkpoint() {
-                    let __mockall_timeses = EXPECTATIONS
+                    let __mockall_timeses = get_expectations()
                         .lock()
                         .unwrap()
                         .checkpoint()
@@ -1583,7 +1586,7 @@ impl<'a> ToTokens for Context<'a> {
                 #v fn expect #meth_ig ( &self,) -> ExpectationGuard #e_tg
                     #meth_wc
                 {
-                    ExpectationGuard::new(EXPECTATIONS.lock().unwrap())
+                    ExpectationGuard::new(get_expectations().lock().unwrap())
                 }
             }
             impl #ty_ig Default for Context #ty_tg #ty_wc {
@@ -1597,7 +1600,7 @@ impl<'a> ToTokens for Context<'a> {
                         // Drain all expectations so other tests can run with a
                         // blank slate.  But ignore errors so we don't
                         // double-panic.
-                        let _ = EXPECTATIONS
+                        let _ = get_expectations()
                             .lock()
                             .map(|mut g| g.checkpoint().collect::<Vec<_>>());
                     } else {