Fix deselfify for trait objects with associated types

This is especially important for constructors that return impl
Future<Type=Self,...>

CHANGELOG.md

@@ -23,6 +23,10 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Fixed
 
+- Fixed mocking methods with arguments or return values that use `Self` as an
+  associated type of some other trait.
+  ([#28](https://github.com/asomers/mockall/pull/28))
+
 - Fixed mocking structs and traits with more than one static method.
   ([#22](https://github.com/asomers/mockall/pull/22))
 

mockall/tests/automock_associated_type_constructor.rs

@@ -0,0 +1,38 @@
+// vim: tw=80
+/// A constructor that returns Self as an associated type of some other trait.
+/// This is very useful when working with Futures.
+
+use mockall::*;
+
+pub trait Future {
+    type Item;
+    type Error;
+}
+
+#[allow(unused)]
+pub struct Foo{}
+
+#[automock]
+impl Foo {
+    pub fn open() -> impl Future<Item=Self, Error=i32> {
+        struct Bar {}
+        impl Future for Bar {
+            type Item=Foo;
+            type Error=i32;
+        }
+        Bar{}
+    }
+}
+
+#[test]
+fn returning() {
+    MockFoo::expect_open().returning(|| {
+        struct Baz {}
+        impl Future for Baz {
+            type Item=MockFoo;
+            type Error=i32;
+        }
+        Box::new(Baz{})
+    });
+    let _a = MockFoo::open();
+}

mockall_derive/src/lib.rs

@@ -303,14 +303,22 @@ fn deselfify(literal_type: &mut Type, actual: &Ident, generics: &Generics) {
             panic!("deimplify should've already been run on this output type");
         },
         Type::TraitObject(tto) => {
+            //dbg!(&tto);
             // Change types like `dyn Self` into `MockXXX`.  For now,
             // don't worry about multiple trait bounds, because they aren't very
             // useful in combination with Self.
             if tto.bounds.len() == 1 {
                 if let TypeParamBound::Trait(t)
                     = tto.bounds.first().unwrap().value()
                 {
-                    let path = &t.path;
+                    // No need to substitute Self for the full path, because
+                    // traits can't return "impl Trait", and structs can't
+                    // return "impl Self" (because Self, in that case, isn't a
+                    // trait).  However, we do need to recurse to deselfify any
+                    // generics and associated types.
+                    let tp = TypePath{qself: None, path: t.path.clone()};
+                    let mut path = Type::Path(tp);
+                    deselfify(&mut path, actual, generics);
                     let new_type: Type = parse2(quote!(dyn #path)).unwrap();
                     *literal_type = new_type;
                 }