---

brson · brson · commit ab8236cc4c4b · 2012-09-10T19:02:57.000-07:00
yaml --- r: 32531 b: refs/heads/dist-snap c: 1a8a0a7 h: refs/heads/master i: 32529: 5a2fbc3 32527: 26c582b v: v3
diff --git a/[refs] b/[refs]
@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: f8b3eaae820f87a5d51fe382aef5e9f8256beb29
+refs/heads/dist-snap: 1a8a0a77b14c44d98501cd9fb0f14ed88d4c38d9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
diff --git a/branches/dist-snap/src/libstd/ebml.rs b/branches/dist-snap/src/libstd/ebml.rs
@@ -340,7 +340,7 @@ impl ebml::Writer: SerializerPriv {
     }
 }
 
-impl ebml::Writer: serialization::serializer {
+impl ebml::Writer: serialization::Serializer {
     fn emit_nil() {}
 
     fn emit_uint(v: uint) { self.wr_tagged_u64(EsUint as uint, v as u64); }
@@ -462,7 +462,7 @@ priv impl EbmlDeserializer {
     }
 }
 
-impl EbmlDeserializer: serialization::deserializer {
+impl EbmlDeserializer: serialization::Deserializer {
     fn read_nil() -> () { () }
 
     fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(EsU64)) }
diff --git a/branches/dist-snap/src/libstd/prettyprint.rs b/branches/dist-snap/src/libstd/prettyprint.rs
@@ -3,9 +3,9 @@
 
 use io::Writer;
 use io::WriterUtil;
-use serialization::serializer;
+use serialization::Serializer;
 
-impl Writer: serializer {
+impl Writer: Serializer {
     fn emit_nil() {
         self.write_str(~"()")
     }
diff --git a/branches/dist-snap/src/libstd/serialization.rs b/branches/dist-snap/src/libstd/serialization.rs
@@ -1,12 +1,18 @@
 //! Support code for serialization.
 
-use core;
+// XXX remove
+#[cfg(stage0)]
+#[allow(non_camel_case_types)]
+type serializer = Serializer;
+#[cfg(stage0)]
+#[allow(non_camel_case_types)]
+type deserializer = Deserializer;
 
 /*
 Core serialization interfaces.
 */
 
-trait serializer {
+trait Serializer {
     // Primitive types:
     fn emit_nil();
     fn emit_uint(v: uint);
@@ -39,7 +45,7 @@ trait serializer {
     fn emit_tup_elt(idx: uint, f: fn());
 }
 
-trait deserializer {
+trait Deserializer {
     // Primitive types:
     fn read_nil() -> ();
 
@@ -83,7 +89,7 @@ trait deserializer {
 //
 // In some cases, these should eventually be coded as traits.
 
-fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {
+fn emit_from_vec<S: Serializer, T>(s: S, v: ~[T], f: fn(T)) {
     do s.emit_vec(vec::len(v)) {
         do vec::iteri(v) |i,e| {
             do s.emit_vec_elt(i) {
@@ -93,155 +99,155 @@ fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {
     }
 }
 
-fn read_to_vec<D: deserializer, T: Copy>(d: D, f: fn() -> T) -> ~[T] {
+fn read_to_vec<D: Deserializer, T: Copy>(d: D, f: fn() -> T) -> ~[T] {
     do d.read_vec |len| {
         do vec::from_fn(len) |i| {
             d.read_vec_elt(i, || f())
         }
     }
 }
 
-trait serializer_helpers {
+trait SerializerHelpers {
     fn emit_from_vec<T>(v: ~[T], f: fn(T));
 }
 
-impl<S: serializer> S: serializer_helpers {
+impl<S: Serializer> S: SerializerHelpers {
     fn emit_from_vec<T>(v: ~[T], f: fn(T)) {
         emit_from_vec(self, v, f)
     }
 }
 
-trait deserializer_helpers {
+trait DeserializerHelpers {
     fn read_to_vec<T: Copy>(f: fn() -> T) -> ~[T];
 }
 
-impl<D: deserializer> D: deserializer_helpers {
+impl<D: Deserializer> D: DeserializerHelpers {
     fn read_to_vec<T: Copy>(f: fn() -> T) -> ~[T] {
         read_to_vec(self, f)
     }
 }
 
-fn serialize_uint<S: serializer>(s: S, v: uint) {
+fn serialize_uint<S: Serializer>(s: S, v: uint) {
     s.emit_uint(v);
 }
 
-fn deserialize_uint<D: deserializer>(d: D) -> uint {
+fn deserialize_uint<D: Deserializer>(d: D) -> uint {
     d.read_uint()
 }
 
-fn serialize_u8<S: serializer>(s: S, v: u8) {
+fn serialize_u8<S: Serializer>(s: S, v: u8) {
     s.emit_u8(v);
 }
 
-fn deserialize_u8<D: deserializer>(d: D) -> u8 {
+fn deserialize_u8<D: Deserializer>(d: D) -> u8 {
     d.read_u8()
 }
 
-fn serialize_u16<S: serializer>(s: S, v: u16) {
+fn serialize_u16<S: Serializer>(s: S, v: u16) {
     s.emit_u16(v);
 }
 
-fn deserialize_u16<D: deserializer>(d: D) -> u16 {
+fn deserialize_u16<D: Deserializer>(d: D) -> u16 {
     d.read_u16()
 }
 
-fn serialize_u32<S: serializer>(s: S, v: u32) {
+fn serialize_u32<S: Serializer>(s: S, v: u32) {
     s.emit_u32(v);
 }
 
-fn deserialize_u32<D: deserializer>(d: D) -> u32 {
+fn deserialize_u32<D: Deserializer>(d: D) -> u32 {
     d.read_u32()
 }
 
-fn serialize_u64<S: serializer>(s: S, v: u64) {
+fn serialize_u64<S: Serializer>(s: S, v: u64) {
     s.emit_u64(v);
 }
 
-fn deserialize_u64<D: deserializer>(d: D) -> u64 {
+fn deserialize_u64<D: Deserializer>(d: D) -> u64 {
     d.read_u64()
 }
 
-fn serialize_int<S: serializer>(s: S, v: int) {
+fn serialize_int<S: Serializer>(s: S, v: int) {
     s.emit_int(v);
 }
 
-fn deserialize_int<D: deserializer>(d: D) -> int {
+fn deserialize_int<D: Deserializer>(d: D) -> int {
     d.read_int()
 }
 
-fn serialize_i8<S: serializer>(s: S, v: i8) {
+fn serialize_i8<S: Serializer>(s: S, v: i8) {
     s.emit_i8(v);
 }
 
-fn deserialize_i8<D: deserializer>(d: D) -> i8 {
+fn deserialize_i8<D: Deserializer>(d: D) -> i8 {
     d.read_i8()
 }
 
-fn serialize_i16<S: serializer>(s: S, v: i16) {
+fn serialize_i16<S: Serializer>(s: S, v: i16) {
     s.emit_i16(v);
 }
 
-fn deserialize_i16<D: deserializer>(d: D) -> i16 {
+fn deserialize_i16<D: Deserializer>(d: D) -> i16 {
     d.read_i16()
 }
 
-fn serialize_i32<S: serializer>(s: S, v: i32) {
+fn serialize_i32<S: Serializer>(s: S, v: i32) {
     s.emit_i32(v);
 }
 
-fn deserialize_i32<D: deserializer>(d: D) -> i32 {
+fn deserialize_i32<D: Deserializer>(d: D) -> i32 {
     d.read_i32()
 }
 
-fn serialize_i64<S: serializer>(s: S, v: i64) {
+fn serialize_i64<S: Serializer>(s: S, v: i64) {
     s.emit_i64(v);
 }
 
-fn deserialize_i64<D: deserializer>(d: D) -> i64 {
+fn deserialize_i64<D: Deserializer>(d: D) -> i64 {
     d.read_i64()
 }
 
-fn serialize_str<S: serializer>(s: S, v: &str) {
+fn serialize_str<S: Serializer>(s: S, v: &str) {
     s.emit_str(v);
 }
 
-fn deserialize_str<D: deserializer>(d: D) -> ~str {
+fn deserialize_str<D: Deserializer>(d: D) -> ~str {
     d.read_str()
 }
 
-fn serialize_float<S: serializer>(s: S, v: float) {
+fn serialize_float<S: Serializer>(s: S, v: float) {
     s.emit_float(v);
 }
 
-fn deserialize_float<D: deserializer>(d: D) -> float {
+fn deserialize_float<D: Deserializer>(d: D) -> float {
     d.read_float()
 }
 
-fn serialize_f32<S: serializer>(s: S, v: f32) {
+fn serialize_f32<S: Serializer>(s: S, v: f32) {
     s.emit_f32(v);
 }
 
-fn deserialize_f32<D: deserializer>(d: D) -> f32 {
+fn deserialize_f32<D: Deserializer>(d: D) -> f32 {
     d.read_f32()
 }
 
-fn serialize_f64<S: serializer>(s: S, v: f64) {
+fn serialize_f64<S: Serializer>(s: S, v: f64) {
     s.emit_f64(v);
 }
 
-fn deserialize_f64<D: deserializer>(d: D) -> f64 {
+fn deserialize_f64<D: Deserializer>(d: D) -> f64 {
     d.read_f64()
 }
 
-fn serialize_bool<S: serializer>(s: S, v: bool) {
+fn serialize_bool<S: Serializer>(s: S, v: bool) {
     s.emit_bool(v);
 }
 
-fn deserialize_bool<D: deserializer>(d: D) -> bool {
+fn deserialize_bool<D: Deserializer>(d: D) -> bool {
     d.read_bool()
 }
 
-fn serialize_Option<S: serializer,T>(s: S, v: Option<T>, st: fn(T)) {
+fn serialize_Option<S: Serializer,T>(s: S, v: Option<T>, st: fn(T)) {
     do s.emit_enum(~"option") {
         match v {
           None => do s.emit_enum_variant(~"none", 0u, 0u) {
@@ -256,7 +262,7 @@ fn serialize_Option<S: serializer,T>(s: S, v: Option<T>, st: fn(T)) {
     }
 }
 
-fn deserialize_Option<D: deserializer,T: Copy>(d: D, st: fn() -> T)
+fn deserialize_Option<D: Deserializer,T: Copy>(d: D, st: fn() -> T)
     -> Option<T> {
     do d.read_enum(~"option") {
         do d.read_enum_variant |i| {
diff --git a/branches/dist-snap/src/libstd/std.rc b/branches/dist-snap/src/libstd/std.rc
@@ -91,7 +91,6 @@ mod unicode;
 // Compiler support modules
 
 mod test;
-#[allow(non_camel_case_types)] // XXX
 mod serialization;
 
 // Local Variables:
diff --git a/branches/dist-snap/src/libsyntax/ast.rs b/branches/dist-snap/src/libsyntax/ast.rs
@@ -1,8 +1,8 @@
 // The Rust abstract syntax tree.
 
 use codemap::{span, filename};
-use std::serialization::{serializer,
-                            deserializer,
+use std::serialization::{Serializer,
+                            Deserializer,
                             serialize_Option,
                             deserialize_Option,
                             serialize_uint,
@@ -38,15 +38,15 @@ macro_rules! interner_key (
         (-3 as uint, 0u)))
 )
 
-fn serialize_ident<S: serializer>(s: S, i: ident) {
+fn serialize_ident<S: Serializer>(s: S, i: ident) {
     let intr = match unsafe{task::local_data_get(interner_key!())}{
         None => fail ~"serialization: TLS interner not set up",
         Some(intr) => intr
     };
 
     s.emit_str(*(*intr).get(i));
 }
-fn deserialize_ident<D: deserializer>(d: D) -> ident  {
+fn deserialize_ident<D: Deserializer>(d: D) -> ident  {
     let intr = match unsafe{task::local_data_get(interner_key!())}{
         None => fail ~"deserialization: TLS interner not set up",
         Some(intr) => intr
diff --git a/branches/dist-snap/src/libsyntax/ext/auto_serialize.rs b/branches/dist-snap/src/libsyntax/ext/auto_serialize.rs
@@ -583,7 +583,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
         ast::bound_trait(cx.ty_path(span,
                                     ~[cx.ident_of(~"std"),
                                       cx.ident_of(~"serialization"),
-                                      cx.ident_of(~"serializer")],
+                                      cx.ident_of(~"Serializer")],
                                     ~[]))];
 
     let ser_tps: ~[ast::ty_param] =
@@ -789,7 +789,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
         ast::bound_trait(cx.ty_path(
             span,
             ~[cx.ident_of(~"std"), cx.ident_of(~"serialization"),
-              cx.ident_of(~"deserializer")],
+              cx.ident_of(~"Deserializer")],
             ~[]))];
 
     let deser_tps: ~[ast::ty_param] =
diff --git a/branches/dist-snap/src/libsyntax/parse/token.rs b/branches/dist-snap/src/libsyntax/parse/token.rs
@@ -1,8 +1,8 @@
 use util::interner;
 use util::interner::interner;
 use std::map::{HashMap, str_hash};
-use std::serialization::{serializer,
-                            deserializer,
+use std::serialization::{Serializer,
+                            Deserializer,
                             serialize_uint,
                             deserialize_uint,
                             serialize_i64,
diff --git a/branches/dist-snap/src/rustc/metadata/encoder.rs b/branches/dist-snap/src/rustc/metadata/encoder.rs
@@ -16,8 +16,6 @@ use middle::ty::node_id_to_type;
 use middle::resolve;
 use syntax::ast_map;
 use syntax::attr;
-use std::serialization::serializer;
-use std::ebml::serializer;
 use str::to_bytes;
 use syntax::ast;
 use syntax::diagnostic::span_handler;
diff --git a/branches/dist-snap/src/rustc/middle/astencode.rs b/branches/dist-snap/src/rustc/middle/astencode.rs
@@ -11,11 +11,11 @@ use std::ebml;
 use std::ebml::Writer;
 use std::ebml::get_doc;
 use std::map::HashMap;
-use std::serialization::serializer;
-use std::serialization::deserializer;
-use std::serialization::serializer_helpers;
-use std::serialization::deserializer_helpers;
-use std::prettyprint::serializer;
+use std::serialization::Serializer;
+use std::serialization::Deserializer;
+use std::serialization::SerializerHelpers;
+use std::serialization::DeserializerHelpers;
+use std::prettyprint::Serializer;
 use middle::{ty, typeck};
 use middle::typeck::{method_origin, method_map_entry,
                         serialize_method_map_entry,
@@ -189,7 +189,7 @@ trait def_id_serializer_helpers {
     fn emit_def_id(did: ast::def_id);
 }
 
-impl<S: serializer> S: def_id_serializer_helpers {
+impl<S: Serializer> S: def_id_serializer_helpers {
     fn emit_def_id(did: ast::def_id) {
         ast::serialize_def_id(self, did)
     }
@@ -199,7 +199,7 @@ trait def_id_deserializer_helpers {
     fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id;
 }
 
-impl<D: deserializer> D: def_id_deserializer_helpers {
+impl<D: Deserializer> D: def_id_deserializer_helpers {
 
     fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id {
         let did = ast::deserialize_def_id(self);

Original file line number	Diff line number	Diff line change
`@@ -340,7 +340,7 @@ impl ebml::Writer: SerializerPriv {`
`340`	`340`	`}`
`341`	`341`	`}`
`342`	`342`
`343`		`-impl ebml::Writer: serialization::serializer {`
	`343`	`+impl ebml::Writer: serialization::Serializer {`
`344`	`344`	`fn emit_nil() {}`
`345`	`345`
`346`	`346`	`fn emit_uint(v: uint) { self.wr_tagged_u64(EsUint as uint, v as u64); }`
`@@ -462,7 +462,7 @@ priv impl EbmlDeserializer {`
`462`	`462`	`}`
`463`	`463`	`}`
`464`	`464`
`465`		`-impl EbmlDeserializer: serialization::deserializer {`
	`465`	`+impl EbmlDeserializer: serialization::Deserializer {`
`466`	`466`	`fn read_nil() -> () { () }`
`467`	`467`
`468`	`468`	`fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(EsU64)) }`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,18 @@`
`1`	`1`	`//! Support code for serialization.`
`2`	`2`
`3`		`-use core;`
	`3`	`+// XXX remove`
	`4`	`+#[cfg(stage0)]`
	`5`	`+#[allow(non_camel_case_types)]`
	`6`	`+type serializer = Serializer;`
	`7`	`+#[cfg(stage0)]`
	`8`	`+#[allow(non_camel_case_types)]`
	`9`	`+type deserializer = Deserializer;`
`4`	`10`
`5`	`11`	`/*`
`6`	`12`	`Core serialization interfaces.`
`7`	`13`	`*/`
`8`	`14`
`9`		`-trait serializer {`
	`15`	`+trait Serializer {`
`10`	`16`	`// Primitive types:`
`11`	`17`	`fn emit_nil();`
`12`	`18`	`fn emit_uint(v: uint);`
`@@ -39,7 +45,7 @@ trait serializer {`
`39`	`45`	`fn emit_tup_elt(idx: uint, f: fn());`
`40`	`46`	`}`
`41`	`47`
`42`		`-trait deserializer {`
	`48`	`+trait Deserializer {`
`43`	`49`	`// Primitive types:`
`44`	`50`	`fn read_nil() -> ();`
`45`	`51`
`@@ -83,7 +89,7 @@ trait deserializer {`
`83`	`89`	`//`
`84`	`90`	`// In some cases, these should eventually be coded as traits.`
`85`	`91`
`86`		`-fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {`
	`92`	`+fn emit_from_vec<S: Serializer, T>(s: S, v: ~[T], f: fn(T)) {`
`87`	`93`	`do s.emit_vec(vec::len(v)) {`
`88`	`94`	`do vec::iteri(v) \|i,e\| {`
`89`	`95`	`do s.emit_vec_elt(i) {`
`@@ -93,155 +99,155 @@ fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {`
`93`	`99`	`}`
`94`	`100`	`}`
`95`	`101`
`96`		`-fn read_to_vec<D: deserializer, T: Copy>(d: D, f: fn() -> T) -> ~[T] {`
	`102`	`+fn read_to_vec<D: Deserializer, T: Copy>(d: D, f: fn() -> T) -> ~[T] {`
`97`	`103`	`do d.read_vec \|len\| {`
`98`	`104`	`do vec::from_fn(len) \|i\| {`
`99`	`105`	`d.read_vec_elt(i, \|\| f())`
`100`	`106`	`}`
`101`	`107`	`}`
`102`	`108`	`}`
`103`	`109`
`104`		`-trait serializer_helpers {`
	`110`	`+trait SerializerHelpers {`
`105`	`111`	`fn emit_from_vec<T>(v: ~[T], f: fn(T));`
`106`	`112`	`}`
`107`	`113`
`108`		`-impl<S: serializer> S: serializer_helpers {`
	`114`	`+impl<S: Serializer> S: SerializerHelpers {`
`109`	`115`	`fn emit_from_vec<T>(v: ~[T], f: fn(T)) {`
`110`	`116`	`emit_from_vec(self, v, f)`
`111`	`117`	`}`
`112`	`118`	`}`
`113`	`119`
`114`		`-trait deserializer_helpers {`
	`120`	`+trait DeserializerHelpers {`
`115`	`121`	`fn read_to_vec<T: Copy>(f: fn() -> T) -> ~[T];`
`116`	`122`	`}`
`117`	`123`
`118`		`-impl<D: deserializer> D: deserializer_helpers {`
	`124`	`+impl<D: Deserializer> D: DeserializerHelpers {`
`119`	`125`	`fn read_to_vec<T: Copy>(f: fn() -> T) -> ~[T] {`
`120`	`126`	`read_to_vec(self, f)`
`121`	`127`	`}`
`122`	`128`	`}`
`123`	`129`
`124`		`-fn serialize_uint<S: serializer>(s: S, v: uint) {`
	`130`	`+fn serialize_uint<S: Serializer>(s: S, v: uint) {`
`125`	`131`	`s.emit_uint(v);`
`126`	`132`	`}`
`127`	`133`
`128`		`-fn deserialize_uint<D: deserializer>(d: D) -> uint {`
	`134`	`+fn deserialize_uint<D: Deserializer>(d: D) -> uint {`
`129`	`135`	`d.read_uint()`
`130`	`136`	`}`
`131`	`137`
`132`		`-fn serialize_u8<S: serializer>(s: S, v: u8) {`
	`138`	`+fn serialize_u8<S: Serializer>(s: S, v: u8) {`
`133`	`139`	`s.emit_u8(v);`
`134`	`140`	`}`
`135`	`141`
`136`		`-fn deserialize_u8<D: deserializer>(d: D) -> u8 {`
	`142`	`+fn deserialize_u8<D: Deserializer>(d: D) -> u8 {`
`137`	`143`	`d.read_u8()`
`138`	`144`	`}`
`139`	`145`
`140`		`-fn serialize_u16<S: serializer>(s: S, v: u16) {`
	`146`	`+fn serialize_u16<S: Serializer>(s: S, v: u16) {`
`141`	`147`	`s.emit_u16(v);`
`142`	`148`	`}`
`143`	`149`
`144`		`-fn deserialize_u16<D: deserializer>(d: D) -> u16 {`
	`150`	`+fn deserialize_u16<D: Deserializer>(d: D) -> u16 {`
`145`	`151`	`d.read_u16()`
`146`	`152`	`}`
`147`	`153`
`148`		`-fn serialize_u32<S: serializer>(s: S, v: u32) {`
	`154`	`+fn serialize_u32<S: Serializer>(s: S, v: u32) {`
`149`	`155`	`s.emit_u32(v);`
`150`	`156`	`}`
`151`	`157`
`152`		`-fn deserialize_u32<D: deserializer>(d: D) -> u32 {`
	`158`	`+fn deserialize_u32<D: Deserializer>(d: D) -> u32 {`
`153`	`159`	`d.read_u32()`
`154`	`160`	`}`
`155`	`161`
`156`		`-fn serialize_u64<S: serializer>(s: S, v: u64) {`
	`162`	`+fn serialize_u64<S: Serializer>(s: S, v: u64) {`
`157`	`163`	`s.emit_u64(v);`
`158`	`164`	`}`
`159`	`165`
`160`		`-fn deserialize_u64<D: deserializer>(d: D) -> u64 {`
	`166`	`+fn deserialize_u64<D: Deserializer>(d: D) -> u64 {`
`161`	`167`	`d.read_u64()`
`162`	`168`	`}`
`163`	`169`
`164`		`-fn serialize_int<S: serializer>(s: S, v: int) {`
	`170`	`+fn serialize_int<S: Serializer>(s: S, v: int) {`
`165`	`171`	`s.emit_int(v);`
`166`	`172`	`}`
`167`	`173`
`168`		`-fn deserialize_int<D: deserializer>(d: D) -> int {`
	`174`	`+fn deserialize_int<D: Deserializer>(d: D) -> int {`
`169`	`175`	`d.read_int()`
`170`	`176`	`}`
`171`	`177`
`172`		`-fn serialize_i8<S: serializer>(s: S, v: i8) {`
	`178`	`+fn serialize_i8<S: Serializer>(s: S, v: i8) {`
`173`	`179`	`s.emit_i8(v);`
`174`	`180`	`}`
`175`	`181`
`176`		`-fn deserialize_i8<D: deserializer>(d: D) -> i8 {`
	`182`	`+fn deserialize_i8<D: Deserializer>(d: D) -> i8 {`
`177`	`183`	`d.read_i8()`
`178`	`184`	`}`
`179`	`185`
`180`		`-fn serialize_i16<S: serializer>(s: S, v: i16) {`
	`186`	`+fn serialize_i16<S: Serializer>(s: S, v: i16) {`
`181`	`187`	`s.emit_i16(v);`
`182`	`188`	`}`
`183`	`189`
`184`		`-fn deserialize_i16<D: deserializer>(d: D) -> i16 {`
	`190`	`+fn deserialize_i16<D: Deserializer>(d: D) -> i16 {`
`185`	`191`	`d.read_i16()`
`186`	`192`	`}`
`187`	`193`
`188`		`-fn serialize_i32<S: serializer>(s: S, v: i32) {`
	`194`	`+fn serialize_i32<S: Serializer>(s: S, v: i32) {`
`189`	`195`	`s.emit_i32(v);`
`190`	`196`	`}`
`191`	`197`
`192`		`-fn deserialize_i32<D: deserializer>(d: D) -> i32 {`
	`198`	`+fn deserialize_i32<D: Deserializer>(d: D) -> i32 {`
`193`	`199`	`d.read_i32()`
`194`	`200`	`}`
`195`	`201`
`196`		`-fn serialize_i64<S: serializer>(s: S, v: i64) {`
	`202`	`+fn serialize_i64<S: Serializer>(s: S, v: i64) {`
`197`	`203`	`s.emit_i64(v);`
`198`	`204`	`}`
`199`	`205`
`200`		`-fn deserialize_i64<D: deserializer>(d: D) -> i64 {`
	`206`	`+fn deserialize_i64<D: Deserializer>(d: D) -> i64 {`
`201`	`207`	`d.read_i64()`
`202`	`208`	`}`
`203`	`209`
`204`		`-fn serialize_str<S: serializer>(s: S, v: &str) {`
	`210`	`+fn serialize_str<S: Serializer>(s: S, v: &str) {`
`205`	`211`	`s.emit_str(v);`
`206`	`212`	`}`
`207`	`213`
`208`		`-fn deserialize_str<D: deserializer>(d: D) -> ~str {`
	`214`	`+fn deserialize_str<D: Deserializer>(d: D) -> ~str {`
`209`	`215`	`d.read_str()`
`210`	`216`	`}`
`211`	`217`
`212`		`-fn serialize_float<S: serializer>(s: S, v: float) {`
	`218`	`+fn serialize_float<S: Serializer>(s: S, v: float) {`
`213`	`219`	`s.emit_float(v);`
`214`	`220`	`}`
`215`	`221`
`216`		`-fn deserialize_float<D: deserializer>(d: D) -> float {`
	`222`	`+fn deserialize_float<D: Deserializer>(d: D) -> float {`
`217`	`223`	`d.read_float()`
`218`	`224`	`}`
`219`	`225`
`220`		`-fn serialize_f32<S: serializer>(s: S, v: f32) {`
	`226`	`+fn serialize_f32<S: Serializer>(s: S, v: f32) {`
`221`	`227`	`s.emit_f32(v);`
`222`	`228`	`}`
`223`	`229`
`224`		`-fn deserialize_f32<D: deserializer>(d: D) -> f32 {`
	`230`	`+fn deserialize_f32<D: Deserializer>(d: D) -> f32 {`
`225`	`231`	`d.read_f32()`
`226`	`232`	`}`
`227`	`233`
`228`		`-fn serialize_f64<S: serializer>(s: S, v: f64) {`
	`234`	`+fn serialize_f64<S: Serializer>(s: S, v: f64) {`
`229`	`235`	`s.emit_f64(v);`
`230`	`236`	`}`
`231`	`237`
`232`		`-fn deserialize_f64<D: deserializer>(d: D) -> f64 {`
	`238`	`+fn deserialize_f64<D: Deserializer>(d: D) -> f64 {`
`233`	`239`	`d.read_f64()`
`234`	`240`	`}`
`235`	`241`
`236`		`-fn serialize_bool<S: serializer>(s: S, v: bool) {`
	`242`	`+fn serialize_bool<S: Serializer>(s: S, v: bool) {`
`237`	`243`	`s.emit_bool(v);`
`238`	`244`	`}`
`239`	`245`
`240`		`-fn deserialize_bool<D: deserializer>(d: D) -> bool {`
	`246`	`+fn deserialize_bool<D: Deserializer>(d: D) -> bool {`
`241`	`247`	`d.read_bool()`
`242`	`248`	`}`
`243`	`249`
`244`		`-fn serialize_Option<S: serializer,T>(s: S, v: Option<T>, st: fn(T)) {`
	`250`	`+fn serialize_Option<S: Serializer,T>(s: S, v: Option<T>, st: fn(T)) {`
`245`	`251`	`do s.emit_enum(~"option") {`
`246`	`252`	`match v {`
`247`	`253`	`None => do s.emit_enum_variant(~"none", 0u, 0u) {`
`@@ -256,7 +262,7 @@ fn serialize_Option<S: serializer,T>(s: S, v: Option<T>, st: fn(T)) {`
`256`	`262`	`}`
`257`	`263`	`}`
`258`	`264`
`259`		`-fn deserialize_Option<D: deserializer,T: Copy>(d: D, st: fn() -> T)`
	`265`	`+fn deserialize_Option<D: Deserializer,T: Copy>(d: D, st: fn() -> T)`
`260`	`266`	`-> Option<T> {`
`261`	`267`	`do d.read_enum(~"option") {`
`262`	`268`	`do d.read_enum_variant \|i\| {`