---

yaml
---
r: 235964
b: refs/heads/stable
c: 033b886
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: cca0ea718d363acb85e075aee41223f4da009e82
+refs/heads/stable: 033b886f8c4f4b8de0b1f670f45a780e5679620b
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/.gitattributes

@@ -6,6 +6,4 @@
 *.rs rust
 src/etc/pkg/rust-logo.ico binary
 src/etc/pkg/rust-logo.png binary
-src/rt/msvc/* -whitespace
-src/rt/valgrind/* -whitespace
 *.woff binary

branches/stable/src/doc/trpl/crates-and-modules.md

@@ -355,6 +355,10 @@ Hello in English: Hello!
 Goodbye in English: Goodbye.
 ```
 
+`pub` also applies to `struct`s and their member fields. In keeping with Rust’s
+tendency toward safety, simply making a `struct` public won't automatically
+make its members public: you must mark the fields individually with `pub`.
+
 Now that our functions are public, we can use them. Great! However, typing out
 `phrases::english::greetings::hello()` is very long and repetitive. Rust has
 another keyword for importing names into the current scope, so that you can

branches/stable/src/libcollections/vec_deque.rs

@@ -231,7 +231,7 @@ impl<T> VecDeque<T> {
     /// buf.push_back(3);
     /// buf.push_back(4);
     /// buf.push_back(5);
-    /// assert_eq!(buf.get(1).unwrap(), &4);
+    /// assert_eq!(buf.get(1), Some(&4));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get(&self, index: usize) -> Option<&T> {
@@ -852,12 +852,14 @@ impl<T> VecDeque<T> {
     ///
     /// let mut buf = VecDeque::new();
     /// assert_eq!(buf.swap_back_remove(0), None);
-    /// buf.push_back(5);
-    /// buf.push_back(99);
-    /// buf.push_back(15);
-    /// buf.push_back(20);
-    /// buf.push_back(10);
-    /// assert_eq!(buf.swap_back_remove(1), Some(99));
+    /// buf.push_back(1);
+    /// buf.push_back(2);
+    /// buf.push_back(3);
+    ///
+    /// assert_eq!(buf.swap_back_remove(0), Some(1));
+    /// assert_eq!(buf.len(), 2);
+    /// assert_eq!(buf[0], 3);
+    /// assert_eq!(buf[1], 2);
     /// ```
     #[unstable(feature = "deque_extras",
                reason = "the naming of this function may be altered")]
@@ -886,12 +888,14 @@ impl<T> VecDeque<T> {
     ///
     /// let mut buf = VecDeque::new();
     /// assert_eq!(buf.swap_front_remove(0), None);
-    /// buf.push_back(15);
-    /// buf.push_back(5);
-    /// buf.push_back(10);
-    /// buf.push_back(99);
-    /// buf.push_back(20);
-    /// assert_eq!(buf.swap_front_remove(3), Some(99));
+    /// buf.push_back(1);
+    /// buf.push_back(2);
+    /// buf.push_back(3);
+    ///
+    /// assert_eq!(buf.swap_front_remove(2), Some(3));
+    /// assert_eq!(buf.len(), 2);
+    /// assert_eq!(buf[0], 2);
+    /// assert_eq!(buf[1], 1);
     /// ```
     #[unstable(feature = "deque_extras",
                reason = "the naming of this function may be altered")]
@@ -1123,12 +1127,12 @@ impl<T> VecDeque<T> {
     /// use std::collections::VecDeque;
     ///
     /// let mut buf = VecDeque::new();
-    /// buf.push_back(5);
-    /// buf.push_back(10);
-    /// buf.push_back(12);
-    /// buf.push_back(15);
-    /// buf.remove(2);
-    /// assert_eq!(Some(&15), buf.get(2));
+    /// buf.push_back(1);
+    /// buf.push_back(2);
+    /// buf.push_back(3);
+    ///
+    /// assert_eq!(buf.remove(1), Some(2));
+    /// assert_eq!(buf.get(1), Some(&3));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn remove(&mut self, index: usize) -> Option<T> {

branches/stable/src/libcore/slice.rs

@@ -300,11 +300,12 @@ impl<T> SliceExt for [T] {
 
     #[inline]
     fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
+        let len = self.len();
+        let ptr = self.as_mut_ptr();
+        assert!(mid <= len);
         unsafe {
-            let self2: &mut [T] = mem::transmute_copy(&self);
-
-            (ops::IndexMut::index_mut(self, ops::RangeTo { end: mid } ),
-             ops::IndexMut::index_mut(self2, ops::RangeFrom { start: mid } ))
+            (from_raw_parts_mut(ptr, mid),
+             from_raw_parts_mut(ptr.offset(mid as isize), len - mid))
         }
     }
 

branches/stable/src/liblibc/lib.rs

@@ -1009,7 +1009,7 @@ pub mod types {
                 use types::os::arch::posix88::{uid_t};
 
                 pub type nlink_t = u16;
-                pub type blksize_t = i32;
+                pub type blksize_t = u32;
                 pub type blkcnt_t = i64;
                 pub type fflags_t = u32;
                 #[repr(C)]
@@ -1035,7 +1035,7 @@ pub mod types {
                     pub st_lspare: int32_t,
                     pub st_birthtime: time_t,
                     pub st_birthtime_nsec: c_long,
-                    pub __unused: [uint8_t; 2],
+                    pub __unused: [u8; 8],
                 }
 
                 #[repr(C)]
@@ -1103,7 +1103,7 @@ pub mod types {
                 use types::os::arch::posix88::{uid_t};
 
                 pub type nlink_t = u16;
-                pub type blksize_t = i64;
+                pub type blksize_t = u32;
                 pub type blkcnt_t = i64;
                 pub type fflags_t = u32;
                 #[repr(C)]
@@ -1129,7 +1129,6 @@ pub mod types {
                     pub st_lspare: int32_t,
                     pub st_birthtime: time_t,
                     pub st_birthtime_nsec: c_long,
-                    pub __unused: [uint8_t; 2],
                 }
 
                 #[repr(C)]

branches/stable/src/librustc/lint/context.rs

@@ -34,6 +34,7 @@ use lint::builtin;
 use util::nodemap::FnvHashMap;
 
 use std::cell::RefCell;
+use std::cmp;
 use std::mem;
 use syntax::ast_util::IdVisitingOperation;
 use syntax::attr::AttrMetaMethods;
@@ -66,6 +67,9 @@ pub struct LintStore {
     /// Map of registered lint groups to what lints they expand to. The bool
     /// is true if the lint group was added by a plugin.
     lint_groups: FnvHashMap<&'static str, (Vec<LintId>, bool)>,
+
+    /// Maximum level a lint can be
+    lint_cap: Option<Level>,
 }
 
 /// The targed of the `by_name` map, which accounts for renaming/deprecation.
@@ -94,7 +98,10 @@ impl LintStore {
         }
     }
 
-    fn set_level(&mut self, lint: LintId, lvlsrc: LevelSource) {
+    fn set_level(&mut self, lint: LintId, mut lvlsrc: LevelSource) {
+        if let Some(cap) = self.lint_cap {
+            lvlsrc.0 = cmp::min(lvlsrc.0, cap);
+        }
         if lvlsrc.0 == Allow {
             self.levels.remove(&lint);
         } else {
@@ -109,6 +116,7 @@ impl LintStore {
             by_name: FnvHashMap(),
             levels: FnvHashMap(),
             lint_groups: FnvHashMap(),
+            lint_cap: None,
         }
     }
 
@@ -227,6 +235,13 @@ impl LintStore {
                 }
             }
         }
+
+        self.lint_cap = sess.opts.lint_cap;
+        if let Some(cap) = self.lint_cap {
+            for level in self.levels.iter_mut().map(|p| &mut (p.1).0) {
+                *level = cmp::min(*level, cap);
+            }
+        }
     }
 }
 

branches/stable/src/librustc/session/config.rs

@@ -84,6 +84,7 @@ pub struct Options {
     pub debug_assertions: bool,
     pub debuginfo: DebugInfoLevel,
     pub lint_opts: Vec<(String, lint::Level)>,
+    pub lint_cap: Option<lint::Level>,
     pub describe_lints: bool,
     pub output_types: Vec<OutputType>,
     // This was mutable for rustpkg, which updates search paths based on the
@@ -203,6 +204,7 @@ pub fn basic_options() -> Options {
         optimize: No,
         debuginfo: NoDebugInfo,
         lint_opts: Vec::new(),
+        lint_cap: None,
         describe_lints: false,
         output_types: Vec::new(),
         search_paths: SearchPaths::new(),
@@ -794,6 +796,9 @@ pub fn rustc_short_optgroups() -> Vec<RustcOptGroup> {
         opt::multi("A", "allow", "Set lint allowed", "OPT"),
         opt::multi("D", "deny", "Set lint denied", "OPT"),
         opt::multi("F", "forbid", "Set lint forbidden", "OPT"),
+        opt::multi("", "cap-lints", "Set the most restrictive lint level. \
+                                     More restrictive lints are capped at this \
+                                     level", "LEVEL"),
         opt::multi("C", "codegen", "Set a codegen option", "OPT[=VALUE]"),
         opt::flag("V", "version", "Print version info and exit"),
         opt::flag("v", "verbose", "Use verbose output"),
@@ -862,6 +867,12 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         }
     }
 
+    let lint_cap = matches.opt_str("cap-lints").map(|cap| {
+        lint::Level::from_str(&cap).unwrap_or_else(|| {
+            early_error(&format!("unknown lint level: `{}`", cap))
+        })
+    });
+
     let debugging_opts = build_debugging_options(matches);
 
     let parse_only = debugging_opts.parse_only;
@@ -1025,6 +1036,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         optimize: opt_level,
         debuginfo: debuginfo,
         lint_opts: lint_opts,
+        lint_cap: lint_cap,
         describe_lints: describe_lints,
         output_types: output_types,
         search_paths: search_paths,

branches/stable/src/librustc_resolve/lib.rs

@@ -2654,23 +2654,22 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         let pat_id = pattern.id;
         walk_pat(pattern, |pattern| {
             match pattern.node {
-                PatIdent(binding_mode, ref path1, _) => {
-
-                    // The meaning of pat_ident with no type parameters
+                PatIdent(binding_mode, ref path1, ref at_rhs) => {
+                    // The meaning of PatIdent with no type parameters
                     // depends on whether an enum variant or unit-like struct
                     // with that name is in scope. The probing lookup has to
                     // be careful not to emit spurious errors. Only matching
                     // patterns (match) can match nullary variants or
-                    // unit-like structs. For binding patterns (let), matching
-                    // such a value is simply disallowed (since it's rarely
-                    // what you want).
+                    // unit-like structs. For binding patterns (let
+                    // and the LHS of @-patterns), matching such a value is
+                    // simply disallowed (since it's rarely what you want).
+                    let const_ok = mode == RefutableMode && at_rhs.is_none();
 
                     let ident = path1.node;
                     let renamed = mtwt::resolve(ident);
 
                     match self.resolve_bare_identifier_pattern(ident.name, pattern.span) {
-                        FoundStructOrEnumVariant(def, lp)
-                                if mode == RefutableMode => {
+                        FoundStructOrEnumVariant(def, lp) if const_ok => {
                             debug!("(resolving pattern) resolving `{}` to \
                                     struct or enum variant",
                                    renamed);
@@ -2693,7 +2692,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                     renamed)
                             );
                         }
-                        FoundConst(def, lp) if mode == RefutableMode => {
+                        FoundConst(def, lp) if const_ok => {
                             debug!("(resolving pattern) resolving `{}` to \
                                     constant",
                                    renamed);