@@ -113,7 +113,7 @@ impl<T> ChanOne<T> {
113
113
114
114
// 'do_resched' configures whether the scheduler immediately switches to
115
115
// the receiving task, or leaves the sending task still running.
116
- fn try_send_inner ( self , val : T , do_resched : bool ) -> bool {
116
+ fn try_send_inner ( mut self , val : T , do_resched : bool ) -> bool {
117
117
if do_resched {
118
118
rtassert ! ( !rt:: in_sched_context( ) ) ;
119
119
}
@@ -129,9 +129,8 @@ impl<T> ChanOne<T> {
129
129
sched. maybe_yield ( ) ;
130
130
}
131
131
132
- let mut this = self ;
133
132
let mut recvr_active = true ;
134
- let packet = this . packet ( ) ;
133
+ let packet = self . packet ( ) ;
135
134
136
135
unsafe {
137
136
@@ -150,15 +149,15 @@ impl<T> ChanOne<T> {
150
149
// done with the packet. NB: In case of do_resched, this *must*
151
150
// happen before waking up a blocked task (or be unkillable),
152
151
// because we might get a kill signal during the reschedule.
153
- this . suppress_finalize = true ;
152
+ self . suppress_finalize = true ;
154
153
155
154
match oldstate {
156
155
STATE_BOTH => {
157
156
// Port is not waiting yet. Nothing to do
158
157
}
159
158
STATE_ONE => {
160
159
// Port has closed. Need to clean up.
161
- let _packet: ~Packet < T > = cast:: transmute ( this . void_packet ) ;
160
+ let _packet: ~Packet < T > = cast:: transmute ( self . void_packet ) ;
162
161
recvr_active = false ;
163
162
}
164
163
task_as_state => {
@@ -202,22 +201,20 @@ impl<T> PortOne<T> {
202
201
}
203
202
204
203
/// As `recv`, but returns `None` if the send end is closed rather than failing.
205
- pub fn try_recv ( self ) -> Option < T > {
206
- let mut this = self ;
207
-
204
+ pub fn try_recv ( mut self ) -> Option < T > {
208
205
// Optimistic check. If data was sent already, we don't even need to block.
209
206
// No release barrier needed here; we're not handing off our task pointer yet.
210
- if !this . optimistic_check ( ) {
207
+ if !self . optimistic_check ( ) {
211
208
// No data available yet.
212
209
// Switch to the scheduler to put the ~Task into the Packet state.
213
210
let sched: ~Scheduler = Local :: take ( ) ;
214
211
do sched. deschedule_running_task_and_then |sched, task| {
215
- this . block_on ( sched, task) ;
212
+ self . block_on ( sched, task) ;
216
213
}
217
214
}
218
215
219
216
// Task resumes.
220
- this . recv_ready ( )
217
+ self . recv_ready ( )
221
218
}
222
219
}
223
220
@@ -325,9 +322,8 @@ impl<T> SelectInner for PortOne<T> {
325
322
impl < T > Select for PortOne < T > { }
326
323
327
324
impl < T > SelectPortInner < T > for PortOne < T > {
328
- fn recv_ready ( self ) -> Option < T > {
329
- let mut this = self ;
330
- let packet = this. packet ( ) ;
325
+ fn recv_ready ( mut self ) -> Option < T > {
326
+ let packet = self . packet ( ) ;
331
327
332
328
// No further memory barrier is needed here to access the
333
329
// payload. Some scenarios:
@@ -348,9 +344,9 @@ impl<T> SelectPortInner<T> for PortOne<T> {
348
344
let payload = ( * packet) . payload . take ( ) ;
349
345
350
346
// The sender has closed up shop. Drop the packet.
351
- let _packet: ~Packet < T > = cast:: transmute ( this . void_packet ) ;
347
+ let _packet: ~Packet < T > = cast:: transmute ( self . void_packet ) ;
352
348
// Suppress the synchronizing actions in the finalizer. We're done with the packet.
353
- this . suppress_finalize = true ;
349
+ self . suppress_finalize = true ;
354
350
return payload;
355
351
}
356
352
}
@@ -378,18 +374,17 @@ impl<T> Drop for ChanOne<T> {
378
374
if self . suppress_finalize { return }
379
375
380
376
unsafe {
381
- let this = cast:: transmute_mut ( self ) ;
382
- let oldstate = ( * this. packet ( ) ) . state . swap ( STATE_ONE , SeqCst ) ;
377
+ let oldstate = ( * self . packet ( ) ) . state . swap ( STATE_ONE , SeqCst ) ;
383
378
match oldstate {
384
379
STATE_BOTH => {
385
380
// Port still active. It will destroy the Packet.
386
381
} ,
387
382
STATE_ONE => {
388
- let _packet: ~Packet < T > = cast:: transmute ( this . void_packet ) ;
383
+ let _packet: ~Packet < T > = cast:: transmute ( self . void_packet ) ;
389
384
} ,
390
385
task_as_state => {
391
386
// The port is blocked waiting for a message we will never send. Wake it.
392
- rtassert ! ( ( * this . packet( ) ) . payload. is_none( ) ) ;
387
+ rtassert ! ( ( * self . packet( ) ) . payload. is_none( ) ) ;
393
388
let recvr = BlockedTask :: cast_from_uint ( task_as_state) ;
394
389
do recvr. wake ( ) . map |woken_task| {
395
390
Scheduler :: run_task ( woken_task) ;
@@ -406,14 +401,13 @@ impl<T> Drop for PortOne<T> {
406
401
if self . suppress_finalize { return }
407
402
408
403
unsafe {
409
- let this = cast:: transmute_mut ( self ) ;
410
- let oldstate = ( * this. packet ( ) ) . state . swap ( STATE_ONE , SeqCst ) ;
404
+ let oldstate = ( * self . packet ( ) ) . state . swap ( STATE_ONE , SeqCst ) ;
411
405
match oldstate {
412
406
STATE_BOTH => {
413
407
// Chan still active. It will destroy the packet.
414
408
} ,
415
409
STATE_ONE => {
416
- let _packet: ~Packet < T > = cast:: transmute ( this . void_packet ) ;
410
+ let _packet: ~Packet < T > = cast:: transmute ( self . void_packet ) ;
417
411
}
418
412
task_as_state => {
419
413
// This case occurs during unwinding, when the blocked
0 commit comments