---

yaml
---
r: 145915
b: refs/heads/try2
c: b571039
h: refs/heads/master
i:
  145913: 40748bb
  145911: dfa6423
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: a6d7fe6209bb31cc46ec5ba60e16b789b5c91914
+refs/heads/try2: b571039021e031888cea4e0b53d8f9b4e81c6d31
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial.md

@@ -2811,7 +2811,7 @@ For every crate you can define a number of metadata items, such as link name, ve
 You can also toggle settings that have crate-global consequences. Both mechanism
 work by providing attributes in the crate root.
 
-For example, Rust uniquely identifies crates by their link metadate, which includes
+For example, Rust uniquely identifies crates by their link metadata, which includes
 the link name and the version. It also hashes the filename and the symbols in a binary
 based on the link metadata, allowing you to use two different versions of the same library in a crate
 without conflict.
@@ -2916,7 +2916,7 @@ As well as this line into every module body:
 use std::prelude::*;
 ~~~
 
-The role of the `prelude` module is to re-exports common definitions from `std`.
+The role of the `prelude` module is to re-export common definitions from `std`.
 
 This allows you to use common types and functions like `Option<T>` or `println`
 without needing to import them. And if you need something from `std` that's not in the prelude,

branches/try2/src/librustdoc/clean.rs

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

branches/try2/src/librustdoc/fold.rs

@@ -27,7 +27,9 @@ 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) => {
@@ -36,7 +38,9 @@ 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) => {
@@ -73,7 +77,9 @@ 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/try2/src/librustdoc/html/render.rs

@@ -1265,7 +1265,8 @@ 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, "", true);
+    render_struct(w, it, Some(&s.generics), s.struct_type, s.fields,
+                  s.fields_stripped, "", true);
     write!(w, "</pre>");
 
     document(w, it);
@@ -1312,14 +1313,18 @@ 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,
-                                          "    ", false);
+                                          s.fields_stripped, "    ", false);
                         }
                     }
                 }
                 _ => unreachable!()
             }
             write!(w, ",\n");
         }
+
+        if e.variants_stripped {
+            write!(w, "    // some variants omitted\n");
+        }
         write!(w, "\\}");
     }
     write!(w, "</pre>");
@@ -1343,6 +1348,7 @@ 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, "{}{}{}",
@@ -1368,6 +1374,10 @@ 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/try2/src/librustdoc/passes.rs

@@ -70,17 +70,13 @@ pub fn strip_private(mut crate: clean::Crate) -> plugins::PluginResult {
                     }
                 }
 
-                // These are public-by-default (if the enum was public)
-                clean::VariantItem(*) => {
+                // These are public-by-default (if the enum/struct was public)
+                clean::VariantItem(*) | clean::StructFieldItem(*) => {
                     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/try2/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.0";
+pub static SCHEMA_VERSION: &'static str = "0.8.1";
 
 type Pass = (&'static str,                                      // name
              extern fn(clean::Crate) -> plugins::PluginResult,  // fn

branches/try2/src/libstd/libc.rs

@@ -19,9 +19,8 @@
 * C bindings as appropriate for the target platform. The exact
 * set of functions available are platform specific.
 *
-* *Note* Rustdoc does not indicate reexports currently. Also, because these
-* definitions are platform-specific, some may not
-* appear in the generated documentation.
+* *Note* Because these definitions are platform-specific, some may not appear in
+* the generated documentation.
 *
 * We consider the following specs reasonably normative with respect
 * to interoperating with the C standard library (libc/msvcrt):