---

yaml
---
r: 140719
b: refs/heads/try2
c: ed41864
h: refs/heads/master
i:
  140717: ca162df
  140715: a0a8e0c
  140711: abc5ad1
  140703: 9ae0c1d
v: v3

Author: catamorphism

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 35e6ce548f2008331c0fa50f1cff30ab7b412ab7
+refs/heads/try2: ed4186446492e141a4dc37829dc9599133d00dd0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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");

branches/try2/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<T: Owned> GenericChan<T> for Chan<T> {
     #[inline(always)]
     fn send(&self, x: T) {
         unsafe {
-            let mut self_endp = transmute_mut(&self.endp);
+            let self_endp = transmute_mut(&self.endp);
             let endp = replace(self_endp, None);
             *self_endp = Some(streamp::client::data(endp.unwrap(), x))
         }
@@ -161,7 +160,7 @@ impl<T: Owned> GenericSmartChan<T> for Chan<T> {
     #[inline(always)]
     fn try_send(&self, x: T) -> bool {
         unsafe {
-            let mut self_endp = transmute_mut(&self.endp);
+            let self_endp = transmute_mut(&self.endp);
             let endp = replace(self_endp, None);
             match streamp::client::try_data(endp.unwrap(), x) {
                 Some(next) => {
@@ -178,7 +177,7 @@ impl<T: Owned> GenericPort<T> for Port<T> {
     #[inline(always)]
     fn recv(&self) -> T {
         unsafe {
-            let mut self_endp = transmute_mut(&self.endp);
+            let self_endp = transmute_mut(&self.endp);
             let endp = replace(self_endp, None);
             let streamp::data(x, endp) = recv(endp.unwrap());
             *self_endp = Some(endp);
@@ -189,7 +188,7 @@ impl<T: Owned> GenericPort<T> for Port<T> {
     #[inline(always)]
     fn try_recv(&self) -> Option<T> {
         unsafe {
-            let mut self_endp = transmute_mut(&self.endp);
+            let self_endp = transmute_mut(&self.endp);
             let endp = replace(self_endp, None);
             match try_recv(endp.unwrap()) {
                 Some(streamp::data(x, endp)) => {
@@ -206,7 +205,7 @@ impl<T: Owned> Peekable<T> for Port<T> {
     #[inline(always)]
     fn peek(&self) -> bool {
         unsafe {
-            let mut self_endp = transmute_mut(&self.endp);
+            let self_endp = transmute_mut(&self.endp);
             let mut endp = replace(self_endp, None);
             let peek = match endp {
                 Some(ref mut endp) => peek(endp),
@@ -220,12 +219,10 @@ impl<T: Owned> Peekable<T> for Port<T> {
 
 impl<T: Owned> Selectable for Port<T> {
     fn header(&mut self) -> *mut PacketHeader {
-        unsafe {
             match self.endp {
                 Some(ref mut endp) => endp.header(),
                 None => fail!(~"peeking empty stream")
             }
-        }
     }
 }
 
@@ -259,7 +256,7 @@ pub impl<T: Owned> PortSet<T> {
 impl<T:Owned> GenericPort<T> for PortSet<T> {
     fn try_recv(&self) -> Option<T> {
         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.
@@ -351,7 +348,7 @@ pub mod oneshot {
     pub fn init<T: Owned>() -> (client::Oneshot<T>, server::Oneshot<T>) {
         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::<Oneshot<T>>()

branches/try2/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");

branches/try2/src/libcore/old_iter.rs

@@ -93,7 +93,7 @@ pub trait CopyableNonstrictIter<A:Copy> {
     // Like "each", but copies out the value. If the receiver is mutated while
     // iterating over it, the semantics must not be memory-unsafe but are
     // otherwise undefined.
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool;
+    fn each_val(&const self, f: &fn(A) -> bool);
 }
 
 // A trait for sequences that can be built by imperatively pushing elements

branches/try2/src/libcore/pipes.rs

@@ -348,7 +348,7 @@ pub fn send<T,Tbuffer>(mut p: SendPacketBuffered<T,Tbuffer>,
                        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());
@@ -405,10 +405,8 @@ a message, or `Some(T)` if a message was received.
 */
 pub fn try_recv<T:Owned,Tbuffer:Owned>(mut p: RecvPacketBuffered<T, Tbuffer>)
                                        -> Option<T> {
-    let mut p_ = p.unwrap();
-    let mut p = unsafe {
-        &mut *p_
-    };
+    let p_ = p.unwrap();
+    let p = unsafe { &mut *p_ };
 
     do (|| {
         try_recv_(p)

branches/try2/src/libcore/reflect.rs

@@ -409,7 +409,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
                                 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<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
                                                  n_fields, name) {
             return false;
         }
-        self.inner.pop_ptr(); // NOTE remove after next snapshot
         true
     }
 

branches/try2/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| {

branches/try2/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 {

branches/try2/src/libcore/task/spawn.rs

@@ -472,7 +472,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

branches/try2/src/libcore/vec.rs

@@ -2945,37 +2945,34 @@ impl<A:Copy + Ord> old_iter::CopyableOrderedIter<A> for @[A] {
 }
 
 impl<'self,A:Copy> old_iter::CopyableNonstrictIter<A> for &'self [A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
+    fn each_val(&const self, f: &fn(A) -> bool) {
         let mut i = 0;
         while i < self.len() {
-            if !f(copy self[i]) { return false; }
+            if !f(copy self[i]) { break; }
             i += 1;
         }
-        return true;
     }
 }
 
 // FIXME(#4148): This should be redundant
 impl<A:Copy> old_iter::CopyableNonstrictIter<A> for ~[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
+    fn each_val(&const self, f: &fn(A) -> bool) {
         let mut i = 0;
         while i < uniq_len(self) {
-            if !f(copy self[i]) { return false; }
+            if !f(copy self[i]) { break; }
             i += 1;
         }
-        return true;
     }
 }
 
 // FIXME(#4148): This should be redundant
 impl<A:Copy> old_iter::CopyableNonstrictIter<A> for @[A] {
-    fn each_val(&const self, f: &fn(A) -> bool) -> bool {
+    fn each_val(&const self, f: &fn(A) -> bool) {
         let mut i = 0;
         while i < self.len() {
-            if !f(copy self[i]) { return false; }
+            if !f(copy self[i]) { break; }
             i += 1;
         }
-        return true;
     }
 }
 
@@ -4691,14 +4688,4 @@ mod tests {
             i += 1;
         }
     }
-
-    #[test]
-    fn test_each_val() {
-        use old_iter::CopyableNonstrictIter;
-        let mut i = 0;
-        for [1, 2, 3].each_val |v| {
-            i += v;
-        }
-        assert!(i == 6);
-    }
 }

branches/try2/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};

branches/try2/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<N:ast_node>(&self,
                              node: N,
                              base_cmt: cmt,

branches/try2/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;

branches/try2/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;
 

branches/try2/src/libstd/ebml.rs

@@ -634,13 +634,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],

branches/try2/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;
@@ -337,7 +335,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() }
 
@@ -380,8 +379,7 @@ Fails when attempting to read from a file that can't be opened.
 */
 #[cfg(stage0)]
 pub fn input(f: &fn(&str) -> bool) {
-    let mut i = FileInput::from_args();
-    i.each_line(f);
+    FileInput::from_args().each_line(f);
 }
 /**
 Iterate directly over the command line arguments (no arguments implies
@@ -404,8 +402,7 @@ Fails when attempting to read from a file that can't be opened.
 */
 #[cfg(stage0)]
 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);
 }
 /**
 Iterate directly over the command line arguments (no arguments
@@ -427,8 +424,7 @@ Fails when attempting to read from a file that can't be opened.
 */
 #[cfg(stage0)]
 pub fn input_vec(files: ~[Option<Path>], f: &fn(&str) -> bool) {
-    let mut i = FileInput::from_vec(files);
-    i.each_line(f);
+    FileInput::from_vec(files).each_line(f);
 }
 /**
 Iterate over a vector of files (an empty vector implies just `stdin`).
@@ -450,8 +446,7 @@ Fails when attempting to read from a file that can't be opened.
 #[cfg(stage0)]
 pub fn input_vec_state(files: ~[Option<Path>],
                        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);
 }
 /**
 Iterate over a vector of files (an empty vector implies just `stdin`)