Merge pull request #247 from lbeschastny/fix/duration-imports

Qualify `std::time::Duration` in proc macros

Author: jaemk

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## [Unreleased]
 ## Added
 ## Changed
+- Using proc macros no longer require importing `std::time::Duration`
 ## Removed
 
 ## [0.56.0 / [cached_proc_macro[0.25.0]]]

README.md

@@ -86,7 +86,6 @@ fn keyed(a: &str, b: &str) -> usize {
 
 ```rust
 use cached::proc_macro::once;
-use std::time::Duration;
 
 /// Only cache the initial function call.
 /// Function will be re-executed after the cache

cached_proc_macro/src/cached.rs

@@ -125,12 +125,12 @@ pub fn cached(args: TokenStream, input: TokenStream) -> TokenStream {
         }
         (false, None, Some(time), None, None, time_refresh) => {
             let cache_ty = quote! {cached::TimedCache<#cache_key_ty, #cache_value_ty>};
-            let cache_create = quote! {cached::TimedCache::with_lifespan_and_refresh(Duration::from_secs(#time), #time_refresh)};
+            let cache_create = quote! {cached::TimedCache::with_lifespan_and_refresh(std::time::Duration::from_secs(#time), #time_refresh)};
             (cache_ty, cache_create)
         }
         (false, Some(size), Some(time), None, None, time_refresh) => {
             let cache_ty = quote! {cached::TimedSizedCache<#cache_key_ty, #cache_value_ty>};
-            let cache_create = quote! {cached::TimedSizedCache::with_size_and_lifespan_and_refresh(#size, Duration::from_secs(#time), #time_refresh)};
+            let cache_create = quote! {cached::TimedSizedCache::with_size_and_lifespan_and_refresh(#size, std::time::Duration::from_secs(#time), #time_refresh)};
             (cache_ty, cache_create)
         }
         (false, None, None, None, None, _) => {

cached_proc_macro/src/helpers.rs

@@ -201,7 +201,7 @@ pub(super) fn gen_return_cache_block(
     if let Some(time) = &time {
         quote! {
             let (created_sec, result) = result;
-            if now.duration_since(*created_sec) < Duration::from_secs(#time) {
+            if now.duration_since(*created_sec) < std::time::Duration::from_secs(#time) {
                 #return_cache_block
             }
         }

cached_proc_macro/src/io_cached.rs

@@ -225,19 +225,19 @@ pub fn io_cached(args: TokenStream, input: TokenStream) -> TokenStream {
                         match time_refresh {
                             Some(time_refresh) => {
                                 if asyncness.is_some() {
-                                    quote! { cached::AsyncRedisCache::new(#cache_prefix, Duration::from_secs(#time)).set_refresh(#time_refresh).build().await.expect("error constructing AsyncRedisCache in #[io_cached] macro") }
+                                    quote! { cached::AsyncRedisCache::new(#cache_prefix, std::time::Duration::from_secs(#time)).set_refresh(#time_refresh).build().await.expect("error constructing AsyncRedisCache in #[io_cached] macro") }
                                 } else {
                                     quote! {
-                                        cached::RedisCache::new(#cache_prefix, Duration::from_secs(#time)).set_refresh(#time_refresh).build().expect("error constructing RedisCache in #[io_cached] macro")
+                                        cached::RedisCache::new(#cache_prefix, std::time::Duration::from_secs(#time)).set_refresh(#time_refresh).build().expect("error constructing RedisCache in #[io_cached] macro")
                                     }
                                 }
                             }
                             None => {
                                 if asyncness.is_some() {
-                                    quote! { cached::AsyncRedisCache::new(#cache_prefix, Duration::from_secs(#time)).build().await.expect("error constructing AsyncRedisCache in #[io_cached] macro") }
+                                    quote! { cached::AsyncRedisCache::new(#cache_prefix, std::time::Duration::from_secs(#time)).build().await.expect("error constructing AsyncRedisCache in #[io_cached] macro") }
                                 } else {
                                     quote! {
-                                        cached::RedisCache::new(#cache_prefix, Duration::from_secs(#time)).build().expect("error constructing RedisCache in #[io_cached] macro")
+                                        cached::RedisCache::new(#cache_prefix, std::time::Duration::from_secs(#time)).build().expect("error constructing RedisCache in #[io_cached] macro")
                                     }
                                 }
                             }
@@ -297,7 +297,7 @@ pub fn io_cached(args: TokenStream, input: TokenStream) -> TokenStream {
                         None => create,
                         Some(time) => {
                             quote! {
-                                (#create).set_lifespan(Duration::from_secs(#time))
+                                (#create).set_lifespan(std::time::Duration::from_secs(#time))
                             }
                         }
                     };

src/lib.rs

@@ -87,7 +87,6 @@ fn keyed(a: &str, b: &str) -> usize {
 
 ```rust,no_run
 use cached::proc_macro::once;
-use std::time::Duration;
 
 /// Only cache the initial function call.
 /// Function will be re-executed after the cache