Fix rust-lang#1021: Handle .. in tuple / tuple struct patterns

Author: sinkuu

src/patterns.rs

@@ -13,10 +13,14 @@ use codemap::SpanUtils;
 use rewrite::{Rewrite, RewriteContext};
 use utils::{wrap_str, format_mutability};
 use lists::{format_item_list, itemize_list};
-use expr::{rewrite_unary_prefix, rewrite_pair, rewrite_tuple};
+use expr::{rewrite_unary_prefix, rewrite_pair};
 use types::rewrite_path;
+use super::Spanned;
+use comment::FindUncommented;
 
-use syntax::ast::{BindingMode, Pat, PatKind, FieldPat};
+use syntax::ast::{self, BindingMode, Pat, PatKind, FieldPat};
+use syntax::ptr;
+use syntax::codemap::{self, BytePos, Span};
 
 impl Rewrite for Pat {
     fn rewrite(&self, context: &RewriteContext, width: usize, offset: Indent) -> Option<String> {
@@ -60,49 +64,19 @@ impl Rewrite for Pat {
                 let prefix = format!("&{}", format_mutability(mutability));
                 rewrite_unary_prefix(context, &prefix, &**pat, width, offset)
             }
-            // FIXME(#1021): Handle `..` in tuple / tuple struct patterns (RFC 1492)
             PatKind::Tuple(ref items, dotdot_pos) => {
-                if dotdot_pos.is_some() {
-                    return None;
-                }
-                rewrite_tuple(context,
-                              items.iter().map(|x| &**x),
-                              self.span,
-                              width,
-                              offset)
+                rewrite_tuple_pat(items, dotdot_pos, None, self.span, context, width, offset)
             }
             PatKind::Path(ref path) => rewrite_path(context, true, None, path, width, offset),
             PatKind::TupleStruct(ref path, ref pat_vec, dotdot_pos) => {
                 let path_str = try_opt!(rewrite_path(context, true, None, path, width, offset));
-
-                // FIXME(#1021): Handle `..` in tuple / tuple struct patterns (RFC 1492)
-                match dotdot_pos {
-                    Some(_) => Some(format!("{}(..)", path_str)),
-                    None => {
-                        if pat_vec.is_empty() {
-                            Some(path_str)
-                        } else {
-                            // 2 = "()".len()
-                            let width = try_opt!(width.checked_sub(path_str.len() + 2));
-                            // 1 = "(".len()
-                            let offset = offset + path_str.len() + 1;
-                            let items = itemize_list(context.codemap,
-                                                     pat_vec.iter(),
-                                                     ")",
-                                                     |item| item.span.lo,
-                                                     |item| item.span.hi,
-                                                     |item| item.rewrite(context, width, offset),
-                                                     context.codemap.span_after(self.span, "("),
-                                                     self.span.hi);
-                            Some(format!("{}({})",
-                                         path_str,
-                                         try_opt!(format_item_list(items,
-                                                                   width,
-                                                                   offset,
-                                                                   context.config))))
-                        }
-                    }
-                }
+                rewrite_tuple_pat(pat_vec,
+                                  dotdot_pos,
+                                  Some(path_str),
+                                  self.span,
+                                  context,
+                                  width,
+                                  offset)
             }
             PatKind::Lit(ref expr) => expr.rewrite(context, width, offset),
             PatKind::Vec(ref prefix, ref slice_pat, ref suffix) => {
@@ -190,3 +164,87 @@ impl Rewrite for FieldPat {
         }
     }
 }
+
+enum TaplePatField<'a> {
+    Pat(&'a ptr::P<ast::Pat>),
+    Dotdot(BytePos, BytePos),
+}
+
+impl<'a> Rewrite for TaplePatField<'a> {
+    fn rewrite(&self, context: &RewriteContext, width: usize, offset: Indent) -> Option<String> {
+        match *self {
+            TaplePatField::Pat(ref p) => p.rewrite(context, width, offset),
+            TaplePatField::Dotdot(..) => Some("..".to_string()),
+        }
+    }
+}
+
+impl<'a> Spanned for TaplePatField<'a> {
+    fn span(&self) -> Span {
+        match *self {
+            TaplePatField::Pat(ref p) => p.span(),
+            TaplePatField::Dotdot(lo, hi) => {
+                Span {
+                    lo: lo,
+                    hi: hi,
+                    expn_id: codemap::NO_EXPANSION,
+                }
+            }
+        }
+    }
+}
+
+fn rewrite_tuple_pat(pats: &[ptr::P<ast::Pat>],
+                     dotdot_pos: Option<usize>,
+                     path_str: Option<String>,
+                     span: Span,
+                     context: &RewriteContext,
+                     width: usize,
+                     offset: Indent)
+                     -> Option<String> {
+    let mut pat_vec: Vec<_> = pats.into_iter().map(|x| TaplePatField::Pat(x)).collect();
+
+    if let Some(pos) = dotdot_pos {
+        let snippet = context.snippet(span);
+        let lo = span.lo + BytePos(snippet.find_uncommented("..").unwrap() as u32);
+        // 2 == "..".len()
+        let dotdot = TaplePatField::Dotdot(lo, lo + BytePos(2));
+
+        if pat_vec.is_empty() {
+            pat_vec = vec![dotdot];
+        } else {
+            pat_vec.insert(pos, dotdot);
+        }
+    }
+
+    if pat_vec.is_empty() {
+        path_str
+    } else {
+        // add comma if `(x,)`
+        let add_comma = path_str.is_none() && pat_vec.len() == 1 && dotdot_pos.is_none();
+
+        let path_len = path_str.as_ref().map(|p| p.len()).unwrap_or(0);
+        // 2 = "()".len()
+        let width = try_opt!(width.checked_sub(path_len + 2));
+        // 1 = "(".len()
+        let offset = offset + path_len + 1;
+        let items = itemize_list(context.codemap,
+                                 pat_vec.iter(),
+                                 if add_comma { ",)" } else { ")" },
+                                 |item| item.span().lo,
+                                 |item| item.span().hi,
+                                 |item| item.rewrite(context, width, offset),
+                                 context.codemap.span_after(span, "("),
+                                 span.hi - BytePos(1));
+
+        let list = try_opt!(format_item_list(items, width, offset, context.config));
+
+        match path_str {
+            Some(path_str) => Some(format!("{}({})", path_str, list)),
+            None => {
+                let comma = if add_comma { "," } else { "" };
+                Some(format!("({}{})", list, comma))
+            }
+        }
+    }
+}

tests/source/issue-1021.rs

@@ -0,0 +1,21 @@
+fn main() {
+    match x {
+        S(true , .., true ) => (),
+        S(true , .. ) => (),
+        S(.., true ) => (),
+        S( .. ) => (),
+        S(_) => (),
+        S(/* .. */ .. ) => (),
+        S(/* .. */ .., true ) => (),
+    }
+
+    match y {
+        (true , .., true ) => (),
+        (true , .. ) => (),
+        (.., true ) => (),
+        ( .. ) => (),
+        (_,) => (),
+        (/* .. */ .. ) => (),
+        (/* .. */ .., true ) => (),
+    }
+}

tests/target/issue-1021.rs

@@ -0,0 +1,27 @@
+fn main() {
+    match x {
+        S(true, .., true) => (),
+        S(true, ..) => (),
+        S(.., true) => (),
+        S(..) => (),
+        S(_) => (),
+        S(// ..
+          ..) => (),
+        S(// ..
+          ..,
+          true) => (),
+    }
+
+    match y {
+        (true, .., true) => (),
+        (true, ..) => (),
+        (.., true) => (),
+        (..) => (),
+        (_,) => (),
+        (// ..
+         ..) => (),
+        (// ..
+         ..,
+         true) => (),
+    }
+}