Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "async-recursion"
-version = "1.0.4"
+version = "1.0.5"
 authors = ["Robert Usher <266585+dcchut@users.noreply.github.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"

src/expand.rs

@@ -61,8 +61,18 @@ fn transform_sig(sig: &mut Signature, args: &RecursionArgs) {
 
     for arg in &mut sig.inputs {
         if let FnArg::Typed(pt) = arg {
-            if let Type::Reference(tr) = pt.ty.as_mut() {
-                ref_arguments.push(tr);
+            match pt.ty.as_mut() {
+                // rustc can give us a None-delimited group if this type comes from
+                // a macro_rules macro.  I don't this can happen for code the user has written.
+                Type::Group(tg) => {
+                    if let Type::Reference(tr) = &mut *tg.elem {
+                        ref_arguments.push(tr);
+                    }
+                }
+                Type::Reference(tr) => {
+                    ref_arguments.push(tr);
+                }
+                _ => {}
             }
         } else if let FnArg::Receiver(recv) = arg {
             if let Some((_, slt)) = &mut recv.reference {

tests/macros_all_the_way_down.rs

@@ -0,0 +1,26 @@
+use futures_executor::block_on;
+
+macro_rules! recurse {
+    ($name:ident, $param:ty) => {
+        #[::async_recursion::async_recursion]
+        async fn $name<F>(param: $param, f: &F)
+        where
+            F: Fn($param) + Sync + Send,
+        {
+            f(param);
+        }
+    };
+}
+
+recurse!(owned, usize);
+recurse!(by_ref, &usize);
+recurse!(by_ref_mut, &mut usize);
+
+#[test]
+fn async_in_macro() {
+    block_on(async move {
+        owned(5, &|_| ()).await;
+        by_ref(&5, &|_| ()).await;
+        by_ref_mut(&mut 5, &|_| ()).await;
+    });
+}

tests/ui/must_use.stderr

@@ -9,3 +9,7 @@ note: the lint level is defined here
   |
 1 | #![deny(unused_must_use)]
   |         ^^^^^^^^^^^^^^^
+help: use `let _ = ...` to ignore the resulting value
+  |
+9 |     let _ = apples(3);
+  |     +++++++