Change set:

- Add more inlining
- Fix/simplify comments
- Fix Send + Sync for async

Author: commonsensesoftware

Cargo.toml

@@ -11,3 +11,4 @@ edition = "2018"
 
 [workspace.dependencies]
 cfg-if = "1.0"
+maybe-impl = "0.1.0"

src/di/Cargo.toml

@@ -43,3 +43,6 @@ colored = { version = "2.0", optional = true }
 path = "."
 default-features = false
 features = ["builder", "lazy", "fmt"]
+
+[dev-dependencies]
+maybe-impl.workspace = true

src/di/activator.rs

@@ -1,6 +1,30 @@
 use crate::{Mut, Ref, RefMut, ServiceFactory, ServiceProvider, Type};
 use std::any::Any;
 
+macro_rules! new {
+    ($($traits:tt)+) => {
+        /// Creates a new activator using the specified factory methods to instantiate the service.
+        ///
+        /// # Arguments
+        ///
+        /// * `factory` - The factory method used to create a service instance
+        /// * `factory_mut` - The factory method used to create a mutable service instance
+        pub fn new<TSvc: ?Sized + $($traits)+, TImpl>(
+            factory: fn(&ServiceProvider) -> Ref<TSvc>,
+            factory_mut: fn(&ServiceProvider) -> RefMut<TSvc>,
+        ) -> Self {
+            Self {
+                service_type: Type::of::<TSvc>(),
+                service_type_mut: Type::of::<Mut<TSvc>>(),
+                implementation_type: Type::of::<TImpl>(),
+                factory: Ref::new(move |sp| Ref::new(factory(sp))),
+                factory_mut: Ref::new(move |sp| Ref::new(factory_mut(sp))),
+                mutable: false,
+            }
+        }
+    };
+}
+
 /// Represents an activator for a service instance.
 pub struct Activator {
     service_type: Type,
@@ -12,7 +36,7 @@ pub struct Activator {
 }
 
 impl Activator {
-    /// Gets the [service type](crate::Type) associated with the service descriptor.
+    /// Gets the [service type](Type) associated with the service descriptor.
     pub fn service_type(&self) -> &Type {
         if self.mutable {
             &self.service_type_mut
@@ -21,17 +45,19 @@ impl Activator {
         }
     }
 
-    /// Gets the [implementation type](crate::Type) associated with the service descriptor.
+    /// Gets the [implementation type](Type) associated with the service descriptor.
+    #[inline]
     pub fn implementation_type(&self) -> &Type {
         &self.implementation_type
     }
 
     /// Sets a value indicating whether the activated instance should be mutable.
+    #[inline]
     pub fn as_mut(&mut self) {
         self.mutable = true;
     }
 
-    /// Gets the factory method the activator represents.
+    /// Gets the [factory](ServiceFactory) method the activator represents.
     pub fn factory(&self) -> Ref<ServiceFactory> {
         if self.mutable {
             self.factory_mut.clone()
@@ -40,23 +66,11 @@ impl Activator {
         }
     }
 
-    /// Creates a new activator using the specified factory methods to instantiate the service.
-    ///
-    /// # Arguments
-    ///
-    /// * `factory` - The factory method used to create a service instance
-    /// * `factory_mut` - The factory method used to create a mutable service instance
-    pub fn new<TSvc: Any + ?Sized, TImpl>(
-        factory: fn(&ServiceProvider) -> Ref<TSvc>,
-        factory_mut: fn(&ServiceProvider) -> RefMut<TSvc>,
-    ) -> Self {
-        Self {
-            service_type: Type::of::<TSvc>(),
-            service_type_mut: Type::of::<Mut<TSvc>>(),
-            implementation_type: Type::of::<TImpl>(),
-            factory: Ref::new(move |sp| Ref::new(factory(sp))),
-            factory_mut: Ref::new(move |sp| Ref::new(factory_mut(sp))),
-            mutable: false,
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "async")] {
+            new!(Any + Send + Sync);
+        } else {
+            new!(Any);
         }
     }
 }