syntax: add {read,emit}_enum_struct_variant{,_field}

src/libstd/ebml.rs

@@ -335,6 +335,20 @@ pub mod reader {
             f()
         }
 
+        fn read_enum_struct_variant<T>(&self, _names: &[&str], f: &fn(uint) -> T) -> T {
+            debug!("read_enum_struct_variant()");
+            let idx = self._next_uint(EsEnumVid);
+            debug!("  idx=%u", idx);
+            do self.push_doc(self.next_doc(EsEnumBody)) {
+                f(idx)
+            }
+        }
+
+        fn read_enum_struct_variant_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
+            debug!("read_enum_struct_variant_arg(name=%?, idx=%u)", name, idx);
+            f()
+        }
+
         fn read_struct<T>(&self, name: &str, _len: uint, f: &fn() -> T) -> T {
             debug!("read_struct(name=%s)", name);
             f()
@@ -636,13 +650,23 @@ pub mod writer {
             self._emit_label(name);
             self.wr_tag(EsEnum as uint, f)
         }
+
         fn emit_enum_variant(&self, _v_name: &str, v_id: uint, _cnt: uint,
                              f: &fn()) {
             self._emit_tagged_uint(EsEnumVid, v_id);
             self.wr_tag(EsEnumBody as uint, f)
         }
+
         fn emit_enum_variant_arg(&self, _idx: uint, f: &fn()) { f() }
 
+        fn emit_enum_struct_variant(&self, v_name: &str, v_id: uint, cnt: uint, f: &fn()) {
+            self.emit_enum_variant(v_name, v_id, cnt, f)
+        }
+
+        fn emit_enum_struct_variant_field(&self, _f_name: &str, idx: uint, f: &fn()) {
+            self.emit_enum_variant_arg(idx, f)
+        }
+
         fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) { f() }
         #[cfg(stage0)]
         fn emit_field(&self, name: &str, _idx: uint, f: &fn()) {

src/libstd/json.rs

@@ -109,6 +109,7 @@ impl serialize::Encoder for Encoder {
     fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)) }
 
     fn emit_enum(&self, _name: &str, f: &fn()) { f() }
+
     fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) {
         // enums are encoded as strings or vectors:
         // Bunny => "Bunny"
@@ -126,10 +127,18 @@ impl serialize::Encoder for Encoder {
     }
 
     fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
-        if (idx != 0) {self.wr.write_char(',');}
+        if idx != 0 {self.wr.write_char(',');}
         f();
     }
 
+    fn emit_enum_struct_variant(&self, name: &str, id: uint, cnt: uint, f: &fn()) {
+        self.emit_enum_variant(name, id, cnt, f)
+    }
+
+    fn emit_enum_struct_variant_field(&self, _field: &str, idx: uint, f: &fn()) {
+        self.emit_enum_variant_arg(idx, f)
+    }
+
     fn emit_struct(&self, _name: &str, _len: uint, f: &fn()) {
         self.wr.write_char('{');
         f();
@@ -232,6 +241,7 @@ impl serialize::Encoder for PrettyEncoder {
     fn emit_str(&self, v: &str) { self.wr.write_str(escape_str(v)); }
 
     fn emit_enum(&self, _name: &str, f: &fn()) { f() }
+
     fn emit_enum_variant(&self, name: &str, _id: uint, cnt: uint, f: &fn()) {
         if cnt == 0 {
             self.wr.write_str(escape_str(name));
@@ -249,6 +259,7 @@ impl serialize::Encoder for PrettyEncoder {
             self.wr.write_char(']');
         }
     }
+
     fn emit_enum_variant_arg(&self, idx: uint, f: &fn()) {
         if idx != 0 {
             self.wr.write_str(",\n");
@@ -257,6 +268,15 @@ impl serialize::Encoder for PrettyEncoder {
         f()
     }
 
+    fn emit_enum_struct_variant(&self, name: &str, id: uint, cnt: uint, f: &fn()) {
+        self.emit_enum_variant(name, id, cnt, f)
+    }
+
+    fn emit_enum_struct_variant_field(&self, _field: &str, idx: uint, f: &fn()) {
+        self.emit_enum_variant_arg(idx, f)
+    }
+
+
     fn emit_struct(&self, _name: &str, len: uint, f: &fn()) {
         if len == 0 {
             self.wr.write_str("{}");
@@ -864,6 +884,17 @@ impl serialize::Decoder for Decoder {
         f()
     }
 
+    fn read_enum_struct_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T {
+        debug!("read_enum_struct_variant(names=%?)", names);
+        self.read_enum_variant(names, f)
+    }
+
+
+    fn read_enum_struct_variant_field<T>(&self, name: &str, idx: uint, f: &fn() -> T) -> T {
+        debug!("read_enum_struct_variant_field(name=%?, idx=%u)", name, idx);
+        self.read_enum_variant_arg(idx, f)
+    }
+
     fn read_struct<T>(&self, name: &str, len: uint, f: &fn() -> T) -> T {
         debug!("read_struct(name=%s, len=%u)", name, len);
         let value = f();

src/libstd/serialize.rs

@@ -45,8 +45,12 @@ pub trait Encoder {
 
     // Compound types:
     fn emit_enum(&self, name: &str, f: &fn());
-    fn emit_enum_variant(&self, v_name: &str, v_id: uint, sz: uint, f: &fn());
-    fn emit_enum_variant_arg(&self, idx: uint, f: &fn());
+
+    fn emit_enum_variant(&self, v_name: &str, v_id: uint, len: uint, f: &fn());
+    fn emit_enum_variant_arg(&self, a_idx: uint, f: &fn());
+
+    fn emit_enum_struct_variant(&self, v_name: &str, v_id: uint, len: uint, f: &fn());
+    fn emit_enum_struct_variant_field(&self, f_name: &str, f_idx: uint, f: &fn());
 
     fn emit_struct(&self, name: &str, len: uint, f: &fn());
     #[cfg(stage0)]
@@ -97,8 +101,12 @@ pub trait Decoder {
 
     // Compound types:
     fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T;
+
     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_enum_variant_arg<T>(&self, a_idx: uint, f: &fn() -> T) -> T;
+
+    fn read_enum_struct_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T;
+    fn read_enum_struct_variant_field<T>(&self, &f_name: &str, f_idx: uint, f: &fn() -> T) -> T;
 
     fn read_struct<T>(&self, s_name: &str, len: uint, f: &fn() -> T) -> T;
     #[cfg(stage0)]

src/libsyntax/ext/auto_encode.rs

@@ -1253,6 +1253,14 @@ mod test {
             self.add_to_log(CallToEmitEnumVariantArg (idx)); f();
         }
 
+        fn emit_enum_struct_variant(&self, name: &str, id: uint, cnt: uint, f: &fn()) {
+            self.emit_enum_variant(name, id, cnt, f)
+        }
+
+        fn emit_enum_struct_variant_field(&self, _name: &str, idx: uint, f: &fn()) {
+            self.emit_enum_variant_arg(idx, f)
+        }
+
         fn emit_struct(&self, name: &str, +len: uint, f: &fn()) {
             self.add_to_log(CallToEmitStruct (name.to_str(),len)); f();
         }