Skip to content

Commit 25e7e7f

Browse files
bytboxbytbox
committed
Removing do keyword from libstd and librustc
1 parent af218d6 commit 25e7e7f

File tree

27 files changed

+265
-266
lines changed

27 files changed

+265
-266
lines changed

‎src/librustc/middle/typeck/check/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -146,7 +146,7 @@ pub mod method;
146146
/// closures defined within the function. For example:
147147
///
148148
/// fn foo() {
149-
/// do bar() { ... }
149+
/// bar(proc() { ... })
150150
/// }
151151
///
152152
/// Here, the function `foo()` and the closure passed to

‎src/libstd/comm/mod.rs

Lines changed: 67 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -60,18 +60,18 @@
6060
//! ```rust,should_fail
6161
//! // Create a simple streaming channel
6262
//! let (port, chan) = Chan::new();
63-
//! do spawn {
63+
//! spawn(proc() {
6464
//! chan.send(10);
65-
//! }
65+
//! })
6666
//! assert_eq!(port.recv(), 10);
6767
//!
6868
//! // Create a shared channel which can be sent along from many tasks
6969
//! let (port, chan) = SharedChan::new();
7070
//! for i in range(0, 10) {
7171
//! let chan = chan.clone();
72-
//! do spawn {
72+
//! spawn(proc() {
7373
//! chan.send(i);
74-
//! }
74+
//! })
7575
//! }
7676
//!
7777
//! for _ in range(0, 10) {
@@ -264,7 +264,7 @@ macro_rules! test (
264264
$($a)* #[test] fn native() {
265265
use native;
266266
let (p, c) = Chan::new();
267-
do native::task::spawn { c.send(f()) }
267+
native::task::spawn(proc() { c.send(f()) });
268268
p.recv();
269269
}
270270
}
@@ -962,9 +962,9 @@ mod test {
962962

963963
test!(fn smoke_threads() {
964964
let (p, c) = Chan::new();
965-
do spawn {
965+
spawn(proc() {
966966
c.send(1);
967-
}
967+
});
968968
assert_eq!(p.recv(), 1);
969969
})
970970

@@ -990,18 +990,18 @@ mod test {
990990

991991
test!(fn port_gone_concurrent() {
992992
let (p, c) = Chan::new();
993-
do spawn {
993+
spawn(proc() {
994994
p.recv();
995-
}
995+
});
996996
loop { c.send(1) }
997997
} #[should_fail])
998998

999999
test!(fn port_gone_concurrent_shared() {
10001000
let (p, c) = SharedChan::new();
10011001
let c1 = c.clone();
1002-
do spawn {
1002+
spawn(proc() {
10031003
p.recv();
1004-
}
1004+
});
10051005
loop {
10061006
c.send(1);
10071007
c1.send(1);
@@ -1024,18 +1024,18 @@ mod test {
10241024

10251025
test!(fn chan_gone_concurrent() {
10261026
let (p, c) = Chan::new();
1027-
do spawn {
1027+
spawn(proc() {
10281028
c.send(1);
10291029
c.send(1);
1030-
}
1030+
});
10311031
loop { p.recv(); }
10321032
} #[should_fail])
10331033

10341034
test!(fn stress() {
10351035
let (p, c) = Chan::new();
1036-
do spawn {
1036+
spawn(proc() {
10371037
for _ in range(0, 10000) { c.send(1); }
1038-
}
1038+
});
10391039
for _ in range(0, 10000) {
10401040
assert_eq!(p.recv(), 1);
10411041
}
@@ -1047,7 +1047,7 @@ mod test {
10471047
let (p, c) = SharedChan::<int>::new();
10481048
let (p1, c1) = Chan::new();
10491049

1050-
do spawn {
1050+
spawn(proc() {
10511051
for _ in range(0, AMT * NTHREADS) {
10521052
assert_eq!(p.recv(), 1);
10531053
}
@@ -1056,13 +1056,13 @@ mod test {
10561056
_ => {}
10571057
}
10581058
c1.send(());
1059-
}
1059+
});
10601060

10611061
for _ in range(0, NTHREADS) {
10621062
let c = c.clone();
1063-
do spawn {
1063+
spawn(proc() {
10641064
for _ in range(0, AMT) { c.send(1); }
1065-
}
1065+
});
10661066
}
10671067
p1.recv();
10681068
})
@@ -1073,20 +1073,20 @@ mod test {
10731073
let (p1, c1) = Chan::new();
10741074
let (port, chan) = SharedChan::new();
10751075
let chan2 = chan.clone();
1076-
do spawn {
1076+
spawn(proc() {
10771077
c1.send(());
10781078
for _ in range(0, 40) {
10791079
assert_eq!(p.recv(), 1);
10801080
}
10811081
chan2.send(());
1082-
}
1082+
});
10831083
p1.recv();
1084-
do native::task::spawn {
1084+
native::task::spawn(proc() {
10851085
for _ in range(0, 40) {
10861086
c.send(1);
10871087
}
10881088
chan.send(());
1089-
}
1089+
});
10901090
port.recv();
10911091
port.recv();
10921092
}
@@ -1095,12 +1095,12 @@ mod test {
10951095
fn recv_from_outside_runtime() {
10961096
let (p, c) = Chan::<int>::new();
10971097
let (dp, dc) = Chan::new();
1098-
do native::task::spawn {
1098+
native::task::spawn(proc() {
10991099
for _ in range(0, 40) {
11001100
assert_eq!(p.recv(), 1);
11011101
}
11021102
dc.send(());
1103-
};
1103+
});
11041104
for _ in range(0, 40) {
11051105
c.send(1);
11061106
}
@@ -1113,16 +1113,16 @@ mod test {
11131113
let (p2, c2) = Chan::<int>::new();
11141114
let (port, chan) = SharedChan::new();
11151115
let chan2 = chan.clone();
1116-
do native::task::spawn {
1116+
native::task::spawn(proc() {
11171117
assert_eq!(p1.recv(), 1);
11181118
c2.send(2);
11191119
chan2.send(());
1120-
}
1121-
do native::task::spawn {
1120+
});
1121+
native::task::spawn(proc() {
11221122
c1.send(1);
11231123
assert_eq!(p2.recv(), 2);
11241124
chan.send(());
1125-
}
1125+
});
11261126
port.recv();
11271127
port.recv();
11281128
}
@@ -1148,11 +1148,11 @@ mod test {
11481148

11491149
test!(fn oneshot_single_thread_recv_chan_close() {
11501150
// Receiving on a closed chan will fail
1151-
let res = do task::try {
1151+
let res = task::try(proc() {
11521152
let (port, chan) = Chan::<~int>::new();
11531153
{ let _c = chan; }
11541154
port.recv();
1155-
};
1155+
});
11561156
// What is our res?
11571157
assert!(res.is_err());
11581158
})
@@ -1208,74 +1208,74 @@ mod test {
12081208

12091209
test!(fn oneshot_multi_task_recv_then_send() {
12101210
let (port, chan) = Chan::<~int>::new();
1211-
do spawn {
1211+
spawn(proc() {
12121212
assert!(port.recv() == ~10);
1213-
}
1213+
});
12141214

12151215
chan.send(~10);
12161216
})
12171217

12181218
test!(fn oneshot_multi_task_recv_then_close() {
12191219
let (port, chan) = Chan::<~int>::new();
1220-
do spawn {
1220+
spawn(proc() {
12211221
let _chan = chan;
1222-
}
1223-
let res = do task::try {
1222+
});
1223+
let res = task::try(proc() {
12241224
assert!(port.recv() == ~10);
1225-
};
1225+
});
12261226
assert!(res.is_err());
12271227
})
12281228

12291229
test!(fn oneshot_multi_thread_close_stress() {
12301230
stress_factor().times(|| {
12311231
let (port, chan) = Chan::<int>::new();
1232-
do spawn {
1232+
spawn(proc() {
12331233
let _p = port;
1234-
}
1234+
});
12351235
let _chan = chan;
12361236
})
12371237
})
12381238

12391239
test!(fn oneshot_multi_thread_send_close_stress() {
12401240
stress_factor().times(|| {
12411241
let (port, chan) = Chan::<int>::new();
1242-
do spawn {
1242+
spawn(proc() {
12431243
let _p = port;
1244-
}
1245-
do task::try {
1244+
});
1245+
task::try(proc() {
12461246
chan.send(1);
1247-
};
1247+
});
12481248
})
12491249
})
12501250

12511251
test!(fn oneshot_multi_thread_recv_close_stress() {
12521252
stress_factor().times(|| {
12531253
let (port, chan) = Chan::<int>::new();
1254-
do spawn {
1254+
spawn(proc() {
12551255
let port = port;
1256-
let res = do task::try {
1256+
let res = task::try(proc() {
12571257
port.recv();
1258-
};
1258+
});
12591259
assert!(res.is_err());
1260-
};
1261-
do spawn {
1260+
});
1261+
spawn(proc() {
12621262
let chan = chan;
1263-
do spawn {
1263+
spawn(proc() {
12641264
let _chan = chan;
1265-
}
1266-
};
1265+
});
1266+
});
12671267
})
12681268
})
12691269

12701270
test!(fn oneshot_multi_thread_send_recv_stress() {
12711271
stress_factor().times(|| {
12721272
let (port, chan) = Chan::<~int>::new();
1273-
do spawn {
1273+
spawn(proc() {
12741274
chan.send(~10);
1275-
}
1276-
do spawn {
1275+
});
1276+
spawn(proc() {
12771277
assert!(port.recv() == ~10);
1278-
}
1278+
});
12791279
})
12801280
})
12811281

@@ -1289,19 +1289,19 @@ mod test {
12891289
fn send(chan: Chan<~int>, i: int) {
12901290
if i == 10 { return }
12911291

1292-
do spawn {
1292+
spawn(proc() {
12931293
chan.send(~i);
12941294
send(chan, i + 1);
1295-
}
1295+
});
12961296
}
12971297

12981298
fn recv(port: Port<~int>, i: int) {
12991299
if i == 10 { return }
13001300

1301-
do spawn {
1301+
spawn(proc() {
13021302
assert!(port.recv() == ~i);
13031303
recv(port, i + 1);
1304-
};
1304+
});
13051305
}
13061306
})
13071307
})
@@ -1318,9 +1318,9 @@ mod test {
13181318
let total = stress_factor() + 100;
13191319
total.times(|| {
13201320
let chan_clone = chan.clone();
1321-
do spawn {
1321+
spawn(proc() {
13221322
chan_clone.send(());
1323-
}
1323+
});
13241324
});
13251325

13261326
total.times(|| {
@@ -1332,13 +1332,13 @@ mod test {
13321332
let (port, chan) = Chan::<int>::new();
13331333
let (total_port, total_chan) = Chan::<int>::new();
13341334

1335-
do spawn {
1335+
spawn(proc() {
13361336
let mut acc = 0;
13371337
for x in port.iter() {
13381338
acc += x;
13391339
}
13401340
total_chan.send(acc);
1341-
}
1341+
});
13421342

13431343
chan.send(3);
13441344
chan.send(1);
@@ -1351,7 +1351,7 @@ mod test {
13511351
let (port, chan) = Chan::<int>::new();
13521352
let (count_port, count_chan) = Chan::<int>::new();
13531353

1354-
do spawn {
1354+
spawn(proc() {
13551355
let mut count = 0;
13561356
for x in port.iter() {
13571357
if count >= 3 {
@@ -1361,7 +1361,7 @@ mod test {
13611361
}
13621362
}
13631363
count_chan.send(count);
1364-
}
1364+
});
13651365

13661366
chan.send(2);
13671367
chan.send(2);
@@ -1375,14 +1375,14 @@ mod test {
13751375
let (p, c) = Chan::<int>::new();
13761376
let (p1, c1) = Chan::<()>::new();
13771377
let (p2, c2) = Chan::<()>::new();
1378-
do spawn {
1378+
spawn(proc() {
13791379
p1.recv();
13801380
c.send(1);
13811381
c2.send(());
13821382
p1.recv();
13831383
drop(c);
13841384
c2.send(());
1385-
}
1385+
});
13861386

13871387
assert_eq!(p.try_recv(), Empty);
13881388
c1.send(());

0 commit comments

Comments
 (0)