@@ -15,8 +15,11 @@ use utils::{wrap_str, format_mutability};
15
15
use lists:: { format_item_list, itemize_list} ;
16
16
use expr:: { rewrite_unary_prefix, rewrite_pair, rewrite_tuple} ;
17
17
use types:: rewrite_path;
18
+ use super :: Spanned ;
18
19
19
- use syntax:: ast:: { BindingMode , Pat , PatKind , FieldPat } ;
20
+ use syntax:: ast:: { self , BindingMode , Pat , PatKind , FieldPat } ;
21
+ use syntax:: ptr;
22
+ use syntax:: codemap:: { self , BytePos , Span } ;
20
23
21
24
impl Rewrite for Pat {
22
25
fn rewrite ( & self , context : & RewriteContext , width : usize , offset : Indent ) -> Option < String > {
@@ -60,49 +63,67 @@ impl Rewrite for Pat {
60
63
let prefix = format ! ( "&{}" , format_mutability( mutability) ) ;
61
64
rewrite_unary_prefix ( context, & prefix, & * * pat, width, offset)
62
65
}
63
- // FIXME(#1021): Handle `..` in tuple / tuple struct patterns (RFC 1492)
64
66
PatKind :: Tuple ( ref items, dotdot_pos) => {
65
- if dotdot_pos. is_some ( ) {
66
- return None ;
67
+ let mut pat_vec: Vec < _ > = items. into_iter ( ) . map ( |x| PatOrDotdot :: Pat ( x) ) . collect ( ) ;
68
+
69
+ if let Some ( pos) = dotdot_pos {
70
+ let snippet = context. snippet ( self . span ) ;
71
+ let lo_pos = snippet. find ( ".." ) . unwrap ( ) ;
72
+ let lo = self . span . lo + BytePos ( lo_pos as u32 ) ;
73
+ // 2 == "..".len()
74
+ let dotdot = PatOrDotdot :: Dotdot ( lo, lo + BytePos ( 2 ) ) ;
75
+
76
+ if pat_vec. is_empty ( ) {
77
+ pat_vec = vec ! [ dotdot] ;
78
+ } else {
79
+ pat_vec. insert ( pos, dotdot) ;
80
+ }
67
81
}
68
- rewrite_tuple ( context,
69
- items. iter ( ) . map ( |x| & * * x) ,
70
- self . span ,
71
- width,
72
- offset)
82
+
83
+ rewrite_tuple ( context, pat_vec. iter ( ) , self . span , width, offset)
73
84
}
74
85
PatKind :: Path ( ref path) => rewrite_path ( context, true , None , path, width, offset) ,
75
86
PatKind :: TupleStruct ( ref path, ref pat_vec, dotdot_pos) => {
76
- let path_str = try_opt ! ( rewrite_path( context, true , None , path, width, offset) ) ;
87
+ let mut pat_vec: Vec < _ > =
88
+ pat_vec. into_iter ( ) . map ( |x| PatOrDotdot :: Pat ( x) ) . collect ( ) ;
77
89
78
- // FIXME(#1021): Handle `..` in tuple / tuple struct patterns (RFC 1492)
79
- match dotdot_pos {
80
- Some ( _) => Some ( format ! ( "{}(..)" , path_str) ) ,
81
- None => {
82
- if pat_vec. is_empty ( ) {
83
- Some ( path_str)
84
- } else {
85
- // 2 = "()".len()
86
- let width = try_opt ! ( width. checked_sub( path_str. len( ) + 2 ) ) ;
87
- // 1 = "(".len()
88
- let offset = offset + path_str. len ( ) + 1 ;
89
- let items = itemize_list ( context. codemap ,
90
- pat_vec. iter ( ) ,
91
- ")" ,
92
- |item| item. span . lo ,
93
- |item| item. span . hi ,
94
- |item| item. rewrite ( context, width, offset) ,
95
- context. codemap . span_after ( self . span , "(" ) ,
96
- self . span . hi ) ;
97
- Some ( format ! ( "{}({})" ,
98
- path_str,
99
- try_opt!( format_item_list( items,
100
- width,
101
- offset,
102
- context. config) ) ) )
103
- }
90
+ if let Some ( pos) = dotdot_pos {
91
+ let snippet = context. snippet ( self . span ) ;
92
+ let lo_pos = snippet. find ( ".." ) . unwrap ( ) ;
93
+ let lo = self . span . lo + BytePos ( lo_pos as u32 ) ;
94
+ // 2 == "..".len()
95
+ let dotdot = PatOrDotdot :: Dotdot ( lo, lo + BytePos ( 2 ) ) ;
96
+
97
+ if pat_vec. is_empty ( ) {
98
+ pat_vec = vec ! [ dotdot] ;
99
+ } else {
100
+ pat_vec. insert ( pos, dotdot) ;
104
101
}
105
102
}
103
+
104
+ let path_str = try_opt ! ( rewrite_path( context, true , None , path, width, offset) ) ;
105
+
106
+ if pat_vec. is_empty ( ) {
107
+ Some ( path_str)
108
+ } else if pat_vec. len ( ) == 1 && pat_vec[ 0 ] . is_dotdot ( ) {
109
+ Some ( format ! ( "{}(..)" , path_str) )
110
+ } else {
111
+ // 2 = "()".len()
112
+ let width = try_opt ! ( width. checked_sub( path_str. len( ) + 2 ) ) ;
113
+ // 1 = "(".len()
114
+ let offset = offset + path_str. len ( ) + 1 ;
115
+ let items = itemize_list ( context. codemap ,
116
+ pat_vec. iter ( ) ,
117
+ ")" ,
118
+ |item| item. span ( ) . lo ,
119
+ |item| item. span ( ) . hi ,
120
+ |item| item. rewrite ( context, width, offset) ,
121
+ context. codemap . span_after ( self . span , "(" ) ,
122
+ self . span . hi ) ;
123
+ Some ( format ! ( "{}({})" ,
124
+ path_str,
125
+ try_opt!( format_item_list( items, width, offset, context. config) ) ) )
126
+ }
106
127
}
107
128
PatKind :: Lit ( ref expr) => expr. rewrite ( context, width, offset) ,
108
129
PatKind :: Vec ( ref prefix, ref slice_pat, ref suffix) => {
@@ -190,3 +211,41 @@ impl Rewrite for FieldPat {
190
211
}
191
212
}
192
213
}
214
+
215
+ enum PatOrDotdot < ' a > {
216
+ Pat ( & ' a ptr:: P < ast:: Pat > ) ,
217
+ Dotdot ( BytePos , BytePos ) ,
218
+ }
219
+
220
+ impl < ' a > PatOrDotdot < ' a > {
221
+ fn is_dotdot ( & self ) -> bool {
222
+ match * self {
223
+ PatOrDotdot :: Dotdot ( ..) => true ,
224
+ _ => false ,
225
+ }
226
+ }
227
+ }
228
+
229
+ impl < ' a > Rewrite for PatOrDotdot < ' a > {
230
+ fn rewrite ( & self , context : & RewriteContext , width : usize , offset : Indent ) -> Option < String > {
231
+ match * self {
232
+ PatOrDotdot :: Pat ( ref p) => p. rewrite ( context, width, offset) ,
233
+ PatOrDotdot :: Dotdot ( ..) => Some ( ".." . to_string ( ) ) ,
234
+ }
235
+ }
236
+ }
237
+
238
+ impl < ' a > Spanned for PatOrDotdot < ' a > {
239
+ fn span ( & self ) -> Span {
240
+ match * self {
241
+ PatOrDotdot :: Pat ( ref p) => p. span ( ) ,
242
+ PatOrDotdot :: Dotdot ( lo, hi) => {
243
+ Span {
244
+ lo : lo,
245
+ hi : hi,
246
+ expn_id : codemap:: NO_EXPANSION ,
247
+ }
248
+ }
249
+ }
250
+ }
251
+ }
0 commit comments