diff options
| author | bors <bors@rust-lang.org> | 2014-05-03 10:56:57 -0700 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2014-05-03 10:56:57 -0700 |
| commit | 0c691df8acaf10aa3721476e5d7fafcee11b0aaa (patch) | |
| tree | 7aca9144c64039fea0aff444e13870b4be40fae7 /src/libstd | |
| parent | bca9647cd34c78a1c7c2409fbb2c31cb2c8194d7 (diff) | |
| parent | a5be12ce7e88c1d28de1c98215991127d1e765f0 (diff) | |
| download | rust-0c691df8acaf10aa3721476e5d7fafcee11b0aaa.tar.gz rust-0c691df8acaf10aa3721476e5d7fafcee11b0aaa.zip | |
auto merge of #13773 : brson/rust/boxxy, r=alexcrichton
`box` is the way you allocate in future-rust.
Diffstat (limited to 'src/libstd')
45 files changed, 361 insertions, 360 deletions
diff --git a/src/libstd/any.rs b/src/libstd/any.rs index 5a6ecdb1f21..e448b7b8e24 100644 --- a/src/libstd/any.rs +++ b/src/libstd/any.rs @@ -190,7 +190,7 @@ mod tests { #[test] fn any_owning() { - let (a, b, c) = (~5u as ~Any, ~TEST as ~Any, ~Test as ~Any); + let (a, b, c) = (box 5u as ~Any, box TEST as ~Any, box Test as ~Any); assert!(a.is::<uint>()); assert!(!b.is::<uint>()); @@ -223,7 +223,7 @@ mod tests { #[test] fn any_as_mut() { let mut a = 5u; - let mut b = ~7u; + let mut b = box 7u; let a_r = &mut a as &mut Any; let tmp: &mut uint = b; @@ -268,20 +268,20 @@ mod tests { #[test] fn any_move() { - let a = ~8u as ~Any; - let b = ~Test as ~Any; + let a = box 8u as ~Any; + let b = box Test as ~Any; match a.move::<uint>() { - Ok(a) => { assert_eq!(a, ~8u); } + Ok(a) => { assert_eq!(a, box 8u); } Err(..) => fail!() } match b.move::<Test>() { - Ok(a) => { assert_eq!(a, ~Test); } + Ok(a) => { assert_eq!(a, box Test); } Err(..) => fail!() } - let a = ~8u as ~Any; - let b = ~Test as ~Any; + let a = box 8u as ~Any; + let b = box Test as ~Any; assert!(a.move::<~Test>().is_err()); assert!(b.move::<~uint>().is_err()); @@ -289,8 +289,8 @@ mod tests { #[test] fn test_show() { - let a = ~8u as ~Any; - let b = ~Test as ~Any; + let a = box 8u as ~Any; + let b = box Test as ~Any; assert_eq!(format!("{}", a), "~Any".to_owned()); assert_eq!(format!("{}", b), "~Any".to_owned()); diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 6ffe0cfe57d..5b4400593b4 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -492,7 +492,7 @@ mod tests { macro_rules! v2ascii ( ( [$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]); (&[$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]); - (~[$($e:expr),*]) => (~[$(Ascii{chr:$e}),*]); + (~[$($e:expr),*]) => (box [$(Ascii{chr:$e}),*]); ) macro_rules! vec2ascii ( @@ -536,7 +536,7 @@ mod tests { assert_eq!("( ;".to_ascii(), v2ascii!([40, 32, 59])); // FIXME: #5475 borrowchk error, owned vectors do not live long enough // if chained-from directly - let v = ~[40u8, 32u8, 59u8]; assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59])); + let v = box [40u8, 32u8, 59u8]; assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59])); let v = "( ;".to_owned(); assert_eq!(v.to_ascii(), v2ascii!([40, 32, 59])); assert_eq!("abCDef&?#".to_ascii().to_lower().into_str(), "abcdef&?#".to_owned()); @@ -569,7 +569,7 @@ mod tests { #[test] fn test_owned_ascii_vec() { assert_eq!(("( ;".to_owned()).into_ascii(), v2ascii!(~[40, 32, 59])); - assert_eq!((~[40u8, 32u8, 59u8]).into_ascii(), v2ascii!(~[40, 32, 59])); + assert_eq!((box [40u8, 32u8, 59u8]).into_ascii(), v2ascii!(~[40, 32, 59])); } #[test] @@ -586,7 +586,7 @@ mod tests { #[test] fn test_ascii_to_bytes() { - assert_eq!(v2ascii!(~[40, 32, 59]).into_bytes(), ~[40u8, 32u8, 59u8]); + assert_eq!(v2ascii!(~[40, 32, 59]).into_bytes(), box [40u8, 32u8, 59u8]); } #[test] #[should_fail] @@ -625,8 +625,8 @@ mod tests { assert_eq!(v.to_ascii_opt(), Some(v2)); assert_eq!("zoä华".to_ascii_opt(), None); - assert_eq!((~[40u8, 32u8, 59u8]).into_ascii_opt(), Some(v2ascii!(~[40, 32, 59]))); - assert_eq!((~[127u8, 128u8, 255u8]).into_ascii_opt(), None); + assert_eq!((box [40u8, 32u8, 59u8]).into_ascii_opt(), Some(v2ascii!(~[40, 32, 59]))); + assert_eq!((box [127u8, 128u8, 255u8]).into_ascii_opt(), None); assert_eq!(("( ;".to_owned()).into_ascii_opt(), Some(v2ascii!(~[40, 32, 59]))); assert_eq!(("zoä华".to_owned()).into_ascii_opt(), None); diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs index eb7eb8d1df9..bcbf804d7b3 100644 --- a/src/libstd/cast.rs +++ b/src/libstd/cast.rs @@ -142,7 +142,7 @@ mod tests { #[test] fn test_transmute2() { unsafe { - assert_eq!(~[76u8], transmute("L".to_owned())); + assert_eq!(box [76u8], transmute("L".to_owned())); } } } diff --git a/src/libstd/clone.rs b/src/libstd/clone.rs index cf5a9c6711c..e25f9c5ad4f 100644 --- a/src/libstd/clone.rs +++ b/src/libstd/clone.rs @@ -42,7 +42,7 @@ pub trait Clone { impl<T: Clone> Clone for ~T { /// Return a copy of the owned box. #[inline] - fn clone(&self) -> ~T { ~(**self).clone() } + fn clone(&self) -> ~T { box {(**self).clone()} } /// Perform copy-assignment from `source` by reusing the existing allocation. #[inline] @@ -126,7 +126,7 @@ extern_fn_clone!(A, B, C, D, E, F, G, H) #[test] fn test_owned_clone() { - let a = ~5i; + let a = box 5i; let b: ~int = a.clone(); assert_eq!(a, b); } @@ -148,8 +148,8 @@ fn test_borrowed_clone() { #[test] fn test_clone_from() { - let a = ~5; - let mut b = ~10; + let a = box 5; + let mut b = box 10; b.clone_from(&a); assert_eq!(*b, 5); } diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs index ce1c09af07c..92e3e82c1c5 100644 --- a/src/libstd/comm/mod.rs +++ b/src/libstd/comm/mod.rs @@ -976,14 +976,14 @@ mod test { test!(fn drop_full() { let (tx, _rx) = channel(); - tx.send(~1); + tx.send(box 1); }) test!(fn drop_full_shared() { let (tx, _rx) = channel(); drop(tx.clone()); drop(tx.clone()); - tx.send(~1); + tx.send(box 1); }) test!(fn smoke_shared() { @@ -1179,7 +1179,7 @@ mod test { // Testing that the sender cleans up the payload if receiver is closed let (tx, rx) = channel::<~int>(); drop(rx); - tx.send(~0); + tx.send(box 0); } #[should_fail]) test!(fn oneshot_single_thread_recv_chan_close() { @@ -1195,8 +1195,8 @@ mod test { test!(fn oneshot_single_thread_send_then_recv() { let (tx, rx) = channel::<~int>(); - tx.send(~10); - assert!(rx.recv() == ~10); + tx.send(box 10); + assert!(rx.recv() == box 10); }) test!(fn oneshot_single_thread_try_send_open() { @@ -1245,10 +1245,10 @@ mod test { test!(fn oneshot_multi_task_recv_then_send() { let (tx, rx) = channel::<~int>(); spawn(proc() { - assert!(rx.recv() == ~10); + assert!(rx.recv() == box 10); }); - tx.send(~10); + tx.send(box 10); }) test!(fn oneshot_multi_task_recv_then_close() { @@ -1257,7 +1257,7 @@ mod test { drop(tx); }); let res = task::try(proc() { - assert!(rx.recv() == ~10); + assert!(rx.recv() == box 10); }); assert!(res.is_err()); }) @@ -1305,10 +1305,10 @@ mod test { for _ in range(0, stress_factor()) { let (tx, rx) = channel(); spawn(proc() { - tx.send(~10); + tx.send(box 10); }); spawn(proc() { - assert!(rx.recv() == ~10); + assert!(rx.recv() == box 10); }); } }) @@ -1324,7 +1324,7 @@ mod test { if i == 10 { return } spawn(proc() { - tx.send(~i); + tx.send(box i); send(tx, i + 1); }); } @@ -1333,7 +1333,7 @@ mod test { if i == 10 { return } spawn(proc() { - assert!(rx.recv() == ~i); + assert!(rx.recv() == box i); recv(rx, i + 1); }); } @@ -1509,7 +1509,7 @@ mod sync_tests { test!(fn drop_full() { let (tx, _rx) = sync_channel(1); - tx.send(~1); + tx.send(box 1); }) test!(fn smoke_shared() { @@ -1639,7 +1639,7 @@ mod sync_tests { // Testing that the sender cleans up the payload if receiver is closed let (tx, rx) = sync_channel::<~int>(0); drop(rx); - tx.send(~0); + tx.send(box 0); } #[should_fail]) test!(fn oneshot_single_thread_recv_chan_close() { @@ -1655,8 +1655,8 @@ mod sync_tests { test!(fn oneshot_single_thread_send_then_recv() { let (tx, rx) = sync_channel::<~int>(1); - tx.send(~10); - assert!(rx.recv() == ~10); + tx.send(box 10); + assert!(rx.recv() == box 10); }) test!(fn oneshot_single_thread_try_send_open() { @@ -1710,10 +1710,10 @@ mod sync_tests { test!(fn oneshot_multi_task_recv_then_send() { let (tx, rx) = sync_channel::<~int>(0); spawn(proc() { - assert!(rx.recv() == ~10); + assert!(rx.recv() == box 10); }); - tx.send(~10); + tx.send(box 10); }) test!(fn oneshot_multi_task_recv_then_close() { @@ -1722,7 +1722,7 @@ mod sync_tests { drop(tx); }); let res = task::try(proc() { - assert!(rx.recv() == ~10); + assert!(rx.recv() == box 10); }); assert!(res.is_err()); }) @@ -1770,10 +1770,10 @@ mod sync_tests { for _ in range(0, stress_factor()) { let (tx, rx) = sync_channel(0); spawn(proc() { - tx.send(~10); + tx.send(box 10); }); spawn(proc() { - assert!(rx.recv() == ~10); + assert!(rx.recv() == box 10); }); } }) @@ -1789,7 +1789,7 @@ mod sync_tests { if i == 10 { return } spawn(proc() { - tx.send(~i); + tx.send(box i); send(tx, i + 1); }); } @@ -1798,7 +1798,7 @@ mod sync_tests { if i == 10 { return } spawn(proc() { - assert!(rx.recv() == ~i); + assert!(rx.recv() == box i); recv(rx, i + 1); }); } diff --git a/src/libstd/default.rs b/src/libstd/default.rs index 60f38e3b3de..8dcce3fd146 100644 --- a/src/libstd/default.rs +++ b/src/libstd/default.rs @@ -21,5 +21,5 @@ impl<T: Default + 'static> Default for @T { } impl<T: Default> Default for ~T { - fn default() -> ~T { ~Default::default() } + fn default() -> ~T { box Default::default() } } diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs index 36ffb857237..0ba8cff742b 100644 --- a/src/libstd/fmt/parse.rs +++ b/src/libstd/fmt/parse.rs @@ -499,7 +499,7 @@ impl<'a> Parser<'a> { vec!() } }; - ~Select(arms, other) + box Select(arms, other) } /// Parses a 'plural' statement (after the initial 'plural' word) @@ -597,7 +597,7 @@ impl<'a> Parser<'a> { vec!() } }; - ~Plural(offset, arms, other) + box Plural(offset, arms, other) } /// Parses a Count parameter at the current position. This does not check @@ -912,25 +912,25 @@ mod tests { same("{, select, other { haha } }", [Argument(Argument{ position: ArgumentNext, format: fmtdflt(), - method: Some(~Select(vec![], vec![String(" haha ")])) + method: Some(box Select(vec![], vec![String(" haha ")])) })]); same("{1, select, other { haha } }", [Argument(Argument{ position: ArgumentIs(1), format: fmtdflt(), - method: Some(~Select(vec![], vec![String(" haha ")])) + method: Some(box Select(vec![], vec![String(" haha ")])) })]); same("{1, select, other {#} }", [Argument(Argument{ position: ArgumentIs(1), format: fmtdflt(), - method: Some(~Select(vec![], vec![CurrentArgument])) + method: Some(box Select(vec![], vec![CurrentArgument])) })]); same("{1, select, other {{2, select, other {lol}}} }", [Argument(Argument{ position: ArgumentIs(1), format: fmtdflt(), - method: Some(~Select(vec![], vec![Argument(Argument{ + method: Some(box Select(vec![], vec![Argument(Argument{ position: ArgumentIs(2), format: fmtdflt(), - method: Some(~Select(vec![], vec![String("lol")])) + method: Some(box Select(vec![], vec![String("lol")])) })])) // wat })]); } @@ -940,7 +940,7 @@ mod tests { same("{1, select, a{1} b{2} c{3} other{4} }", [Argument(Argument{ position: ArgumentIs(1), format: fmtdflt(), - method: Some(~Select(vec![ + method: Some(box Select(vec![ SelectArm{ selector: "a", result: vec![String("1")] }, SelectArm{ selector: "b", result: vec![String("2")] }, SelectArm{ selector: "c", result: vec![String("3")] }, @@ -964,18 +964,18 @@ mod tests { same("{, plural, other { haha } }", [Argument(Argument{ position: ArgumentNext, format: fmtdflt(), - method: Some(~Plural(None, vec![], vec![String(" haha ")])) + method: Some(box Plural(None, vec![], vec![String(" haha ")])) })]); same("{:, plural, other { haha } }", [Argument(Argument{ position: ArgumentNext, format: fmtdflt(), - method: Some(~Plural(None, vec![], vec![String(" haha ")])) + method: Some(box Plural(None, vec![], vec![String(" haha ")])) })]); same("{, plural, offset:1 =2{2} =3{3} many{yes} other{haha} }", [Argument(Argument{ position: ArgumentNext, format: fmtdflt(), - method: Some(~Plural(Some(1), vec![ + method: Some(box Plural(Some(1), vec![ PluralArm{ selector: Literal(2), result: vec![String("2")] }, PluralArm{ selector: Literal(3), result: vec![String("3")] }, PluralArm{ selector: Keyword(Many), result: vec![String("yes")] } diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs index bd383218ba1..7387eff3dfc 100644 --- a/src/libstd/gc.rs +++ b/src/libstd/gc.rs @@ -117,7 +117,7 @@ mod tests { #[test] fn test_destructor() { - let x = Gc::new(~5); + let x = Gc::new(box 5); assert_eq!(**x.borrow(), 5); } } diff --git a/src/libstd/hash/sip.rs b/src/libstd/hash/sip.rs index eae13735809..3c1d5897e38 100644 --- a/src/libstd/hash/sip.rs +++ b/src/libstd/hash/sip.rs @@ -467,7 +467,7 @@ mod tests { } fn result_bytes(h: u64) -> ~[u8] { - ~[(h >> 0) as u8, + box [(h >> 0) as u8, (h >> 8) as u8, (h >> 16) as u8, (h >> 24) as u8, diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs index bb45e519e5e..45f783698cd 100644 --- a/src/libstd/io/comm_adapters.rs +++ b/src/libstd/io/comm_adapters.rs @@ -139,40 +139,40 @@ mod test { fn test_rx_reader() { let (tx, rx) = channel(); task::spawn(proc() { - tx.send(~[1u8, 2u8]); - tx.send(~[]); - tx.send(~[3u8, 4u8]); - tx.send(~[5u8, 6u8]); - tx.send(~[7u8, 8u8]); + tx.send(box [1u8, 2u8]); + tx.send(box []); + tx.send(box [3u8, 4u8]); + tx.send(box [5u8, 6u8]); + tx.send(box [7u8, 8u8]); }); let mut reader = ChanReader::new(rx); - let mut buf = ~[0u8, ..3]; + let mut buf = box [0u8, ..3]; assert_eq!(Ok(0), reader.read([])); assert_eq!(Ok(3), reader.read(buf)); - assert_eq!(~[1,2,3], buf); + assert_eq!(box [1,2,3], buf); assert_eq!(Ok(3), reader.read(buf)); - assert_eq!(~[4,5,6], buf); + assert_eq!(box [4,5,6], buf); assert_eq!(Ok(2), reader.read(buf)); - assert_eq!(~[7,8,6], buf); + assert_eq!(box [7,8,6], buf); match reader.read(buf) { Ok(..) => fail!(), Err(e) => assert_eq!(e.kind, io::EndOfFile), } - assert_eq!(~[7,8,6], buf); + assert_eq!(box [7,8,6], buf); // Ensure it continues to fail in the same way. match reader.read(buf) { Ok(..) => fail!(), Err(e) => assert_eq!(e.kind, io::EndOfFile), } - assert_eq!(~[7,8,6], buf); + assert_eq!(box [7,8,6], buf); } #[test] @@ -181,7 +181,7 @@ mod test { let mut writer = ChanWriter::new(tx); writer.write_be_u32(42).unwrap(); - let wanted = ~[0u8, 0u8, 0u8, 42u8]; + let wanted = box [0u8, 0u8, 0u8, 42u8]; let got = task::try(proc() { rx.recv() }).unwrap(); assert_eq!(wanted, got); diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index 955d4c07d28..c2e8fbeeb78 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -447,7 +447,7 @@ mod test { #[test] fn test_read_f32() { //big-endian floating-point 8.1250 - let buf = ~[0x41, 0x02, 0x00, 0x00]; + let buf = box [0x41, 0x02, 0x00, 0x00]; let mut writer = MemWriter::new(); writer.write(buf).unwrap(); diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index 2f64592ec7a..9abe1bee9a3 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -450,7 +450,7 @@ mod test { #[test] fn test_buf_reader() { - let in_buf = ~[0, 1, 2, 3, 4, 5, 6, 7]; + let in_buf = box [0, 1, 2, 3, 4, 5, 6, 7]; let mut reader = BufReader::new(in_buf); let mut buf = []; assert_eq!(reader.read(buf), Ok(0)); diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index 86d8be49401..184069bab33 100644 --- a/src/libstd/io/net/udp.rs +++ b/src/libstd/io/net/udp.rs @@ -243,7 +243,7 @@ mod test { spawn(proc() { match UdpSocket::bind(client_ip) { Ok(client) => { - let client = ~client; + let client = box client; let mut stream = client.connect(server_ip); rx1.recv(); stream.write([99]).unwrap(); @@ -255,7 +255,7 @@ mod test { match UdpSocket::bind(server_ip) { Ok(server) => { - let server = ~server; + let server = box server; let mut stream = server.connect(client_ip); tx1.send(()); let mut buf = [0]; @@ -281,7 +281,7 @@ mod test { spawn(proc() { match UdpSocket::bind(client_ip) { Ok(client) => { - let client = ~client; + let client = box client; let mut stream = client.connect(server_ip); rx1.recv(); stream.write([99]).unwrap(); @@ -293,7 +293,7 @@ mod test { match UdpSocket::bind(server_ip) { Ok(server) => { - let server = ~server; + let server = box server; let mut stream = server.connect(client_ip); tx1.send(()); let mut buf = [0]; diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index b507f61bb45..b89e3ec3c77 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -417,7 +417,7 @@ impl Drop for Process { drop(self.stdin.take()); drop(self.stdout.take()); drop(self.stderr.take()); - drop(mem::replace(&mut self.extra_io, ~[])); + drop(mem::replace(&mut self.extra_io, box [])); self.wait(); } @@ -804,7 +804,7 @@ mod tests { }) iotest!(fn test_add_to_env() { - let new_env = ~[("RUN_TEST_NEW_ENV".to_owned(), "123".to_owned())]; + let new_env = box [("RUN_TEST_NEW_ENV".to_owned(), "123".to_owned())]; let mut prog = run_env(Some(new_env)); let result = prog.wait_with_output(); diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index afef21e7c68..7cb58e1ea48 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -216,7 +216,7 @@ fn with_task_stdout(f: |&mut Writer| -> IoResult<()> ) { Local::put(task); if my_stdout.is_none() { - my_stdout = Some(~stdout() as ~Writer:Send); + my_stdout = Some(box stdout() as ~Writer:Send); } let ret = f(*my_stdout.get_mut_ref()); @@ -396,7 +396,7 @@ mod tests { let (tx, rx) = channel(); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); spawn(proc() { - set_stdout(~w); + set_stdout(box w); println!("hello!"); }); assert_eq!(r.read_to_str().unwrap(), "hello!\n".to_owned()); @@ -408,7 +408,7 @@ mod tests { let (tx, rx) = channel(); let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx)); spawn(proc() { - set_stderr(~w); + set_stderr(box w); fail!("my special message"); }); let s = r.read_to_str().unwrap(); diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs index cbe157633b2..5cae79d371f 100644 --- a/src/libstd/io/util.rs +++ b/src/libstd/io/util.rs @@ -235,7 +235,7 @@ mod test { #[test] fn test_null_writer() { let mut s = NullWriter; - let buf = ~[0, 0, 0]; + let buf = box [0, 0, 0]; s.write(buf).unwrap(); s.flush().unwrap(); } @@ -243,15 +243,15 @@ mod test { #[test] fn test_zero_reader() { let mut s = ZeroReader; - let mut buf = ~[1, 2, 3]; + let mut buf = box [1, 2, 3]; assert_eq!(s.read(buf), Ok(3)); - assert_eq!(~[0, 0, 0], buf); + assert_eq!(box [0, 0, 0], buf); } #[test] fn test_null_reader() { let mut r = NullReader; - let mut buf = ~[0]; + let mut buf = box [0]; assert!(r.read(buf).is_err()); } @@ -273,8 +273,8 @@ mod test { } } - let mut multi = MultiWriter::new(vec!(~TestWriter as ~Writer, - ~TestWriter as ~Writer)); + let mut multi = MultiWriter::new(vec!(box TestWriter as ~Writer, + box TestWriter as ~Writer)); multi.write([1, 2, 3]).unwrap(); assert_eq!(2, unsafe { writes }); assert_eq!(0, unsafe { flushes }); diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs index 18532c39443..daeba2365e6 100644 --- a/src/libstd/iter.rs +++ b/src/libstd/iter.rs @@ -2340,7 +2340,7 @@ mod tests { fn test_counter_from_iter() { let it = count(0, 5).take(10); let xs: ~[int] = FromIterator::from_iter(it); - assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); + assert_eq!(xs, box [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); } #[test] @@ -2370,7 +2370,7 @@ mod tests { fn test_filter_map() { let mut it = count(0u, 1u).take(10) .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None }); - assert_eq!(it.collect::<~[uint]>(), ~[0*0, 2*2, 4*4, 6*6, 8*8]); + assert_eq!(it.collect::<~[uint]>(), box [0*0, 2*2, 4*4, 6*6, 8*8]); } #[test] @@ -2384,7 +2384,7 @@ mod tests { #[test] fn test_iterator_peekable() { - let xs = ~[0u, 1, 2, 3, 4, 5]; + let xs = box [0u, 1, 2, 3, 4, 5]; let mut it = xs.iter().map(|&x|x).peekable(); assert_eq!(it.peek().unwrap(), &0); assert_eq!(it.next().unwrap(), 0); @@ -2627,14 +2627,14 @@ mod tests { #[test] fn test_collect() { - let a = ~[1, 2, 3, 4, 5]; + let a = box [1, 2, 3, 4, 5]; let b: ~[int] = a.iter().map(|&x| x).collect(); assert_eq!(a, b); } #[test] fn test_all() { - let v: ~&[int] = ~&[1, 2, 3, 4, 5]; + let v: ~&[int] = box &[1, 2, 3, 4, 5]; assert!(v.iter().all(|&x| x < 10)); assert!(!v.iter().all(|&x| x % 2 == 0)); assert!(!v.iter().all(|&x| x > 100)); @@ -2643,7 +2643,7 @@ mod tests { #[test] fn test_any() { - let v: ~&[int] = ~&[1, 2, 3, 4, 5]; + let v: ~&[int] = box &[1, 2, 3, 4, 5]; assert!(v.iter().any(|&x| x < 10)); assert!(v.iter().any(|&x| x % 2 == 0)); assert!(!v.iter().any(|&x| x > 100)); @@ -2701,7 +2701,7 @@ mod tests { let mut it = xs.iter(); it.next(); it.next(); - assert_eq!(it.rev().map(|&x| x).collect::<~[int]>(), ~[16, 14, 12, 10, 8, 6]); + assert_eq!(it.rev().map(|&x| x).collect::<~[int]>(), box [16, 14, 12, 10, 8, 6]); } #[test] @@ -2767,7 +2767,7 @@ mod tests { #[test] fn test_double_ended_chain() { let xs = [1, 2, 3, 4, 5]; - let ys = ~[7, 9, 11]; + let ys = box [7, 9, 11]; let mut it = xs.iter().chain(ys.iter()).rev(); assert_eq!(it.next().unwrap(), &11) assert_eq!(it.next().unwrap(), &9) @@ -2784,7 +2784,7 @@ mod tests { fn test_rposition() { fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } - let v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; + let v = box [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert_eq!(v.iter().rposition(f), Some(3u)); assert!(v.iter().rposition(g).is_none()); @@ -2793,7 +2793,7 @@ mod tests { #[test] #[should_fail] fn test_rposition_fail() { - let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; + let v = [(box 0, @0), (box 0, @0), (box 0, @0), (box 0, @0)]; let mut i = 0; v.iter().rposition(|_elt| { if i == 2 { @@ -2845,7 +2845,7 @@ mod tests { #[test] fn test_random_access_chain() { let xs = [1, 2, 3, 4, 5]; - let ys = ~[7, 9, 11]; + let ys = box [7, 9, 11]; let mut it = xs.iter().chain(ys.iter()); assert_eq!(it.idx(0).unwrap(), &1); assert_eq!(it.idx(5).unwrap(), &7); @@ -2939,12 +2939,12 @@ mod tests { #[test] fn test_double_ended_range() { - assert_eq!(range(11i, 14).rev().collect::<~[int]>(), ~[13i, 12, 11]); + assert_eq!(range(11i, 14).rev().collect::<~[int]>(), box [13i, 12, 11]); for _ in range(10i, 0).rev() { fail!("unreachable"); } - assert_eq!(range(11u, 14).rev().collect::<~[uint]>(), ~[13u, 12, 11]); + assert_eq!(range(11u, 14).rev().collect::<~[uint]>(), box [13u, 12, 11]); for _ in range(10u, 0).rev() { fail!("unreachable"); } @@ -2996,13 +2996,13 @@ mod tests { } } - assert_eq!(range(0i, 5).collect::<~[int]>(), ~[0i, 1, 2, 3, 4]); - assert_eq!(range(-10i, -1).collect::<~[int]>(), ~[-10, -9, -8, -7, -6, -5, -4, -3, -2]); - assert_eq!(range(0i, 5).rev().collect::<~[int]>(), ~[4, 3, 2, 1, 0]); - assert_eq!(range(200, -5).collect::<~[int]>(), ~[]); - assert_eq!(range(200, -5).rev().collect::<~[int]>(), ~[]); - assert_eq!(range(200, 200).collect::<~[int]>(), ~[]); - assert_eq!(range(200, 200).rev().collect::<~[int]>(), ~[]); + assert_eq!(range(0i, 5).collect::<~[int]>(), box [0i, 1, 2, 3, 4]); + assert_eq!(range(-10i, -1).collect::<~[int]>(), box [-10, -9, -8, -7, -6, -5, -4, -3, -2]); + assert_eq!(range(0i, 5).rev().collect::<~[int]>(), box [4, 3, 2, 1, 0]); + assert_eq!(range(200, -5).collect::<~[int]>(), box []); + assert_eq!(range(200, -5).rev().collect::<~[int]>(), box []); + assert_eq!(range(200, 200).collect::<~[int]>(), box []); + assert_eq!(range(200, 200).rev().collect::<~[int]>(), box []); assert_eq!(range(0i, 100).size_hint(), (100, Some(100))); // this test is only meaningful when sizeof uint < sizeof u64 @@ -3013,32 +3013,32 @@ mod tests { #[test] fn test_range_inclusive() { - assert_eq!(range_inclusive(0i, 5).collect::<~[int]>(), ~[0i, 1, 2, 3, 4, 5]); - assert_eq!(range_inclusive(0i, 5).rev().collect::<~[int]>(), ~[5i, 4, 3, 2, 1, 0]); - assert_eq!(range_inclusive(200, -5).collect::<~[int]>(), ~[]); - assert_eq!(range_inclusive(200, -5).rev().collect::<~[int]>(), ~[]); - assert_eq!(range_inclusive(200, 200).collect::<~[int]>(), ~[200]); - assert_eq!(range_inclusive(200, 200).rev().collect::<~[int]>(), ~[200]); + assert_eq!(range_inclusive(0i, 5).collect::<~[int]>(), box [0i, 1, 2, 3, 4, 5]); + assert_eq!(range_inclusive(0i, 5).rev().collect::<~[int]>(), box [5i, 4, 3, 2, 1, 0]); + assert_eq!(range_inclusive(200, -5).collect::<~[int]>(), box []); + assert_eq!(range_inclusive(200, -5).rev().collect::<~[int]>(), box []); + assert_eq!(range_inclusive(200, 200).collect::<~[int]>(), box [200]); + assert_eq!(range_inclusive(200, 200).rev().collect::<~[int]>(), box [200]); } #[test] fn test_range_step() { - assert_eq!(range_step(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15]); - assert_eq!(range_step(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5]); - assert_eq!(range_step(20i, 0, -6).collect::<~[int]>(), ~[20, 14, 8, 2]); - assert_eq!(range_step(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]); - assert_eq!(range_step(200, -5, 1).collect::<~[int]>(), ~[]); - assert_eq!(range_step(200, 200, 1).collect::<~[int]>(), ~[]); + assert_eq!(range_step(0i, 20, 5).collect::<~[int]>(), box [0, 5, 10, 15]); + assert_eq!(range_step(20i, 0, -5).collect::<~[int]>(), box [20, 15, 10, 5]); + assert_eq!(range_step(20i, 0, -6).collect::<~[int]>(), box [20, 14, 8, 2]); + assert_eq!(range_step(200u8, 255, 50).collect::<~[u8]>(), box [200u8, 250]); + assert_eq!(range_step(200, -5, 1).collect::<~[int]>(), box []); + assert_eq!(range_step(200, 200, 1).collect::<~[int]>(), box []); } #[test] fn test_range_step_inclusive() { - assert_eq!(range_step_inclusive(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15, 20]); - assert_eq!(range_step_inclusive(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5, 0]); - assert_eq!(range_step_inclusive(20i, 0, -6).collect::<~[int]>(), ~[20, 14, 8, 2]); - assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]); - assert_eq!(range_step_inclusive(200, -5, 1).collect::<~[int]>(), ~[]); - assert_eq!(range_step_inclusive(200, 200, 1).collect::<~[int]>(), ~[200]); + assert_eq!(range_step_inclusive(0i, 20, 5).collect::<~[int]>(), box [0, 5, 10, 15, 20]); + assert_eq!(range_step_inclusive(20i, 0, -5).collect::<~[int]>(), box [20, 15, 10, 5, 0]); + assert_eq!(range_step_inclusive(20i, 0, -6).collect::<~[int]>(), box [20, 14, 8, 2]); + assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<~[u8]>(), box [200u8, 250]); + assert_eq!(range_step_inclusive(200, -5, 1).collect::<~[int]>(), box []); + assert_eq!(range_step_inclusive(200, 200, 1).collect::<~[int]>(), box [200]); } #[test] diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index a6199aa43ab..bc6e324a5f7 100644 --- a/src/libstd/local_data.rs +++ b/src/libstd/local_data.rs @@ -302,7 +302,7 @@ pub fn set<T: 'static>(key: Key<T>, data: T) { // everything to a trait (LocalData) which is then stored inside the map. // Upon destruction of the map, all the objects will be destroyed and the // traits have enough information about them to destroy themselves. - let data = ~data as ~LocalData:; + let data = box data as ~LocalData:; fn insertion_position(map: &mut Map, key: *u8) -> Option<uint> { @@ -486,7 +486,7 @@ mod tests { #[test] fn test_owned() { static key: Key<~int> = &Key; - set(key, ~1); + set(key, box 1); get(key, |v| { get(key, |v| { @@ -497,7 +497,7 @@ mod tests { }); assert_eq!(**v.unwrap(), 1); }); - set(key, ~2); + set(key, box 2); get(key, |v| { assert_eq!(**v.unwrap(), 2); }) diff --git a/src/libstd/option.rs b/src/libstd/option.rs index efbb1abacfa..eabaf4f2f9a 100644 --- a/src/libstd/option.rs +++ b/src/libstd/option.rs @@ -619,7 +619,7 @@ mod tests { #[test] fn test_get_ptr() { unsafe { - let x = ~0; + let x = box 0; let addr_x: *int = ::cast::transmute(&*x); let opt = Some(x); let y = opt.unwrap(); @@ -862,11 +862,11 @@ mod tests { fn test_collect() { let v: Option<~[int]> = collect(range(0, 0) .map(|_| Some(0))); - assert_eq!(v, Some(~[])); + assert_eq!(v, Some(box [])); let v: Option<~[int]> = collect(range(0, 3) .map(|x| Some(x))); - assert_eq!(v, Some(~[0, 1, 2])); + assert_eq!(v, Some(box [0, 1, 2])); let v: Option<~[int]> = collect(range(0, 3) .map(|x| if x > 1 { None } else { Some(x) })); diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 004652d786f..071aae974db 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -225,7 +225,7 @@ pub fn env_as_bytes() -> ~[(~[u8],~[u8])] { for p in input.iter() { let vs: ~[&[u8]] = p.splitn(1, |b| *b == '=' as u8).collect(); let key = vs[0].to_owned(); - let val = if vs.len() < 2 { ~[] } else { vs[1].to_owned() }; + let val = if vs.len() < 2 { box [] } else { vs[1].to_owned() }; pairs.push((key, val)); } pairs @@ -419,7 +419,7 @@ pub fn self_exe_name() -> Option<Path> { unsafe { use libc::funcs::bsd44::*; use libc::consts::os::extra::*; - let mib = ~[CTL_KERN as c_int, + let mib = box [CTL_KERN as c_int, KERN_PROC as c_int, KERN_PROC_PATHNAME as c_int, -1 as c_int]; let mut sz: libc::size_t = 0; diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs index ca7680413a0..b4b5185c221 100644 --- a/src/libstd/ptr.rs +++ b/src/libstd/ptr.rs @@ -544,8 +544,8 @@ pub mod ptr_tests { assert_eq!(p.fst, 50); assert_eq!(p.snd, 60); - let v0 = ~[32000u16, 32001u16, 32002u16]; - let mut v1 = ~[0u16, 0u16, 0u16]; + let v0 = box [32000u16, 32001u16, 32002u16]; + let mut v1 = box [0u16, 0u16, 0u16]; copy_memory(v1.as_mut_ptr().offset(1), v0.as_ptr().offset(1), 1); @@ -579,7 +579,7 @@ pub mod ptr_tests { "hello".with_c_str(|p0| { "there".with_c_str(|p1| { "thing".with_c_str(|p2| { - let v = ~[p0, p1, p2, null()]; + let v = box [p0, p1, p2, null()]; unsafe { assert_eq!(buf_len(v.as_ptr()), 3u); } @@ -627,7 +627,7 @@ pub mod ptr_tests { #[test] fn test_ptr_addition() { unsafe { - let xs = ~[5, ..16]; + let xs = box [5, ..16]; let mut ptr = xs.as_ptr(); let end = ptr.offset(16); @@ -645,14 +645,14 @@ pub mod ptr_tests { m_ptr = m_ptr.offset(1); } - assert_eq!(xs_mut, ~[10, ..16]); + assert_eq!(xs_mut, box [10, ..16]); } } #[test] fn test_ptr_subtraction() { unsafe { - let xs = ~[0,1,2,3,4,5,6,7,8,9]; + let xs = box [0,1,2,3,4,5,6,7,8,9]; let mut idx = 9i8; let ptr = xs.as_ptr(); @@ -670,7 +670,7 @@ pub mod ptr_tests { m_ptr = m_ptr.offset(-1); } - assert_eq!(xs_mut, ~[0,2,4,6,8,10,12,14,16,18]); + assert_eq!(xs_mut, box [0,2,4,6,8,10,12,14,16,18]); } } @@ -680,7 +680,7 @@ pub mod ptr_tests { let one = "oneOne".to_c_str(); let two = "twoTwo".to_c_str(); let three = "threeThree".to_c_str(); - let arr = ~[ + let arr = box [ one.with_ref(|buf| buf), two.with_ref(|buf| buf), three.with_ref(|buf| buf), @@ -713,7 +713,7 @@ pub mod ptr_tests { let one = "oneOne".to_c_str(); let two = "twoTwo".to_c_str(); let three = "threeThree".to_c_str(); - let arr = ~[ + let arr = box [ one.with_ref(|buf| buf), two.with_ref(|buf| buf), three.with_ref(|buf| buf), diff --git a/src/libstd/rc.rs b/src/libstd/rc.rs index 5673929d5a1..51ab885a85f 100644 --- a/src/libstd/rc.rs +++ b/src/libstd/rc.rs @@ -58,7 +58,7 @@ impl<T> Rc<T> { // destructor never frees the allocation while the // strong destructor is running, even if the weak // pointer is stored inside the strong one. - ptr: transmute(~RcBox { + ptr: transmute(box RcBox { value: value, strong: Cell::new(1), weak: Cell::new(1) @@ -255,7 +255,7 @@ mod tests { #[test] fn test_destructor() { - let x = Rc::new(~5); + let x = Rc::new(box 5); assert_eq!(**x, 5); } diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index fc0137d00b7..29d4f9e36d2 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -642,7 +642,7 @@ fn test_repr() { exact_test(&("he\u10f3llo".to_owned()), "~\"he\\u10f3llo\""); exact_test(&(@10), "@10"); - exact_test(&(~10), "~10"); + exact_test(&(box 10), "~10"); exact_test(&(&10), "&10"); let mut x = 10; exact_test(&(&mut x), "&mut 10"); @@ -651,7 +651,7 @@ fn test_repr() { exact_test(&(0 as *mut ()), "(0x0 as *mut ())"); exact_test(&(1,), "(1,)"); - exact_test(&(~["hi", "there"]), + exact_test(&(box ["hi", "there"]), "~[\"hi\", \"there\"]"); exact_test(&(&["hi", "there"]), "&[\"hi\", \"there\"]"); @@ -659,7 +659,7 @@ fn test_repr() { "repr::P{a: 10, b: 1.234f64}"); exact_test(&(@P{a:10, b:1.234}), "@repr::P{a: 10, b: 1.234f64}"); - exact_test(&(~P{a:10, b:1.234}), + exact_test(&(box P{a:10, b:1.234}), "~repr::P{a: 10, b: 1.234f64}"); exact_test(&(10u8, "hello".to_owned()), "(10u8, ~\"hello\")"); @@ -681,10 +681,10 @@ fn test_repr() { exact_test(&println, "fn(&str)"); exact_test(&swap::<int>, "fn(&mut int, &mut int)"); exact_test(&is_alphabetic, "fn(char) -> bool"); - exact_test(&(~5 as ~ToStr), "~to_str::ToStr<no-bounds>"); + exact_test(&(box 5 as ~ToStr), "~to_str::ToStr<no-bounds>"); struct Foo; - exact_test(&(~[Foo, Foo]), "~[repr::test_repr::Foo, repr::test_repr::Foo]"); + exact_test(&(box [Foo, Foo]), "~[repr::test_repr::Foo, repr::test_repr::Foo]"); struct Bar(int, int); exact_test(&(Bar(2, 2)), "repr::test_repr::Bar(2, 2)"); diff --git a/src/libstd/result.rs b/src/libstd/result.rs index 058548eb151..922d2cf3d32 100644 --- a/src/libstd/result.rs +++ b/src/libstd/result.rs @@ -685,10 +685,10 @@ mod tests { #[test] fn test_collect() { let v: Result<~[int], ()> = collect(range(0, 0).map(|_| Ok::<int, ()>(0))); - assert_eq!(v, Ok(~[])); + assert_eq!(v, Ok(box [])); let v: Result<~[int], ()> = collect(range(0, 3).map(|x| Ok::<int, ()>(x))); - assert_eq!(v, Ok(~[0, 1, 2])); + assert_eq!(v, Ok(box [0, 1, 2])); let v: Result<~[int], int> = collect(range(0, 3) .map(|x| if x > 1 { Err(x) } else { Ok(x) })); diff --git a/src/libstd/rt/args.rs b/src/libstd/rt/args.rs index 824d9e5ec92..092efcad831 100644 --- a/src/libstd/rt/args.rs +++ b/src/libstd/rt/args.rs @@ -99,7 +99,7 @@ mod imp { with_lock(|| unsafe { let ptr = get_global_ptr(); rtassert!((*ptr).is_none()); - (*ptr) = Some(~args.clone()); + (*ptr) = Some(box args.clone()); }) } @@ -147,7 +147,7 @@ mod imp { // Preserve the actual global state. let saved_value = take(); - let expected = ~[bytes!("happy").to_owned(), bytes!("today?").to_owned()]; + let expected = box [bytes!("happy").to_owned(), bytes!("today?").to_owned()]; put(expected.clone()); assert!(clone() == Some(expected.clone())); diff --git a/src/libstd/rt/at_exit_imp.rs b/src/libstd/rt/at_exit_imp.rs index 67b8b40b47e..2c8e159aeb9 100644 --- a/src/libstd/rt/at_exit_imp.rs +++ b/src/libstd/rt/at_exit_imp.rs @@ -36,7 +36,7 @@ pub fn init() { unsafe { rtassert!(!RUNNING); rtassert!(QUEUE.is_null()); - let state: ~Queue = ~Exclusive::new(vec!()); + let state: ~Queue = box Exclusive::new(vec!()); QUEUE = cast::transmute(state); } } diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs index b9c0a02d7d2..094bbd13889 100644 --- a/src/libstd/rt/global_heap.rs +++ b/src/libstd/rt/global_heap.rs @@ -125,14 +125,14 @@ mod bench { #[bench] fn alloc_owned_small(b: &mut Bencher) { b.iter(|| { - ~10 + box 10 }) } #[bench] fn alloc_owned_big(b: &mut Bencher) { b.iter(|| { - ~[10, ..1000] + box [10, ..1000] }) } } diff --git a/src/libstd/rt/local.rs b/src/libstd/rt/local.rs index 3cfa494d382..828bbc118c1 100644 --- a/src/libstd/rt/local.rs +++ b/src/libstd/rt/local.rs @@ -59,7 +59,7 @@ mod test { #[test] fn thread_local_task_smoke_test() { run_in_bare_thread(proc() { - let task = ~Task::new(); + let task = box Task::new(); Local::put(task); let task: ~Task = Local::take(); cleanup_task(task); @@ -69,11 +69,11 @@ mod test { #[test] fn thread_local_task_two_instances() { run_in_bare_thread(proc() { - let task = ~Task::new(); + let task = box Task::new(); Local::put(task); let task: ~Task = Local::take(); cleanup_task(task); - let task = ~Task::new(); + let task = box Task::new(); Local::put(task); let task: ~Task = Local::take(); cleanup_task(task); @@ -83,7 +83,7 @@ mod test { #[test] fn borrow_smoke_test() { run_in_bare_thread(proc() { - let task = ~Task::new(); + let task = box Task::new(); Local::put(task); unsafe { @@ -97,7 +97,7 @@ mod test { #[test] fn borrow_with_return() { run_in_bare_thread(proc() { - let task = ~Task::new(); + let task = box Task::new(); Local::put(task); { @@ -112,7 +112,7 @@ mod test { #[test] fn try_take() { run_in_bare_thread(proc() { - let task = ~Task::new(); + let task = box Task::new(); Local::put(task); let t: ~Task = Local::try_take().unwrap(); diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs index 2dab0e975da..ae5786604c7 100644 --- a/src/libstd/rt/task.rs +++ b/src/libstd/rt/task.rs @@ -353,7 +353,7 @@ impl BlockedTask { blocked_task_ptr } Shared(arc) => { - let blocked_task_ptr: uint = cast::transmute(~arc); + let blocked_task_ptr: uint = cast::transmute(box arc); rtassert!(blocked_task_ptr & 0x1 == 0); blocked_task_ptr | 0x1 } @@ -485,7 +485,7 @@ mod test { #[test] fn block_and_wake() { - let task = ~Task::new(); + let task = box Task::new(); let mut task = BlockedTask::block(task).wake().unwrap(); task.destroyed = true; } diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs index 9f5986e3dc6..a836958279b 100644 --- a/src/libstd/rt/thread.rs +++ b/src/libstd/rt/thread.rs @@ -80,12 +80,12 @@ impl Thread<()> { // We need the address of the packet to fill in to be stable so when // `main` fills it in it's still valid, so allocate an extra ~ box to do // so. - let packet = ~None; + let packet = box None; let packet2: *mut Option<T> = unsafe { *cast::transmute::<&~Option<T>, **mut Option<T>>(&packet) }; let main = proc() unsafe { *packet2 = Some(main()); }; - let native = unsafe { imp::create(stack, ~main) }; + let native = unsafe { imp::create(stack, box main) }; Thread { native: native, @@ -108,7 +108,7 @@ impl Thread<()> { /// stack size for the new thread. pub fn spawn_stack(stack: uint, main: proc():Send) { unsafe { - let handle = imp::create(stack, ~main); + let handle = imp::create(stack, box main); imp::detach(handle); } } diff --git a/src/libstd/rt/thread_local_storage.rs b/src/libstd/rt/thread_local_storage.rs index 2f567e91b4c..fceff80e792 100644 --- a/src/libstd/rt/thread_local_storage.rs +++ b/src/libstd/rt/thread_local_storage.rs @@ -96,14 +96,14 @@ fn tls_smoke_test() { use cast::transmute; unsafe { let mut key = 0; - let value = ~20; + let value = box 20; create(&mut key); set(key, transmute(value)); let value: ~int = transmute(get(key)); - assert_eq!(value, ~20); - let value = ~30; + assert_eq!(value, box 20); + let value = box 30; set(key, transmute(value)); let value: ~int = transmute(get(key)); - assert_eq!(value, ~30); + assert_eq!(value, box 30); } } diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 4f84202f8f8..98623c35b78 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -141,7 +141,7 @@ impl Unwinder { #[no_mangle] fn rust_fail() -> ! { unsafe { - let exception = ~uw::_Unwind_Exception { + let exception = box uw::_Unwind_Exception { exception_class: rust_exception_class(), exception_cleanup: exception_cleanup, private: [0, ..uw::unwinder_private_data_size], @@ -346,7 +346,7 @@ pub fn begin_unwind_fmt(msg: &fmt::Arguments, file: &'static str, line: uint) -> // required with the current scheme, and (b) we don't handle // failure + OOM properly anyway (see comment in begin_unwind // below). - begin_unwind_inner(~fmt::format(msg), file, line) + begin_unwind_inner(box fmt::format(msg), file, line) } /// This is the entry point of unwinding for fail!() and assert!(). @@ -360,7 +360,7 @@ pub fn begin_unwind<M: Any + Send>(msg: M, file: &'static str, line: uint) -> ! // failing. // see below for why we do the `Any` coercion here. - begin_unwind_inner(~msg, file, line) + begin_unwind_inner(box msg, file, line) } diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs index 64f6b59be24..cb8550d248e 100644 --- a/src/libstd/slice.rs +++ b/src/libstd/slice.rs @@ -2042,7 +2042,7 @@ impl<'a, A> Default for &'a [A] { } impl<A> Default for ~[A] { - fn default() -> ~[A] { ~[] } + fn default() -> ~[A] { box [] } } /// Immutable slice iterator @@ -2361,7 +2361,7 @@ mod tests { fn test_unsafe_ptrs() { unsafe { // Test on-stack copy-from-buf. - let a = ~[1, 2, 3]; + let a = box [1, 2, 3]; let mut ptr = a.as_ptr(); let b = from_buf(ptr, 3u); assert_eq!(b.len(), 3u); @@ -2370,7 +2370,7 @@ mod tests { assert_eq!(b[2], 3); // Test on-heap copy-from-buf. - let c = ~[1, 2, 3, 4, 5]; + let c = box [1, 2, 3, 4, 5]; ptr = c.as_ptr(); let d = from_buf(ptr, 5u); assert_eq!(d.len(), 5u); @@ -2452,91 +2452,91 @@ mod tests { #[test] fn test_get() { - let mut a = ~[11]; + let mut a = box [11]; assert_eq!(a.get(1), None); - a = ~[11, 12]; + a = box [11, 12]; assert_eq!(a.get(1).unwrap(), &12); - a = ~[11, 12, 13]; + a = box [11, 12, 13]; assert_eq!(a.get(1).unwrap(), &12); } #[test] fn test_head() { - let mut a = ~[]; + let mut a = box []; assert_eq!(a.head(), None); - a = ~[11]; + a = box [11]; assert_eq!(a.head().unwrap(), &11); - a = ~[11, 12]; + a = box [11, 12]; assert_eq!(a.head().unwrap(), &11); } #[test] fn test_tail() { - let mut a = ~[11]; + let mut a = box [11]; assert_eq!(a.tail(), &[]); - a = ~[11, 12]; + a = box [11, 12]; assert_eq!(a.tail(), &[12]); } #[test] #[should_fail] fn test_tail_empty() { - let a: ~[int] = ~[]; + let a: ~[int] = box []; a.tail(); } #[test] fn test_tailn() { - let mut a = ~[11, 12, 13]; + let mut a = box [11, 12, 13]; assert_eq!(a.tailn(0), &[11, 12, 13]); - a = ~[11, 12, 13]; + a = box [11, 12, 13]; assert_eq!(a.tailn(2), &[13]); } #[test] #[should_fail] fn test_tailn_empty() { - let a: ~[int] = ~[]; + let a: ~[int] = box []; a.tailn(2); } #[test] fn test_init() { - let mut a = ~[11]; + let mut a = box [11]; assert_eq!(a.init(), &[]); - a = ~[11, 12]; + a = box [11, 12]; assert_eq!(a.init(), &[11]); } #[test] #[should_fail] fn test_init_empty() { - let a: ~[int] = ~[]; + let a: ~[int] = box []; a.init(); } #[test] fn test_initn() { - let mut a = ~[11, 12, 13]; + let mut a = box [11, 12, 13]; assert_eq!(a.initn(0), &[11, 12, 13]); - a = ~[11, 12, 13]; + a = box [11, 12, 13]; assert_eq!(a.initn(2), &[11]); } #[test] #[should_fail] fn test_initn_empty() { - let a: ~[int] = ~[]; + let a: ~[int] = box []; a.initn(2); } #[test] fn test_last() { - let mut a = ~[]; + let mut a = box []; assert_eq!(a.last(), None); - a = ~[11]; + a = box [11]; assert_eq!(a.last().unwrap(), &11); - a = ~[11, 12]; + a = box [11, 12]; assert_eq!(a.last().unwrap(), &12); } @@ -2558,7 +2558,7 @@ mod tests { assert_eq!(v_b[1], 3); // Test on exchange heap. - let vec_unique = ~[1, 2, 3, 4, 5, 6]; + let vec_unique = box [1, 2, 3, 4, 5, 6]; let v_d = vec_unique.slice(1u, 6u).to_owned(); assert_eq!(v_d.len(), 5u); assert_eq!(v_d[0], 2); @@ -2692,7 +2692,7 @@ mod tests { #[test] fn test_truncate() { - let mut v = vec![~6,~5,~4]; + let mut v = vec![box 6,box 5,box 4]; v.truncate(1); let v = v.as_slice(); assert_eq!(v.len(), 1); @@ -2702,7 +2702,7 @@ mod tests { #[test] fn test_clear() { - let mut v = vec![~6,~5,~4]; + let mut v = vec![box 6,box 5,box 4]; v.clear(); assert_eq!(v.len(), 0); // If the unsafe block didn't drop things properly, we blow up here. @@ -2727,11 +2727,11 @@ mod tests { #[test] fn test_dedup_unique() { - let mut v0 = vec![~1, ~1, ~2, ~3]; + let mut v0 = vec![box 1, box 1, box 2, box 3]; v0.dedup(); - let mut v1 = vec![~1, ~2, ~2, ~3]; + let mut v1 = vec![box 1, box 2, box 2, box 3]; v1.dedup(); - let mut v2 = vec![~1, ~2, ~3, ~3]; + let mut v2 = vec![box 1, box 2, box 3, box 3]; v2.dedup(); /* * If the ~pointers were leaked or otherwise misused, valgrind and/or @@ -2741,11 +2741,11 @@ mod tests { #[test] fn test_dedup_shared() { - let mut v0 = vec![~1, ~1, ~2, ~3]; + let mut v0 = vec![box 1, box 1, box 2, box 3]; v0.dedup(); - let mut v1 = vec![~1, ~2, ~2, ~3]; + let mut v1 = vec![box 1, box 2, box 2, box 3]; v1.dedup(); - let mut v2 = vec![~1, ~2, ~3, ~3]; + let mut v2 = vec![box 1, box 2, box 3, box 3]; v2.dedup(); /* * If the pointers were leaked or otherwise misused, valgrind and/or @@ -2814,15 +2814,15 @@ mod tests { let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 3*2); assert_eq!(max_opt.unwrap(), 3*2); - assert_eq!(it.next(), Some(~[1,2,3])); - assert_eq!(it.next(), Some(~[1,3,2])); - assert_eq!(it.next(), Some(~[3,1,2])); + assert_eq!(it.next(), Some(box [1,2,3])); + assert_eq!(it.next(), Some(box [1,3,2])); + assert_eq!(it.next(), Some(box [3,1,2])); let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 3); assert_eq!(max_opt.unwrap(), 3); - assert_eq!(it.next(), Some(~[3,2,1])); - assert_eq!(it.next(), Some(~[2,3,1])); - assert_eq!(it.next(), Some(~[2,1,3])); + assert_eq!(it.next(), Some(box [3,2,1])); + assert_eq!(it.next(), Some(box [2,3,1])); + assert_eq!(it.next(), Some(box [2,1,3])); assert_eq!(it.next(), None); } { @@ -2845,7 +2845,7 @@ mod tests { fn test_position_elem() { assert!([].position_elem(&1).is_none()); - let v1 = ~[1, 2, 3, 3, 2, 5]; + let v1 = box [1, 2, 3, 3, 2, 5]; assert_eq!(v1.position_elem(&1), Some(0u)); assert_eq!(v1.position_elem(&2), Some(1u)); assert_eq!(v1.position_elem(&5), Some(5u)); @@ -2899,14 +2899,14 @@ mod tests { #[test] fn test_reverse() { - let mut v: ~[int] = ~[10, 20]; + let mut v: ~[int] = box [10, 20]; assert_eq!(v[0], 10); assert_eq!(v[1], 20); v.reverse(); assert_eq!(v[0], 20); assert_eq!(v[1], 10); - let mut v3: ~[int] = ~[]; + let mut v3: ~[int] = box []; v3.reverse(); assert!(v3.is_empty()); } @@ -2973,39 +2973,39 @@ mod tests { #[test] fn test_partition() { - assert_eq!((~[]).partition(|x: &int| *x < 3), (~[], ~[])); - assert_eq!((~[1, 2, 3]).partition(|x: &int| *x < 4), (~[1, 2, 3], ~[])); - assert_eq!((~[1, 2, 3]).partition(|x: &int| *x < 2), (~[1], ~[2, 3])); - assert_eq!((~[1, 2, 3]).partition(|x: &int| *x < 0), (~[], ~[1, 2, 3])); + assert_eq!((box []).partition(|x: &int| *x < 3), (box [], box [])); + assert_eq!((box [1, 2, 3]).partition(|x: &int| *x < 4), (box [1, 2, 3], box [])); + assert_eq!((box [1, 2, 3]).partition(|x: &int| *x < 2), (box [1], box [2, 3])); + assert_eq!((box [1, 2, 3]).partition(|x: &int| *x < 0), (box [], box [1, 2, 3])); } #[test] fn test_partitioned() { - assert_eq!(([]).partitioned(|x: &int| *x < 3), (~[], ~[])) - assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 4), (~[1, 2, 3], ~[])); - assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 2), (~[1], ~[2, 3])); - assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 0), (~[], ~[1, 2, 3])); + assert_eq!(([]).partitioned(|x: &int| *x < 3), (box [], box [])) + assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 4), (box [1, 2, 3], box [])); + assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 2), (box [1], box [2, 3])); + assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 0), (box [], box [1, 2, 3])); } #[test] fn test_concat() { let v: [~[int], ..0] = []; - assert_eq!(v.concat_vec(), ~[]); - assert_eq!([~[1], ~[2,3]].concat_vec(), ~[1, 2, 3]); + assert_eq!(v.concat_vec(), box []); + assert_eq!([box [1], box [2,3]].concat_vec(), box [1, 2, 3]); - assert_eq!([&[1], &[2,3]].concat_vec(), ~[1, 2, 3]); + assert_eq!([&[1], &[2,3]].concat_vec(), box [1, 2, 3]); } #[test] fn test_connect() { let v: [~[int], ..0] = []; - assert_eq!(v.connect_vec(&0), ~[]); - assert_eq!([~[1], ~[2, 3]].connect_vec(&0), ~[1, 0, 2, 3]); - assert_eq!([~[1], ~[2], ~[3]].connect_vec(&0), ~[1, 0, 2, 0, 3]); + assert_eq!(v.connect_vec(&0), box []); + assert_eq!([box [1], box [2, 3]].connect_vec(&0), box [1, 0, 2, 3]); + assert_eq!([box [1], box [2], box [3]].connect_vec(&0), box [1, 0, 2, 0, 3]); - assert_eq!(v.connect_vec(&0), ~[]); - assert_eq!([&[1], &[2, 3]].connect_vec(&0), ~[1, 0, 2, 3]); - assert_eq!([&[1], &[2], &[3]].connect_vec(&0), ~[1, 0, 2, 0, 3]); + assert_eq!(v.connect_vec(&0), box []); + assert_eq!([&[1], &[2, 3]].connect_vec(&0), box [1, 0, 2, 3]); + assert_eq!([&[1], &[2], &[3]].connect_vec(&0), box [1, 0, 2, 0, 3]); } #[test] @@ -3100,7 +3100,7 @@ mod tests { fn test_from_fn_fail() { Vec::from_fn(100, |v| { if v == 50 { fail!() } - ~0 + box 0 }); } @@ -3124,7 +3124,7 @@ mod tests { } } - let s = S { f: 0, boxes: (~0, Rc::new(0)) }; + let s = S { f: 0, boxes: (box 0, Rc::new(0)) }; let _ = Vec::from_elem(100, s); } @@ -3137,7 +3137,7 @@ mod tests { if i == 50 { fail!() } - (~0, Rc::new(0)) + (box 0, Rc::new(0)) }) } @@ -3145,7 +3145,8 @@ mod tests { #[should_fail] fn test_permute_fail() { use rc::Rc; - let v = [(~0, Rc::new(0)), (~0, Rc::new(0)), (~0, Rc::new(0)), (~0, Rc::new(0))]; + let v = [(box 0, Rc::new(0)), (box 0, Rc::new(0)), + (box 0, Rc::new(0)), (box 0, Rc::new(0))]; let mut i = 0; for _ in v.permutations() { if i == 2 { @@ -3288,14 +3289,14 @@ mod tests { #[test] fn test_move_iterator() { use iter::*; - let xs = ~[1u,2,3,4,5]; + let xs = box [1u,2,3,4,5]; assert_eq!(xs.move_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345); } #[test] fn test_move_rev_iterator() { use iter::*; - let xs = ~[1u,2,3,4,5]; + let xs = box [1u,2,3,4,5]; assert_eq!(xs.move_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321); } @@ -3304,18 +3305,18 @@ mod tests { let xs = &[1i,2,3,4,5]; assert_eq!(xs.split(|x| *x % 2 == 0).collect::<~[&[int]]>(), - ~[&[1], &[3], &[5]]); + box [&[1], &[3], &[5]]); assert_eq!(xs.split(|x| *x == 1).collect::<~[&[int]]>(), - ~[&[], &[2,3,4,5]]); + box [&[], &[2,3,4,5]]); assert_eq!(xs.split(|x| *x == 5).collect::<~[&[int]]>(), - ~[&[1,2,3,4], &[]]); + box [&[1,2,3,4], &[]]); assert_eq!(xs.split(|x| *x == 10).collect::<~[&[int]]>(), - ~[&[1,2,3,4,5]]); + box [&[1,2,3,4,5]]); assert_eq!(xs.split(|_| true).collect::<~[&[int]]>(), - ~[&[], &[], &[], &[], &[], &[]]); + box [&[], &[], &[], &[], &[], &[]]); let xs: &[int] = &[]; - assert_eq!(xs.split(|x| *x == 5).collect::<~[&[int]]>(), ~[&[]]); + assert_eq!(xs.split(|x| *x == 5).collect::<~[&[int]]>(), box [&[]]); } #[test] @@ -3323,14 +3324,14 @@ mod tests { let xs = &[1i,2,3,4,5]; assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<~[&[int]]>(), - ~[&[1,2,3,4,5]]); + box [&[1,2,3,4,5]]); assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<~[&[int]]>(), - ~[&[1], &[3,4,5]]); + box [&[1], &[3,4,5]]); assert_eq!(xs.splitn(3, |_| true).collect::<~[&[int]]>(), - ~[&[], &[], &[], &[4,5]]); + box [&[], &[], &[], &[4,5]]); let xs: &[int] = &[]; - assert_eq!(xs.splitn(1, |x| *x == 5).collect::<~[&[int]]>(), ~[&[]]); + assert_eq!(xs.splitn(1, |x| *x == 5).collect::<~[&[int]]>(), box [&[]]); } #[test] @@ -3338,16 +3339,16 @@ mod tests { let xs = &[1i,2,3,4,5]; assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<~[&[int]]>(), - ~[&[5], &[3], &[1]]); + box [&[5], &[3], &[1]]); assert_eq!(xs.split(|x| *x == 1).rev().collect::<~[&[int]]>(), - ~[&[2,3,4,5], &[]]); + box [&[2,3,4,5], &[]]); assert_eq!(xs.split(|x| *x == 5).rev().collect::<~[&[int]]>(), - ~[&[], &[1,2,3,4]]); + box [&[], &[1,2,3,4]]); assert_eq!(xs.split(|x| *x == 10).rev().collect::<~[&[int]]>(), - ~[&[1,2,3,4,5]]); + box [&[1,2,3,4,5]]); let xs: &[int] = &[]; - assert_eq!(xs.split(|x| *x == 5).rev().collect::<~[&[int]]>(), ~[&[]]); + assert_eq!(xs.split(|x| *x == 5).rev().collect::<~[&[int]]>(), box [&[]]); } #[test] @@ -3355,22 +3356,22 @@ mod tests { let xs = &[1,2,3,4,5]; assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<~[&[int]]>(), - ~[&[1,2,3,4,5]]); + box [&[1,2,3,4,5]]); assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<~[&[int]]>(), - ~[&[5], &[1,2,3]]); + box [&[5], &[1,2,3]]); assert_eq!(xs.rsplitn(3, |_| true).collect::<~[&[int]]>(), - ~[&[], &[], &[], &[1,2]]); + box [&[], &[], &[], &[1,2]]); let xs: &[int] = &[]; - assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<~[&[int]]>(), ~[&[]]); + assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<~[&[int]]>(), box [&[]]); } #[test] fn test_windowsator() { let v = &[1i,2,3,4]; - assert_eq!(v.windows(2).collect::<~[&[int]]>(), ~[&[1,2], &[2,3], &[3,4]]); - assert_eq!(v.windows(3).collect::<~[&[int]]>(), ~[&[1i,2,3], &[2,3,4]]); + assert_eq!(v.windows(2).collect::<~[&[int]]>(), box [&[1,2], &[2,3], &[3,4]]); + assert_eq!(v.windows(3).collect::<~[&[int]]>(), box [&[1i,2,3], &[2,3,4]]); assert!(v.windows(6).next().is_none()); } @@ -3385,11 +3386,11 @@ mod tests { fn test_chunksator() { let v = &[1i,2,3,4,5]; - assert_eq!(v.chunks(2).collect::<~[&[int]]>(), ~[&[1i,2], &[3,4], &[5]]); - assert_eq!(v.chunks(3).collect::<~[&[int]]>(), ~[&[1i,2,3], &[4,5]]); - assert_eq!(v.chunks(6).collect::<~[&[int]]>(), ~[&[1i,2,3,4,5]]); + assert_eq!(v.chunks(2).collect::<~[&[int]]>(), box [&[1i,2], &[3,4], &[5]]); + assert_eq!(v.chunks(3).collect::<~[&[int]]>(), box [&[1i,2,3], &[4,5]]); + assert_eq!(v.chunks(6).collect::<~[&[int]]>(), box [&[1i,2,3,4,5]]); - assert_eq!(v.chunks(2).rev().collect::<~[&[int]]>(), ~[&[5i], &[3,4], &[1,2]]); + assert_eq!(v.chunks(2).rev().collect::<~[&[int]]>(), box [&[5i], &[3,4], &[1,2]]); let mut it = v.chunks(2); assert_eq!(it.indexable(), 3); assert_eq!(it.idx(0).unwrap(), &[1,2]); @@ -3408,19 +3409,19 @@ mod tests { #[test] fn test_move_from() { let mut a = [1,2,3,4,5]; - let b = ~[6,7,8]; + let b = box [6,7,8]; assert_eq!(a.move_from(b, 0, 3), 3); assert!(a == [6,7,8,4,5]); let mut a = [7,2,8,1]; - let b = ~[3,1,4,1,5,9]; + let b = box [3,1,4,1,5,9]; assert_eq!(a.move_from(b, 0, 6), 4); assert!(a == [3,1,4,1]); let mut a = [1,2,3,4]; - let b = ~[5,6,7,8,9,0]; + let b = box [5,6,7,8,9,0]; assert_eq!(a.move_from(b, 2, 3), 1); assert!(a == [7,2,3,4]); let mut a = [1,2,3,4,5]; - let b = ~[5,6,7,8,9,0]; + let b = box [5,6,7,8,9,0]; assert_eq!(a.mut_slice(2,4).move_from(b,1,6), 2); assert!(a == [1,2,6,7,5]); } @@ -3453,11 +3454,11 @@ mod tests { assert_eq!(format!("{}", x.as_slice()), x_str); }) ) - let empty: ~[int] = ~[]; + let empty: ~[int] = box []; test_show_vec!(empty, "[]".to_owned()); - test_show_vec!(~[1], "[1]".to_owned()); - test_show_vec!(~[1, 2, 3], "[1, 2, 3]".to_owned()); - test_show_vec!(~[~[], ~[1u], ~[1u, 1u]], "[[], [1], [1, 1]]".to_owned()); + test_show_vec!(box [1], "[1]".to_owned()); + test_show_vec!(box [1, 2, 3], "[1, 2, 3]".to_owned()); + test_show_vec!(box [box [], box [1u], box [1u, 1u]], "[[], [1], [1, 1]]".to_owned()); let empty_mut: &mut [int] = &mut[]; test_show_vec!(empty_mut, "[]".to_owned()); @@ -3890,7 +3891,7 @@ mod bench { #[bench] fn zero_1kb_fixed_repeat(b: &mut Bencher) { b.iter(|| { - ~[0u8, ..1024] + box [0u8, ..1024] }); } diff --git a/src/libstd/str.rs b/src/libstd/str.rs index b105dd0ca5a..430f6326327 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -137,7 +137,7 @@ impl FromStr for ~str { /// Fails if invalid UTF-8 pub fn from_byte(b: u8) -> ~str { assert!(b < 128u8); - unsafe { ::cast::transmute(~[b]) } + unsafe { ::cast::transmute(box [b]) } } /// Convert a char to a string @@ -1387,7 +1387,7 @@ pub mod raw { } /// Converts a byte to a string. - pub unsafe fn from_byte(u: u8) -> ~str { from_utf8_owned(~[u]) } + pub unsafe fn from_byte(u: u8) -> ~str { from_utf8_owned(box [u]) } /// Form a slice from a C string. Unsafe because the caller must ensure the /// C string has the static lifetime, or else the return value may be @@ -1448,7 +1448,7 @@ pub mod raw { #[test] fn test_from_buf_len() { unsafe { - let a = ~[65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; + let a = box [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8]; let b = a.as_ptr(); let c = from_buf_len(b, 3u); assert_eq!(c, "AAA".to_owned()); @@ -3342,7 +3342,7 @@ mod tests { #[test] fn test_raw_from_c_str() { unsafe { - let a = ~[65, 65, 65, 65, 65, 65, 65, 0]; + let a = box [65, 65, 65, 65, 65, 65, 65, 0]; let b = a.as_ptr(); let c = raw::from_c_str(b); assert_eq!(c, "AAAAAAA".to_owned()); @@ -3456,13 +3456,13 @@ mod tests { fn test_utf16() { let pairs = [("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n".to_owned(), - ~[0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16, + box [0xd800_u16, 0xdf45_u16, 0xd800_u16, 0xdf3f_u16, 0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf46_u16, 0xd800_u16, 0xdf39_u16, 0xd800_u16, 0xdf3b_u16, 0xd800_u16, 0xdf30_u16, 0x000a_u16]), ("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n".to_owned(), - ~[0xd801_u16, 0xdc12_u16, 0xd801_u16, + box [0xd801_u16, 0xdc12_u16, 0xd801_u16, 0xdc49_u16, 0xd801_u16, 0xdc2e_u16, 0xd801_u16, 0xdc40_u16, 0xd801_u16, 0xdc32_u16, 0xd801_u16, 0xdc4b_u16, 0x0020_u16, 0xd801_u16, 0xdc0f_u16, @@ -3470,7 +3470,7 @@ mod tests { 0x000a_u16]), ("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n".to_owned(), - ~[0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16, + box [0xd800_u16, 0xdf00_u16, 0xd800_u16, 0xdf16_u16, 0xd800_u16, 0xdf0b_u16, 0xd800_u16, 0xdf04_u16, 0xd800_u16, 0xdf11_u16, 0xd800_u16, 0xdf09_u16, 0x00b7_u16, 0xd800_u16, 0xdf0c_u16, 0xd800_u16, @@ -3479,7 +3479,7 @@ mod tests { 0xdf09_u16, 0xd800_u16, 0xdf11_u16, 0x000a_u16 ]), ("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n".to_owned(), - ~[0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16, + box [0xd801_u16, 0xdc8b_u16, 0xd801_u16, 0xdc98_u16, 0xd801_u16, 0xdc88_u16, 0xd801_u16, 0xdc91_u16, 0xd801_u16, 0xdc9b_u16, 0xd801_u16, 0xdc92_u16, 0x0020_u16, 0xd801_u16, 0xdc95_u16, 0xd801_u16, @@ -3492,7 +3492,7 @@ mod tests { 0x000a_u16 ]), // Issue #12318, even-numbered non-BMP planes ("\U00020000".to_owned(), - ~[0xD840, 0xDC00])]; + box [0xD840, 0xDC00])]; for p in pairs.iter() { let (s, u) = (*p).clone(); @@ -3558,7 +3558,7 @@ mod tests { #[test] fn test_char_at() { let s = "ศไทย中华Việt Nam".to_owned(); - let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; + let v = box ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; for ch in v.iter() { assert!(s.char_at(pos) == *ch); @@ -3569,7 +3569,7 @@ mod tests { #[test] fn test_char_at_reverse() { let s = "ศไทย中华Việt Nam".to_owned(); - let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; + let v = box ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = s.len(); for ch in v.iter().rev() { assert!(s.char_at_reverse(pos) == *ch); @@ -3652,7 +3652,7 @@ mod tests { fn test_iterator() { use iter::*; let s = "ศไทย中华Việt Nam".to_owned(); - let v = ~['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; + let v = box ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m']; let mut pos = 0; let mut it = s.chars(); @@ -3668,7 +3668,7 @@ mod tests { fn test_rev_iterator() { use iter::*; let s = "ศไทย中华Việt Nam".to_owned(); - let v = ~['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ']; + let v = box ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ']; let mut pos = 0; let mut it = s.chars().rev(); @@ -3761,33 +3761,33 @@ mod tests { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: ~[&str] = data.split(' ').collect(); - assert_eq!( split, ~["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!( split, box ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); let mut rsplit: ~[&str] = data.split(' ').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, ~["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(rsplit, box ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); let split: ~[&str] = data.split(|c: char| c == ' ').collect(); - assert_eq!( split, ~["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!( split, box ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); let mut rsplit: ~[&str] = data.split(|c: char| c == ' ').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, ~["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(rsplit, box ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); // Unicode let split: ~[&str] = data.split('ä').collect(); - assert_eq!( split, ~["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!( split, box ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); let mut rsplit: ~[&str] = data.split('ä').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, ~["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(rsplit, box ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); let split: ~[&str] = data.split(|c: char| c == 'ä').collect(); - assert_eq!( split, ~["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!( split, box ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); let mut rsplit: ~[&str] = data.split(|c: char| c == 'ä').rev().collect(); rsplit.reverse(); - assert_eq!(rsplit, ~["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(rsplit, box ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); } #[test] @@ -3795,17 +3795,17 @@ mod tests { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: ~[&str] = data.splitn(' ', 3).collect(); - assert_eq!(split, ~["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + assert_eq!(split, box ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); let split: ~[&str] = data.splitn(|c: char| c == ' ', 3).collect(); - assert_eq!(split, ~["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + assert_eq!(split, box ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); // Unicode let split: ~[&str] = data.splitn('ä', 3).collect(); - assert_eq!(split, ~["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); + assert_eq!(split, box ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); let split: ~[&str] = data.splitn(|c: char| c == 'ä', 3).collect(); - assert_eq!(split, ~["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); + assert_eq!(split, box ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); } #[test] @@ -3814,20 +3814,20 @@ mod tests { let mut split: ~[&str] = data.rsplitn(' ', 3).collect(); split.reverse(); - assert_eq!(split, ~["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(split, box ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); let mut split: ~[&str] = data.rsplitn(|c: char| c == ' ', 3).collect(); split.reverse(); - assert_eq!(split, ~["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + assert_eq!(split, box ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); // Unicode let mut split: ~[&str] = data.rsplitn('ä', 3).collect(); split.reverse(); - assert_eq!(split, ~["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(split, box ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); let mut split: ~[&str] = data.rsplitn(|c: char| c == 'ä', 3).collect(); split.reverse(); - assert_eq!(split, ~["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); + assert_eq!(split, box ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); } #[test] @@ -3835,10 +3835,10 @@ mod tests { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: ~[&str] = data.split('\n').collect(); - assert_eq!(split, ~["", "Märy häd ä little lämb", "Little lämb", ""]); + assert_eq!(split, box ["", "Märy häd ä little lämb", "Little lämb", ""]); let split: ~[&str] = data.split_terminator('\n').collect(); - assert_eq!(split, ~["", "Märy häd ä little lämb", "Little lämb"]); + assert_eq!(split, box ["", "Märy häd ä little lämb", "Little lämb"]); } #[test] @@ -3847,18 +3847,18 @@ mod tests { let mut split: ~[&str] = data.split('\n').rev().collect(); split.reverse(); - assert_eq!(split, ~["", "Märy häd ä little lämb", "Little lämb", ""]); + assert_eq!(split, box ["", "Märy häd ä little lämb", "Little lämb", ""]); let mut split: ~[&str] = data.split_terminator('\n').rev().collect(); split.reverse(); - assert_eq!(split, ~["", "Märy häd ä little lämb", "Little lämb"]); + assert_eq!(split, box ["", "Märy häd ä little lämb", "Little lämb"]); } #[test] fn test_words() { let data = "\n \tMäry häd\tä little lämb\nLittle lämb\n"; let words: ~[&str] = data.words().collect(); - assert_eq!(words, ~["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"]) + assert_eq!(words, box ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"]) } #[test] @@ -3893,11 +3893,11 @@ mod tests { fn test_lines() { let data = "\nMäry häd ä little lämb\n\nLittle lämb\n"; let lines: ~[&str] = data.lines().collect(); - assert_eq!(lines, ~["", "Märy häd ä little lämb", "", "Little lämb"]); + assert_eq!(lines, box ["", "Märy häd ä little lämb", "", "Little lämb"]); let data = "\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n let lines: ~[&str] = data.lines().collect(); - assert_eq!(lines, ~["", "Märy häd ä little lämb", "", "Little lämb"]); + assert_eq!(lines, box ["", "Märy häd ä little lämb", "", "Little lämb"]); } #[test] @@ -3906,20 +3906,20 @@ mod tests { let v: ~[&str] = s.split_str(sep).collect(); assert_eq!(v, u); } - t("--1233345--", "12345", ~["--1233345--"]); - t("abc::hello::there", "::", ~["abc", "hello", "there"]); - t("::hello::there", "::", ~["", "hello", "there"]); - t("hello::there::", "::", ~["hello", "there", ""]); - t("::hello::there::", "::", ~["", "hello", "there", ""]); - t("ประเทศไทย中华Việt Nam", "中华", ~["ประเทศไทย", "Việt Nam"]); - t("zzXXXzzYYYzz", "zz", ~["", "XXX", "YYY", ""]); - t("zzXXXzYYYz", "XXX", ~["zz", "zYYYz"]); - t(".XXX.YYY.", ".", ~["", "XXX", "YYY", ""]); - t("", ".", ~[""]); - t("zz", "zz", ~["",""]); - t("ok", "z", ~["ok"]); - t("zzz", "zz", ~["","z"]); - t("zzzzz", "zz", ~["","","z"]); + t("--1233345--", "12345", box ["--1233345--"]); + t("abc::hello::there", "::", box ["abc", "hello", "there"]); + t("::hello::there", "::", box ["", "hello", "there"]); + t("hello::there::", "::", box ["hello", "there", ""]); + t("::hello::there::", "::", box ["", "hello", "there", ""]); + t("ประเทศไทย中华Việt Nam", "中华", box ["ประเทศไทย", "Việt Nam"]); + t("zzXXXzzYYYzz", "zz", box ["", "XXX", "YYY", ""]); + t("zzXXXzYYYz", "XXX", box ["zz", "zYYYz"]); + t(".XXX.YYY.", ".", box ["", "XXX", "YYY", ""]); + t("", ".", box [""]); + t("zz", "zz", box ["",""]); + t("ok", "z", box ["ok"]); + t("zzz", "zz", box ["","z"]); + t("zzzzz", "zz", box ["","","z"]); } #[test] diff --git a/src/libstd/sync/arc.rs b/src/libstd/sync/arc.rs index 8d6d1c222cf..0cf975a4c1c 100644 --- a/src/libstd/sync/arc.rs +++ b/src/libstd/sync/arc.rs @@ -45,7 +45,7 @@ struct ArcData<T> { } unsafe fn new_inner<T: Send>(data: T, refcount: uint) -> *mut ArcData<T> { - let data = ~ArcData { + let data = box ArcData { count: AtomicUint::new(refcount), data: Unsafe::new(data) }; @@ -71,7 +71,7 @@ impl<T: Send> UnsafeArc<T> { pub fn newN(data: T, num_handles: uint) -> ~[UnsafeArc<T>] { unsafe { if num_handles == 0 { - ~[] // need to free data here + box [] // need to free data here } else { let ptr = new_inner(data, num_handles); let v = Vec::from_fn(num_handles, |_| UnsafeArc { data: ptr }); diff --git a/src/libstd/sync/atomics.rs b/src/libstd/sync/atomics.rs index e6b71b502c2..a3c1c33f77c 100644 --- a/src/libstd/sync/atomics.rs +++ b/src/libstd/sync/atomics.rs @@ -894,36 +894,36 @@ mod test { #[test] fn option_swap() { - let p = AtomicOption::new(~1); - let a = ~2; + let p = AtomicOption::new(box 1); + let a = box 2; let b = p.swap(a, SeqCst); - assert_eq!(b, Some(~1)); - assert_eq!(p.take(SeqCst), Some(~2)); + assert_eq!(b, Some(box 1)); + assert_eq!(p.take(SeqCst), Some(box 2)); } #[test] fn option_take() { - let p = AtomicOption::new(~1); + let p = AtomicOption::new(box 1); - assert_eq!(p.take(SeqCst), Some(~1)); + assert_eq!(p.take(SeqCst), Some(box 1)); assert_eq!(p.take(SeqCst), None); - let p2 = ~2; + let p2 = box 2; p.swap(p2, SeqCst); - assert_eq!(p.take(SeqCst), Some(~2)); + assert_eq!(p.take(SeqCst), Some(box 2)); } #[test] fn option_fill() { - let p = AtomicOption::new(~1); - assert!(p.fill(~2, SeqCst).is_some()); // should fail; shouldn't leak! - assert_eq!(p.take(SeqCst), Some(~1)); + let p = AtomicOption::new(box 1); + assert!(p.fill(box 2, SeqCst).is_some()); // should fail; shouldn't leak! + assert_eq!(p.take(SeqCst), Some(box 1)); - assert!(p.fill(~2, SeqCst).is_none()); // shouldn't fail - assert_eq!(p.take(SeqCst), Some(~2)); + assert!(p.fill(box 2, SeqCst).is_none()); // shouldn't fail + assert_eq!(p.take(SeqCst), Some(box 2)); } #[test] diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs index 97239707d32..22ed66b708b 100644 --- a/src/libstd/sync/deque.rs +++ b/src/libstd/sync/deque.rs @@ -159,7 +159,7 @@ impl<T: Send> BufferPool<T> { self.pool.with(|pool| { match pool.iter().position(|x| x.size() >= (1 << bits)) { Some(i) => pool.remove(i).unwrap(), - None => ~Buffer::new(bits) + None => box Buffer::new(bits) } }) } @@ -314,7 +314,7 @@ impl<T: Send> Deque<T> { // continue to be read after we flag this buffer for reclamation. unsafe fn swap_buffer(&mut self, b: int, old: *mut Buffer<T>, buf: Buffer<T>) -> *mut Buffer<T> { - let newbuf: *mut Buffer<T> = cast::transmute(~buf); + let newbuf: *mut Buffer<T> = cast::transmute(box buf); self.array.store(newbuf, SeqCst); let ss = (*newbuf).size(); self.bottom.store(b + ss, SeqCst); @@ -474,7 +474,7 @@ mod tests { fn stampede(mut w: Worker<~int>, s: Stealer<~int>, nthreads: int, amt: uint) { for _ in range(0, amt) { - w.push(~20); + w.push(box 20); } let mut remaining = AtomicUint::new(amt); let unsafe_remaining: *mut AtomicUint = &mut remaining; @@ -603,7 +603,7 @@ mod tests { let (threads, hits) = slice::unzip(range(0, NTHREADS).map(|_| { let s = s.clone(); - let unique_box = ~AtomicUint::new(0); + let unique_box = box AtomicUint::new(0); let thread_box = unsafe { *cast::transmute::<&~AtomicUint,**mut AtomicUint>(&unique_box) }; diff --git a/src/libstd/sync/mpsc_queue.rs b/src/libstd/sync/mpsc_queue.rs index 142a6239df6..315e412446d 100644 --- a/src/libstd/sync/mpsc_queue.rs +++ b/src/libstd/sync/mpsc_queue.rs @@ -73,7 +73,7 @@ pub struct Queue<T> { impl<T> Node<T> { unsafe fn new(v: Option<T>) -> *mut Node<T> { - cast::transmute(~Node { + cast::transmute(box Node { next: AtomicPtr::new(0 as *mut Node<T>), value: v, }) @@ -163,8 +163,8 @@ mod tests { #[test] fn test_full() { let mut q = Queue::new(); - q.push(~1); - q.push(~2); + q.push(box 1); + q.push(box 2); } #[test] diff --git a/src/libstd/sync/spsc_queue.rs b/src/libstd/sync/spsc_queue.rs index 4e043ecf171..f155bdca446 100644 --- a/src/libstd/sync/spsc_queue.rs +++ b/src/libstd/sync/spsc_queue.rs @@ -73,7 +73,7 @@ pub struct Queue<T> { impl<T: Send> Node<T> { fn new() -> *mut Node<T> { unsafe { - cast::transmute(~Node { + cast::transmute(box Node { value: None, next: AtomicPtr::new(0 as *mut Node<T>), }) @@ -247,8 +247,8 @@ mod test { #[test] fn drop_full() { let mut q = Queue::new(0); - q.push(~1); - q.push(~2); + q.push(box 1); + q.push(box 2); } #[test] diff --git a/src/libstd/task.rs b/src/libstd/task.rs index f8b3d25033c..e9b01063f94 100644 --- a/src/libstd/task.rs +++ b/src/libstd/task.rs @@ -418,7 +418,7 @@ fn test_spawn_sched_childs_on_default_sched() { fn avoid_copying_the_body(spawnfn: |v: proc():Send|) { let (tx, rx) = channel::<uint>(); - let x = ~1; + let x = box 1; let x_in_parent = (&*x) as *int as uint; spawnfn(proc() { @@ -507,7 +507,7 @@ fn test_try_fail_message_owned_str() { #[test] fn test_try_fail_message_any() { match try(proc() { - fail!(~413u16 as ~Any:Send); + fail!(box 413u16 as ~Any:Send); }) { Err(e) => { type T = ~Any:Send; diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs index d29b0b3b07c..bdeae0340e2 100644 --- a/src/libstd/to_str.rs +++ b/src/libstd/to_str.rs @@ -51,11 +51,11 @@ mod tests { #[test] fn test_vectors() { - let x: ~[int] = ~[]; + let x: ~[int] = box []; assert_eq!(x.to_str(), "[]".to_owned()); - assert_eq!((~[1]).to_str(), "[1]".to_owned()); - assert_eq!((~[1, 2, 3]).to_str(), "[1, 2, 3]".to_owned()); - assert!((~[~[], ~[1], ~[1, 1]]).to_str() == + assert_eq!((box [1]).to_str(), "[1]".to_owned()); + assert_eq!((box [1, 2, 3]).to_str(), "[1, 2, 3]".to_owned()); + assert!((box [box [], box [1], box [1, 1]]).to_str() == "[[], [1], [1, 1]]".to_owned()); } } diff --git a/src/libstd/unstable/dynamic_lib.rs b/src/libstd/unstable/dynamic_lib.rs index 671cacbbb6f..68f0aaab05b 100644 --- a/src/libstd/unstable/dynamic_lib.rs +++ b/src/libstd/unstable/dynamic_lib.rs @@ -72,7 +72,7 @@ impl DynamicLibrary { } else { ("LD_LIBRARY_PATH", ':' as u8) }; - let newenv = os::getenv_as_bytes(envvar).unwrap_or(~[]); + let newenv = os::getenv_as_bytes(envvar).unwrap_or(box []); let newenv = newenv + &[sep] + path.as_vec(); os::setenv(envvar, str::from_utf8(newenv).unwrap()); } diff --git a/src/libstd/unstable/mod.rs b/src/libstd/unstable/mod.rs index f660d7ae97a..372fcc396b1 100644 --- a/src/libstd/unstable/mod.rs +++ b/src/libstd/unstable/mod.rs @@ -44,9 +44,9 @@ fn test_run_in_bare_thread() { #[test] fn test_run_in_bare_thread_exchange() { // Does the exchange heap work without the runtime? - let i = ~100; + let i = box 100; run_in_bare_thread(proc() { - assert!(i == ~100); + assert!(i == box 100); }); } diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs index b7f6d730d12..5be10fc27df 100644 --- a/src/libstd/unstable/sync.rs +++ b/src/libstd/unstable/sync.rs @@ -120,7 +120,7 @@ mod tests { let num_tasks = 10; let count = 10; - let total = Exclusive::new(~0); + let total = Exclusive::new(box 0); for _ in range(0u, num_tasks) { let total = total.clone(); diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index fa2f53fcf69..e264615578e 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -1585,8 +1585,8 @@ mod tests { #[test] fn test_clone_from() { let mut v = vec!(); - let three = vec!(~1, ~2, ~3); - let two = vec!(~4, ~5); + let three = vec!(box 1, box 2, box 3); + let two = vec!(box 4, box 5); // zero, long v.clone_from(&three); assert_eq!(v, three); |