@@ -55,7 +55,103 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t
55
55
None => { }
56
56
}
57
57
let pos = w. tell ( ) . unwrap ( ) ;
58
- enc_sty ( w, cx, & t. sty ) ;
58
+
59
+ match t. sty {
60
+ ty:: ty_bool => mywrite ! ( w, "b" ) ,
61
+ ty:: ty_char => mywrite ! ( w, "c" ) ,
62
+ ty:: ty_int( t) => {
63
+ match t {
64
+ ast:: TyI => mywrite ! ( w, "i" ) ,
65
+ ast:: TyI8 => mywrite ! ( w, "MB" ) ,
66
+ ast:: TyI16 => mywrite ! ( w, "MW" ) ,
67
+ ast:: TyI32 => mywrite ! ( w, "ML" ) ,
68
+ ast:: TyI64 => mywrite ! ( w, "MD" )
69
+ }
70
+ }
71
+ ty:: ty_uint( t) => {
72
+ match t {
73
+ ast:: TyU => mywrite ! ( w, "u" ) ,
74
+ ast:: TyU8 => mywrite ! ( w, "Mb" ) ,
75
+ ast:: TyU16 => mywrite ! ( w, "Mw" ) ,
76
+ ast:: TyU32 => mywrite ! ( w, "Ml" ) ,
77
+ ast:: TyU64 => mywrite ! ( w, "Md" )
78
+ }
79
+ }
80
+ ty:: ty_float( t) => {
81
+ match t {
82
+ ast:: TyF32 => mywrite ! ( w, "Mf" ) ,
83
+ ast:: TyF64 => mywrite ! ( w, "MF" ) ,
84
+ }
85
+ }
86
+ ty:: ty_enum( def, ref substs) => {
87
+ mywrite ! ( w, "t[{}|" , ( cx. ds) ( def) ) ;
88
+ enc_substs ( w, cx, substs) ;
89
+ mywrite ! ( w, "]" ) ;
90
+ }
91
+ ty:: ty_trait( box ty:: TyTrait { ref principal,
92
+ ref bounds } ) => {
93
+ mywrite ! ( w, "x[" ) ;
94
+ enc_trait_ref ( w, cx, & principal. 0 ) ;
95
+ enc_existential_bounds ( w, cx, bounds) ;
96
+ mywrite ! ( w, "]" ) ;
97
+ }
98
+ ty:: ty_tup( ref ts) => {
99
+ mywrite ! ( w, "T[" ) ;
100
+ for t in ts. iter ( ) { enc_ty ( w, cx, * t) ; }
101
+ mywrite ! ( w, "]" ) ;
102
+ }
103
+ ty:: ty_uniq( typ) => { mywrite ! ( w, "~" ) ; enc_ty ( w, cx, typ) ; }
104
+ ty:: ty_ptr( mt) => { mywrite ! ( w, "*" ) ; enc_mt ( w, cx, mt) ; }
105
+ ty:: ty_rptr( r, mt) => {
106
+ mywrite ! ( w, "&" ) ;
107
+ enc_region ( w, cx, r) ;
108
+ enc_mt ( w, cx, mt) ;
109
+ }
110
+ ty:: ty_vec( t, sz) => {
111
+ mywrite ! ( w, "V" ) ;
112
+ enc_ty ( w, cx, t) ;
113
+ mywrite ! ( w, "/" ) ;
114
+ match sz {
115
+ Some ( n) => mywrite ! ( w, "{}|" , n) ,
116
+ None => mywrite ! ( w, "|" ) ,
117
+ }
118
+ }
119
+ ty:: ty_str => {
120
+ mywrite ! ( w, "v" ) ;
121
+ }
122
+ ty:: ty_closure( ref f) => {
123
+ mywrite ! ( w, "f" ) ;
124
+ enc_closure_ty ( w, cx, & * * f) ;
125
+ }
126
+ ty:: ty_bare_fn( ref f) => {
127
+ mywrite ! ( w, "F" ) ;
128
+ enc_bare_fn_ty ( w, cx, f) ;
129
+ }
130
+ ty:: ty_infer( _) => {
131
+ cx. diag . handler ( ) . bug ( "cannot encode inference variable types" ) ;
132
+ }
133
+ ty:: ty_param( ParamTy { space, idx : id, def_id : did} ) => {
134
+ mywrite ! ( w, "p{}|{}|{}|" , ( cx. ds) ( did) , id, space. to_uint( ) )
135
+ }
136
+ ty:: ty_struct( def, ref substs) => {
137
+ mywrite ! ( w, "a[{}|" , ( cx. ds) ( def) ) ;
138
+ enc_substs ( w, cx, substs) ;
139
+ mywrite ! ( w, "]" ) ;
140
+ }
141
+ ty:: ty_unboxed_closure( def, region, ref substs) => {
142
+ mywrite ! ( w, "k[{}|" , ( cx. ds) ( def) ) ;
143
+ enc_region ( w, cx, region) ;
144
+ enc_substs ( w, cx, substs) ;
145
+ mywrite ! ( w, "]" ) ;
146
+ }
147
+ ty:: ty_err => {
148
+ mywrite ! ( w, "e" ) ;
149
+ }
150
+ ty:: ty_open( _) => {
151
+ cx. diag . handler ( ) . bug ( "unexpected type in enc_sty (ty_open)" ) ;
152
+ }
153
+ }
154
+
59
155
let end = w. tell ( ) . unwrap ( ) ;
60
156
let len = end - pos;
61
157
fn estimate_sz ( u : u64 ) -> u64 {
@@ -214,105 +310,6 @@ pub fn enc_trait_store(w: &mut SeekableMemWriter, cx: &ctxt, s: ty::TraitStore)
214
310
}
215
311
}
216
312
217
- fn enc_sty < ' a , ' tcx > ( w : & mut SeekableMemWriter , cx : & ctxt < ' a , ' tcx > ,
218
- st : & ty:: sty < ' tcx > ) {
219
- match * st {
220
- ty:: ty_bool => mywrite ! ( w, "b" ) ,
221
- ty:: ty_char => mywrite ! ( w, "c" ) ,
222
- ty:: ty_int( t) => {
223
- match t {
224
- ast:: TyI => mywrite ! ( w, "i" ) ,
225
- ast:: TyI8 => mywrite ! ( w, "MB" ) ,
226
- ast:: TyI16 => mywrite ! ( w, "MW" ) ,
227
- ast:: TyI32 => mywrite ! ( w, "ML" ) ,
228
- ast:: TyI64 => mywrite ! ( w, "MD" )
229
- }
230
- }
231
- ty:: ty_uint( t) => {
232
- match t {
233
- ast:: TyU => mywrite ! ( w, "u" ) ,
234
- ast:: TyU8 => mywrite ! ( w, "Mb" ) ,
235
- ast:: TyU16 => mywrite ! ( w, "Mw" ) ,
236
- ast:: TyU32 => mywrite ! ( w, "Ml" ) ,
237
- ast:: TyU64 => mywrite ! ( w, "Md" )
238
- }
239
- }
240
- ty:: ty_float( t) => {
241
- match t {
242
- ast:: TyF32 => mywrite ! ( w, "Mf" ) ,
243
- ast:: TyF64 => mywrite ! ( w, "MF" ) ,
244
- }
245
- }
246
- ty:: ty_enum( def, ref substs) => {
247
- mywrite ! ( w, "t[{}|" , ( cx. ds) ( def) ) ;
248
- enc_substs ( w, cx, substs) ;
249
- mywrite ! ( w, "]" ) ;
250
- }
251
- ty:: ty_trait( box ty:: TyTrait { ref principal,
252
- ref bounds } ) => {
253
- mywrite ! ( w, "x[" ) ;
254
- enc_trait_ref ( w, cx, & principal. 0 ) ;
255
- enc_existential_bounds ( w, cx, bounds) ;
256
- mywrite ! ( w, "]" ) ;
257
- }
258
- ty:: ty_tup( ref ts) => {
259
- mywrite ! ( w, "T[" ) ;
260
- for t in ts. iter ( ) { enc_ty ( w, cx, * t) ; }
261
- mywrite ! ( w, "]" ) ;
262
- }
263
- ty:: ty_uniq( typ) => { mywrite ! ( w, "~" ) ; enc_ty ( w, cx, typ) ; }
264
- ty:: ty_ptr( mt) => { mywrite ! ( w, "*" ) ; enc_mt ( w, cx, mt) ; }
265
- ty:: ty_rptr( r, mt) => {
266
- mywrite ! ( w, "&" ) ;
267
- enc_region ( w, cx, r) ;
268
- enc_mt ( w, cx, mt) ;
269
- }
270
- ty:: ty_vec( t, sz) => {
271
- mywrite ! ( w, "V" ) ;
272
- enc_ty ( w, cx, t) ;
273
- mywrite ! ( w, "/" ) ;
274
- match sz {
275
- Some ( n) => mywrite ! ( w, "{}|" , n) ,
276
- None => mywrite ! ( w, "|" ) ,
277
- }
278
- }
279
- ty:: ty_str => {
280
- mywrite ! ( w, "v" ) ;
281
- }
282
- ty:: ty_closure( ref f) => {
283
- mywrite ! ( w, "f" ) ;
284
- enc_closure_ty ( w, cx, & * * f) ;
285
- }
286
- ty:: ty_bare_fn( ref f) => {
287
- mywrite ! ( w, "F" ) ;
288
- enc_bare_fn_ty ( w, cx, f) ;
289
- }
290
- ty:: ty_infer( _) => {
291
- cx. diag . handler ( ) . bug ( "cannot encode inference variable types" ) ;
292
- }
293
- ty:: ty_param( ParamTy { space, idx : id, def_id : did} ) => {
294
- mywrite ! ( w, "p{}|{}|{}|" , ( cx. ds) ( did) , id, space. to_uint( ) )
295
- }
296
- ty:: ty_struct( def, ref substs) => {
297
- mywrite ! ( w, "a[{}|" , ( cx. ds) ( def) ) ;
298
- enc_substs ( w, cx, substs) ;
299
- mywrite ! ( w, "]" ) ;
300
- }
301
- ty:: ty_unboxed_closure( def, region, ref substs) => {
302
- mywrite ! ( w, "k[{}|" , ( cx. ds) ( def) ) ;
303
- enc_region ( w, cx, region) ;
304
- enc_substs ( w, cx, substs) ;
305
- mywrite ! ( w, "]" ) ;
306
- }
307
- ty:: ty_err => {
308
- mywrite ! ( w, "e" ) ;
309
- }
310
- ty:: ty_open( _) => {
311
- cx. diag . handler ( ) . bug ( "unexpected type in enc_sty (ty_open)" ) ;
312
- }
313
- }
314
- }
315
-
316
313
fn enc_unsafety ( w : & mut SeekableMemWriter , p : ast:: Unsafety ) {
317
314
match p {
318
315
ast:: Unsafety :: Normal => mywrite ! ( w, "n" ) ,
0 commit comments