Implement &pin patterns and ref pin bindings

Author: frank-king

src/patterns.rs

@@ -17,7 +17,9 @@ use crate::shape::Shape;
 use crate::source_map::SpanUtils;
 use crate::spanned::Spanned;
 use crate::types::{PathContext, rewrite_path};
-use crate::utils::{format_mutability, mk_sp, mk_sp_lo_plus_one, rewrite_ident};
+use crate::utils::{
+    format_mutability, format_pinnedness_and_mutability, mk_sp, mk_sp_lo_plus_one, rewrite_ident,
+};
 
 /// Returns `true` if the given pattern is "short".
 /// A short pattern is defined by the following grammar:
@@ -69,7 +71,7 @@ fn is_short_pattern_inner(context: &RewriteContext<'_>, pat: &ast::Pat) -> bool
         }
         ast::PatKind::Box(ref p)
         | PatKind::Deref(ref p)
-        | ast::PatKind::Ref(ref p, _)
+        | ast::PatKind::Ref(ref p, _, _)
         | ast::PatKind::Paren(ref p) => is_short_pattern_inner(context, &*p),
         PatKind::Or(ref pats) => pats.iter().all(|p| is_short_pattern_inner(context, p)),
     }
@@ -133,10 +135,13 @@ impl Rewrite for Pat {
             PatKind::Ident(BindingMode(by_ref, mutability), ident, ref sub_pat) => {
                 let mut_prefix = format_mutability(mutability).trim();
 
-                let (ref_kw, mut_infix) = match by_ref {
-                    // FIXME(pin_ergonomics): format the pinnedness
-                    ByRef::Yes(_, rmutbl) => ("ref", format_mutability(rmutbl).trim()),
-                    ByRef::No => ("", ""),
+                let (ref_kw, pin_infix, mut_infix) = match by_ref {
+                    ByRef::Yes(pinnedness, rmutbl) => {
+                        let (pin_infix, mut_infix) =
+                            format_pinnedness_and_mutability(pinnedness, rmutbl);
+                        ("ref", pin_infix.trim(), mut_infix.trim())
+                    }
+                    ByRef::No => ("", "", ""),
                 };
                 let id_str = rewrite_ident(context, ident);
                 let sub_pat = match *sub_pat {
@@ -147,6 +152,7 @@ impl Rewrite for Pat {
                             .checked_sub(
                                 mut_prefix.len()
                                     + ref_kw.len()
+                                    + pin_infix.len()
                                     + mut_infix.len()
                                     + id_str.len()
                                     + 2,
@@ -193,26 +199,51 @@ impl Rewrite for Pat {
                     (true, true) => (self.span.lo(), "".to_owned()),
                 };
 
-                // combine result of above and mut
-                let (second_lo, second) = match (first.is_empty(), mut_infix.is_empty()) {
+                // combine result of above and pin
+                let (second_lo, second) = match (first.is_empty(), pin_infix.is_empty()) {
                     (false, false) => {
                         let lo = context.snippet_provider.span_after(self.span, "ref");
-                        let end_span = mk_sp(first_lo, self.span.hi());
-                        let hi = context.snippet_provider.span_before(end_span, "mut");
+                        let hi = context.snippet_provider.span_before(self.span, "pin");
                         (
-                            context.snippet_provider.span_after(end_span, "mut"),
+                            context.snippet_provider.span_after(self.span, "pin"),
                             combine_strs_with_missing_comments(
                                 context,
                                 &first,
-                                mut_infix,
+                                pin_infix,
                                 mk_sp(lo, hi),
                                 shape,
                                 true,
                             )?,
                         )
                     }
                     (false, true) => (first_lo, first),
-                    (true, false) => unreachable!("mut_infix necessarily follows a ref"),
+                    (true, false) => unreachable!("pin_infix necessarily follows a ref"),
+                    (true, true) => (self.span.lo(), "".to_owned()),
+                };
+
+                // combine result of above and const|mut
+                let (third_lo, third) = match (second.is_empty(), mut_infix.is_empty()) {
+                    (false, false) => {
+                        let lo = context.snippet_provider.span_after(
+                            self.span,
+                            if pin_infix.is_empty() { "ref" } else { "pin" },
+                        );
+                        let end_span = mk_sp(second_lo, self.span.hi());
+                        let hi = context.snippet_provider.span_before(end_span, mut_infix);
+                        (
+                            context.snippet_provider.span_after(end_span, mut_infix),
+                            combine_strs_with_missing_comments(
+                                context,
+                                &second,
+                                mut_infix,
+                                mk_sp(lo, hi),
+                                shape,
+                                true,
+                            )?,
+                        )
+                    }
+                    (false, true) => (second_lo, second),
+                    (true, false) => unreachable!("mut_infix necessarily follows a pin or ref"),
                     (true, true) => (self.span.lo(), "".to_owned()),
                 };
 
@@ -232,9 +263,9 @@ impl Rewrite for Pat {
 
                 combine_strs_with_missing_comments(
                     context,
-                    &second,
+                    &third,
                     &next,
-                    mk_sp(second_lo, ident.span.lo()),
+                    mk_sp(third_lo, ident.span.lo()),
                     shape,
                     true,
                 )
@@ -263,8 +294,10 @@ impl Rewrite for Pat {
             PatKind::Range(ref lhs, ref rhs, ref end_kind) => {
                 rewrite_range_pat(context, shape, lhs, rhs, end_kind, self.span)
             }
-            PatKind::Ref(ref pat, mutability) => {
-                let prefix = format!("&{}", format_mutability(mutability));
+            PatKind::Ref(ref pat, pinnedness, mutability) => {
+                let (pin_prefix, mut_prefix) =
+                    format_pinnedness_and_mutability(pinnedness, mutability);
+                let prefix = format!("&{}{}", pin_prefix, mut_prefix);
                 rewrite_unary_prefix(context, &prefix, &**pat, shape)
             }
             PatKind::Tuple(ref items) => rewrite_tuple_pat(items, None, self.span, context, shape),
@@ -551,7 +584,7 @@ pub(crate) fn can_be_overflowed_pat(
             | ast::PatKind::Tuple(..)
             | ast::PatKind::Struct(..)
             | ast::PatKind::TupleStruct(..) => context.use_block_indent() && len == 1,
-            ast::PatKind::Ref(ref p, _) | ast::PatKind::Box(ref p) => {
+            ast::PatKind::Ref(ref p, _, _) | ast::PatKind::Box(ref p) => {
                 can_be_overflowed_pat(context, &TuplePatField::Pat(p), len)
             }
             ast::PatKind::Expr(ref expr) => can_be_overflowed_expr(context, expr, len),

src/utils.rs

@@ -132,6 +132,19 @@ pub(crate) fn format_mutability(mutability: ast::Mutability) -> &'static str {
     }
 }
 
+#[inline]
+pub(crate) fn format_pinnedness_and_mutability(
+    pinnedness: ast::Pinnedness,
+    mutability: ast::Mutability,
+) -> (&'static str, &'static str) {
+    match (pinnedness, mutability) {
+        (ast::Pinnedness::Pinned, ast::Mutability::Mut) => ("pin ", "mut "),
+        (ast::Pinnedness::Pinned, ast::Mutability::Not) => ("pin ", "const "),
+        (ast::Pinnedness::Not, ast::Mutability::Mut) => ("", "mut "),
+        (ast::Pinnedness::Not, ast::Mutability::Not) => ("", ""),
+    }
+}
+
 #[inline]
 pub(crate) fn format_extern(ext: ast::Extern, explicit_abi: bool) -> Cow<'static, str> {
     match ext {

tests/source/pin_sugar.rs

@@ -28,3 +28,22 @@ fn borrows() {
     pin                const 
     foo;
 }
+
+fn patterns<'a>(
+    &pin         mut     x: &pin 
+    mut 
+    i32,
+    &
+    pin         
+         const
+         y: &
+    'a pin 
+    const 
+    i32,
+    ref      pin      mut      z: i32,
+    mut 
+    ref      
+       pin     
+    const
+          w: i32,
+) {}

tests/target/pin_sugar.rs

@@ -23,3 +23,11 @@ fn borrows() {
 
     let x: Pin<&_> = &pin const foo;
 }
+
+fn patterns<'a>(
+    &pin mut x: &pin mut i32,
+    &pin const y: &'a pin const i32,
+    ref pin mut z: i32,
+    mut ref pin const w: i32,
+) {
+}