bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

remove vecs_implicitly_copyable from libstd/libcore

Browse source
This commit is contained in:
Daniel Micay 2013-05-08 22:44:43 -04:00
parent d82d9874a6
commit 2bc12635a2
14 changed files with 105 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/libcore/core.rc
View file

@ -60,7 +60,6 @@ they contained the following prologue:
// Don't link to core. We are core. // Don't link to core. We are core.
#[no_core]; #[no_core];
#[warn(vecs_implicitly_copyable)];
#[deny(non_camel_case_types)]; #[deny(non_camel_case_types)];
#[allow(deprecated_mutable_fields)]; #[allow(deprecated_mutable_fields)];

2
src/libstd/arc.rs
View file

@ -499,7 +499,7 @@ mod tests {
let arc_v = p.recv(); let arc_v = p.recv();
let v = *arc::get::<~[int]>(&arc_v); let v = copy *arc::get::<~[int]>(&arc_v);
assert!(v[3] == 4); assert!(v[3] == 4);
}; };

4
src/libstd/future.rs
View file

@ -238,8 +238,8 @@ mod test {
#[test] #[test]
fn test_sendable_future() { fn test_sendable_future() {
let expected = ~"schlorf"; let expected = "schlorf";
let f = Cell(do spawn { copy expected }); let f = Cell(do spawn { expected });
do task::spawn { do task::spawn {
let mut f = f.take(); let mut f = f.take();
let actual = f.get(); let actual = f.get();

71
src/libstd/getopts.rs
View file

@ -229,13 +229,13 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
let l = args.len(); let l = args.len();
let mut i = 0; let mut i = 0;
while i < l { while i < l {
let cur = args[i]; let cur = copy args[i];
let curlen = cur.len(); let curlen = cur.len();
if !is_arg(cur) { if !is_arg(cur) {
free.push(cur); free.push(cur);
} else if cur == ~"--" { } else if cur == ~"--" {
let mut j = i + 1; let mut j = i + 1;
while j < l { free.push(args[j]); j += 1; } while j < l { free.push(copy args[j]); j += 1; }
break; break;
} else { } else {
let mut names; let mut names;
@ -248,8 +248,8 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
names = ~[Long(tail)]; names = ~[Long(tail)];
} else { } else {
names = names =
~[Long(tail_eq[0])]; ~[Long(copy tail_eq[0])];
i_arg = Some(tail_eq[1]); i_arg = Some(copy tail_eq[1]);
} }
} else { } else {
let mut j = 1; let mut j = 1;
@ -266,7 +266,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
interpreted correctly interpreted correctly
*/ */
match find_opt(opts, opt) { match find_opt(opts, copy opt) {
Some(id) => last_valid_opt_id = Some(id), Some(id) => last_valid_opt_id = Some(id),
None => { None => {
let arg_follows = let arg_follows =
@ -292,7 +292,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
let mut name_pos = 0; let mut name_pos = 0;
for names.each() |nm| { for names.each() |nm| {
name_pos += 1; name_pos += 1;
let optid = match find_opt(opts, *nm) { let optid = match find_opt(opts, copy *nm) {
Some(id) => id, Some(id) => id,
None => return Err(UnrecognizedOption(name_str(nm))) None => return Err(UnrecognizedOption(name_str(nm)))
}; };
@ -305,18 +305,18 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
} }
Maybe => { Maybe => {
if !i_arg.is_none() { if !i_arg.is_none() {
vals[optid].push(Val(i_arg.get())); vals[optid].push(Val((copy i_arg).get()));
} else if name_pos < names.len() || } else if name_pos < names.len() ||
i + 1 == l || is_arg(args[i + 1]) { i + 1 == l || is_arg(args[i + 1]) {
vals[optid].push(Given); vals[optid].push(Given);
} else { i += 1; vals[optid].push(Val(args[i])); } } else { i += 1; vals[optid].push(Val(copy args[i])); }
} }
Yes => { Yes => {
if !i_arg.is_none() { if !i_arg.is_none() {
vals[optid].push(Val(i_arg.get())); vals[optid].push(Val((copy i_arg).get()));
} else if i + 1 == l { } else if i + 1 == l {
return Err(ArgumentMissing(name_str(nm))); return Err(ArgumentMissing(name_str(nm)));
} else { i += 1; vals[optid].push(Val(args[i])); } } else { i += 1; vals[optid].push(Val(copy args[i])); }
} }
} }
} }
@ -346,7 +346,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
fn opt_vals(mm: &Matches, nm: &str) -> ~[Optval] { fn opt_vals(mm: &Matches, nm: &str) -> ~[Optval] {
return match find_opt(mm.opts, mkname(nm)) { return match find_opt(mm.opts, mkname(nm)) {
Some(id) => mm.vals[id], Some(id) => copy mm.vals[id],
None => { None => {
error!("No option '%s' defined", nm); error!("No option '%s' defined", nm);
fail!() fail!()
@ -354,7 +354,7 @@ fn opt_vals(mm: &Matches, nm: &str) -> ~[Optval] {
}; };
} }
fn opt_val(mm: &Matches, nm: &str) -> Optval { return opt_vals(mm, nm)[0]; } fn opt_val(mm: &Matches, nm: &str) -> Optval { copy opt_vals(mm, nm)[0] }
/// Returns true if an option was matched /// Returns true if an option was matched
pub fn opt_present(mm: &Matches, nm: &str) -> bool { pub fn opt_present(mm: &Matches, nm: &str) -> bool {
@ -547,25 +547,29 @@ pub mod groups {
// translate OptGroup into Opt // translate OptGroup into Opt
// (both short and long names correspond to different Opts) // (both short and long names correspond to different Opts)
pub fn long_to_short(lopt: &OptGroup) -> ~[Opt] { pub fn long_to_short(lopt: &OptGroup) -> ~[Opt] {
match ((*lopt).short_name.len(), let OptGroup{short_name: short_name,
(*lopt).long_name.len()) { long_name: long_name,
hasarg: hasarg,
occur: occur,
_} = copy *lopt;
match (short_name.len(), long_name.len()) {
(0,0) => fail!(~"this long-format option was given no name"), (0,0) => fail!(~"this long-format option was given no name"),
(0,_) => ~[Opt {name: Long(((*lopt).long_name)), (0,_) => ~[Opt {name: Long((long_name)),
hasarg: (*lopt).hasarg, hasarg: hasarg,
occur: (*lopt).occur}], occur: occur}],
(1,0) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)), (1,0) => ~[Opt {name: Short(str::char_at(short_name, 0)),
hasarg: (*lopt).hasarg, hasarg: hasarg,
occur: (*lopt).occur}], occur: occur}],
(1,_) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)), (1,_) => ~[Opt {name: Short(str::char_at(short_name, 0)),
hasarg: (*lopt).hasarg, hasarg: hasarg,
occur: (*lopt).occur}, occur: occur},
Opt {name: Long(((*lopt).long_name)), Opt {name: Long((long_name)),
hasarg: (*lopt).hasarg, hasarg: hasarg,
occur: (*lopt).occur}], occur: occur}],
(_,_) => fail!(~"something is wrong with the long-form opt") (_,_) => fail!(~"something is wrong with the long-form opt")
} }
@ -586,11 +590,12 @@ pub mod groups {
let desc_sep = ~"\n" + str::repeat(~" ", 24); let desc_sep = ~"\n" + str::repeat(~" ", 24);
let rows = vec::map(opts, |optref| { let rows = vec::map(opts, |optref| {
let short_name = (*optref).short_name; let OptGroup{short_name: short_name,
let long_name = (*optref).long_name; long_name: long_name,
let hint = (*optref).hint; hint: hint,
let desc = (*optref).desc; desc: desc,
let hasarg = (*optref).hasarg; hasarg: hasarg,
_} = copy *optref;
let mut row = str::repeat(~" ", 4); let mut row = str::repeat(~" ", 4);
@ -620,7 +625,7 @@ pub mod groups {
row += if rowlen < 24 { row += if rowlen < 24 {
str::repeat(~" ", 24 - rowlen) str::repeat(~" ", 24 - rowlen)
} else { } else {
desc_sep copy desc_sep
}; };
// Normalize desc to contain words seperated by one space character // Normalize desc to contain words seperated by one space character
@ -892,7 +897,7 @@ mod tests {
let rs = getopts(args, opts); let rs = getopts(args, opts);
match rs { match rs {
Err(copy f) => { Err(copy f) => {
error!(fail_str(f)); error!(fail_str(copy f));
check_fail_type(f, UnexpectedArgument_); check_fail_type(f, UnexpectedArgument_);
} }
_ => fail!() _ => fail!()

4
src/libstd/net_ip.rs
View file

@ -175,7 +175,7 @@ pub mod v4 {
pub fn parse_addr(ip: &str) -> IpAddr { pub fn parse_addr(ip: &str) -> IpAddr {
match try_parse_addr(ip) { match try_parse_addr(ip) {
result::Ok(addr) => addr, result::Ok(addr) => addr,
result::Err(ref err_data) => fail!(err_data.err_msg) result::Err(ref err_data) => fail!(copy err_data.err_msg)
} }
} }
// the simple, old style numberic representation of // the simple, old style numberic representation of
@ -272,7 +272,7 @@ pub mod v6 {
pub fn parse_addr(ip: &str) -> IpAddr { pub fn parse_addr(ip: &str) -> IpAddr {
match try_parse_addr(ip) { match try_parse_addr(ip) {
result::Ok(addr) => addr, result::Ok(addr) => addr,
result::Err(copy err_data) => fail!(err_data.err_msg) result::Err(copy err_data) => fail!(copy err_data.err_msg)
} }
} }
pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> { pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {

61
src/libstd/net_tcp.rs
View file

@ -277,8 +277,8 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
as *libc::c_void); as *libc::c_void);
let tcp_conn_err = match err_data.err_name { let tcp_conn_err = match err_data.err_name {
~"ECONNREFUSED" => ConnectionRefused, ~"ECONNREFUSED" => ConnectionRefused,
_ => GenericConnectErr(err_data.err_name, _ => GenericConnectErr(copy err_data.err_name,
err_data.err_msg) copy err_data.err_msg)
}; };
result::Err(tcp_conn_err) result::Err(tcp_conn_err)
} }
@ -769,8 +769,8 @@ fn listen_common(host_ip: ip::IpAddr,
debug!("Got '%s' '%s' libuv error", debug!("Got '%s' '%s' libuv error",
err_data.err_name, err_data.err_msg); err_data.err_name, err_data.err_msg);
result::Err( result::Err(
GenericListenErr(err_data.err_name, GenericListenErr(copy err_data.err_name,
err_data.err_msg)) copy err_data.err_msg))
} }
} }
} }
@ -790,8 +790,8 @@ fn listen_common(host_ip: ip::IpAddr,
match kill_result { match kill_result {
// some failure post bind/listen // some failure post bind/listen
Some(ref err_data) => result::Err(GenericListenErr( Some(ref err_data) => result::Err(GenericListenErr(
err_data.err_name, copy err_data.err_name,
err_data.err_msg)), copy err_data.err_msg)),
// clean exit // clean exit
None => result::Ok(()) None => result::Ok(())
} }
@ -1275,7 +1275,7 @@ trait ToTcpErr {
impl ToTcpErr for uv::ll::uv_err_data { impl ToTcpErr for uv::ll::uv_err_data {
fn to_tcp_err(&self) -> TcpErrData { fn to_tcp_err(&self) -> TcpErrData {
TcpErrData { err_name: self.err_name, err_msg: self.err_msg } TcpErrData { err_name: copy self.err_name, err_msg: copy self.err_msg }
} }
} }
@ -1447,12 +1447,8 @@ mod test {
use uv::iotask::IoTask; use uv::iotask::IoTask;
use uv; use uv;
use core::io; use core::cell::Cell;
use core::comm::{stream, SharedChan}; use core::comm::{stream, SharedChan};
use core::result;
use core::str;
use core::task;
use core::vec;
// FIXME don't run on fbsd or linux 32 bit (#2064) // FIXME don't run on fbsd or linux 32 bit (#2064)
#[cfg(target_os="win32")] #[cfg(target_os="win32")]
@ -1467,7 +1463,6 @@ mod test {
#[test] #[test]
fn test_gl_tcp_server_and_client_ipv4() { fn test_gl_tcp_server_and_client_ipv4() {
unsafe { unsafe {
use net::tcp::test::tcp_ipv4_server_and_client_test::*;
impl_gl_tcp_ipv4_server_and_client(); impl_gl_tcp_ipv4_server_and_client();
} }
} }
@ -1558,10 +1553,10 @@ mod test {
} }
pub fn impl_gl_tcp_ipv4_server_and_client() { pub fn impl_gl_tcp_ipv4_server_and_client() {
let hl_loop = &uv::global_loop::get(); let hl_loop = &uv::global_loop::get();
let server_ip = ~"127.0.0.1"; let server_ip = "127.0.0.1";
let server_port = 8888u; let server_port = 8888u;
let expected_req = ~"ping"; let expected_req = ~"ping";
let expected_resp = ~"pong"; let expected_resp = "pong";
let (server_result_po, server_result_ch) = stream::<~str>(); let (server_result_po, server_result_ch) = stream::<~str>();
@ -1574,7 +1569,7 @@ mod test {
let actual_req = run_tcp_test_server( let actual_req = run_tcp_test_server(
server_ip, server_ip,
server_port, server_port,
expected_resp, expected_resp.to_str(),
cont_ch.clone(), cont_ch.clone(),
&hl_loop_clone); &hl_loop_clone);
server_result_ch.send(actual_req); server_result_ch.send(actual_req);
@ -1599,9 +1594,9 @@ mod test {
} }
pub fn impl_gl_tcp_ipv4_get_peer_addr() { pub fn impl_gl_tcp_ipv4_get_peer_addr() {
let hl_loop = &uv::global_loop::get(); let hl_loop = &uv::global_loop::get();
let server_ip = ~"127.0.0.1"; let server_ip = "127.0.0.1";
let server_port = 8887u; let server_port = 8887u;
let expected_resp = ~"pong"; let expected_resp = "pong";
let (cont_po, cont_ch) = stream::<()>(); let (cont_po, cont_ch) = stream::<()>();
let cont_ch = SharedChan::new(cont_ch); let cont_ch = SharedChan::new(cont_ch);
@ -1612,7 +1607,7 @@ mod test {
run_tcp_test_server( run_tcp_test_server(
server_ip, server_ip,
server_port, server_port,
expected_resp, expected_resp.to_str(),
cont_ch.clone(), cont_ch.clone(),
&hl_loop_clone); &hl_loop_clone);
}; };
@ -1641,7 +1636,7 @@ mod test {
} }
pub fn impl_gl_tcp_ipv4_client_error_connection_refused() { pub fn impl_gl_tcp_ipv4_client_error_connection_refused() {
let hl_loop = &uv::global_loop::get(); let hl_loop = &uv::global_loop::get();
let server_ip = ~"127.0.0.1"; let server_ip = "127.0.0.1";
let server_port = 8889u; let server_port = 8889u;
let expected_req = ~"ping"; let expected_req = ~"ping";
// client // client
@ -1658,10 +1653,10 @@ mod test {
} }
pub fn impl_gl_tcp_ipv4_server_address_in_use() { pub fn impl_gl_tcp_ipv4_server_address_in_use() {
let hl_loop = &uv::global_loop::get(); let hl_loop = &uv::global_loop::get();
let server_ip = ~"127.0.0.1"; let server_ip = "127.0.0.1";
let server_port = 8890u; let server_port = 8890u;
let expected_req = ~"ping"; let expected_req = ~"ping";
let expected_resp = ~"pong"; let expected_resp = "pong";
let (cont_po, cont_ch) = stream::<()>(); let (cont_po, cont_ch) = stream::<()>();
let cont_ch = SharedChan::new(cont_ch); let cont_ch = SharedChan::new(cont_ch);
@ -1672,7 +1667,7 @@ mod test {
run_tcp_test_server( run_tcp_test_server(
server_ip, server_ip,
server_port, server_port,
expected_resp, expected_resp.to_str(),
cont_ch.clone(), cont_ch.clone(),
&hl_loop_clone); &hl_loop_clone);
} }
@ -1701,7 +1696,7 @@ mod test {
} }
pub fn impl_gl_tcp_ipv4_server_access_denied() { pub fn impl_gl_tcp_ipv4_server_access_denied() {
let hl_loop = &uv::global_loop::get(); let hl_loop = &uv::global_loop::get();
let server_ip = ~"127.0.0.1"; let server_ip = "127.0.0.1";
let server_port = 80u; let server_port = 80u;
// this one should fail.. // this one should fail..
let listen_err = run_tcp_test_server_fail( let listen_err = run_tcp_test_server_fail(
@ -1721,10 +1716,10 @@ mod test {
pub fn impl_gl_tcp_ipv4_server_client_reader_writer() { pub fn impl_gl_tcp_ipv4_server_client_reader_writer() {
let iotask = &uv::global_loop::get(); let iotask = &uv::global_loop::get();
let server_ip = ~"127.0.0.1"; let server_ip = "127.0.0.1";
let server_port = 8891u; let server_port = 8891u;
let expected_req = ~"ping"; let expected_req = ~"ping";
let expected_resp = ~"pong"; let expected_resp = "pong";
let (server_result_po, server_result_ch) = stream::<~str>(); let (server_result_po, server_result_ch) = stream::<~str>();
@ -1737,7 +1732,7 @@ mod test {
let actual_req = run_tcp_test_server( let actual_req = run_tcp_test_server(
server_ip, server_ip,
server_port, server_port,
expected_resp, expected_resp.to_str(),
cont_ch.clone(), cont_ch.clone(),
&iotask_clone); &iotask_clone);
server_result_ch.send(actual_req); server_result_ch.send(actual_req);
@ -1753,7 +1748,7 @@ mod test {
buf_write(sock_buf, expected_req); buf_write(sock_buf, expected_req);
// so contrived! // so contrived!
let actual_resp = do str::as_bytes(&expected_resp) |resp_buf| { let actual_resp = do str::as_bytes(&expected_resp.to_str()) |resp_buf| {
buf_read(sock_buf, resp_buf.len()) buf_read(sock_buf, resp_buf.len())
}; };
@ -1770,10 +1765,10 @@ mod test {
use core::io::{Reader,ReaderUtil}; use core::io::{Reader,ReaderUtil};
let hl_loop = &uv::global_loop::get(); let hl_loop = &uv::global_loop::get();
let server_ip = ~"127.0.0.1"; let server_ip = "127.0.0.1";
let server_port = 10041u; let server_port = 10041u;
let expected_req = ~"GET /"; let expected_req = ~"GET /";
let expected_resp = ~"A string\nwith multiple lines\n"; let expected_resp = "A string\nwith multiple lines\n";
let (cont_po, cont_ch) = stream::<()>(); let (cont_po, cont_ch) = stream::<()>();
let cont_ch = SharedChan::new(cont_ch); let cont_ch = SharedChan::new(cont_ch);
@ -1784,7 +1779,7 @@ mod test {
run_tcp_test_server( run_tcp_test_server(
server_ip, server_ip,
server_port, server_port,
expected_resp, expected_resp.to_str(),
cont_ch.clone(), cont_ch.clone(),
&hl_loop_clone); &hl_loop_clone);
}; };
@ -1827,6 +1822,7 @@ mod test {
let (server_po, server_ch) = stream::<~str>(); let (server_po, server_ch) = stream::<~str>();
let server_ch = SharedChan::new(server_ch); let server_ch = SharedChan::new(server_ch);
let server_ip_addr = ip::v4::parse_addr(server_ip); let server_ip_addr = ip::v4::parse_addr(server_ip);
let resp_cell = Cell(resp);
let listen_result = listen(server_ip_addr, server_port, 128, let listen_result = listen(server_ip_addr, server_port, 128,
iotask, iotask,
// on_establish_cb -- called when listener is set up // on_establish_cb -- called when listener is set up
@ -1838,6 +1834,7 @@ mod test {
// risky to run this on the loop, but some users // risky to run this on the loop, but some users
// will want the POWER // will want the POWER
|new_conn, kill_ch| { |new_conn, kill_ch| {
let resp_cell2 = Cell(resp_cell.take());
debug!("SERVER: new connection!"); debug!("SERVER: new connection!");
let (cont_po, cont_ch) = stream(); let (cont_po, cont_ch) = stream();
let server_ch = server_ch.clone(); let server_ch = server_ch.clone();
@ -1872,7 +1869,7 @@ mod test {
server_ch.send( server_ch.send(
str::from_bytes(data)); str::from_bytes(data));
debug!("SERVER: before write"); debug!("SERVER: before write");
tcp_write_single(&sock, str::to_bytes(resp)); tcp_write_single(&sock, str::to_bytes(resp_cell2.take()));
debug!("SERVER: after write.. die"); debug!("SERVER: after write.. die");
kill_ch.send(None); kill_ch.send(None);
} }

1
src/libstd/num/bigint.rs
View file

@ -16,7 +16,6 @@ A BigUint is represented as an array of BigDigits.
A BigInt is a combination of BigUint and Sign. A BigInt is a combination of BigUint and Sign.
*/ */
#[deny(vecs_implicitly_copyable)];
#[deny(deprecated_mutable_fields)]; #[deny(deprecated_mutable_fields)];
use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater}; use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};

4
src/libstd/priority_queue.rs
View file

@ -270,8 +270,8 @@ mod tests {
} }
fn check_to_vec(data: ~[int]) { fn check_to_vec(data: ~[int]) {
let heap = from_vec(data); let heap = from_vec(copy data);
assert!(merge_sort(heap.to_vec(), le) == merge_sort(data, le)); assert!(merge_sort((copy heap).to_vec(), le) == merge_sort(data, le));
assert!(heap.to_sorted_vec() == merge_sort(data, le)); assert!(heap.to_sorted_vec() == merge_sort(data, le));
} }

22
src/libstd/rope.rs
View file

@ -822,7 +822,7 @@ pub mod node {
None => break, None => break,
Some(x) => { Some(x) => {
//FIXME (#2744): Replace with memcpy or something similar //FIXME (#2744): Replace with memcpy or something similar
let local_buf: ~[u8] = cast::transmute(*x.content); let local_buf: ~[u8] = cast::transmute(copy *x.content);
let mut i = x.byte_offset; let mut i = x.byte_offset;
while i < x.byte_len { while i < x.byte_len {
buf[offset] = local_buf[i]; buf[offset] = local_buf[i];
@ -1299,12 +1299,12 @@ mod tests {
let buf = @ mut ~"1234567890"; let buf = @ mut ~"1234567890";
let mut i = 0; let mut i = 0;
while i < 10 { while i < 10 {
let a = *buf; let a = copy *buf;
let b = *buf; let b = copy *buf;
*buf = a + b; *buf = a + b;
i+=1; i+=1;
} }
let sample = @*buf; let sample = @copy *buf;
let r = of_str(sample); let r = of_str(sample);
assert!(char_len(r) == str::char_len(*sample)); assert!(char_len(r) == str::char_len(*sample));
assert!(rope_to_string(r) == *sample); assert!(rope_to_string(r) == *sample);
@ -1335,12 +1335,12 @@ mod tests {
let buf = @ mut ~"1234567890"; let buf = @ mut ~"1234567890";
let mut i = 0; let mut i = 0;
while i < 10 { while i < 10 {
let a = *buf; let a = copy *buf;
let b = *buf; let b = copy *buf;
*buf = a + b; *buf = a + b;
i+=1; i+=1;
} }
let sample = @*buf; let sample = @copy *buf;
let r = of_str(sample); let r = of_str(sample);
let mut len = 0u; let mut len = 0u;
@ -1358,15 +1358,15 @@ mod tests {
#[test] #[test]
fn bal1() { fn bal1() {
let init = @~"1234567890"; let init = @~"1234567890";
let buf = @mut * init; let buf = @mut copy *init;
let mut i = 0; let mut i = 0;
while i < 8 { while i < 8 {
let a = *buf; let a = copy *buf;
let b = *buf; let b = copy *buf;
*buf = a + b; *buf = a + b;
i+=1; i+=1;
} }
let sample = @*buf; let sample = @copy *buf;
let r1 = of_str(sample); let r1 = of_str(sample);
let mut r2 = of_str(init); let mut r2 = of_str(init);
i = 0; i = 0;

6
src/libstd/sha1.rs
View file

@ -177,7 +177,7 @@ pub fn sha1() -> @Sha1 {
let b = (hpart >> 16u32 & 0xFFu32) as u8; let b = (hpart >> 16u32 & 0xFFu32) as u8;
let c = (hpart >> 8u32 & 0xFFu32) as u8; let c = (hpart >> 8u32 & 0xFFu32) as u8;
let d = (hpart & 0xFFu32) as u8; let d = (hpart & 0xFFu32) as u8;
rs = vec::append(rs, ~[a, b, c, d]); rs = vec::append(copy rs, ~[a, b, c, d]);
} }
return rs; return rs;
} }
@ -381,7 +381,7 @@ mod tests {
for vec::each(tests) |t| { for vec::each(tests) |t| {
sh.input_str(t.input); sh.input_str(t.input);
let out = sh.result(); let out = sh.result();
check_vec_eq(t.output, out); check_vec_eq(copy t.output, out);
let out_str = sh.result_str(); let out_str = sh.result_str();
assert!((out_str.len() == 40)); assert!((out_str.len() == 40));
@ -402,7 +402,7 @@ mod tests {
left = left - take; left = left - take;
} }
let out = sh.result(); let out = sh.result();
check_vec_eq(t.output, out); check_vec_eq(copy t.output, out);
let out_str = sh.result_str(); let out_str = sh.result_str();
assert!((out_str.len() == 40)); assert!((out_str.len() == 40));

1
src/libstd/std.rc
View file

@ -26,7 +26,6 @@ not required in or otherwise suitable for the core library.
#[license = "MIT/ASL2"]; #[license = "MIT/ASL2"];
#[crate_type = "lib"]; #[crate_type = "lib"];
#[allow(vecs_implicitly_copyable)];
#[deny(non_camel_case_types)]; #[deny(non_camel_case_types)];
// Allow mutable fields only in stage0. // Allow mutable fields only in stage0.

24
src/libstd/test.rs
View file

@ -42,9 +42,9 @@ pub enum TestName {
} }
impl ToStr for TestName { impl ToStr for TestName {
fn to_str(&self) -> ~str { fn to_str(&self) -> ~str {
match self { match copy *self {
&StaticTestName(s) => s.to_str(), StaticTestName(s) => s.to_str(),
&DynTestName(s) => s.to_str() DynTestName(s) => s.to_str()
} }
} }
} }
@ -145,7 +145,7 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
let filter = let filter =
if vec::len(matches.free) > 0 { if vec::len(matches.free) > 0 {
option::Some(matches.free[0]) option::Some(copy (matches).free[0])
} else { option::None }; } else { option::None };
let run_ignored = getopts::opt_present(&matches, ~"ignored"); let run_ignored = getopts::opt_present(&matches, ~"ignored");
@ -203,7 +203,7 @@ pub fn run_tests_console(opts: &TestOpts,
fn callback(event: &TestEvent, st: &mut ConsoleTestState) { fn callback(event: &TestEvent, st: &mut ConsoleTestState) {
debug!("callback(event=%?)", event); debug!("callback(event=%?)", event);
match *event { match copy *event {
TeFiltered(ref filtered_tests) => { TeFiltered(ref filtered_tests) => {
st.total = filtered_tests.len(); st.total = filtered_tests.len();
let noun = if st.total != 1 { ~"tests" } else { ~"test" }; let noun = if st.total != 1 { ~"tests" } else { ~"test" };
@ -213,7 +213,7 @@ pub fn run_tests_console(opts: &TestOpts,
fmt!("test %s ... ", test.name.to_str())), fmt!("test %s ... ", test.name.to_str())),
TeResult(copy test, result) => { TeResult(copy test, result) => {
match st.log_out { match st.log_out {
Some(f) => write_log(f, result, &test), Some(f) => write_log(f, copy result, &test),
None => () None => ()
} }
match result { match result {
@ -412,7 +412,7 @@ fn run_tests(opts: &TestOpts,
callback: @fn(e: TestEvent)) { callback: @fn(e: TestEvent)) {
let mut filtered_tests = filter_tests(opts, tests); let mut filtered_tests = filter_tests(opts, tests);
let filtered_descs = filtered_tests.map(|t| t.desc); let filtered_descs = filtered_tests.map(|t| copy t.desc);
callback(TeFiltered(filtered_descs)); callback(TeFiltered(filtered_descs));
let (filtered_tests, filtered_benchs) = let (filtered_tests, filtered_benchs) =
@ -442,7 +442,7 @@ fn run_tests(opts: &TestOpts,
// We are doing one test at a time so we can print the name // We are doing one test at a time so we can print the name
// of the test before we run it. Useful for debugging tests // of the test before we run it. Useful for debugging tests
// that hang forever. // that hang forever.
callback(TeWait(test.desc)); callback(TeWait(copy test.desc));
} }
run_test(!opts.run_tests, test, ch.clone()); run_test(!opts.run_tests, test, ch.clone());
pending += 1; pending += 1;
@ -450,7 +450,7 @@ fn run_tests(opts: &TestOpts,
let (desc, result) = p.recv(); let (desc, result) = p.recv();
if concurrency != 1 { if concurrency != 1 {
callback(TeWait(desc)); callback(TeWait(copy desc));
} }
callback(TeResult(desc, result)); callback(TeResult(desc, result));
pending -= 1; pending -= 1;
@ -565,7 +565,7 @@ pub fn run_test(force_ignore: bool,
let task_result = result_future.unwrap().recv(); let task_result = result_future.unwrap().recv();
let test_result = calc_result(&desc, let test_result = calc_result(&desc,
task_result == task::Success); task_result == task::Success);
monitor_ch.send((desc, test_result)); monitor_ch.send((copy desc, test_result));
} }
} }
@ -850,7 +850,7 @@ mod tests {
either::Left(copy o) => o, either::Left(copy o) => o,
_ => fail!(~"Malformed arg in first_free_arg_should_be_a_filter") _ => fail!(~"Malformed arg in first_free_arg_should_be_a_filter")
}; };
assert!(~"filter" == opts.filter.get()); assert!("filter" == (copy opts.filter).get());
} }
#[test] #[test]
@ -931,7 +931,7 @@ mod tests {
for vec::each(names) |name| { for vec::each(names) |name| {
let test = TestDescAndFn { let test = TestDescAndFn {
desc: TestDesc { desc: TestDesc {
name: DynTestName(*name), name: DynTestName(copy *name),
ignore: false, ignore: false,
should_fail: false should_fail: false
}, },

6
src/libstd/timer.rs
View file

@ -175,9 +175,9 @@ extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use timer::*; use timer::*;
use uv; use uv;
use core::cell::Cell;
use core::rand::RngUtil; use core::rand::RngUtil;
use core::pipes::{stream, SharedChan}; use core::pipes::{stream, SharedChan};
@ -277,11 +277,11 @@ mod test {
for old_iter::repeat(times as uint) { for old_iter::repeat(times as uint) {
let mut rng = rand::rng(); let mut rng = rand::rng();
let expected = rng.gen_str(16u); let expected = Cell(rng.gen_str(16u));
let (test_po, test_ch) = stream::<~str>(); let (test_po, test_ch) = stream::<~str>();
let hl_loop_clone = hl_loop.clone(); let hl_loop_clone = hl_loop.clone();
do task::spawn() { do task::spawn() {
delayed_send(&hl_loop_clone, 50u, &test_ch, expected); delayed_send(&hl_loop_clone, 50u, &test_ch, expected.take());
}; };
match recv_timeout(&hl_loop, 1u, &test_po) { match recv_timeout(&hl_loop, 1u, &test_po) {

4
src/libstd/workcache.rs
View file

@ -339,7 +339,7 @@ impl TPrep for Prep {
&self.declared_inputs) && &self.declared_inputs) &&
self.all_fresh("discovered input", disc_in) && self.all_fresh("discovered input", disc_in) &&
self.all_fresh("discovered output", disc_out) => { self.all_fresh("discovered output", disc_out) => {
Work::new(@mut *self, Left(json_decode(*res))) Work::new(@mut copy *self, Left(json_decode(*res)))
} }
_ => { _ => {
@ -358,7 +358,7 @@ impl TPrep for Prep {
let v = blk(&exe); let v = blk(&exe);
send_one(chan, (exe, v)); send_one(chan, (exe, v));
} }
Work::new(@mut *self, Right(port)) Work::new(@mut copy *self, Right(port))
} }
} }
} }