Allow #[project] to be used on if let expressions

pin-project-internal/src/project.rs

@@ -13,12 +13,33 @@ pub(crate) fn attribute(args: &TokenStream, input: Stmt, mutability: Mutability)
         .unwrap_or_else(|e| e.to_compile_error())
 }
 
-fn parse(mut stmt: Stmt, mutability: Mutability) -> Result<TokenStream> {
-    match &mut stmt {
+fn replace_stmt(stmt: &mut Stmt, mutability: Mutability) -> Result<()> {
+    match stmt {
         Stmt::Expr(Expr::Match(expr)) | Stmt::Semi(Expr::Match(expr), _) => {
-            Context::new(mutability).replace_expr_match(expr)
+            Context::new(mutability).replace_expr_match(expr);
+        }
+        Stmt::Expr(Expr::If(expr_if)) => {
+            let mut expr_if = expr_if;
+            while let Expr::Let(ref mut expr) = &mut *expr_if.cond {
+                Context::new(mutability).replace_expr_let(expr);
+                if let Some((_, ref mut expr)) = expr_if.else_branch {
+                    if let Expr::If(new_expr_if) = &mut **expr {
+                        expr_if = new_expr_if;
+                        continue;
+                    }
+                }
+                break;
+            }
         }
         Stmt::Local(local) => Context::new(mutability).replace_local(local)?,
+        _ => {}
+    }
+    Ok(())
+}
+
+fn parse(mut stmt: Stmt, mutability: Mutability) -> Result<TokenStream> {
+    replace_stmt(&mut stmt, mutability)?;
+    match &mut stmt {
         Stmt::Item(Item::Fn(item)) => replace_item_fn(item, mutability)?,
         Stmt::Item(Item::Impl(item)) => replace_item_impl(item, mutability),
         Stmt::Item(Item::Use(item)) => replace_item_use(item, mutability)?,
@@ -73,6 +94,10 @@ impl Context {
         Ok(())
     }
 
+    fn replace_expr_let(&mut self, expr: &mut ExprLet) {
+        self.replace_pat(&mut expr.pat, true)
+    }
+
     fn replace_expr_match(&mut self, expr: &mut ExprMatch) {
         expr.arms.iter_mut().for_each(|Arm { pat, .. }| self.replace_pat(pat, true))
     }
@@ -195,17 +220,18 @@ impl FnVisitor {
                 expr.attrs.find_remove(self.name())?
             }
             Stmt::Local(local) => local.attrs.find_remove(self.name())?,
+            Stmt::Expr(Expr::If(expr_if)) => {
+                if let Expr::Let(_) = &*expr_if.cond {
+                    expr_if.attrs.find_remove(self.name())?
+                } else {
+                    None
+                }
+            }
             _ => return Ok(()),
         };
         if let Some(attr) = attr {
             parse_as_empty(&attr.tokens)?;
-            match node {
-                Stmt::Expr(Expr::Match(expr)) | Stmt::Semi(Expr::Match(expr), _) => {
-                    Context::new(self.mutability).replace_expr_match(expr)
-                }
-                Stmt::Local(local) => Context::new(self.mutability).replace_local(local)?,
-                _ => unreachable!(),
-            }
+            replace_stmt(node, self.mutability)?;
         }
         Ok(())
     }

tests/project.rs

@@ -2,6 +2,16 @@
 #![warn(rust_2018_idioms, single_use_lifetimes)]
 #![allow(dead_code)]
 
+// This hack is needed until https://github.com/rust-lang/rust/pull/69201
+// makes it way into stable.
+// Ceurrently, `#[attr] if true {}` doesn't even *parse* on stable,
+// which means that it will error even behind a `#[rustversion::nightly]`
+//
+// This trick makes sure that we don't even attempt to parse
+// the `#[project] if let _` test on stable.
+#[rustversion::nightly]
+include!("project_if_attr.rs.in");
+
 use pin_project::{pin_project, project};
 use std::pin::Pin;
 

tests/project_if_attr.rs.in

@@ -0,0 +1,29 @@
+// FIXME: Once https://github.com/rust-lang/rust/pull/69201 makes its
+// way into stable, move this back into `project.rs
+
+#[test]
+#[project]
+fn project_if_let() {
+    #[pin_project]
+    enum Foo<A, B> {
+        Variant1(#[pin] A),
+        Variant2(u8),
+        Variant3 {
+            #[pin] field: B
+        }
+    }
+
+    let mut foo: Foo<bool, f32> = Foo::Variant1(true);
+    let foo = Pin::new(&mut foo).project();
+
+    #[project]
+    if let Foo::Variant1(a) = foo {
+        let a: Pin<&mut bool> = a;
+        assert_eq!(*a, true);
+    } else if let Foo::Variant2(_) = foo {
+        unreachable!();
+    } else if let Foo::Variant3 { .. } = foo {
+        unreachable!();
+    }
+}
+