Auto merge of #31777 - steveklabnik:rollup, r=steveklabnik

- Successful merges: #31721, #31737, #31741, #31750, #31763, #31764, #31765, #31775
- Failed merges:

Author: bors

.mailmap

@@ -82,7 +82,7 @@ Gareth Daniel Smith <garethdanielsmith@gmail.com> Gareth Smith <garethdanielsmit
 Georges Dubus <georges.dubus@gmail.com> <georges.dubus@compiletoi.net>
 Graham Fawcett <graham.fawcett@gmail.com> Graham Fawcett <fawcett@uwindsor.ca>
 Graydon Hoare <graydon@pobox.com> Graydon Hoare <graydon@mozilla.com>
-Guillaume Gomez <guillaume1.gomez@gmail.com>
+Guillaume Gomez <guillaume1.gomez@gmail.com> Guillaume Gomez <ggomez@ggo.ifr.lan>
 Heather <heather@cynede.net> <Cynede@Gentoo.org>
 Heather <heather@cynede.net> <Heather@cynede.net>
 Herman J. Radtke III <herman@hermanradtke.com> Herman J. Radtke III <hermanradtke@gmail.com>

src/liballoc_jemalloc/lib.rs

@@ -45,19 +45,19 @@ extern {}
 // explicitly request it), and on Android we explicitly request it as
 // unprefixing cause segfaults (mismatches in allocators).
 extern {
-    #[cfg_attr(any(target_os = "macos", target_os = "android"),
+    #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios"),
                link_name = "je_mallocx")]
     fn mallocx(size: size_t, flags: c_int) -> *mut c_void;
-    #[cfg_attr(any(target_os = "macos", target_os = "android"),
+    #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios"),
                link_name = "je_rallocx")]
     fn rallocx(ptr: *mut c_void, size: size_t, flags: c_int) -> *mut c_void;
-    #[cfg_attr(any(target_os = "macos", target_os = "android"),
+    #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios"),
                link_name = "je_xallocx")]
     fn xallocx(ptr: *mut c_void, size: size_t, extra: size_t, flags: c_int) -> size_t;
-    #[cfg_attr(any(target_os = "macos", target_os = "android"),
+    #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios"),
                link_name = "je_sdallocx")]
     fn sdallocx(ptr: *mut c_void, size: size_t, flags: c_int);
-    #[cfg_attr(any(target_os = "macos", target_os = "android"),
+    #[cfg_attr(any(target_os = "macos", target_os = "android", target_os = "ios"),
                link_name = "je_nallocx")]
     fn nallocx(size: size_t, flags: c_int) -> size_t;
 }

src/librustc/front/check_attr.rs

@@ -101,6 +101,7 @@ impl<'a, 'v> Visitor<'v> for CheckAttrVisitor<'a> {
         for attr in &item.attrs {
             self.check_attribute(attr, target);
         }
+        visit::walk_item(self, item);
     }
 }
 

src/librustc_privacy/diagnostics.rs

@@ -205,8 +205,8 @@ let f = Bar::Foo{ a: 0, b: 0 }; // error: field `b` of struct `Bar::Foo`
                                 //        is private
 ```
 
-To fix this error, please ensure that all the fields of the struct, or
-implement a function for easy instantiation. Examples:
+To fix this error, please ensure that all the fields of the struct are public,
+or implement a function for easy instantiation. Examples:
 
 ```
 mod Bar {

src/librustc_privacy/lib.rs

@@ -833,7 +833,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
             NamedField(name) => format!("field `{}` of {} is private",
                                         name, struct_desc),
             UnnamedField(idx) => format!("field #{} of {} is private",
-                                         idx + 1, struct_desc),
+                                         idx, struct_desc),
         };
         span_err!(self.tcx.sess, span, E0451,
                   "{}", &msg[..]);

src/libstd/env.rs

@@ -528,13 +528,13 @@ pub struct ArgsOs { inner: os_imp::Args }
 /// via the command line).
 ///
 /// The first element is traditionally the path to the executable, but it can be
-/// set to arbitrary text, and it may not even exist, so this property should
+/// set to arbitrary text, and may not even exist. This means this property should
 /// not be relied upon for security purposes.
 ///
 /// # Panics
 ///
 /// The returned iterator will panic during iteration if any argument to the
-/// process is not valid unicode. If this is not desired it is recommended to
+/// process is not valid unicode. If this is not desired,
 /// use the `args_os` function instead.
 ///
 /// # Examples
