---

yaml
---
r: 51134
b: refs/heads/try
c: 3564389
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 706ed6dd532eaf8848e60f4368ad519647a41107
+refs/heads/try: 356438989830d8b9e597096a9d1ea2c7b6aa9af9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/hashmap.rs

@@ -393,10 +393,16 @@ pub mod linear {
         }
     }
 
-    pub impl<K:Hash + IterBytes + Eq,V> LinearMap<K, V> {
+    pub impl<K: Hash + IterBytes + Eq, V> LinearMap<K, V> {
         /// Create an empty LinearMap
         fn new() -> LinearMap<K, V> {
-            linear_map_with_capacity(INITIAL_CAPACITY)
+            LinearMap::with_capacity(INITIAL_CAPACITY)
+        }
+
+        /// Create an empty LinearMap with space for at least `n` elements in
+        /// the hash table.
+        fn with_capacity(capacity: uint) -> LinearMap<K, V> {
+            linear_map_with_capacity(capacity)
         }
 
         /// Reserve space for at least `n` elements in the hash table.
@@ -652,7 +658,15 @@ pub mod linear {
 
     pub impl <T:Hash + IterBytes + Eq> LinearSet<T> {
         /// Create an empty LinearSet
-        fn new() -> LinearSet<T> { LinearSet{map: LinearMap::new()} }
+        fn new() -> LinearSet<T> {
+            LinearSet::with_capacity(INITIAL_CAPACITY)
+        }
+
+        /// Create an empty LinearSet with space for at least `n` elements in
+        /// the hash table.
+        fn with_capacity(capacity: uint) -> LinearSet<T> {
+            LinearSet { map: LinearMap::with_capacity(capacity) }
+        }
 
         /// Reserve space for at least `n` elements in the hash table.
         fn reserve_at_least(&mut self, n: uint) {

branches/try/src/libcore/vec.rs

@@ -560,6 +560,28 @@ pub fn consume<T>(mut v: ~[T], f: &fn(uint, v: T)) {
     }
 }
 
+pub fn consume_reverse<T>(mut v: ~[T], f: &fn(uint, v: T)) {
+    unsafe {
+        do as_mut_buf(v) |p, ln| {
+            let mut i = ln;
+            while i > 0 {
+                i -= 1;
+
+                // NB: This unsafe operation counts on init writing 0s to the
+                // holes we create in the vector. That ensures that, if the
+                // iterator fails then we won't try to clean up the consumed
+                // elements during unwinding
+                let mut x = intrinsics::init();
+                let p = ptr::mut_offset(p, i);
+                x <-> *p;
+                f(i, x);
+            }
+        }
+
+        raw::set_len(&mut v, 0);
+    }
+}
+
 /// Remove the last element from a vector and return it
 pub fn pop<T>(v: &mut ~[T]) -> T {
     let ln = v.len();
@@ -1985,6 +2007,7 @@ pub trait OwnedVector<T> {
     fn truncate(&mut self, newlen: uint);
     fn retain(&mut self, f: &fn(t: &T) -> bool);
     fn consume(self, f: &fn(uint, v: T));
+    fn consume_reverse(self, f: &fn(uint, v: T));
     fn filter(self, f: &fn(t: &T) -> bool) -> ~[T];
     fn partition(self, f: &fn(&T) -> bool) -> (~[T], ~[T]);
     fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
@@ -2046,6 +2069,11 @@ impl<T> OwnedVector<T> for ~[T] {
         consume(self, f)
     }
 
+    #[inline]
+    fn consume_reverse(self, f: &fn(uint, v: T)) {
+        consume_reverse(self, f)
+    }
+
     #[inline]
     fn filter(self, f: &fn(&T) -> bool) -> ~[T] {
         filter(self, f)

branches/try/src/librustc/middle/astencode.rs

@@ -558,7 +558,7 @@ trait read_method_map_entry_helper {
 fn encode_method_map_entry(ecx: @e::EncodeContext,
                               ebml_w: writer::Encoder,
                               mme: method_map_entry) {
-    do ebml_w.emit_rec {
+    do ebml_w.emit_struct("method_map_entry", 3) {
         do ebml_w.emit_field(~"self_arg", 0u) {
             ebml_w.emit_arg(ecx, mme.self_arg);
         }
@@ -574,7 +574,7 @@ fn encode_method_map_entry(ecx: @e::EncodeContext,
 impl read_method_map_entry_helper for reader::Decoder {
     fn read_method_map_entry(&self, xcx: @ExtendedDecodeContext)
         -> method_map_entry {
-        do self.read_rec {
+        do self.read_struct("method_map_entry", 3) {
             method_map_entry {
                 self_arg: self.read_field(~"self_arg", 0u, || {
                     self.read_arg(xcx)
@@ -817,7 +817,7 @@ impl ebml_writer_helpers for writer::Encoder {
 
     fn emit_tpbt(&self, ecx: @e::EncodeContext,
                  tpbt: ty::ty_param_bounds_and_ty) {
-        do self.emit_rec {
+        do self.emit_struct("ty_param_bounds_and_ty", 3) {
             do self.emit_field(~"bounds", 0) {
                 do self.emit_from_vec(*tpbt.bounds) |bs| {
                     self.emit_bounds(ecx, *bs);
@@ -1084,7 +1084,7 @@ impl ebml_decoder_decoder_helpers for reader::Decoder {
     fn read_ty_param_bounds_and_ty(&self, xcx: @ExtendedDecodeContext)
         -> ty::ty_param_bounds_and_ty
     {
-        do self.read_rec {
+        do self.read_struct("ty_param_bounds_and_ty", 3) {
             ty::ty_param_bounds_and_ty {
                 bounds: self.read_field(~"bounds", 0u, || {
                     @self.read_to_vec(|| self.read_bounds(xcx) )

branches/try/src/libstd/ebml.rs

@@ -311,23 +311,10 @@ pub mod reader {
         fn read_f64(&self) -> f64 { fail!(~"read_f64()"); }
         fn read_f32(&self) -> f32 { fail!(~"read_f32()"); }
         fn read_float(&self) -> float { fail!(~"read_float()"); }
-
         fn read_char(&self) -> char { fail!(~"read_char()"); }
-
-        fn read_owned_str(&self) -> ~str { doc_as_str(self.next_doc(EsStr)) }
-        fn read_managed_str(&self) -> @str { fail!(~"read_managed_str()"); }
+        fn read_str(&self) -> ~str { doc_as_str(self.next_doc(EsStr)) }
 
         // Compound types:
-        fn read_owned<T>(&self, f: &fn() -> T) -> T {
-            debug!("read_owned()");
-            f()
-        }
-
-        fn read_managed<T>(&self, f: &fn() -> T) -> T {
-            debug!("read_managed()");
-            f()
-        }
-
         fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T {
             debug!("read_enum(%s)", name);
             self._check_label(name);
@@ -361,34 +348,20 @@ pub mod reader {
             f()
         }
 
-        fn read_owned_vec<T>(&self, f: &fn(uint) -> T) -> T {
-            debug!("read_owned_vec()");
+        fn read_seq<T>(&self, f: &fn(uint) -> T) -> T {
+            debug!("read_seq()");
             do self.push_doc(self.next_doc(EsVec)) {
                 let len = self._next_uint(EsVecLen);
                 debug!("  len=%u", len);
                 f(len)
             }
         }
 
-        fn read_managed_vec<T>(&self, f: &fn(uint) -> T) -> T {
-            debug!("read_managed_vec()");
-            do self.push_doc(self.next_doc(EsVec)) {
-                let len = self._next_uint(EsVecLen);
-                debug!("  len=%u", len);
-                f(len)
-            }
-        }
-
-        fn read_vec_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
-            debug!("read_vec_elt(idx=%u)", idx);
+        fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
+            debug!("read_seq_elt(idx=%u)", idx);
             self.push_doc(self.next_doc(EsVecElt), f)
         }
 
-        fn read_rec<T>(&self, f: &fn() -> T) -> T {
-            debug!("read_rec()");
-            f()
-        }
-
         fn read_struct<T>(&self, name: &str, _len: uint, f: &fn() -> T) -> T {
             debug!("read_struct(name=%s)", name);
             f()
@@ -400,16 +373,6 @@ pub mod reader {
             f()
         }
 
-        fn read_tup<T>(&self, len: uint, f: &fn() -> T) -> T {
-            debug!("read_tup(len=%u)", len);
-            f()
-        }
-
-        fn read_tup_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
-            debug!("read_tup_elt(idx=%u)", idx);
-            f()
-        }
-
         #[cfg(stage0)]
         fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
             debug!("read_option()");
@@ -439,6 +402,21 @@ pub mod reader {
                 }
             }
         }
+
+        fn read_map<T>(&self, _f: &fn(uint) -> T) -> T {
+            debug!("read_map()");
+            fail!(~"read_map is unimplemented");
+        }
+
+        fn read_map_elt_key<T>(&self, idx: uint, _f: &fn() -> T) -> T {
+            debug!("read_map_elt_key(idx=%u)", idx);
+            fail!(~"read_map_elt_val is unimplemented");
+        }
+
+        fn read_map_elt_val<T>(&self, idx: uint, _f: &fn() -> T) -> T {
+            debug!("read_map_elt_val(idx=%u)", idx);
+            fail!(~"read_map_elt_val is unimplemented");
+        }
     }
 }
 
@@ -650,22 +628,10 @@ pub mod writer {
             fail!(~"Unimplemented: serializing a char");
         }
 
-        fn emit_borrowed_str(&self, v: &str) {
+        fn emit_str(&self, v: &str) {
             self.wr_tagged_str(EsStr as uint, v)
         }
 
-        fn emit_owned_str(&self, v: &str) {
-            self.emit_borrowed_str(v)
-        }
-
-        fn emit_managed_str(&self, v: &str) {
-            self.emit_borrowed_str(v)
-        }
-
-        fn emit_borrowed(&self, f: &fn()) { f() }
-        fn emit_owned(&self, f: &fn()) { f() }
-        fn emit_managed(&self, f: &fn()) { f() }
-
         fn emit_enum(&self, name: &str, f: &fn()) {
             self._emit_label(name);
             self.wr_tag(EsEnum as uint, f)
@@ -677,35 +643,23 @@ pub mod writer {
         }
         fn emit_enum_variant_arg(&self, _idx: uint, f: &fn()) { f() }
 
-        fn emit_borrowed_vec(&self, len: uint, f: &fn()) {
+        fn emit_seq(&self, len: uint, f: &fn()) {
             do self.wr_tag(EsVec as uint) {
                 self._emit_tagged_uint(EsVecLen, len);
                 f()
             }
         }
 
-        fn emit_owned_vec(&self, len: uint, f: &fn()) {
-            self.emit_borrowed_vec(len, f)
-        }
-
-        fn emit_managed_vec(&self, len: uint, f: &fn()) {
-            self.emit_borrowed_vec(len, f)
-        }
-
-        fn emit_vec_elt(&self, _idx: uint, f: &fn()) {
+        fn emit_seq_elt(&self, _idx: uint, f: &fn()) {
             self.wr_tag(EsVecElt as uint, f)
         }
 
-        fn emit_rec(&self, f: &fn()) { f() }
         fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) { f() }
         fn emit_field(&self, name: &str, _idx: uint, f: &fn()) {
             self._emit_label(name);
             f()
         }
 
-        fn emit_tup(&self, _len: uint, f: &fn()) { f() }
-        fn emit_tup_elt(&self, _idx: uint, f: &fn()) { f() }
-
         fn emit_option(&self, f: &fn()) {
             self.emit_enum("Option", f);
         }
@@ -715,6 +669,18 @@ pub mod writer {
         fn emit_option_some(&self, f: &fn()) {
             self.emit_enum_variant("Some", 1, 1, f)
         }
+
+        fn emit_map(&self, _len: uint, _f: &fn()) {
+            fail!(~"emit_map is unimplemented");
+        }
+
+        fn emit_map_elt_key(&self, _idx: uint, _f: &fn()) {
+            fail!(~"emit_map_elt_key is unimplemented");
+        }
+
+        fn emit_map_elt_val(&self, _idx: uint, _f: &fn()) {
+            fail!(~"emit_map_elt_val is unimplemented");
+        }
     }
 }
 

branches/try/src/libstd/flatpipes.rs

@@ -466,8 +466,8 @@ pub mod flatteners {
         fn from_writer(w: @Writer) -> Self;
     }
 
-    impl<'self> FromReader for json::Decoder<'self> {
-        fn from_reader(r: @Reader) -> json::Decoder<'self> {
+    impl FromReader for json::Decoder {
+        fn from_reader(r: @Reader) -> json::Decoder {
             match json::from_reader(r) {
                 Ok(json) => {
                     json::Decoder(json)