Merge remote-tracking branch 'remotes/origin/incoming' into serial

diff --cc src/librustc/middle/astencode.rs
Simple merge

diff --cc src/libstd/ebml.rs
index ffb8dfd6e83cb2e2eef2afeb4b97e9f052dca2af,484220776c3d5772ba967d1c0b130ec707256df3..646f2ce6a84403239987c06cf0a3942d91c39a83
--- 1/src/libstd/ebml.rs
--- 2/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@@ -373,23 -387,16 +360,6 @@@ pub mod reader 
              f()
          }
  
-         #[cfg(stage0)]
-         fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
-             debug!("read_option()");
-             do self.read_enum("Option") || {
-                 do self.read_enum_variant |idx| {
-                     match idx {
-                         0 => f(false),
-                         1 => f(true),
-                         _ => fail!(),
-                     }
-                 }
-             }
 -        fn read_tup<T>(&self, len: uint, f: &fn() -> T) -> T {
 -            debug!("read_tup(len=%u)", len);
 -            f()
--        }
--
-         #[cfg(stage1)]
-         #[cfg(stage2)]
-         #[cfg(stage3)]
 -        fn read_tup_elt<T>(&self, idx: uint, f: &fn() -> T) -> T {
 -            debug!("read_tup_elt(idx=%u)", idx);
 -            f()
 -        }
 -
          fn read_option<T>(&self, f: &fn(bool) -> T) -> T {
              debug!("read_option()");
              do self.read_enum("Option") || {

diff --cc src/libstd/json.rs
index d26c1606a5e5c754db81260058c92feab8a3913f,190d2d3fe0b5662a2922dd9ddc8cdda599d52023..d12488ed01fa7225d43038cdfbbf47d10b063744
--- 1/src/libstd/json.rs
--- 2/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@@ -803,35 -854,14 +803,22 @@@ impl serialize::Decoder for Decoder 
          f()
      }
  
-     #[cfg(stage0)]
-     fn read_enum_variant<T>(&self, f: &fn(uint) -> T) -> T {
-         debug!("read_enum_variant()");
-         let idx = match self.stack.pop() {
-             Null => { self.stack.push(Null); 0 },
-             value => { self.stack.push(value); 1 },
-         };
-         f(idx)
-     }
- 
-     #[cfg(stage1)]
-     #[cfg(stage2)]
-     #[cfg(stage3)]
      fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T {
          debug!("read_enum_variant(names=%?)", names);
 -        let name = match *self.peek() {
 -            String(ref s) => s,
 -            List([String(ref s), .. _]) => s,
 +        let name = match self.stack.pop() {
 +            String(s) => s,
 +            List(list) => {
 +                do vec::consume_reverse(list) |_i, v| {
 +                    self.stack.push(v);
 +                }
 +                match self.stack.pop() {
 +                    String(s) => s,
 +                    value => fail!(fmt!("invalid variant name: %?", value)),
 +                }
 +            }
              ref json => fail!(fmt!("invalid variant: %?", *json)),
          };
 -        let idx = match vec::position(names, |n| str::eq_slice(*n, *name)) {
 +        let idx = match vec::position(names, |n| str::eq_slice(*n, name)) {
              Some(idx) => idx,
              None => fail!(fmt!("Unknown variant name: %?", name)),
          };

diff --cc src/libstd/serialize.rs
index dd487218fe550fa0e208d5087b274135d648b012,8e7ab318e1739a19ccbc5b3dbbe6b4f7d1bcf02a..9e21d1f980d96fabab180f1095a2d1035da4379f
--- 1/src/libstd/serialize.rs
--- 2/src/libstd/serialize.rs
+++ b/src/libstd/serialize.rs
@@@ -83,17 -92,19 +83,12 @@@ pub trait Decoder 
  
      // Compound types:
      fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T;
-     #[cfg(stage0)]
-     fn read_enum_variant<T>(&self, f: &fn(uint) -> T) -> T;
-     #[cfg(stage1)]
-     #[cfg(stage2)]
-     #[cfg(stage3)]
 -
      fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T;
 -
      fn read_enum_variant_arg<T>(&self, idx: uint, f: &fn() -> T) -> T;
  
 -    fn read_owned<T>(&self, f: &fn() -> T) -> T;
 -    fn read_managed<T>(&self, f: &fn() -> T) -> T;
 -
 -    fn read_owned_vec<T>(&self, f: &fn(uint) -> T) -> T;
 -    fn read_managed_vec<T>(&self, f: &fn(uint) -> T) -> T;
 -    fn read_vec_elt<T>(&self, idx: uint, f: &fn() -> T) -> T;
 +    fn read_seq<T>(&self, f: &fn(uint) -> T) -> T;
 +    fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T;
  
 -    fn read_rec<T>(&self, f: &fn() -> T) -> T;
      fn read_struct<T>(&self, name: &str, _len: uint, f: &fn() -> T) -> T;
      fn read_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T;
  
@@@ -536,58 -544,6 +531,41 @@@ impl
      }
  }
  
-     #[cfg(stage0)]
-     fn decode(d: &D) -> LinearMap<K, V> {
-         do d.read_map |len| {
-             let mut map = LinearMap::new();
-             map.reserve_at_least(len);
-             for uint::range(0, len) |i| {
-                 let key = d.read_map_elt_key(i, || Decodable::decode(d));
-                 let val = d.read_map_elt_val(i, || Decodable::decode(d));
-                 map.insert(key, val);
-             }
-             map
-         }
-     }
- 
-     #[cfg(stage1)]
-     #[cfg(stage2)]
-     #[cfg(stage3)]
 +impl<
 +    E: Encoder,
 +    K: Encodable<E> + Hash + IterBytes + Eq,
 +    V: Encodable<E>
 +> Encodable<E> for LinearMap<K, V> {
 +    fn encode(&self, e: &E) {
 +        do e.emit_map(self.len()) {
 +            let mut i = 0;
 +            for self.each |&(key, val)| {
 +                e.emit_map_elt_key(i, || key.encode(e));
 +                e.emit_map_elt_val(i, || val.encode(e));
 +                i += 1;
 +            }
 +        }
 +    }
 +}
 +
 +impl<
 +    D: Decoder,
 +    K: Decodable<D> + Hash + IterBytes + Eq,
 +    V: Decodable<D>
 +> Decodable<D> for LinearMap<K, V> {
 +    fn decode(d: &D) -> LinearMap<K, V> {
 +        do d.read_map |len| {
 +            let mut map = LinearMap::with_capacity(len);
 +            for uint::range(0, len) |i| {
 +                let key = d.read_map_elt_key(i, || Decodable::decode(d));
 +                let val = d.read_map_elt_val(i, || Decodable::decode(d));
 +                map.insert(key, val);
 +            }
 +            map
 +        }
 +    }
 +}
 +
  // ___________________________________________________________________________
  // Helper routines
  //

diff --cc src/libsyntax/ext/auto_encode.rs
index de01d25844924cb4572a0f7688f427296061681d,d7e0e9aa550143db69e0c5bc16eafdd19b5a11c5..52bb4110082a36ee569ff71301a396d54376de5b
--- 1/src/libsyntax/ext/auto_encode.rs
--- 2/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@@ -1280,16 -1304,6 +1280,16 @@@ mod test 
              self.add_to_log(CallToEmitOptionSome);
              f();
          }
-         fn read_map<T>(&self, f: &fn(uint) -> T) -> T {
 +
-         fn read_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T {
++        fn emit_map<T>(&self, f: &fn(uint) -> T) -> T {
 +            self.add_unknown_to_log(); f(0);
 +        }
-         fn read_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T {
++        fn emit_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T {
 +            self.add_unknown_to_log(); f();
 +        }
++        fn emit_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T {
 +            self.add_unknown_to_log(); f();
 +        }
      }