Handle all project* attributes in that scope with one wrapper attribute

Author: taiki-e

pin-project-internal/src/project.rs

@@ -6,7 +6,8 @@ use syn::{
 };
 
 use crate::utils::{
-    determine_lifetime_name, insert_lifetime, parse_as_empty, Mutability, SliceExt, VecExt,
+    determine_lifetime_name, insert_lifetime, parse_as_empty, Immutable, Mutability, Mutable,
+    Owned, SliceExt, VecExt,
 };
 
 pub(crate) fn attribute(args: &TokenStream, input: Stmt, mutability: Mutability) -> TokenStream {
@@ -199,21 +200,30 @@ fn replace_item_impl(item: &mut ItemImpl, mutability: Mutability) -> Result<()>
 }
 
 fn replace_item_fn(item: &mut ItemFn, mutability: Mutability) -> Result<()> {
-    struct FnVisitor {
-        res: Result<()>,
-        mutability: Mutability,
-    }
+    struct FnVisitor(Result<()>);
 
     impl FnVisitor {
         fn visit_stmt(&mut self, node: &mut Stmt) -> Result<()> {
             match node {
                 Stmt::Expr(expr) | Stmt::Semi(expr, _) => self.visit_expr(expr),
                 Stmt::Local(local) => {
                     visit_mut::visit_local_mut(self, local);
-                    if let Some(attr) = local.attrs.find_remove(self.mutability.method_name())? {
-                        parse_as_empty(&attr.tokens)?;
-                        Context::new(self.mutability).replace_local(local)?;
+
+                    let mut prev = None;
+                    for &mutability in &[Immutable, Mutable, Owned] {
+                        if let Some(attr) = local.attrs.find_remove(mutability.method_name())? {
+                            if let Some(prev) = prev.replace(mutability) {
+                                return Err(error!(
+                                    attr,
+                                    "attributes `{}` and `{}` are mutually exclusive",
+                                    prev.method_name(),
+                                    mutability.method_name(),
+                                ));
+                            }
+                            Context::new(mutability).replace_local(local)?;
+                        }
                     }
+
                     Ok(())
                 }
                 // Do not recurse into nested items.
@@ -223,41 +233,69 @@ fn replace_item_fn(item: &mut ItemFn, mutability: Mutability) -> Result<()> {
 
         fn visit_expr(&mut self, node: &mut Expr) -> Result<()> {
             visit_mut::visit_expr_mut(self, node);
-            let attr = match node {
-                Expr::Match(expr) => expr.attrs.find_remove(self.mutability.method_name())?,
+            match node {
+                Expr::Match(expr) => {
+                    let mut prev = None;
+                    for &mutability in &[Immutable, Mutable, Owned] {
+                        if let Some(attr) = expr.attrs.find_remove(mutability.method_name())? {
+                            if let Some(prev) = prev.replace(mutability) {
+                                return Err(error!(
+                                    attr,
+                                    "attributes `{}` and `{}` are mutually exclusive",
+                                    prev.method_name(),
+                                    mutability.method_name(),
+                                ));
+                            }
+                        }
+                    }
+                    if let Some(mutability) = prev {
+                        replace_expr(node, mutability);
+                    }
+                }
                 Expr::If(expr_if) => {
                     if let Expr::Let(_) = &*expr_if.cond {
-                        expr_if.attrs.find_remove(self.mutability.method_name())?
-                    } else {
-                        None
+                        let mut prev = None;
+                        for &mutability in &[Immutable, Mutable, Owned] {
+                            if let Some(attr) =
+                                expr_if.attrs.find_remove(mutability.method_name())?
+                            {
+                                if let Some(prev) = prev.replace(mutability) {
+                                    return Err(error!(
+                                        attr,
+                                        "attributes `{}` and `{}` are mutually exclusive",
+                                        prev.method_name(),
+                                        mutability.method_name(),
+                                    ));
+                                }
+                            }
+                        }
+                        if let Some(mutability) = prev {
+                            replace_expr(node, mutability);
+                        }
                     }
                 }
-                _ => return Ok(()),
-            };
-            if let Some(attr) = attr {
-                parse_as_empty(&attr.tokens)?;
-                replace_expr(node, self.mutability);
+                _ => {}
             }
             Ok(())
         }
     }
 
     impl VisitMut for FnVisitor {
         fn visit_stmt_mut(&mut self, node: &mut Stmt) {
-            if self.res.is_err() {
+            if self.0.is_err() {
                 return;
             }
             if let Err(e) = self.visit_stmt(node) {
-                self.res = Err(e)
+                self.0 = Err(e)
             }
         }
 
         fn visit_expr_mut(&mut self, node: &mut Expr) {
-            if self.res.is_err() {
+            if self.0.is_err() {
                 return;
             }
             if let Err(e) = self.visit_expr(node) {
-                self.res = Err(e)
+                self.0 = Err(e)
             }
         }
 
@@ -270,9 +308,9 @@ fn replace_item_fn(item: &mut ItemFn, mutability: Mutability) -> Result<()> {
         return Err(error!(attr, "duplicate #[{}] attribute", mutability.method_name()));
     }
 
-    let mut visitor = FnVisitor { res: Ok(()), mutability };
+    let mut visitor = FnVisitor(Ok(()));
     visitor.visit_block_mut(&mut item.block);
-    visitor.res
+    visitor.0
 }
 
 fn replace_item_use(item: &mut ItemUse, mutability: Mutability) -> Result<()> {

tests/project.rs

@@ -239,11 +239,39 @@ fn issue_206() {
     }
 }
 
+#[project]
+#[test]
+fn combine() {
+    #[pin_project(Replace)]
+    enum Enum<A> {
+        V1(#[pin] A),
+        V2,
+    }
+
+    let mut x = Enum::V1(1);
+    #[project]
+    match Pin::new(&mut x).project() {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+    #[project_ref]
+    match Pin::new(&x).project_ref() {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+    #[project_replace]
+    match Pin::new(&mut x).project_replace(Enum::V2) {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+}
+
+// FIXME: This should be denied, but allowed for compatibility at this time.
 #[project]
 #[project_ref]
 #[project_replace]
 #[test]
-fn combine() {
+fn combine_compat() {
     #[pin_project(Replace)]
     enum Enum<A> {
         V1(#[pin] A),

tests/project_ref.rs

@@ -145,3 +145,30 @@ fn project_impl() {
         fn foo<'pin>(&'pin self) {}
     }
 }
+
+#[project_ref]
+#[test]
+fn combine() {
+    #[pin_project(Replace)]
+    enum Enum<A> {
+        V1(#[pin] A),
+        V2,
+    }
+
+    let mut x = Enum::V1(1);
+    #[project]
+    match Pin::new(&mut x).project() {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+    #[project_ref]
+    match Pin::new(&x).project_ref() {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+    #[project_replace]
+    match Pin::new(&mut x).project_replace(Enum::V2) {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+}

tests/project_replace.rs

@@ -69,3 +69,30 @@ fn project_replace_stmt_expr() {
         Enum::None => panic!(),
     }
 }
+
+#[project_replace]
+#[test]
+fn combine() {
+    #[pin_project(Replace)]
+    enum Enum<A> {
+        V1(#[pin] A),
+        V2,
+    }
+
+    let mut x = Enum::V1(1);
+    #[project]
+    match Pin::new(&mut x).project() {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+    #[project_ref]
+    match Pin::new(&x).project_ref() {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+    #[project_replace]
+    match Pin::new(&mut x).project_replace(Enum::V2) {
+        Enum::V1(_) => {}
+        Enum::V2 => unreachable!(),
+    }
+}

tests/ui/project/invalid.rs

@@ -73,6 +73,78 @@ mod attribute {
         let A(_) = Pin::new(&mut x).project();
     }
 
+    #[project]
+    fn combine_stmt_project1() {
+        let mut x = A(());
+        #[project]
+        #[project_ref] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project]
+    fn combine_stmt_project2() {
+        let mut x = A(());
+        #[project]
+        #[project_replace] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project]
+    fn combine_stmt_project3() {
+        let mut x = A(());
+        #[project_ref]
+        #[project_replace] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project_ref]
+    fn combine_stmt_project_ref1() {
+        let mut x = A(());
+        #[project]
+        #[project_ref] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project_ref]
+    fn combine_stmt_project_ref2() {
+        let mut x = A(());
+        #[project]
+        #[project_replace] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project_ref]
+    fn combine_stmt_project_ref3() {
+        let mut x = A(());
+        #[project_ref]
+        #[project_replace] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project_replace]
+    fn combine_stmt_project_replace1() {
+        let mut x = A(());
+        #[project]
+        #[project_ref] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project_replace]
+    fn combine_stmt_project_replace2() {
+        let mut x = A(());
+        #[project]
+        #[project_replace] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
+    #[project_replace]
+    fn combine_stmt_project_replace3() {
+        let mut x = A(());
+        #[project_ref]
+        #[project_replace] //~ ERROR are mutually exclusive
+        let A(_) = Pin::new(&mut x).project();
+    }
+
     #[project]
     #[project] //~ ERROR duplicate #[project] attribute
     fn duplicate_fn_project() {}