---

yaml
---
r: 273927
b: refs/heads/beta
c: 8c2a8ae
h: refs/heads/master
i:
  273925: 0b2e895
  273923: 9e46496
  273919: 836df36

Author: nrc

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 084d9fa94345c72e450184a0a6e4b46ba95285cd
+refs/heads/beta: 8c2a8ae9cc81d86363e5c3180ce75e5925efe4a2
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/CONTRIBUTING.md

@@ -71,8 +71,7 @@ which includes important information about what platform you're on, what
 version of Rust you're using, etc.
 
 Sometimes, a backtrace is helpful, and so including that is nice. To get
-a backtrace, set the `RUST_BACKTRACE` environment variable to a value
-other than `0`. The easiest way
+a backtrace, set the `RUST_BACKTRACE` environment variable. The easiest way
 to do this is to invoke `rustc` like this:
 
 ```bash

branches/beta/README.md

@@ -177,11 +177,10 @@ To contribute to Rust, please see [CONTRIBUTING](CONTRIBUTING.md).
 Rust has an [IRC] culture and most real-time collaboration happens in a
 variety of channels on Mozilla's IRC network, irc.mozilla.org. The
 most popular channel is [#rust], a venue for general discussion about
-Rust. And a good place to ask for help would be [#rust-beginners].
+Rust, and a good place to ask for help.
 
 [IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat
 [#rust]: irc://irc.mozilla.org/rust
-[#rust-beginners]: irc://irc.mozilla.org/rust-beginners
 
 ## License
 

branches/beta/configure

@@ -608,7 +608,6 @@ opt inject-std-version 1 "inject the current compiler version of libstd into pro
 opt llvm-version-check 1 "check if the LLVM version is supported, build anyway"
 opt rustbuild 0 "use the rust and cargo based build system"
 opt orbit 0 "get MIR where it belongs - everywhere; most importantly, in orbit"
-opt codegen-tests 1 "run the src/test/codegen tests"
 
 # Optimization and debugging options. These may be overridden by the release channel, etc.
 opt_nosave optimize 1 "build optimized rust code"
@@ -1498,9 +1497,7 @@ do
         LLVM_INST_DIR=$CFG_LLVM_ROOT
         do_reconfigure=0
         # Check that LLVm FileCheck is available. Needed for the tests
-        if [ -z "$CFG_DISABLE_CODEGEN_TESTS" ]; then
-            need_cmd $LLVM_INST_DIR/bin/FileCheck
-        fi
+        need_cmd $LLVM_INST_DIR/bin/FileCheck
     fi
 
     if [ ${do_reconfigure} -ne 0 ]

branches/beta/man/rustc.1

@@ -268,15 +268,15 @@ the maximum number of threads used for this purpose.
 
 .TP
 \fBRUST_TEST_NOCAPTURE\fR
-If set to a value other than "0", a synonym for the --nocapture flag.
+A synonym for the --nocapture flag.
 
 .TP
 \fBRUST_MIN_STACK\fR
 Sets the minimum stack size for new threads.
 
 .TP
 \fBRUST_BACKTRACE\fR
-If set to a value different than "0", produces a backtrace in the output of a program which panics.
+If set, produces a backtrace in the output of a program which panics.
 
 .SH "EXAMPLES"
 To build an executable from a source file with a main function:

branches/beta/mk/rt.mk

@@ -157,8 +157,6 @@ else ifeq ($(findstring android, $(OSTYPE_$(1))), android)
   # If the test suite passes, however, without symbol prefixes then we should be
   # good to go!
   JEMALLOC_ARGS_$(1) := --disable-tls --with-jemalloc-prefix=je_
-else ifeq ($(findstring dragonfly, $(OSTYPE_$(1))), dragonfly)
-  JEMALLOC_ARGS_$(1) := --with-jemalloc-prefix=je_
 endif
 
 ifdef CFG_ENABLE_DEBUG_JEMALLOC

branches/beta/mk/tests.mk

@@ -305,15 +305,11 @@ check-stage$(1)-T-$(2)-H-$(3)-exec: \
 	check-stage$(1)-T-$(2)-H-$(3)-doc-crates-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-debuginfo-gdb-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-debuginfo-lldb-exec \
+	check-stage$(1)-T-$(2)-H-$(3)-codegen-exec \
+	check-stage$(1)-T-$(2)-H-$(3)-codegen-units-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-doc-exec \
 	check-stage$(1)-T-$(2)-H-$(3)-pretty-exec
 
-ifndef CFG_DISABLE_CODEGEN_TESTS
-check-stage$(1)-T-$(2)-H-$(3)-exec: \
-	check-stage$(1)-T-$(2)-H-$(3)-codegen-exec \
-	check-stage$(1)-T-$(2)-H-$(3)-codegen-units-exec
-endif
-
 # Only test the compiler-dependent crates when the target is
 # able to build a compiler (when the target triple is in the set of host triples)
 ifneq ($$(findstring $(2),$$(CFG_HOST)),)

branches/beta/src/bootstrap/build/mod.rs

@@ -326,13 +326,7 @@ impl Build {
         if !target.contains("msvc") {
             cargo.env(format!("CC_{}", target), self.cc(target))
                  .env(format!("AR_{}", target), self.ar(target))
-                 .env(format!("CFLAGS_{}", target), self.cflags(target).join(" "));
-        }
-
-        // If we're building for OSX, inform the compiler and the linker that
-        // we want to build a compiler runnable on 10.7
-        if target.contains("apple-darwin") {
-            cargo.env("MACOSX_DEPLOYMENT_TARGET", "10.7");
+                 .env(format!("CFLAGS_{}", target), self.cflags(target));
         }
 
         // Environment variables *required* needed throughout the build
@@ -503,20 +497,11 @@ impl Build {
         self.cc[target].0.path()
     }
 
-    fn cflags(&self, target: &str) -> Vec<String> {
-        let mut base = self.cc[target].0.args().iter()
-                           .map(|s| s.to_string_lossy().into_owned())
-                           .collect::<Vec<_>>();
-
-        // If we're compiling on OSX then we add a few unconditional flags
-        // indicating that we want libc++ (more filled out than libstdc++) and
-        // we want to compile for 10.7. This way we can ensure that
-        // LLVM/jemalloc/etc are all properly compiled.
-        if target.contains("apple-darwin") {
-            base.push("-stdlib=libc++".into());
-            base.push("-mmacosx-version-min=10.7".into());
-        }
-        return base
+    fn cflags(&self, target: &str) -> String {
+        self.cc[target].0.args().iter()
+            .map(|s| s.to_string_lossy())
+            .collect::<Vec<_>>()
+            .join(" ")
     }
 
     fn ar(&self, target: &str) -> &Path {

branches/beta/src/bootstrap/build/native.rs

@@ -86,9 +86,6 @@ pub fn llvm(build: &Build, target: &str) {
               .define("CMAKE_CXX_COMPILER", build.cxx(target));
         }
         cfg.build_arg("-j").build_arg(build.jobs().to_string());
-
-        cfg.define("CMAKE_C_FLAGS", build.cflags(target).join(" "));
-        cfg.define("CMAKE_CXX_FLAGS", build.cflags(target).join(" "));
     }
 
     // FIXME: we don't actually need to build all LLVM tools and all LLVM

branches/beta/src/compiletest/compiletest.rs

@@ -263,10 +263,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         logfile: config.logfile.clone(),
         run_tests: true,
         bench_benchmarks: true,
-        nocapture: match env::var("RUST_TEST_NOCAPTURE") {
-            Ok(val) => &val != "0",
-            Err(_) => false
-        },
+        nocapture: env::var("RUST_TEST_NOCAPTURE").is_ok(),
         color: test::AutoColor,
     }
 }

branches/beta/src/doc/book/functions.md

@@ -246,19 +246,6 @@ stack backtrace:
   13:                0x0 - <unknown>
 ```
 
