Merge pull request #555 from asomers/inline

Handle the #[inline], #[cold], and #[must_use] attributes

Author: asomers

CHANGELOG.md

@@ -5,6 +5,12 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [ Unreleased ] - ReleaseDate
 
+### Added
+
+- Add the ability to mock methods that use `#[inline]` or `#[cold]`, and
+  methods or traits that use `#[must_use]`.
+  ([#555](https://github.com/asomers/mockall/pull/555))
+
 ### Changed
 
 - Raised MSRV to 1.70.0 to remove `lazy_static` dependency

mockall/tests/automock_inline.rs

@@ -0,0 +1,52 @@
+// vim: tw=80
+//! Mockall should ignore and not emit attributes like "inline" that affect
+//! code generation.
+#![deny(warnings)]
+
+use mockall::*;
+
+pub struct Foo {}
+
+#[automock]
+impl Foo {
+    #[inline]
+    pub fn foo(&self) -> i32 {unimplemented!()}
+    #[inline]
+    pub fn bar() -> i32 {unimplemented!()}
+    #[cold]
+    pub fn baz(&self) -> i32 {unimplemented!()}
+    #[cold]
+    pub fn bean() -> i32 {unimplemented!()}
+}
+
+#[test]
+fn inline_method() {
+    let mut mock = MockFoo::new();
+    mock.expect_foo()
+        .return_const(42i32);
+    assert_eq!(mock.foo(), 42);
+}
+
+#[test]
+fn inline_static_method() {
+    let ctx = MockFoo::bar_context();
+    ctx.expect()
+        .return_const(42i32);
+    assert_eq!(MockFoo::bar(), 42);
+}
+
+#[test]
+fn cold_method() {
+    let mut mock = MockFoo::new();
+    mock.expect_baz()
+        .return_const(42i32);
+    assert_eq!(mock.baz(), 42);
+}
+
+#[test]
+fn cold_static_method() {
+    let ctx = MockFoo::bean_context();
+    ctx.expect()
+        .return_const(42i32);
+    assert_eq!(MockFoo::bean(), 42);
+}

mockall/tests/automock_must_use.rs

@@ -0,0 +1,60 @@
+// vim: tw=80
+//! Mockall should be able to mock #[must_use] methods.  The generated code
+//! should contain #[must_use] on the mock method, but not the expect method.
+#![deny(warnings)]
+
+use mockall::*;
+
+pub struct Foo {}
+
+#[automock]
+impl Foo {
+    #[must_use]
+    pub fn bloob(&self) -> i32 {unimplemented!()}
+    #[must_use]
+    pub fn blarg() -> i32 {unimplemented!()}
+}
+
+// test that basic code generation works with must_use structs and traits.  The
+// exact output will be verified by the unit tests.
+#[must_use]
+pub struct MustUseStruct {}
+#[automock]
+impl MustUseStruct {}
+#[automock]
+#[must_use]
+pub trait MustUseTrait {}
+
+#[test]
+fn must_use_method() {
+    let mut mock = MockFoo::new();
+    mock.expect_bloob()
+        .return_const(42i32);
+    assert_eq!(42, mock.bloob());
+}
+
+#[cfg(feature = "nightly")]
+#[test]
+fn may_not_use_expectation() {
+    let mut mock = MockFoo::new();
+    // This should not produce a "must_use" warning.
+    mock.expect_bloob();
+}
+
+#[test]
+fn must_use_static_method() {
+    let ctx = MockFoo::blarg_context();
+    ctx.expect()
+        .return_const(42i32);
+    assert_eq!(MockFoo::blarg(), 42);
+}
+
+#[cfg(feature = "nightly")]
+#[test]
+fn may_not_use_static_expectation() {
+    let ctx = MockFoo::blarg_context();
+    // This should not produce a "must_use" warning.
+    ctx.expect();
+}
+
+

mockall_derive/src/lib.rs

@@ -727,19 +727,20 @@ fn find_lifetimes(ty: &Type) -> HashSet<Lifetime> {
     }
 }
 
-
 struct AttrFormatter<'a>{
     attrs: &'a [Attribute],
     async_trait: bool,
     doc: bool,
+    must_use: bool,
 }
 
 impl<'a> AttrFormatter<'a> {
     fn new(attrs: &'a [Attribute]) -> AttrFormatter<'a> {
         Self {
             attrs,
             async_trait: true,
-            doc: true
+            doc: true,
+            must_use: false,
         }
     }
 
@@ -753,6 +754,11 @@ impl<'a> AttrFormatter<'a> {
         self
     }
 
+    fn must_use(&mut self, allowed: bool) -> &mut Self {
+        self.must_use = allowed;
+        self
+    }
+
     // XXX This logic requires that attributes are imported with their
     // standard names.
     #[allow(clippy::needless_bool)]
@@ -773,6 +779,12 @@ impl<'a> AttrFormatter<'a> {
                     self.doc
                 } else if *i.as_ref().unwrap() == "async_trait" {
                     self.async_trait
+                } else if *i.as_ref().unwrap() == "inline" {
+                    // No need to inline mock functions.
+                    false
+                } else if *i.as_ref().unwrap() == "cold" {
+                    // No need for such hints on mock functions.
+                    false
                 } else if *i.as_ref().unwrap() == "instrument" {
                     // We can't usefully instrument the mock method, so just
                     // ignore this attribute.
@@ -782,6 +794,8 @@ impl<'a> AttrFormatter<'a> {
                     // This shows up sometimes when mocking ffi functions.  We
                     // must not emit it on anything that isn't an ffi definition
                     false
+                } else if *i.as_ref().unwrap() == "must_use" {
+                    self.must_use
                 } else {
                     true
                 }
@@ -1323,7 +1337,7 @@ fn assert_contains(output: &str, tokens: TokenStream) {
 
 fn assert_not_contains(output: &str, tokens: TokenStream) {
     let s = tokens.to_string();
-    assert!(!output.contains(&s), "output does not contain {:?}", &s);
+    assert!(!output.contains(&s), "output contains {:?}", &s);
 }
 
 /// Various tests for overall code generation that are hard or impossible to
@@ -1362,6 +1376,17 @@ mod mock {
         assert_contains(&output, quote!(pub(in crate::outer) fn expect_boom));
     }
 
+    #[test]
+    fn must_use_struct() {
+        let code = "
+            #[must_use]
+            pub Foo {}
+        ";
+        let ts = proc_macro2::TokenStream::from_str(code).unwrap();
+        let output = do_mock(ts).to_string();
+        assert_contains(&output, quote!(#[must_use] pub struct MockFoo));
+    }
+
     #[test]
     fn specific_impl() {
         let code = "
@@ -1440,6 +1465,47 @@ mod automock {
         assert_contains(&output, quote!(pub ( in super :: x ) fn expect_bean));
     }
 
+    #[test]
+    fn must_use_method() {
+        let code = "
+        impl Foo {
+            #[must_use]
+            fn foo(&self) -> i32 {42}
+        }";
+        let ts = proc_macro2::TokenStream::from_str(code).unwrap();
+        let attrs_ts = proc_macro2::TokenStream::from_str("").unwrap();
+        let output = do_automock(attrs_ts, ts).to_string();
+        assert_not_contains(&output, quote!(#[must_use] fn expect_foo));
+        assert_contains(&output, quote!(#[must_use] #[allow(dead_code)] fn foo));
+    }
+
+    #[test]
+    fn must_use_static_method() {
+        let code = "
+        impl Foo {
+            #[must_use]
+            fn foo() -> i32 {42}
+        }";
+        let ts = proc_macro2::TokenStream::from_str(code).unwrap();
+        let attrs_ts = proc_macro2::TokenStream::from_str("").unwrap();
+        let output = do_automock(attrs_ts, ts).to_string();
+        assert_not_contains(&output, quote!(#[must_use] fn expect));
+        assert_not_contains(&output, quote!(#[must_use] fn foo_context));
+        assert_contains(&output, quote!(#[must_use] #[allow(dead_code)] fn foo));
+    }
+
+    #[test]
+    fn must_use_trait() {
+        let code = "
+        #[must_use]
+        trait Foo {}
+        ";
+        let ts = proc_macro2::TokenStream::from_str(code).unwrap();
+        let attrs_ts = proc_macro2::TokenStream::from_str("").unwrap();
+        let output = do_automock(attrs_ts, ts).to_string();
+        assert_not_contains(&output, quote!(#[must_use] struct MockFoo));
+    }
+
     #[test]
     #[should_panic(expected = "can only mock inline modules")]
     fn external_module() {

mockall_derive/src/mock_function.rs

@@ -469,7 +469,9 @@ impl MockFunction {
     // Supplying modname is an unfortunately hack.  Ideally MockFunction
     // wouldn't need to know that.
     pub fn call(&self, modname: Option<&Ident>) -> impl ToTokens {
-        let attrs = AttrFormatter::new(&self.attrs).format();
+        let attrs = AttrFormatter::new(&self.attrs)
+            .must_use(true)
+            .format();
         let call_exprs = &self.call_exprs;
         let (_, tg, _) = if self.is_method_generic() || self.is_static() {
             &self.egenerics

mockall_derive/src/mock_item_struct.rs

@@ -245,6 +245,7 @@ impl ToTokens for MockItemStruct {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let attrs = AttrFormatter::new(&self.attrs)
             .async_trait(false)
+            .must_use(true)
             .format();
         let consts = &self.consts;
         let debug_impl = self.debug_impl();
@@ -392,7 +393,16 @@ impl MockItemTraitImpl {
 
 impl ToTokens for MockItemTraitImpl {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let attrs = AttrFormatter::new(&self.attrs)
+        let mod_attrs = AttrFormatter::new(&self.attrs)
+            .async_trait(false)
+            .doc(false)
+            .format();
+        let struct_attrs = AttrFormatter::new(&self.attrs)
+            .async_trait(false)
+            .doc(false)
+            .must_use(false)
+            .format();
+        let impl_attrs = AttrFormatter::new(&self.attrs)
             .async_trait(false)
             .doc(false)
             .format();
@@ -408,28 +418,28 @@ impl ToTokens for MockItemTraitImpl {
         quote!(
             #[allow(non_snake_case)]
             #[allow(missing_docs)]
-            #(#attrs)*
+            #(#mod_attrs)*
             pub mod #modname {
                 use super::*;
                 #(#priv_mods)*
             }
             #[allow(non_camel_case_types)]
             #[allow(non_snake_case)]
             #[allow(missing_docs)]
-            #(#attrs)*
+            #(#struct_attrs)*
             struct #struct_name #ig #wc
             {
                 #(#field_definitions),*
             }
-            #(#attrs)*
+            #(#impl_attrs)*
             impl #ig ::std::default::Default for #struct_name #tg #wc {
                 fn default() -> Self {
                     Self {
                         #(#default_inits),*
                     }
                 }
             }
-            #(#attrs)*
+            #(#impl_attrs)*
             impl #ig #struct_name #tg #wc {
                 /// Validate that all current expectations for all methods have
                 /// been satisfied, and discard them.

mockall_derive/src/mock_trait.rs

@@ -130,7 +130,9 @@ impl MockTrait {
     // Supplying modname is an unfortunately hack.  Ideally MockTrait
     // wouldn't need to know that.
     pub fn trait_impl(&self, modname: &Ident) -> impl ToTokens {
-        let trait_impl_attrs = &self.attrs;
+        let trait_impl_attrs = AttrFormatter::new(&self.attrs)
+            .must_use(false)
+            .format();
         let impl_attrs = AttrFormatter::new(&self.attrs)
             .async_trait(false)
             .doc(false)

mockall_derive/src/mockable_struct.rs

@@ -1,6 +1,25 @@
 // vim: tw=80
-use super::*;
-use syn::parse::{Parse, ParseStream};
+use proc_macro2::{Span, TokenStream};
+use quote::{format_ident, quote};
+use syn::{
+    *,
+    parse::{Parse, ParseStream},
+    spanned::Spanned
+};
+
+use crate::{
+    Attrs,
+    compile_error,
+    deanonymize,
+    deimplify,
+    demutify,
+    deselfify,
+    deselfify_args,
+    dewhereselfify,
+    find_ident_from_path,
+    gen_mock_ident,
+    AttrFormatter,
+};
 
 /// Make any implicit lifetime parameters explicit
 fn add_lifetime_parameters(sig: &mut Signature) {
@@ -345,7 +364,15 @@ impl MockableStruct {
 impl From<(Attrs, ItemTrait)> for MockableStruct {
     fn from((attrs, item_trait): (Attrs, ItemTrait)) -> MockableStruct {
         let trait_ = attrs.substitute_trait(&item_trait);
-        let mut attrs = trait_.attrs.clone();
+        // Strip "must_use" from a trait definition.  For traits, the "must_use"
+        // should apply only when the trait is used like "impl Trait" or "dyn
+        // Trait".  So it shouldn't necessarily affect the mock struct that
+        // implements the trait.
+        let mut attrs = AttrFormatter::new(&trait_.attrs)
+            .doc(true)
+            .async_trait(true)
+            .must_use(false)
+            .format();
         attrs.push(derive_debug());
         let vis = trait_.vis.clone();
         let name = gen_mock_ident(&trait_.ident);