diff --git a/src/compiletest/compiletest.rc b/src/compiletest/compiletest.rc index 6db926b29e394..7f691cc199567 100644 --- a/src/compiletest/compiletest.rc +++ b/src/compiletest/compiletest.rc @@ -12,7 +12,6 @@ #[allow(vecs_implicitly_copyable)]; #[allow(non_camel_case_types)]; -#[allow(deprecated_mode)]; #[allow(deprecated_pattern)]; extern mod std(vers = "0.7-pre"); diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index 7eaa853549336..353b9bf821c83 100644 --- a/src/libcore/comm.rs +++ b/src/libcore/comm.rs @@ -13,7 +13,6 @@ Message passing */ use cast::{transmute, transmute_mut}; -use cast; use either::{Either, Left, Right}; use kinds::Owned; use option::{Option, Some, None}; @@ -150,7 +149,7 @@ impl GenericChan for Chan { fn send(&self, x: T) { unsafe { let mut endp = None; - let mut self_endp = transmute_mut(&self.endp); + let self_endp = transmute_mut(&self.endp); endp <-> *self_endp; *self_endp = Some(streamp::client::data(endp.unwrap(), x)) } @@ -162,7 +161,7 @@ impl GenericSmartChan for Chan { fn try_send(&self, x: T) -> bool { unsafe { let mut endp = None; - let mut self_endp = transmute_mut(&self.endp); + let self_endp = transmute_mut(&self.endp); endp <-> *self_endp; match streamp::client::try_data(endp.unwrap(), x) { Some(next) => { @@ -180,7 +179,7 @@ impl GenericPort for Port { fn recv(&self) -> T { unsafe { let mut endp = None; - let mut self_endp = transmute_mut(&self.endp); + let self_endp = transmute_mut(&self.endp); endp <-> *self_endp; let streamp::data(x, endp) = recv(endp.unwrap()); *self_endp = Some(endp); @@ -192,7 +191,7 @@ impl GenericPort for Port { fn try_recv(&self) -> Option { unsafe { let mut endp = None; - let mut self_endp = transmute_mut(&self.endp); + let self_endp = transmute_mut(&self.endp); endp <-> *self_endp; match try_recv(endp.unwrap()) { Some(streamp::data(x, endp)) => { @@ -210,7 +209,7 @@ impl Peekable for Port { fn peek(&self) -> bool { unsafe { let mut endp = None; - let mut self_endp = transmute_mut(&self.endp); + let self_endp = transmute_mut(&self.endp); endp <-> *self_endp; let peek = match endp { Some(ref mut endp) => peek(endp), @@ -224,12 +223,10 @@ impl Peekable for Port { impl Selectable for Port { fn header(&mut self) -> *mut PacketHeader { - unsafe { match self.endp { Some(ref mut endp) => endp.header(), None => fail!(~"peeking empty stream") } - } } } @@ -263,7 +260,7 @@ pub impl PortSet { impl GenericPort for PortSet { fn try_recv(&self) -> Option { unsafe { - let mut self_ports = transmute_mut(&self.ports); + let self_ports = transmute_mut(&self.ports); let mut result = None; // we have to swap the ports array so we aren't borrowing // aliasable mutable memory. @@ -358,7 +355,7 @@ pub mod oneshot { pub fn init() -> (client::Oneshot, server::Oneshot) { pub use core::pipes::HasBuffer; - let mut buffer = ~::core::pipes::Buffer { + let buffer = ~::core::pipes::Buffer { header: ::core::pipes::BufferHeader(), data: __Buffer { Oneshot: ::core::pipes::mk_packet::>() diff --git a/src/libcore/core.rc b/src/libcore/core.rc index 31229967e934e..5e4cb4f469a28 100644 --- a/src/libcore/core.rc +++ b/src/libcore/core.rc @@ -61,7 +61,6 @@ they contained the following prologue: #[no_core]; #[deny(non_camel_case_types)]; -#[allow(deprecated_mutable_fields)]; // Make core testable by not duplicating lang items. See #2912 #[cfg(test)] extern mod realcore(name = "core", vers = "0.7-pre"); diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index 8301254fbdd18..feb441ef188c8 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -347,7 +347,7 @@ pub fn send(mut p: SendPacketBuffered, payload: T) -> bool { let header = p.header(); - let mut p_ = p.unwrap(); + let p_ = p.unwrap(); let p = unsafe { &mut *p_ }; assert!(ptr::to_unsafe_ptr(&(p.header)) == header); assert!(p.payload.is_none()); @@ -404,10 +404,8 @@ a message, or `Some(T)` if a message was received. */ pub fn try_recv(mut p: RecvPacketBuffered) -> Option { - let mut p_ = p.unwrap(); - let mut p = unsafe { - &mut *p_ - }; + let p_ = p.unwrap(); + let p = unsafe { &mut *p_ }; do (|| { try_recv_(p) diff --git a/src/libcore/reflect.rs b/src/libcore/reflect.rs index 47de360f58995..30f60dce04113 100644 --- a/src/libcore/reflect.rs +++ b/src/libcore/reflect.rs @@ -409,7 +409,6 @@ impl TyVisitor for MovePtrAdaptor { disr_val: int, n_fields: uint, name: &str) -> bool { - self.inner.push_ptr(); // NOTE remove after next snapshot if ! self.inner.visit_enter_enum_variant(variant, disr_val, n_fields, name) { return false; @@ -433,7 +432,6 @@ impl TyVisitor for MovePtrAdaptor { n_fields, name) { return false; } - self.inner.pop_ptr(); // NOTE remove after next snapshot true } diff --git a/src/libcore/rt/uv/net.rs b/src/libcore/rt/uv/net.rs index 04b9008b06770..068d6db2a43be 100644 --- a/src/libcore/rt/uv/net.rs +++ b/src/libcore/rt/uv/net.rs @@ -152,8 +152,7 @@ pub impl StreamWatcher { extern fn close_cb(handle: *uvll::uv_stream_t) { let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle); { - let mut data = get_watcher_data(&mut stream_watcher); - data.close_cb.swap_unwrap()(); + get_watcher_data(&mut stream_watcher).close_cb.swap_unwrap()(); } drop_watcher_data(&mut stream_watcher); unsafe { free_handle(handle as *c_void) } @@ -214,8 +213,7 @@ pub impl TcpWatcher { assert!(get_watcher_data(self).connect_cb.is_none()); get_watcher_data(self).connect_cb = Some(cb); - let mut connect_watcher = ConnectRequest::new(); - let connect_handle = connect_watcher.native_handle(); + let connect_handle = ConnectRequest::new().native_handle(); match address { Ipv4(*) => { do ip4_as_uv_ip4(address) |addr| { diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs index ab8aea2b63c4f..62a165b6d7762 100644 --- a/src/libcore/rt/uvio.rs +++ b/src/libcore/rt/uvio.rs @@ -46,8 +46,7 @@ impl Drop for UvEventLoop { let self = unsafe { transmute::<&UvEventLoop, &mut UvEventLoop>(self) }; - let mut uv_loop = self.uvio.uv_loop(); - uv_loop.close(); + self.uvio.uv_loop().close(); } } @@ -189,9 +188,8 @@ impl TcpListener for UvTcpListener { let maybe_stream = if status.is_none() { let mut server_stream_watcher = server_stream_watcher; let mut loop_ = loop_from_watcher(&server_stream_watcher); - let mut client_tcp_watcher = TcpWatcher::new(&mut loop_); - let client_tcp_watcher = client_tcp_watcher.as_stream(); - // XXX: Need's to be surfaced in interface + let client_tcp_watcher = TcpWatcher::new(&mut loop_).as_stream(); + // XXX: Needs to be surfaced in interface server_stream_watcher.accept(client_tcp_watcher); Some(~UvStream::new(client_tcp_watcher)) } else { diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index 19c417dfdfc95..1b4b24cee50f6 100644 --- a/src/libcore/task/spawn.rs +++ b/src/libcore/task/spawn.rs @@ -467,7 +467,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool) /*##################################################################* * Step 1. Get spawner's taskgroup info. *##################################################################*/ - let mut spawner_group: @@mut TCB = + let spawner_group: @@mut TCB = match local_get(OldHandle(spawner), taskgroup_key!()) { None => { // Main task, doing first spawn ever. Lazily initialise diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 75acc2d951138..a61055340777f 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -10,7 +10,6 @@ /*! See doc.rs for a thorough explanation of the borrow checker */ -use core; use core::prelude::*; use mc = middle::mem_categorization; @@ -22,6 +21,7 @@ use middle::dataflow::DataFlowOperator; use util::common::stmt_set; use util::ppaux::{note_and_explain_region, Repr}; +use core; use core::hashmap::{HashSet, HashMap}; use core::io; use core::result::{Result}; diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 0e819c66f094d..e6b9565285dde 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -571,8 +571,6 @@ pub impl mem_categorization_ctxt { } } - /// The `field_id` parameter is the ID of the enclosing expression or - /// pattern. It is used to determine which variant of an enum is in use. fn cat_field(&self, node: N, base_cmt: cmt, diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 5c3bb6ca401a6..2ee029a8f4d21 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -60,7 +60,7 @@ use syntax::ast_util::{def_id_of_def, local_def}; use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method}; use syntax::ast_util::{Privacy, Public, Private}; use syntax::ast_util::{variant_visibility_to_privacy, visibility_to_privacy}; -use syntax::attr::{attr_metas, contains_name, attrs_contains_name}; +use syntax::attr::{attr_metas, contains_name}; use syntax::parse::token::ident_interner; use syntax::parse::token::special_idents; use syntax::print::pprust::path_to_str; diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index 8349e16d2c440..2c5c5ef3807a4 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/src/librustc/middle/typeck/infer/region_inference.rs @@ -544,12 +544,12 @@ use middle::typeck::infer::cres; use util::common::indenter; use util::ppaux::note_and_explain_region; +use core; use core::cell::{Cell, empty_cell}; use core::hashmap::{HashMap, HashSet}; use core::to_bytes; use core::uint; use core::vec; -use core; use syntax::codemap::span; use syntax::ast; diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs index 486e2959e9ed7..d88f3af11fcf0 100644 --- a/src/librustpkg/tests.rs +++ b/src/librustpkg/tests.rs @@ -14,10 +14,8 @@ use context::Ctx; use core::hashmap::HashMap; use core::path::Path; use std::tempfile::mkdtemp; +use path_util::u_rwx; use util::{PkgId, default_version}; -use path_util::{target_executable_in_workspace, target_library_in_workspace, - target_test_in_workspace, target_bench_in_workspace, - make_dir_rwx, u_rwx}; use core::os::mkdir_recursive; fn fake_ctxt(sysroot_opt: Option<@Path>) -> Ctx { @@ -78,96 +76,103 @@ fn is_rwx(p: &Path) -> bool { } #[cfg(test)] -fn test_sysroot() -> Path { - // Totally gross hack but it's just for test cases. - // Infer the sysroot from the exe name and tack "stage2" - // onto it. (Did I mention it was a gross hack?) - let self_path = os::self_exe_path().expect("Couldn't get self_exe path"); - self_path.pop().push("stage2") -} +mod tests { + use path_util::{target_executable_in_workspace, target_library_in_workspace, + target_test_in_workspace, target_bench_in_workspace, + make_dir_rwx}; -#[test] -fn test_make_dir_rwx() { - let temp = &os::tmpdir(); - let dir = temp.push(~"quux"); - assert!(!os::path_exists(&dir) || - os::remove_dir_recursive(&dir)); - debug!("Trying to make %s", dir.to_str()); - assert!(make_dir_rwx(&dir)); - assert!(os::path_is_dir(&dir)); - assert!(is_rwx(&dir)); - assert!(os::remove_dir_recursive(&dir)); -} + #[cfg(test)] + fn test_sysroot() -> Path { + // Totally gross hack but it's just for test cases. + // Infer the sysroot from the exe name and tack "stage2" + // onto it. (Did I mention it was a gross hack?) + let self_path = os::self_exe_path().expect("Couldn't get self_exe path"); + self_path.pop().push("stage2") + } -#[test] -fn test_install_valid() { - let sysroot = test_sysroot(); - debug!("sysroot = %s", sysroot.to_str()); - let ctxt = fake_ctxt(Some(@sysroot)); - let temp_pkg_id = fake_pkg(); - let temp_workspace = mk_temp_workspace(&temp_pkg_id.path); - // should have test, bench, lib, and main - ctxt.install(&temp_workspace, temp_pkg_id); - // Check that all files exist - let exec = target_executable_in_workspace(temp_pkg_id, &temp_workspace); - debug!("exec = %s", exec.to_str()); - assert!(os::path_exists(&exec)); - assert!(is_rwx(&exec)); - let lib = target_library_in_workspace(temp_pkg_id, &temp_workspace); - debug!("lib = %s", lib.to_str()); - assert!(os::path_exists(&lib)); - assert!(is_rwx(&lib)); - // And that the test and bench executables aren't installed - assert!(!os::path_exists(&target_test_in_workspace(temp_pkg_id, &temp_workspace))); - let bench = target_bench_in_workspace(temp_pkg_id, &temp_workspace); - debug!("bench = %s", bench.to_str()); - assert!(!os::path_exists(&bench)); -} + #[test] + fn test_make_dir_rwx() { + let temp = &os::tmpdir(); + let dir = temp.push(~"quux"); + assert!(!os::path_exists(&dir) || + os::remove_dir_recursive(&dir)); + debug!("Trying to make %s", dir.to_str()); + assert!(make_dir_rwx(&dir)); + assert!(os::path_is_dir(&dir)); + assert!(is_rwx(&dir)); + assert!(os::remove_dir_recursive(&dir)); + } -#[test] -fn test_install_invalid() { - use conditions::nonexistent_package::cond; - use cond1 = conditions::missing_pkg_files::cond; - - let ctxt = fake_ctxt(None); - let pkgid = fake_pkg(); - let temp_workspace = mkdtemp(&os::tmpdir(), "test").expect("couldn't create temp dir"); - let mut error_occurred = false; - let mut error1_occurred = false; - do cond1.trap(|_| { - error1_occurred = true; - }).in { - do cond.trap(|_| { - error_occurred = true; + #[test] + fn test_install_valid() { + let sysroot = test_sysroot(); + debug!("sysroot = %s", sysroot.to_str()); + let ctxt = fake_ctxt(Some(@sysroot)); + let temp_pkg_id = fake_pkg(); + let temp_workspace = mk_temp_workspace(&temp_pkg_id.path); + // should have test, bench, lib, and main + ctxt.install(&temp_workspace, temp_pkg_id); + // Check that all files exist + let exec = target_executable_in_workspace(temp_pkg_id, &temp_workspace); + debug!("exec = %s", exec.to_str()); + assert!(os::path_exists(&exec)); + assert!(is_rwx(&exec)); + let lib = target_library_in_workspace(temp_pkg_id, &temp_workspace); + debug!("lib = %s", lib.to_str()); + assert!(os::path_exists(&lib)); + assert!(is_rwx(&lib)); + // And that the test and bench executables aren't installed + assert!(!os::path_exists(&target_test_in_workspace(temp_pkg_id, &temp_workspace))); + let bench = target_bench_in_workspace(temp_pkg_id, &temp_workspace); + debug!("bench = %s", bench.to_str()); + assert!(!os::path_exists(&bench)); + } + + #[test] + fn test_install_invalid() { + use conditions::nonexistent_package::cond; + use cond1 = conditions::missing_pkg_files::cond; + + let ctxt = fake_ctxt(None); + let pkgid = fake_pkg(); + let temp_workspace = mkdtemp(&os::tmpdir(), "test").expect("couldn't create temp dir"); + let mut error_occurred = false; + let mut error1_occurred = false; + do cond1.trap(|_| { + error1_occurred = true; }).in { - ctxt.install(&temp_workspace, pkgid); + do cond.trap(|_| { + error_occurred = true; + }).in { + ctxt.install(&temp_workspace, pkgid); + } } + assert!(error_occurred && error1_occurred); } - assert!(error_occurred && error1_occurred); -} -#[test] -#[ignore(reason = "install from URL-fragment not yet implemented")] -fn test_install_url() { - let sysroot = test_sysroot(); - debug!("sysroot = %s", sysroot.to_str()); - let ctxt = fake_ctxt(Some(@sysroot)); - let temp_pkg_id = remote_pkg(); - let temp_workspace = mk_temp_workspace(&temp_pkg_id.path); - // should have test, bench, lib, and main - ctxt.install(&temp_workspace, temp_pkg_id); - // Check that all files exist - let exec = target_executable_in_workspace(temp_pkg_id, &temp_workspace); - debug!("exec = %s", exec.to_str()); - assert!(os::path_exists(&exec)); - assert!(is_rwx(&exec)); - let lib = target_library_in_workspace(temp_pkg_id, &temp_workspace); - debug!("lib = %s", lib.to_str()); - assert!(os::path_exists(&lib)); - assert!(is_rwx(&lib)); - // And that the test and bench executables aren't installed - assert!(!os::path_exists(&target_test_in_workspace(temp_pkg_id, &temp_workspace))); - let bench = target_bench_in_workspace(temp_pkg_id, &temp_workspace); - debug!("bench = %s", bench.to_str()); - assert!(!os::path_exists(&bench)); -} \ No newline at end of file + #[test] + #[ignore(reason = "install from URL-fragment not yet implemented")] + fn test_install_url() { + let sysroot = test_sysroot(); + debug!("sysroot = %s", sysroot.to_str()); + let ctxt = fake_ctxt(Some(@sysroot)); + let temp_pkg_id = remote_pkg(); + let temp_workspace = mk_temp_workspace(&temp_pkg_id.path); + // should have test, bench, lib, and main + ctxt.install(&temp_workspace, temp_pkg_id); + // Check that all files exist + let exec = target_executable_in_workspace(temp_pkg_id, &temp_workspace); + debug!("exec = %s", exec.to_str()); + assert!(os::path_exists(&exec)); + assert!(is_rwx(&exec)); + let lib = target_library_in_workspace(temp_pkg_id, &temp_workspace); + debug!("lib = %s", lib.to_str()); + assert!(os::path_exists(&lib)); + assert!(is_rwx(&lib)); + // And that the test and bench executables aren't installed + assert!(!os::path_exists(&target_test_in_workspace(temp_pkg_id, &temp_workspace))); + let bench = target_bench_in_workspace(temp_pkg_id, &temp_workspace); + debug!("bench = %s", bench.to_str()); + assert!(!os::path_exists(&bench)); + } +} diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 5e4f708f52fd4..97b6b2ecafc83 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -600,13 +600,6 @@ pub mod writer { use core::vec; // ebml writing - #[cfg(stage0)] - pub struct Encoder { - writer: @io::Writer, - priv mut size_positions: ~[uint], - } - - #[cfg(not(stage0))] pub struct Encoder { writer: @io::Writer, priv size_positions: ~[uint], diff --git a/src/libstd/fileinput.rs b/src/libstd/fileinput.rs index 90774d19595ab..eb1f10fcf69a0 100644 --- a/src/libstd/fileinput.rs +++ b/src/libstd/fileinput.rs @@ -94,8 +94,6 @@ total line count). } */ -#[allow(deprecated_mutable_fields)]; - use core::io::ReaderUtil; /** @@ -212,8 +210,8 @@ impl FileInput { pub fn next_file(&self) -> bool { // No more files - // Compiler whines about "illegal borrow unless pure" for - // files.is_empty() + // unsafe block can be removed after the next snapshot + // (next one after 2013-05-03) if unsafe { self.fi.files.is_empty() } { self.fi.current_reader = None; return false; @@ -326,7 +324,8 @@ impl io::Reader for FileInput { fn eof(&self) -> bool { // we've run out of files, and current_reader is either None or eof. - // compiler whines about illegal borrows for files.is_empty() + // unsafe block can be removed after the next snapshot + // (next one after 2013-05-03) (unsafe { self.fi.files.is_empty() }) && match self.fi.current_reader { None => true, Some(r) => r.eof() } @@ -368,8 +367,7 @@ reading from `stdin`). Fails when attempting to read from a file that can't be opened. */ pub fn input(f: &fn(&str) -> bool) { - let mut i = FileInput::from_args(); - i.each_line(f); + FileInput::from_args().each_line(f); } /** @@ -380,8 +378,7 @@ provided at each call. Fails when attempting to read from a file that can't be opened. */ pub fn input_state(f: &fn(&str, FileInputState) -> bool) { - let mut i = FileInput::from_args(); - i.each_line_state(f); + FileInput::from_args().each_line_state(f); } /** @@ -390,8 +387,7 @@ Iterate over a vector of files (an empty vector implies just `stdin`). Fails when attempting to read from a file that can't be opened. */ pub fn input_vec(files: ~[Option], f: &fn(&str) -> bool) { - let mut i = FileInput::from_vec(files); - i.each_line(f); + FileInput::from_vec(files).each_line(f); } /** @@ -402,8 +398,7 @@ Fails when attempting to read from a file that can't be opened. */ pub fn input_vec_state(files: ~[Option], f: &fn(&str, FileInputState) -> bool) { - let mut i = FileInput::from_vec(files); - i.each_line_state(f); + FileInput::from_vec(files).each_line_state(f); } #[cfg(test)] diff --git a/src/libstd/future.rs b/src/libstd/future.rs index b1b2fa2cd28e1..73627fff8c42c 100644 --- a/src/libstd/future.rs +++ b/src/libstd/future.rs @@ -28,17 +28,12 @@ use core::pipes::recv; use core::task; #[doc = "The future type"] -#[cfg(stage0)] -pub struct Future { - priv mut state: FutureState, -} - -#[doc = "The future type"] -#[cfg(not(stage0))] pub struct Future { priv state: FutureState, } +// n.b. It should be possible to get rid of this. +// Add a test, though -- tjc // FIXME(#2829) -- futures should not be copyable, because they close // over ~fn's that have pipes and so forth within! #[unsafe_destructor] @@ -61,38 +56,6 @@ pub impl Future { } pub impl Future { - #[cfg(stage0)] - fn get_ref<'a>(&'a self) -> &'a A { - /*! - * Executes the future's closure and then returns a borrowed - * pointer to the result. The borrowed pointer lasts as long as - * the future. - */ - unsafe { - { - match self.state { - Forced(ref mut v) => { return cast::transmute(v); } - Evaluating => fail!(~"Recursive forcing of future!"), - Pending(_) => {} - } - } - { - let mut state = Evaluating; - self.state <-> state; - match state { - Forced(_) | Evaluating => fail!(~"Logic error."), - Pending(f) => { - self.state = Forced(f()); - cast::transmute(self.get_ref()) - } - } - } - } - } - - #[cfg(stage1)] - #[cfg(stage2)] - #[cfg(stage3)] fn get_ref<'a>(&'a mut self) -> &'a A { /*! * Executes the future's closure and then returns a borrowed diff --git a/src/libstd/json.rs b/src/libstd/json.rs index c815c9dd48062..2acbcf5c7ec08 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -220,13 +220,6 @@ impl serialize::Encoder for Encoder { } } -#[cfg(stage0)] -pub struct PrettyEncoder { - priv wr: @io::Writer, - priv mut indent: uint, -} - -#[cfg(not(stage0))] pub struct PrettyEncoder { priv wr: @io::Writer, priv indent: uint, @@ -845,12 +838,6 @@ pub fn from_str(s: &str) -> Result { } } -#[cfg(stage0)] -pub struct Decoder { - priv mut stack: ~[Json], -} - -#[cfg(not(stage0))] pub struct Decoder { priv stack: ~[Json], } diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 7e47106977fe3..20e1a272910cc 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -972,19 +972,17 @@ impl io::Reader for TcpSocketBuf { /// Implementation of `io::Reader` trait for a buffered `net::tcp::TcpSocket` impl io::Writer for TcpSocketBuf { pub fn write(&self, data: &[u8]) { - unsafe { - let socket_data_ptr: *TcpSocketData = - &(*((*(self.data)).sock).socket_data); - let w_result = write_common_impl(socket_data_ptr, - vec::slice(data, - 0, - data.len()).to_vec()); - if w_result.is_err() { - let err_data = w_result.get_err(); - debug!( - "ERROR sock_buf as io::writer.writer err: %? %?", - err_data.err_name, err_data.err_msg); - } + let socket_data_ptr: *TcpSocketData = + &(*((*(self.data)).sock).socket_data); + let w_result = write_common_impl(socket_data_ptr, + vec::slice(data, + 0, + data.len()).to_vec()); + if w_result.is_err() { + let err_data = w_result.get_err(); + debug!( + "ERROR sock_buf as io::writer.writer err: %? %?", + err_data.err_name, err_data.err_msg); } } fn seek(&self, dist: int, seek: io::SeekStyle) { diff --git a/src/libstd/num/bigint.rs b/src/libstd/num/bigint.rs index 5762d8639353f..4f8aa04cc025f 100644 --- a/src/libstd/num/bigint.rs +++ b/src/libstd/num/bigint.rs @@ -16,8 +16,6 @@ A BigUint is represented as an array of BigDigits. A BigInt is a combination of BigUint and Sign. */ -#[deny(deprecated_mutable_fields)]; - use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater}; use core::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix}; diff --git a/src/libstd/std.rc b/src/libstd/std.rc index 7d013a20c67d7..46ebc042bc0ef 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -28,9 +28,6 @@ not required in or otherwise suitable for the core library. #[deny(non_camel_case_types)]; -// Allow mutable fields only in stage0. -#[warn(deprecated_mutable_fields)]; - pub mod uv_ll; // General io and system-services modules diff --git a/src/libstd/test.rs b/src/libstd/test.rs index c320bcea77c3b..bb90b7834447c 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -410,9 +410,10 @@ type MonitorMsg = (TestDesc, TestResult); fn run_tests(opts: &TestOpts, tests: ~[TestDescAndFn], callback: @fn(e: TestEvent)) { - let mut filtered_tests = filter_tests(opts, tests); - let filtered_descs = filtered_tests.map(|t| copy t.desc); + let filtered_tests = filter_tests(opts, tests); + let filtered_descs = filtered_tests.map(|t| t.desc); + callback(TeFiltered(filtered_descs)); let (filtered_tests, filtered_benchs) = diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 68c74c2d12b55..3618e5bff0688 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -27,7 +27,6 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv, fld: @ast_fold, orig: @fn(&expr_, span, @ast_fold) -> (expr_, span)) -> (expr_, span) { - let mut cx = cx; match *e { // expr_mac should really be expr_ext or something; it's the // entry-point for all syntax extensions. @@ -113,7 +112,6 @@ pub fn expand_mod_items(extsbox: @mut SyntaxEnv, fld: @ast_fold, orig: @fn(&ast::_mod, @ast_fold) -> ast::_mod) -> ast::_mod { - let mut cx = cx; // Fold the contents first: let module_ = orig(module_, fld); diff --git a/src/libsyntax/ext/pipes/mod.rs b/src/libsyntax/ext/pipes/mod.rs index 85c578bc2ce1a..642f22e973680 100644 --- a/src/libsyntax/ext/pipes/mod.rs +++ b/src/libsyntax/ext/pipes/mod.rs @@ -74,7 +74,7 @@ pub fn expand_proto(cx: @ext_ctxt, _sp: span, id: ast::ident, let rdr = tt_rdr as @reader; let rust_parser = Parser(sess, cfg, rdr.dup()); - let mut proto = rust_parser.parse_proto(cx.str_of(id)); + let proto = rust_parser.parse_proto(cx.str_of(id)); // check for errors visit(proto, cx); diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 0c1e619985d26..46b09aca8b298 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -247,8 +247,8 @@ pub fn parse( let TokenAndSpan {tok: tok, sp: sp} = rdr.peek(); /* we append new items to this while we go */ - while cur_eis.len() > 0u { /* for each Earley Item */ - let mut ei = cur_eis.pop(); + while !cur_eis.is_empty() { /* for each Earley Item */ + let ei = cur_eis.pop(); let idx = ei.idx; let len = ei.elts.len(); diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index 4e29c3dcf183b..acfd18c74de11 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -202,15 +202,14 @@ fn all_whitespace(s: ~str, begin: uint, end: uint) -> bool { fn trim_whitespace_prefix_and_push_line(lines: &mut ~[~str], s: ~str, col: CharPos) { - let mut s1; - let len = str::len(s); + let len = s.len(); // FIXME #3961: Doing bytewise comparison and slicing with CharPos let col = col.to_uint(); - if all_whitespace(s, 0u, uint::min(len, col)) { + let s1 = if all_whitespace(s, 0, uint::min(len, col)) { if col < len { - s1 = str::slice(s, col, len).to_owned(); - } else { s1 = ~""; } - } else { s1 = s; } + str::slice(s, col, len).to_owned() + } else { ~"" } + } else { s }; debug!("pushing line: %s", s1); lines.push(s1); }