---

yaml
---
r: 81578
b: refs/heads/snap-stage3
c: a6d7fe6
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 16fc6a694cac35ce962e98e180354cbce6a72f54
+refs/heads/snap-stage3: a6d7fe6209bb31cc46ec5ba60e16b789b5c91914
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial-ffi.md

@@ -415,18 +415,21 @@ fn main() {
 
 Most foreign code exposes a C ABI, and Rust uses the platform's C calling convention by default when
 calling foreign functions. Some foreign functions, most notably the Windows API, use other calling
-conventions. Rust provides a way to tell the compiler which convention to use:
+conventions. Rust provides the `abi` attribute as a way to hint to the compiler which calling
+convention to use:
 
 ~~~~
 #[cfg(target_os = "win32")]
+#[abi = "stdcall"]
 #[link_name = "kernel32"]
-extern "stdcall" {
+extern {
     fn SetEnvironmentVariableA(n: *u8, v: *u8) -> int;
 }
 ~~~~
 
-This applies to the entire `extern` block, and must be either `"cdecl"` or
-`"stdcall"`. The compiler may eventually support other calling conventions.
+The `abi` attribute applies to a foreign module (it cannot be applied to a single function within a
+module), and must be either `"cdecl"` or `"stdcall"`. The compiler may eventually support other
+calling conventions.
 
 # Interoperability with foreign code
 

branches/snap-stage3/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 metadata, which includes
+For example, Rust uniquely identifies crates by their link metadate, 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-export common definitions from `std`.
+The role of the `prelude` module is to re-exports 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/snap-stage3/src/libextra/time.rs

@@ -19,7 +19,8 @@ static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 pub mod rustrt {
     use super::Tm;
 
-    extern "cdecl" {
+    #[abi = "cdecl"]
+    extern {
         pub fn get_time(sec: &mut i64, nsec: &mut i32);
         pub fn precise_time_ns(ns: &mut u64);
         pub fn rust_tzset();

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

@@ -162,7 +162,8 @@ pub mod icu {
 
         // #[link_name = "icuuc"]
         #[link_args = "-licuuc"]
-        extern "cdecl" {
+        #[abi = "cdecl"]
+        extern {
             pub fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
             pub fn u_isdigit(c: UChar32) -> UBool;
             pub fn u_islower(c: UChar32) -> UBool;

branches/snap-stage3/src/librustc/lib/llvm.rs

@@ -300,7 +300,8 @@ pub mod llvm {
 
     #[link_args = "-Lrustllvm -lrustllvm"]
     #[link_name = "rustllvm"]
-    extern "cdecl" {
+    #[abi = "cdecl"]
+    extern {
         /* Create and destroy contexts. */
         pub fn LLVMContextCreate() -> ContextRef;
         pub fn LLVMContextDispose(C: ContextRef);

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

branches/snap-stage3/src/libstd/io.rs

@@ -76,8 +76,9 @@ pub type fd_t = c_int;
 pub mod rustrt {
     use libc;
 
+    #[abi = "cdecl"]
     #[link_name = "rustrt"]
-    extern "cdecl" {
+    extern {
         pub fn rust_get_stdin() -> *libc::FILE;
         pub fn rust_get_stdout() -> *libc::FILE;
         pub fn rust_get_stderr() -> *libc::FILE;