@@ -183,30 +183,25 @@ fn drop_and_cancel_clean(bcx: block, dat: Datum) -> block {
183
183
184
184
pub fn trans_to_datum ( bcx : block , expr : @ast:: expr ) -> DatumBlock {
185
185
debug ! ( "trans_to_datum(expr=%s)" , bcx. expr_to_str( expr) ) ;
186
- return match bcx. tcx ( ) . adjustments . find ( & expr. id ) {
187
- None => {
188
- trans_to_datum_unadjusted ( bcx, expr)
189
- }
190
- Some ( & @AutoAddEnv ( * ) ) => {
191
- let mut bcx = bcx;
192
- let datum = unpack_datum ! ( bcx, {
193
- trans_to_datum_unadjusted( bcx, expr)
194
- } ) ;
195
- add_env ( bcx, expr, datum)
196
- }
197
- Some ( & @AutoDerefRef ( ref adj) ) => {
198
- let mut bcx = bcx;
199
- let mut datum = unpack_datum ! ( bcx, {
200
- trans_to_datum_unadjusted( bcx, expr)
201
- } ) ;
202
-
203
- debug ! ( "unadjusted datum: %s" , datum. to_str( bcx. ccx( ) ) ) ;
204
186
187
+ let mut bcx = bcx;
188
+ let mut datum = unpack_datum ! ( bcx, trans_to_datum_unadjusted( bcx, expr) ) ;
189
+ let adjustment = match bcx. tcx ( ) . adjustments . find_copy ( & expr. id ) {
190
+ None => { return DatumBlock { bcx : bcx, datum : datum} ; }
191
+ Some ( adj) => { adj }
192
+ } ;
193
+ debug ! ( "unadjusted datum: %s" , datum. to_str( bcx. ccx( ) ) ) ;
194
+ match * adjustment {
195
+ AutoAddEnv ( * ) => {
196
+ datum = unpack_datum ! ( bcx, add_env( bcx, expr, datum) ) ;
197
+ }
198
+ AutoDerefRef ( ref adj) => {
205
199
if adj. autoderefs > 0 {
206
- let DatumBlock { bcx : new_bcx, datum : new_datum } =
207
- datum. autoderef ( bcx, expr. span , expr. id , adj. autoderefs ) ;
208
- datum = new_datum;
209
- bcx = new_bcx;
200
+ datum =
201
+ unpack_datum ! (
202
+ bcx,
203
+ datum. autoderef( bcx, expr. span,
204
+ expr. id, adj. autoderefs) ) ;
210
205
}
211
206
212
207
datum = match adj. autoref {
@@ -224,23 +219,31 @@ pub fn trans_to_datum(bcx: block, expr: @ast::expr) -> DatumBlock {
224
219
unpack_datum ! ( bcx, auto_slice_and_ref( bcx, expr, datum) )
225
220
}
226
221
Some ( AutoBorrowFn ( * ) ) => {
227
- // currently, all closure types are
228
- // represented precisely the same, so no
229
- // runtime adjustment is required:
230
- datum
222
+ let adjusted_ty = ty:: adjust_ty ( bcx. tcx ( ) , expr. span ,
223
+ datum. ty , Some ( adjustment) ) ;
224
+ unpack_datum ! ( bcx, auto_borrow_fn( bcx, adjusted_ty, datum) )
231
225
}
232
226
} ;
233
-
234
- debug ! ( "after adjustments, datum=%s" , datum. to_str( bcx. ccx( ) ) ) ;
235
-
236
- return DatumBlock { bcx : bcx, datum : datum} ;
237
227
}
238
- } ;
228
+ }
229
+ debug ! ( "after adjustments, datum=%s" , datum. to_str( bcx. ccx( ) ) ) ;
230
+ return DatumBlock { bcx : bcx, datum : datum} ;
239
231
240
232
fn auto_ref ( bcx : block , datum : Datum ) -> DatumBlock {
241
233
DatumBlock { bcx : bcx, datum : datum. to_rptr ( bcx) }
242
234
}
243
235
236
+ fn auto_borrow_fn ( bcx : block ,
237
+ adjusted_ty : ty:: t ,
238
+ datum : Datum ) -> DatumBlock {
239
+ // Currently, all closure types are represented precisely the
240
+ // same, so no runtime adjustment is required, but we still
241
+ // must patchup the type.
242
+ DatumBlock { bcx : bcx,
243
+ datum : Datum { val : datum. val , ty : adjusted_ty,
244
+ mode : datum. mode , source : datum. source } }
245
+ }
246
+
244
247
fn auto_slice ( bcx : block , expr : @ast:: expr , datum : Datum ) -> DatumBlock {
245
248
// This is not the most efficient thing possible; since slices
246
249
// are two words it'd be better if this were compiled in
0 commit comments