---

yaml
---
r: 81575
b: refs/heads/snap-stage3
c: 023466c
h: refs/heads/master
i:
  81573: b3a4bf9
  81571: c9361a6
  81567: 48c79a3
v: v3

Author: emberian

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6aa556db3b4dbabb36cb0782f0c455cb12bd81ff
+refs/heads/snap-stage3: 023466cccaf2230b6f2beb3e9e9802e6be1f29d9
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/uuid.rs

@@ -66,6 +66,8 @@ use std::rand::Rng;
 use std::cmp::Eq;
 use std::cast::{transmute,transmute_copy};
 
+use serialize::{Encoder, Encodable, Decoder, Decodable};
+
 /// A 128-bit (16 byte) buffer containing the ID
 pub type UuidBytes = [u8, ..16];
 
@@ -486,6 +488,19 @@ impl TotalEq for Uuid {
     }
 }
 
+// FIXME #9845: Test these
+impl<T: Encoder> Encodable<T> for Uuid {
+    fn encode(&self, e: &mut T) {
+        e.emit_str(self.to_hyphenated_str());
+    }
+}
+
+impl<T: Decoder> Decodable<T> for Uuid {
+    fn decode(d: &mut T) -> Uuid {
+        from_str(d.read_str()).unwrap()
+    }
+}
+
 /// Generates a random instance of UUID (V4 conformant)
 impl rand::Rand for Uuid {
     #[inline]

branches/snap-stage3/src/librustdoc/clean.rs

@@ -685,7 +685,6 @@ pub struct Struct {
     struct_type: doctree::StructType,
     generics: Generics,
     fields: ~[Item],
-    fields_stripped: bool,
 }
 
 impl Clean<Item> for doctree::Struct {
@@ -700,7 +699,6 @@ impl Clean<Item> for doctree::Struct {
                 struct_type: self.struct_type,
                 generics: self.generics.clean(),
                 fields: self.fields.clean(),
-                fields_stripped: false,
             }),
         }
     }
@@ -713,15 +711,13 @@ impl Clean<Item> for doctree::Struct {
 pub struct VariantStruct {
     struct_type: doctree::StructType,
     fields: ~[Item],
-    fields_stripped: bool,
 }
 
 impl Clean<VariantStruct> for syntax::ast::struct_def {
     fn clean(&self) -> VariantStruct {
         VariantStruct {
             struct_type: doctree::struct_type_from_def(self),
             fields: self.fields.clean(),
-            fields_stripped: false,
         }
     }
 }
@@ -730,7 +726,6 @@ impl Clean<VariantStruct> for syntax::ast::struct_def {
 pub struct Enum {
     variants: ~[Item],
     generics: Generics,
-    variants_stripped: bool,
 }
 
 impl Clean<Item> for doctree::Enum {
@@ -744,7 +739,6 @@ impl Clean<Item> for doctree::Enum {
             inner: EnumItem(Enum {
                 variants: self.variants.clean(),
                 generics: self.generics.clean(),
-                variants_stripped: false,
             }),
         }
     }

branches/snap-stage3/src/librustdoc/fold.rs

@@ -27,9 +27,7 @@ pub trait DocFolder {
             StructItem(i) => {
                 let mut i = i;
                 let mut foo = ~[]; swap(&mut foo, &mut i.fields);
-                let num_fields = foo.len();
                 i.fields.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
-                i.fields_stripped |= num_fields != i.fields.len();
                 StructItem(i)
             },
             ModuleItem(i) => {
@@ -38,9 +36,7 @@ pub trait DocFolder {
             EnumItem(i) => {
                 let mut i = i;
                 let mut foo = ~[]; swap(&mut foo, &mut i.variants);
-                let num_variants = foo.len();
                 i.variants.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
-                i.variants_stripped |= num_variants != i.variants.len();
                 EnumItem(i)
             },
             TraitItem(i) => {
@@ -77,9 +73,7 @@ pub trait DocFolder {
                     StructVariant(j) => {
                         let mut j = j;
                         let mut foo = ~[]; swap(&mut foo, &mut j.fields);
-                        let num_fields = foo.len();
                         j.fields.extend(&mut foo.move_iter().filter_map(c));
-                        j.fields_stripped |= num_fields != j.fields.len();
                         VariantItem(Variant {kind: StructVariant(j), ..i2})
                     },
                     _ => VariantItem(i2)

branches/snap-stage3/src/librustdoc/html/render.rs

@@ -1265,8 +1265,7 @@ fn render_method(w: &mut io::Writer, meth: &clean::Item, withlink: bool) {
 
 fn item_struct(w: &mut io::Writer, it: &clean::Item, s: &clean::Struct) {
     write!(w, "<pre class='struct'>");
-    render_struct(w, it, Some(&s.generics), s.struct_type, s.fields,
-                  s.fields_stripped, "", true);
+    render_struct(w, it, Some(&s.generics), s.struct_type, s.fields, "", true);
     write!(w, "</pre>");
 
     document(w, it);
@@ -1313,18 +1312,14 @@ fn item_enum(w: &mut io::Writer, it: &clean::Item, e: &clean::Enum) {
                         }
                         clean::StructVariant(ref s) => {
                             render_struct(w, v, None, s.struct_type, s.fields,
-                                          s.fields_stripped, "    ", false);
+                                          "    ", false);
                         }
                     }
                 }
                 _ => unreachable!()
             }
             write!(w, ",\n");
         }
-
-        if e.variants_stripped {
-            write!(w, "    // some variants omitted\n");
-        }
         write!(w, "\\}");
     }
     write!(w, "</pre>");
@@ -1348,7 +1343,6 @@ fn render_struct(w: &mut io::Writer, it: &clean::Item,
                  g: Option<&clean::Generics>,
                  ty: doctree::StructType,
                  fields: &[clean::Item],
-                 fields_stripped: bool,
                  tab: &str,
                  structhead: bool) {
     write!(w, "{}{}{}",
@@ -1374,10 +1368,6 @@ fn render_struct(w: &mut io::Writer, it: &clean::Item,
                     _ => unreachable!()
                 }
             }
-
-            if fields_stripped {
-                write!(w, "    // some fields omitted\n{}", tab);
-            }
             write!(w, "\\}");
         }
         doctree::Tuple | doctree::Newtype => {

branches/snap-stage3/src/librustdoc/passes.rs

@@ -70,13 +70,17 @@ pub fn strip_private(mut crate: clean::Crate) -> plugins::PluginResult {
                     }
                 }
 
-                // These are public-by-default (if the enum/struct was public)
-                clean::VariantItem(*) | clean::StructFieldItem(*) => {
+                // These are public-by-default (if the enum was public)
+                clean::VariantItem(*) => {
                     if i.visibility == Some(ast::private) {
                         return None;
                     }
                 }
 
+                // We show these regardless of whether they're public/private
+                // because it's useful to see sometimes
+                clean::StructFieldItem(*) => {}
+
                 // handled below
                 clean::ModuleItem(*) => {}
 

branches/snap-stage3/src/librustdoc/rustdoc.rs

@@ -48,7 +48,7 @@ pub mod passes;
 pub mod plugins;
 pub mod visit_ast;
 
-pub static SCHEMA_VERSION: &'static str = "0.8.1";
+pub static SCHEMA_VERSION: &'static str = "0.8.0";
 
 type Pass = (&'static str,                                      // name
              extern fn(clean::Crate) -> plugins::PluginResult,  // fn