-If you need to override an already set `RUST_BACKTRACE`, 
-in cases when you cannot just unset the variable, 
-then set it to `0` to avoid getting a backtrace. 
-Any other value(even no value at all) turns on backtrace.
-
-```text
-$ export RUST_BACKTRACE=1
-...
-$ RUST_BACKTRACE=0 ./diverges 
-thread '<main>' panicked at 'This function never returns!', hello.rs:2
-note: Run with `RUST_BACKTRACE=1` for a backtrace.
-```
-
 `RUST_BACKTRACE` also works with Cargo’s `run` command:
 
 ```text

branches/beta/src/doc/book/getting-started.md

@@ -164,15 +164,13 @@ installed. Doing so will depend on your specific system, consult its
 documentation for more details.
 
 If not, there are a number of places where we can get help. The easiest is
-[the #rust-beginners IRC channel on irc.mozilla.org][irc-beginners] and for
-general discussion [the #rust IRC channel on irc.mozilla.org][irc], which we
-can access through [Mibbit][mibbit]. Then we'll be chatting with other
-Rustaceans (a silly nickname we call ourselves) who can help us out. Other great
-resources include [the user’s forum][users] and [Stack Overflow][stackoverflow].
+[the #rust IRC channel on irc.mozilla.org][irc], which we can access through
+[Mibbit][mibbit]. Click that link, and we'll be chatting with other Rustaceans
+(a silly nickname we call ourselves) who can help us out. Other great resources
+include [the user’s forum][users], and [Stack Overflow][stackoverflow].
 
-[irc-beginners]: irc://irc.mozilla.org/#rust-beginners
 [irc]: irc://irc.mozilla.org/#rust
-[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners,%23rust
+[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
 [users]: https://users.rust-lang.org/
 [stackoverflow]: http://stackoverflow.com/questions/tagged/rust
 

branches/beta/src/doc/nomicon/vec.md

@@ -2,7 +2,7 @@
 
 To bring everything together, we're going to write `std::Vec` from scratch.
 Because all the best tools for writing unsafe code are unstable, this
-project will only work on nightly (as of Rust 1.9.0). With the exception of the
+project will only work on nightly (as of Rust 1.2.0). With the exception of the
 allocator API, much of the unstable code we'll use is expected to be stabilized
 in a similar form as it is today.
 

branches/beta/src/liballoc_jemalloc/build.rs

@@ -86,8 +86,6 @@ fn main() {
         // should be good to go!
         cmd.arg("--with-jemalloc-prefix=je_");
         cmd.arg("--disable-tls");
-    } else if target.contains("dragonfly") {
-        cmd.arg("--with-jemalloc-prefix=je_");
     }
 
     if cfg!(feature = "debug-jemalloc") {

branches/beta/src/liballoc_jemalloc/lib.rs

@@ -42,27 +42,22 @@ use libc::{c_int, c_void, size_t};
 extern {}
 
 // Note that the symbols here are prefixed by default on OSX (we don't
-// explicitly request it), and on Android and DragonFly we explicitly request
-// it as unprefixing cause segfaults (mismatches in allocators).
+// 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", target_os = "ios",
-                   target_os = "dragonfly"),
+    #[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", target_os = "ios",
-                   target_os = "dragonfly"),
+    #[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", target_os = "ios",
-                   target_os = "dragonfly"),
+    #[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", target_os = "ios",
-                   target_os = "dragonfly"),
+    #[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", target_os = "ios",
-                   target_os = "dragonfly"),
+    #[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;
 }

branches/beta/src/libcollections/btree/map.rs

@@ -285,12 +285,6 @@ pub struct Values<'a, K: 'a, V: 'a> {
     inner: Iter<'a, K, V>,
 }
 
-/// A mutable iterator over a BTreeMap's values.
-#[unstable(feature = "map_values_mut", reason = "recently added", issue = "32551")]
-pub struct ValuesMut<'a, K: 'a, V: 'a> {
-    inner: IterMut<'a, K, V>,
-}
-
 /// An iterator over a sub-range of BTreeMap's entries.
 pub struct Range<'a, K: 'a, V: 'a> {
     front: Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Edge>,
@@ -1012,33 +1006,6 @@ impl<'a, K, V> Iterator for Range<'a, K, V> {
     }
 }
 
-#[unstable(feature = "map_values_mut", reason = "recently added", issue = "32551")]
-impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
-    type Item = &'a mut V;
-
-    fn next(&mut self) -> Option<&'a mut V> {
-        self.inner.next().map(|(_, v)| v)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-}
-
-#[unstable(feature = "map_values_mut", reason = "recently added", issue = "32551")]
-impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V> {
-    fn next_back(&mut self) -> Option<&'a mut V> {
-        self.inner.next_back().map(|(_, v)| v)
-    }
-}
-
-#[unstable(feature = "map_values_mut", reason = "recently added", issue = "32551")]
-impl<'a, K, V> ExactSizeIterator for ValuesMut<'a, K, V> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
 impl<'a, K, V> Range<'a, K, V> {
     unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) {
         let handle = self.front;
@@ -1436,33 +1403,6 @@ impl<K, V> BTreeMap<K, V> {
         Values { inner: self.iter() }
     }
 
-    /// Gets a mutable iterator over the values of the map, in order by key.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// # #![feature(map_values_mut)]
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1, String::from("hello"));
-    /// a.insert(2, String::from("goodbye"));
-    ///
-    /// for value in a.values_mut() {
-    ///     value.push_str("!");
-    /// }
-    ///
-    /// let values: Vec<String> = a.values().cloned().collect();
-    /// assert_eq!(values, [String::from("hello!"),
-    ///                     String::from("goodbye!")]);
-    /// ```
-    #[unstable(feature = "map_values_mut", reason = "recently added", issue = "32551")]
-    pub fn values_mut<'a>(&'a mut self) -> ValuesMut<'a, K, V> {
-        ValuesMut { inner: self.iter_mut() }
-    }
-
     /// Returns the number of elements in the map.
     ///
     /// # Examples

