@@ -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,72 @@ 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| match * * item {
121
+ PatOrDotdot :: Pat ( ref pat) => {
122
+ pat. rewrite ( context, width, offset)
123
+ }
124
+ PatOrDotdot :: Dotdot ( ..) => Some ( ".." . to_string ( ) ) ,
125
+ } ,
126
+ context. codemap . span_after ( self . span , "(" ) ,
127
+ self . span . hi ) ;
128
+ Some ( format ! ( "{}({})" ,
129
+ path_str,
130
+ try_opt!( format_item_list( items, width, offset, context. config) ) ) )
131
+ }
106
132
}
107
133
PatKind :: Lit ( ref expr) => expr. rewrite ( context, width, offset) ,
108
134
PatKind :: Vec ( ref prefix, ref slice_pat, ref suffix) => {
@@ -190,3 +216,41 @@ impl Rewrite for FieldPat {
190
216
}
191
217
}
192
218
}
219
+
220
+ enum PatOrDotdot < ' a > {
221
+ Pat ( & ' a ptr:: P < ast:: Pat > ) ,
222
+ Dotdot ( BytePos , BytePos ) ,
223
+ }
224
+
225
+ impl < ' a > PatOrDotdot < ' a > {
226
+ fn is_dotdot ( & self ) -> bool {
227
+ match * self {
228
+ PatOrDotdot :: Dotdot ( ..) => true ,
229
+ _ => false ,
230
+ }
231
+ }
232
+ }
233
+
234
+ impl < ' a > Rewrite for PatOrDotdot < ' a > {
235
+ fn rewrite ( & self , context : & RewriteContext , width : usize , offset : Indent ) -> Option < String > {
236
+ match * self {
237
+ PatOrDotdot :: Pat ( ref p) => p. rewrite ( context, width, offset) ,
238
+ PatOrDotdot :: Dotdot ( ..) => Some ( ".." . to_string ( ) ) ,
239
+ }
240
+ }
241
+ }
242
+
243
+ impl < ' a > Spanned for PatOrDotdot < ' a > {
244
+ fn span ( & self ) -> Span {
245
+ match * self {
246
+ PatOrDotdot :: Pat ( ref p) => p. span ( ) ,
247
+ PatOrDotdot :: Dotdot ( lo, hi) => {
248
+ Span {
249
+ lo : lo,
250
+ hi : hi,
251
+ expn_id : codemap:: NO_EXPANSION ,
252
+ }
253
+ }
254
+ }
255
+ }
256
+ }
0 commit comments