@@ -603,7 +603,7 @@ impl ExactSizeIterator for ArgsOs {
 /// Constants associated with the current target
 #[stable(feature = "env", since = "1.0.0")]
 pub mod consts {
-    /// A string describing the architecture of the CPU that this is currently
+    /// A string describing the architecture of the CPU that is currently
     /// in use.
     ///
     /// Some possible values:

src/libstd/os/netbsd/raw.rs

@@ -46,9 +46,9 @@ pub struct stat {
     #[stable(feature = "raw_ext", since = "1.1.0")]
     pub st_nlink: u32,
     #[stable(feature = "raw_ext", since = "1.1.0")]
-    pub st_uid: u32,
+    pub st_uid: uid_t,
     #[stable(feature = "raw_ext", since = "1.1.0")]
-    pub st_gid: u32,
+    pub st_gid: gid_t,
     #[stable(feature = "raw_ext", since = "1.1.0")]
     pub st_rdev: u64,
     #[stable(feature = "raw_ext", since = "1.1.0")]

src/test/compile-fail/issue-31769.rs

@@ -0,0 +1,14 @@
+// Copyright 2012-2016 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    #[inline] struct Foo;  //~ ERROR attribute should be applied to function
+    #[repr(C)] fn foo() {} //~ ERROR attribute should be applied to struct or enum
+}

src/test/compile-fail/privacy5.rs

@@ -63,25 +63,25 @@ fn this_crate() {
     let c = a::C(2, 3); //~ ERROR: cannot invoke tuple struct constructor
     let d = a::D(4);
 
-    let a::A(()) = a; //~ ERROR: field #1 of struct `a::A` is private
+    let a::A(()) = a; //~ ERROR: field #0 of struct `a::A` is private
     let a::A(_) = a;
-    match a { a::A(()) => {} } //~ ERROR: field #1 of struct `a::A` is private
+    match a { a::A(()) => {} } //~ ERROR: field #0 of struct `a::A` is private
     match a { a::A(_) => {} }
 
     let a::B(_) = b;
-    let a::B(_b) = b; //~ ERROR: field #1 of struct `a::B` is private
+    let a::B(_b) = b; //~ ERROR: field #0 of struct `a::B` is private
     match b { a::B(_) => {} }
-    match b { a::B(_b) => {} } //~ ERROR: field #1 of struct `a::B` is private
-    match b { a::B(1) => {} a::B(_) => {} } //~ ERROR: field #1 of struct `a::B` is private
+    match b { a::B(_b) => {} } //~ ERROR: field #0 of struct `a::B` is private
+    match b { a::B(1) => {} a::B(_) => {} } //~ ERROR: field #0 of struct `a::B` is private
 
     let a::C(_, _) = c;
     let a::C(_a, _) = c;
-    let a::C(_, _b) = c; //~ ERROR: field #2 of struct `a::C` is private
-    let a::C(_a, _b) = c; //~ ERROR: field #2 of struct `a::C` is private
+    let a::C(_, _b) = c; //~ ERROR: field #1 of struct `a::C` is private
+    let a::C(_a, _b) = c; //~ ERROR: field #1 of struct `a::C` is private
     match c { a::C(_, _) => {} }
     match c { a::C(_a, _) => {} }
-    match c { a::C(_, _b) => {} } //~ ERROR: field #2 of struct `a::C` is private
-    match c { a::C(_a, _b) => {} } //~ ERROR: field #2 of struct `a::C` is private
+    match c { a::C(_, _b) => {} } //~ ERROR: field #1 of struct `a::C` is private
+    match c { a::C(_a, _b) => {} } //~ ERROR: field #1 of struct `a::C` is private
 
     let a::D(_) = d;
     let a::D(_d) = d;
@@ -101,30 +101,30 @@ fn xcrate() {
     let c = other::C(2, 3); //~ ERROR: cannot invoke tuple struct constructor
     let d = other::D(4);
 
-    let other::A(()) = a; //~ ERROR: field #1 of struct `other::A` is private
+    let other::A(()) = a; //~ ERROR: field #0 of struct `other::A` is private
     let other::A(_) = a;
     match a { other::A(()) => {} }
-    //~^ ERROR: field #1 of struct `other::A` is private
+    //~^ ERROR: field #0 of struct `other::A` is private
     match a { other::A(_) => {} }
 
     let other::B(_) = b;
-    let other::B(_b) = b; //~ ERROR: field #1 of struct `other::B` is private
+    let other::B(_b) = b; //~ ERROR: field #0 of struct `other::B` is private
     match b { other::B(_) => {} }
     match b { other::B(_b) => {} }
-    //~^ ERROR: field #1 of struct `other::B` is private
+    //~^ ERROR: field #0 of struct `other::B` is private
     match b { other::B(1) => {} other::B(_) => {} }
-    //~^ ERROR: field #1 of struct `other::B` is private
+    //~^ ERROR: field #0 of struct `other::B` is private
 
     let other::C(_, _) = c;
     let other::C(_a, _) = c;
-    let other::C(_, _b) = c; //~ ERROR: field #2 of struct `other::C` is private
-    let other::C(_a, _b) = c; //~ ERROR: field #2 of struct `other::C` is private
+    let other::C(_, _b) = c; //~ ERROR: field #1 of struct `other::C` is private
+    let other::C(_a, _b) = c; //~ ERROR: field #1 of struct `other::C` is private
     match c { other::C(_, _) => {} }
     match c { other::C(_a, _) => {} }
     match c { other::C(_, _b) => {} }
-    //~^ ERROR: field #2 of struct `other::C` is private
+    //~^ ERROR: field #1 of struct `other::C` is private
     match c { other::C(_a, _b) => {} }
-    //~^ ERROR: field #2 of struct `other::C` is private
+    //~^ ERROR: field #1 of struct `other::C` is private
 
     let other::D(_) = d;
     let other::D(_d) = d;