Fix #[project] on non-statement expressions

Author: taiki-e

pin-project-internal/src/project.rs

@@ -13,12 +13,12 @@ pub(crate) fn attribute(args: &TokenStream, input: Stmt, mutability: Mutability)
         .unwrap_or_else(|e| e.to_compile_error())
 }
 
-fn replace_stmt(stmt: &mut Stmt, mutability: Mutability) -> Result<()> {
-    match stmt {
-        Stmt::Expr(Expr::Match(expr)) | Stmt::Semi(Expr::Match(expr), _) => {
+fn replace_expr(expr: &mut Expr, mutability: Mutability) {
+    match expr {
+        Expr::Match(expr) => {
             Context::new(mutability).replace_expr_match(expr);
         }
-        Stmt::Expr(Expr::If(expr_if)) => {
+        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);
@@ -31,15 +31,18 @@ fn replace_stmt(stmt: &mut Stmt, mutability: Mutability) -> Result<()> {
                 break;
             }
         }
-        Stmt::Local(local) => Context::new(mutability).replace_local(local)?,
         _ => {}
     }
-    Ok(())
+}
+
+fn replace_local(local: &mut Local, mutability: Mutability) -> Result<()> {
+    Context::new(mutability).replace_local(local)
 }
 
 fn parse(mut stmt: Stmt, mutability: Mutability) -> Result<TokenStream> {
-    replace_stmt(&mut stmt, mutability)?;
     match &mut stmt {
+        Stmt::Expr(expr) | Stmt::Semi(expr, _) => replace_expr(expr, mutability),
+        Stmt::Local(local) => replace_local(local, mutability)?,
         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)?,
@@ -219,12 +222,28 @@ impl FnVisitor {
     }
 
     fn visit_stmt(&mut self, node: &mut Stmt) -> Result<()> {
-        let attr = match node {
-            Stmt::Expr(Expr::Match(expr)) | Stmt::Semi(Expr::Match(expr), _) => {
-                expr.attrs.find_remove(self.name())?
+        match node {
+            Stmt::Expr(expr) | Stmt::Semi(expr, _) => {
+                visit_mut::visit_expr_mut(self, expr);
+                self.visit_expr(expr)
+            }
+            Stmt::Local(local) => {
+                visit_mut::visit_local_mut(self, local);
+                if let Some(attr) = local.attrs.find_remove(self.name())? {
+                    parse_as_empty(&attr.tokens)?;
+                    replace_local(local, self.mutability)?;
+                }
+                Ok(())
             }
-            Stmt::Local(local) => local.attrs.find_remove(self.name())?,
-            Stmt::Expr(Expr::If(expr_if)) => {
+            // Do not recurse into nested items.
+            Stmt::Item(_) => Ok(()),
+        }
+    }
+
+    fn visit_expr(&mut self, node: &mut Expr) -> Result<()> {
+        let attr = match node {
+            Expr::Match(expr) => expr.attrs.find_remove(self.name())?,
+            Expr::If(expr_if) => {
                 if let Expr::Let(_) = &*expr_if.cond {
                     expr_if.attrs.find_remove(self.name())?
                 } else {
@@ -235,7 +254,7 @@ impl FnVisitor {
         };
         if let Some(attr) = attr {
             parse_as_empty(&attr.tokens)?;
-            replace_stmt(node, self.mutability)?;
+            replace_expr(node, self.mutability);
         }
         Ok(())
     }
@@ -246,14 +265,20 @@ impl VisitMut for FnVisitor {
         if self.res.is_err() {
             return;
         }
-
-        visit_mut::visit_stmt_mut(self, node);
-
         if let Err(e) = self.visit_stmt(node) {
             self.res = Err(e)
         }
     }
 
+    fn visit_expr_mut(&mut self, node: &mut Expr) {
+        if self.res.is_err() {
+            return;
+        }
+        if let Err(e) = self.visit_expr(node) {
+            self.res = Err(e)
+        }
+    }
+
     fn visit_item_mut(&mut self, _: &mut Item) {
         // Do not recurse into nested items.
     }

tests/pin_project.rs

@@ -556,3 +556,27 @@ fn self_in_where_clause() {
         type Foo = Struct1<T>;
     }
 }
+
+#[test]
+fn where_clause() {
+    #[pin_project]
+    struct StructWhereClause<T>
+    where
+        T: Copy,
+    {
+        field: T,
+    }
+
+    #[pin_project]
+    struct TupleStructWhereClause<T>(T)
+    where
+        T: Copy;
+
+    #[pin_project]
+    enum EnumWhereClause<T>
+    where
+        T: Copy,
+    {
+        Variant(T),
+    }
+}

tests/project.rs

@@ -1,14 +1,12 @@
 #![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]`
+// Ceurrently, `#[attr] if true {}` doesn't even *parse* on MSRV,
+// which means that it will error even behind a `#[rustversion::since(..)]`
 //
 // This trick makes sure that we don't even attempt to parse
-// the `#[project] if let _` test on stable.
-#[rustversion::nightly]
+// the `#[project] if let _` test on MSRV.
+#[rustversion::since(1.43)]
 include!("project_if_attr.rs.in");
 
 use pin_project::{pin_project, project};
@@ -194,23 +192,21 @@ mod project_use_2 {
     }
 }
 
-#[pin_project]
-struct StructWhereClause<T>
-where
-    T: Copy,
-{
-    field: T,
-}
+#[test]
+#[project]
+fn non_stmt_expr_match() {
+    #[pin_project]
+    enum Enum<A> {
+        Variant(#[pin] A),
+    }
 
-#[pin_project]
-struct TupleStructWhereClause<T>(T)
-where
-    T: Copy;
+    let mut x = Enum::Variant(1);
+    let x = Pin::new(&mut x).project();
 
-#[pin_project]
-enum EnumWhereClause<T>
-where
-    T: Copy,
-{
-    Variant(T),
+    Some(
+        #[project]
+        match x {
+            Enum::Variant(_x) => {}
+        },
+    );
 }

tests/project_if_attr.rs.in

@@ -1,6 +1,3 @@
-// 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() {
@@ -27,3 +24,20 @@ fn project_if_let() {
     }
 }
 
+#[test]
+#[project]
+fn non_stmt_expr_if_let() {
+    #[pin_project]
+    enum Enum<A> {
+        Variant(#[pin] A),
+    }
+
+    let mut x = Enum::Variant(1);
+    let x = Pin::new(&mut x).project();
+
+    #[allow(irrefutable_let_patterns)]
+    Some(
+        #[project]
+        if let Enum::Variant(_x) = x {},
+    );
+}