branches/beta/src/libcollectionstest/btree/map.rs

@@ -114,21 +114,6 @@ fn test_iter_rev() {
     test(size, map.into_iter().rev());
 }
 
-#[test]
-fn test_values_mut() {
-    let mut a = BTreeMap::new();
-    a.insert(1, String::from("hello"));
-    a.insert(2, String::from("goodbye"));
-
-    for value in a.values_mut() {
-        value.push_str("!");
-    }
-
-    let values: Vec<String> = a.values().cloned().collect();
-    assert_eq!(values, [String::from("hello!"),
-                        String::from("goodbye!")]);
-}
-
 #[test]
 fn test_iter_mixed() {
     let size = 10000;

branches/beta/src/libcollectionstest/lib.rs

@@ -22,7 +22,6 @@
 #![feature(enumset)]
 #![feature(iter_arith)]
 #![feature(map_entry_keys)]
-#![feature(map_values_mut)]
 #![feature(pattern)]
 #![feature(rand)]
 #![feature(set_recovery)]

branches/beta/src/libcore/cell.rs

@@ -147,8 +147,8 @@
 use clone::Clone;
 use cmp::{PartialEq, Eq};
 use default::Default;
-use marker::{Copy, Send, Sync, Sized, Unsize};
-use ops::{Deref, DerefMut, Drop, FnOnce, CoerceUnsized};
+use marker::{Copy, Send, Sync, Sized};
+use ops::{Deref, DerefMut, Drop, FnOnce};
 use option::Option;
 use option::Option::{None, Some};
 
@@ -634,9 +634,6 @@ impl<'b, T: ?Sized> Ref<'b, T> {
     }
 }
 
-#[unstable(feature = "coerce_unsized", issue = "27732")]
-impl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Ref<'b, U>> for Ref<'b, T> {}
-
 impl<'b, T: ?Sized> RefMut<'b, T> {
     /// Make a new `RefMut` for a component of the borrowed data, e.g. an enum
     /// variant.
@@ -769,9 +766,6 @@ impl<'b, T: ?Sized> DerefMut for RefMut<'b, T> {
     }
 }
 
-#[unstable(feature = "coerce_unsized", issue = "27732")]
-impl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<RefMut<'b, U>> for RefMut<'b, T> {}
-
 /// The core primitive for interior mutability in Rust.
 ///
 /// `UnsafeCell<T>` is a type that wraps some `T` and indicates unsafe interior operations on the