---

yaml
---
r: 143069
b: refs/heads/try2
c: 435fcda
h: refs/heads/master
i:
  143067: 50c77dd
v: v3

Author: blake2-ppc

[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: bb8ca1f52cfa59e0040c2c749a1c46048fc6d48d
+refs/heads/try2: 435fcda5e99ad5944c780f864a550b3211a6ab47
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/fun_treemap.rs

@@ -31,17 +31,10 @@ enum TreeNode<K, V> {
 }
 
 /// Create a treemap
-pub fn init<K: 'static, V: 'static>() -> Treemap<K, V> {
-    @Empty
-}
+pub fn init<K, V>() -> Treemap<K, V> { @Empty }
 
 /// Insert a value into the map
-pub fn insert<K:Eq + Ord + 'static,
-              V:'static>(
-              m: Treemap<K, V>,
-              k: K,
-              v: V)
-              -> Treemap<K, V> {
+pub fn insert<K:Eq + Ord,V>(m: Treemap<K, V>, k: K, v: V) -> Treemap<K, V> {
     @match m {
         @Empty => Node(@k, @v, @Empty, @Empty),
         @Node(kk, vv, left, right) => cond!(
@@ -53,11 +46,7 @@ pub fn insert<K:Eq + Ord + 'static,
 }
 
 /// Find a value based on the key
-pub fn find<K:Eq + Ord + 'static,
-            V:Clone + 'static>(
-            m: Treemap<K, V>,
-            k: K)
-            -> Option<V> {
+pub fn find<K:Eq + Ord,V:Clone>(m: Treemap<K, V>, k: K) -> Option<V> {
     match *m {
         Empty => None,
         Node(kk, v, left, right) => cond!(

branches/try2/src/libextra/list.rs

@@ -25,7 +25,7 @@ pub enum MutList<T> {
 }
 
 /// Create a list from a vector
-pub fn from_vec<T:Clone + 'static>(v: &[T]) -> @List<T> {
+pub fn from_vec<T:Clone>(v: &[T]) -> @List<T> {
     v.rev_iter().fold(@Nil::<T>, |t, h| @Cons((*h).clone(), t))
 }
 
@@ -109,7 +109,7 @@ pub fn head<T:Clone>(ls: @List<T>) -> T {
 }
 
 /// Appends one list to another
-pub fn append<T:Clone + 'static>(l: @List<T>, m: @List<T>) -> @List<T> {
+pub fn append<T:Clone>(l: @List<T>, m: @List<T>) -> @List<T> {
     match *l {
       Nil => return m,
       Cons(ref x, xs) => {

branches/try2/src/libextra/serialize.rs

@@ -423,7 +423,7 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T {
     }
 }
 
-impl<D:Decoder,T:Decodable<D> + 'static> Decodable<D> for @T {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
     fn decode(d: &mut D) -> @T {
         @Decodable::decode(d)
     }
@@ -435,7 +435,7 @@ impl<S:Encoder,T:Encodable<S>> Encodable<S> for @mut T {
     }
 }
 
-impl<D:Decoder,T:Decodable<D> + 'static> Decodable<D> for @mut T {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for @mut T {
     fn decode(d: &mut D) -> @mut T {
         @mut Decodable::decode(d)
     }

branches/try2/src/librustc/metadata/encoder.rs

@@ -1238,9 +1238,8 @@ fn encode_info_for_items(ecx: &EncodeContext,
 
 // Path and definition ID indexing
 
-fn create_index<T:Clone + Hash + IterBytes + 'static>(
-                index: ~[entry<T>])
-                -> ~[@~[entry<T>]] {
+fn create_index<T:Clone + Hash + IterBytes>(index: ~[entry<T>])
+                                            -> ~[@~[entry<T>]] {
     let mut buckets: ~[@mut ~[entry<T>]] = ~[];
     for uint::range(0u, 256u) |_i| { buckets.push(@mut ~[]); };
     for index.iter().advance |elt| {
@@ -1255,10 +1254,9 @@ fn create_index<T:Clone + Hash + IterBytes + 'static>(
     return buckets_frozen;
 }
 
-fn encode_index<T:'static>(
-                ebml_w: &mut writer::Encoder,
-                buckets: ~[@~[entry<T>]],
-                write_fn: &fn(@io::Writer, &T)) {
+fn encode_index<T>(ebml_w: &mut writer::Encoder,
+                   buckets: ~[@~[entry<T>]],
+                   write_fn: &fn(@io::Writer, &T)) {
     let writer = ebml_w.writer;
     ebml_w.start_tag(tag_index);
     let mut bucket_locs: ~[uint] = ~[];

branches/try2/src/librustc/middle/kind.rs

@@ -285,10 +285,6 @@ pub fn check_expr(e: @expr, (cx, v): (Context, visit::vt<Context>)) {
     }
 
     match e.node {
-        expr_unary(_, box(_), interior) => {
-            let interior_type = ty::expr_ty(cx.tcx, interior);
-            let _ = check_durable(cx.tcx, interior_type, interior.span);
-        }
         expr_cast(source, _) => {
             check_cast_for_escaping_regions(cx, source, e);
             match ty::get(ty::expr_ty(cx.tcx, e)).sty {

branches/try2/src/librustc/middle/subst.rs

@@ -79,7 +79,7 @@ impl<T:Subst> Subst for ~[T] {
     }
 }
 
-impl<T:Subst + 'static> Subst for @T {
+impl<T:Subst> Subst for @T {
     fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> @T {
         match self {
             &@ref t => @t.subst(tcx, substs)

branches/try2/src/librustc/middle/ty.rs

@@ -858,7 +858,7 @@ fn mk_rcache() -> creader_cache {
     return @mut HashMap::new();
 }
 
-pub fn new_ty_hash<V:'static>() -> @mut HashMap<t, V> {
+pub fn new_ty_hash<V>() -> @mut HashMap<t, V> {
     @mut HashMap::new()
 }
 

branches/try2/src/libstd/clone.rs

@@ -112,15 +112,15 @@ impl<T: DeepClone> DeepClone for ~T {
 }
 
 // FIXME: #6525: should also be implemented for `T: Send + DeepClone`
-impl<T: Freeze + DeepClone + 'static> DeepClone for @T {
+impl<T: Freeze + DeepClone> DeepClone for @T {
     /// Return a deep copy of the managed box. The `Freeze` trait is required to prevent performing
     /// a deep clone of a potentially cyclical type.
     #[inline]
     fn deep_clone(&self) -> @T { @(**self).deep_clone() }
 }
 
 // FIXME: #6525: should also be implemented for `T: Send + DeepClone`
-impl<T: Freeze + DeepClone + 'static> DeepClone for @mut T {
+impl<T: Freeze + DeepClone> DeepClone for @mut T {
     /// Return a deep copy of the managed box. The `Freeze` trait is required to prevent performing
     /// a deep clone of a potentially cyclical type.
     #[inline]

branches/try2/src/libstd/iterator.rs

@@ -729,6 +729,55 @@ impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T {
     }
 }
 
+/// A trait for iterators that are clonable.
+// FIXME #6967: Dummy A parameter to get around type inference bug
+pub trait ClonableIterator<A> {
+    /// Repeats an iterator endlessly
+    ///
+    /// # Example
+    ///
+    /// ~~~ {.rust}
+    /// let a = Counter::new(1,1).take_(1);
+    /// let mut cy = a.cycle();
+    /// assert_eq!(cy.next(), Some(1));
+    /// assert_eq!(cy.next(), Some(1));
+    /// ~~~
+    fn cycle(self) -> CycleIterator<A, Self>;
+}
+
+impl<A, T: Clone + Iterator<A>> ClonableIterator<A> for T {
+    #[inline]
+    fn cycle(self) -> CycleIterator<A, T> {
+        CycleIterator{orig: self.clone(), iter: self}
+    }
+}
+
+/// An iterator that repeats endlessly
+pub struct CycleIterator<A, T> {
+    priv orig: T,
+    priv iter: T,
+}
+
+impl<A, T: Clone + Iterator<A>> Iterator<A> for CycleIterator<A, T> {
+    #[inline]
+    fn next(&mut self) -> Option<A> {
+        match self.iter.next() {
+            None => { self.iter = self.orig.clone(); self.iter.next() }
+            y => y
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        // the cycle iterator is either empty or infinite
+        match self.orig.size_hint() {
+            sz @ (0, Some(0)) => sz,
+            (0, _) => (0, None),
+            _ => (uint::max_value, None)
+        }
+    }
+}
+
 /// An iterator which strings two iterators together
 // FIXME #6967: Dummy A parameter to get around type inference bug
 pub struct ChainIterator<A, T, U> {

branches/try2/src/libstd/num/num.rs

@@ -446,12 +446,12 @@ pub fn pow_with_uint<T:NumCast+One+Zero+Div<T,T>+Mul<T,T>>(radix: uint, pow: uin
     total
 }
 
-impl<T: Zero + 'static> Zero for @mut T {
+impl<T: Zero> Zero for @mut T {
     fn zero() -> @mut T { @mut Zero::zero() }
     fn is_zero(&self) -> bool { (**self).is_zero() }
 }
 
-impl<T: Zero + 'static> Zero for @T {
+impl<T: Zero> Zero for @T {
     fn zero() -> @T { @Zero::zero() }
     fn is_zero(&self) -> bool { (**self).is_zero() }
 }

branches/try2/src/libstd/rand.rs

@@ -242,7 +242,7 @@ impl<T: Rand> Rand for ~T {
     fn rand<R: Rng>(rng: &mut R) -> ~T { ~rng.gen() }
 }
 
-impl<T: Rand + 'static> Rand for @T {
+impl<T: Rand> Rand for @T {
     #[inline]
     fn rand<R: Rng>(rng: &mut R) -> @T { @rng.gen() }
 }

branches/try2/src/libstd/rt/comm.rs

@@ -9,6 +9,11 @@
 // except according to those terms.
 
 //! Ports and channels.
+//!
+//! XXX: Carefully consider whether the sequentially consistent
+//! atomics here can be converted to acq/rel. I'm not sure they can,
+//! because there is data being transerred in both directions (the payload
+//! goes from sender to receiver and the task pointer goes the other way).
 
 use option::*;
 use cast;

branches/try2/src/libstd/rt/io/net/udp.rs

@@ -30,7 +30,7 @@ impl UdpSocket {
         }
     }
 
-    pub fn recvfrom(&mut self, buf: &mut [u8]) -> Option<(uint, IpAddr)> {
+    pub fn recvfrom(&self, buf: &mut [u8]) -> Option<(uint, IpAddr)> {
         match (**self).recvfrom(buf) {
             Ok((nread, src)) => Some((nread, src)),
             Err(ioerr) => {
@@ -43,7 +43,7 @@ impl UdpSocket {
         }
     }
 
-    pub fn sendto(&mut self, buf: &[u8], dst: IpAddr) {
+    pub fn sendto(&self, buf: &[u8], dst: IpAddr) {
         match (**self).sendto(buf, dst) {
             Ok(_) => (),
             Err(ioerr) => io_error::cond.raise(ioerr),
@@ -61,17 +61,16 @@ pub struct UdpStream {
 }
 
 impl UdpStream {
-    pub fn as_socket<T>(&mut self, f: &fn(&mut UdpSocket) -> T) -> T { f(&mut self.socket) }
+    pub fn as_socket<T>(&self, f: &fn(&UdpSocket) -> T) -> T { f(&self.socket) }
 
     pub fn disconnect(self) -> UdpSocket { self.socket }
 }
 
 impl Reader for UdpStream {
     fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
-        let peer = self.connectedTo;
         do self.as_socket |sock| {
             match sock.recvfrom(buf) {
-                Some((_nread, src)) if src != peer => Some(0),
+                Some((_nread, src)) if src != self.connectedTo => Some(0),
                 Some((nread, _src)) => Some(nread),
                 None => None,
             }
@@ -123,7 +122,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(server_ip) {
-                    Some(ref mut server) => {
+                    Some(server) => {
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -140,7 +139,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(client_ip) {
-                    Some(ref mut client) => client.sendto([99], server_ip),
+                    Some(client) => client.sendto([99], server_ip),
                     None => fail!()
                 }
             }
@@ -155,7 +154,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(server_ip) {
-                    Some(ref mut server) => {
+                    Some(server) => {
                         let mut buf = [0];
                         match server.recvfrom(buf) {
                             Some((nread, src)) => {
@@ -172,7 +171,7 @@ mod test {
 
             do spawntask_immediately {
                 match UdpSocket::bind(client_ip) {
-                    Some(ref mut client) => client.sendto([99], server_ip),
+                    Some(client) => client.sendto([99], server_ip),
                     None => fail!()
                 }
             }

branches/try2/src/libstd/rt/rtio.rs

@@ -50,37 +50,37 @@ pub trait IoFactory {
 
 pub trait RtioTcpListener : RtioSocket {
     fn accept(&mut self) -> Result<~RtioTcpStreamObject, IoError>;
-    fn accept_simultaneously(&mut self);
-    fn dont_accept_simultaneously(&mut self);
+    fn accept_simultaneously(&self);
+    fn dont_accept_simultaneously(&self);
 }
 
 pub trait RtioTcpStream : RtioSocket {
-    fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError>;
-    fn write(&mut self, buf: &[u8]) -> Result<(), IoError>;
-    fn peer_name(&mut self) -> IpAddr;
-    fn control_congestion(&mut self);
-    fn nodelay(&mut self);
-    fn keepalive(&mut self, delay_in_seconds: uint);
-    fn letdie(&mut self);
+    fn read(&self, buf: &mut [u8]) -> Result<uint, IoError>;
+    fn write(&self, buf: &[u8]) -> Result<(), IoError>;
+    fn peer_name(&self) -> IpAddr;
+    fn control_congestion(&self);
+    fn nodelay(&self);
+    fn keepalive(&self, delay_in_seconds: uint);
+    fn letdie(&self);
 }
 
 pub trait RtioSocket {
-    fn socket_name(&mut self) -> IpAddr;
+    fn socket_name(&self) -> IpAddr;
 }
 
 pub trait RtioUdpSocket : RtioSocket {
-    fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError>;
-    fn sendto(&mut self, buf: &[u8], dst: IpAddr) -> Result<(), IoError>;
+    fn recvfrom(&self, buf: &mut [u8]) -> Result<(uint, IpAddr), IoError>;
+    fn sendto(&self, buf: &[u8], dst: IpAddr) -> Result<(), IoError>;
 
-    fn join_multicast(&mut self, multi: IpAddr);
-    fn leave_multicast(&mut self, multi: IpAddr);
+    fn join_multicast(&self, multi: IpAddr);
+    fn leave_multicast(&self, multi: IpAddr);
 
-    fn loop_multicast_locally(&mut self);
-    fn dont_loop_multicast_locally(&mut self);
+    fn loop_multicast_locally(&self);
+    fn dont_loop_multicast_locally(&self);
 
-    fn multicast_time_to_live(&mut self, ttl: int);
-    fn time_to_live(&mut self, ttl: int);
+    fn multicast_time_to_live(&self, ttl: int);
+    fn time_to_live(&self, ttl: int);
 
-    fn hear_broadcasts(&mut self);
-    fn ignore_broadcasts(&mut self);
+    fn hear_broadcasts(&self);
+    fn ignore_broadcasts(&self);
 }