---

yaml
---
r: 273339
b: refs/heads/beta
c: fcaefcf
h: refs/heads/master
i:
  273337: 73d948a
  273335: 3226c20

Author: jonas-schievink

[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: b29e299c180ca62403595b7b25f23545943d38b1
+refs/heads/beta: fcaefcfdb0489e86d9ba7ad6ab75b41ae33bc6c3
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/RELEASES.md

@@ -116,8 +116,8 @@ Compatibility Notes
   that were not intended. In this release, [defaulted type parameters
   appearing outside of type definitions will generate a
   warning][1.7d], which will become an error in future releases.
-* [Parsing "." as a float results in an error instead of 0][1.7p].
-  That is, `".".parse::<f32>()` returns `Err`, not `Ok(0.0)`.
+* [Parsing "." as a float results in an error instead of
+  0][1.7p]. That is, `".".parse::<f32>()` returns `Err`, not `Ok(0)`.
 * [Borrows of closure parameters may not outlive the closure][1.7bc].
 
 [1.7a]: https://github.com/rust-lang/rust/pull/30928

branches/beta/configure

@@ -607,7 +607,6 @@ opt dist-host-only 0 "only install bins for the host architecture"
 opt inject-std-version 1 "inject the current compiler version of libstd into programs"
 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"
 
 # Optimization and debugging options. These may be overridden by the release channel, etc.
 opt_nosave optimize 1 "build optimized rust code"
@@ -714,8 +713,6 @@ if [ -n "$CFG_ENABLE_DEBUG_ASSERTIONS" ]; then putvar CFG_ENABLE_DEBUG_ASSERTION
 if [ -n "$CFG_ENABLE_DEBUGINFO" ]; then putvar CFG_ENABLE_DEBUGINFO; fi
 if [ -n "$CFG_ENABLE_DEBUG_JEMALLOC" ]; then putvar CFG_ENABLE_DEBUG_JEMALLOC; fi
 
-if [ -n "$CFG_ENABLE_ORBIT" ]; then putvar CFG_ENABLE_ORBIT; fi
-
 # A magic value that allows the compiler to use unstable features
 # during the bootstrap even when doing so would normally be an error
 # because of feature staging or because the build turns on

branches/beta/mk/main.mk

@@ -134,11 +134,6 @@ ifdef CFG_ENABLE_DEBUGINFO
   CFG_RUSTC_FLAGS += -g
 endif
 
-ifdef CFG_ENABLE_ORBIT
-  $(info cfg: launching MIR (CFG_ENABLE_ORBIT))
-  CFG_RUSTC_FLAGS += -Z orbit
-endif
-
 ifdef SAVE_TEMPS
   CFG_RUSTC_FLAGS += --save-temps
 endif

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

@@ -114,8 +114,7 @@ pub fn compiler_rt(build: &Build, target: &str) {
     let arch = target.split('-').next().unwrap();
     let mode = if build.config.rust_optimize {"Release"} else {"Debug"};
     let (dir, build_target, libname) = if target.contains("linux") ||
-                                          target.contains("freebsd") ||
-                                          target.contains("netbsd") {
+                                          target.contains("freebsd") {
         let os = if target.contains("android") {"-android"} else {""};
         let arch = if arch.starts_with("arm") && target.contains("eabihf") {
             "armhf"

branches/beta/src/compiletest/header.rs

@@ -31,8 +31,6 @@ pub struct TestProps {
     pub pp_exact: Option<PathBuf>,
     // Modules from aux directory that should be compiled
     pub aux_builds: Vec<String> ,
-    // Environment settings to use for compiling
-    pub rustc_env: Vec<(String,String)> ,
     // Environment settings to use during execution
     pub exec_env: Vec<(String,String)> ,
     // Lines to check if they appear in the expected debugger output
@@ -79,7 +77,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
         pp_exact: pp_exact,
         aux_builds: aux_builds,
         revisions: vec![],
-        rustc_env: vec![],
         exec_env: exec_env,
         check_lines: check_lines,
         build_aux_docs: build_aux_docs,
@@ -156,14 +153,10 @@ pub fn load_props_into(props: &mut TestProps, testfile: &Path, cfg: Option<&str>
             props.aux_builds.push(ab);
         }
 
-        if let Some(ee) = parse_env(ln, "exec-env") {
+        if let Some(ee) = parse_exec_env(ln) {
             props.exec_env.push(ee);
         }
 
-        if let Some(ee) = parse_env(ln, "rustc-env") {
-            props.rustc_env.push(ee);
-        }
-
         if let Some(cl) =  parse_check_line(ln) {
             props.check_lines.push(cl);
         }
@@ -379,8 +372,8 @@ fn parse_pretty_compare_only(line: &str) -> bool {
     parse_name_directive(line, "pretty-compare-only")
 }
 
-fn parse_env(line: &str, name: &str) -> Option<(String, String)> {
-    parse_name_value_directive(line, name).map(|nv| {
+fn parse_exec_env(line: &str) -> Option<(String, String)> {
+    parse_name_value_directive(line, "exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR
         let mut strs: Vec<String> = nv
                                       .splitn(2, '=')

branches/beta/src/compiletest/runtest.rs

@@ -863,28 +863,12 @@ fn cleanup_debug_info_options(options: &Option<String>) -> Option<String> {
         "-g".to_owned(),
         "--debuginfo".to_owned()
     ];
-    let mut new_options =
+    let new_options =
         split_maybe_args(options).into_iter()
                                  .filter(|x| !options_to_remove.contains(x))
-                                 .collect::<Vec<String>>();
-
-    let mut i = 0;
-    while i + 1 < new_options.len() {
-        if new_options[i] == "-Z" {
-            // FIXME #31005 MIR missing debuginfo currently.
-            if new_options[i + 1] == "orbit" {
-                // Remove "-Z" and "orbit".
-                new_options.remove(i);
-                new_options.remove(i);
-                continue;
-            }
-            // Always skip over -Z's argument.
-            i += 1;
-        }
-        i += 1;
-    }
-
-    Some(new_options.join(" "))
+                                 .collect::<Vec<String>>()
+                                 .join(" ");
+    Some(new_options)
 }
 
 fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String]) {
@@ -1025,10 +1009,6 @@ fn check_expected_errors(revision: Option<&str>,
         expected.replace(r"\", "/")
     }).collect::<Vec<String>>();
 
-    // If the testcase being checked contains at least one expected "help"
-    // message, then we'll ensure that all "help" messages are expected.
-    // Otherwise, all "help" messages reported by the compiler will be ignored.
-    // This logic also applies to "note" messages.
     let (expect_help, expect_note) =
         expected_errors.iter()
                         .fold((false, false),
@@ -1406,7 +1386,7 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
     compose_and_run(config,
                     testpaths,
                     args,
-                    props.rustc_env.clone(),
+                    Vec::new(),
                     &config.compile_lib_path,
                     Some(aux_dir.to_str().unwrap()),
                     input)

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

@@ -93,8 +93,8 @@ unofficial locations.
 | `armv7-apple-ios`             |  ✓  |     |     | ARM iOS                    |
 | `armv7s-apple-ios`            |  ✓  |     |     | ARM iOS                    |
 | `aarch64-apple-ios`           |  ✓  |     |     | ARM64 iOS                  |
-| `i686-unknown-freebsd`        |  ✓  |  ✓  |  ✓  | 32-bit FreeBSD             |
-| `x86_64-unknown-freebsd`      |  ✓  |  ✓  |  ✓  | 64-bit FreeBSD             |
+| `i686-unknown-freebsd`        |  ✓  |  ✓  |     | 32-bit FreeBSD             |
+| `x86_64-unknown-freebsd`      |  ✓  |  ✓  |     | 64-bit FreeBSD             |
 | `x86_64-unknown-openbsd`      |  ✓  |  ✓  |     | 64-bit OpenBSD             |
 | `x86_64-unknown-netbsd`       |  ✓  |  ✓  |     | 64-bit NetBSD              |
 | `x86_64-unknown-bitrig`       |  ✓  |  ✓  |     | 64-bit Bitrig              |

branches/beta/src/doc/book/guessing-game.md

@@ -912,7 +912,7 @@ returned by `parse()`, this is an `enum`  like `Ordering`, but in this case,
 each variant has some data associated with it: `Ok` is a success, and `Err` is a
 failure. Each contains more information: the successfully parsed integer, or an
 error type. In this case, we `match` on `Ok(num)`, which sets the name `num` to
-the unwrapped `Ok` value (the integer), and then we  return it on the
+the unwrapped `Ok` value (ythe integer), and then we  return it on the
 right-hand side. In the `Err` case, we don’t care what kind of error it is, so
 we just use the catch all `_` instead of a name. This catches everything that
 isn't `Ok`, and `continue` lets us move to the next iteration of the loop; in

branches/beta/src/doc/book/references-and-borrowing.md

@@ -163,8 +163,8 @@ both at the same time:
 * exactly one mutable reference (`&mut T`).
 
 
-You may notice that this is very similar to, though not exactly the same as,
-the definition of a data race:
+You may notice that this is very similar, though not exactly the same as,
+to the definition of a data race:
 
 > There is a ‘data race’ when two or more pointers access the same memory
 > location at the same time, where at least one of them is writing, and the

branches/beta/src/doc/book/variable-bindings.md

@@ -18,14 +18,14 @@ function, rather than leaving it off. Otherwise, you’ll get an error.
 
 In many languages, a variable binding would be called a *variable*, but Rust’s
 variable bindings have a few tricks up their sleeves. For example the
-left-hand side of a `let` statement is a ‘[pattern][pattern]’, not a
+left-hand side of a `let` expression is a ‘[pattern][pattern]’, not a
 variable name. This means we can do things like:
 
 ```rust
 let (x, y) = (1, 2);
 ```
 
-After this statement is evaluated, `x` will be one, and `y` will be two.
+After this expression is evaluated, `x` will be one, and `y` will be two.
 Patterns are really powerful, and have [their own section][pattern] in the
 book. We don’t need those features for now, so we’ll keep this in the back
 of our minds as we go forward.

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

@@ -1465,13 +1465,6 @@ impl<'a, K: Ord, V> Entry<'a, K, V> {
 }
 
 impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
-    /// Gets a reference to the key that would be used when inserting a value
-    /// through the VacantEntry.
-    #[unstable(feature = "map_entry_keys", issue = "32281")]
-    pub fn key(&self) -> &K {
-        &self.key
-    }
-
     /// Sets the value of the entry with the VacantEntry's key,
     /// and returns a mutable reference to it.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -1516,12 +1509,6 @@ impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
 }
 
 impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
-    /// Gets a reference to the key in the entry.
-    #[unstable(feature = "map_entry_keys", issue = "32281")]
-    pub fn key(&self) -> &K {
-        self.handle.reborrow().into_kv().0
-    }
-
     /// Gets a reference to the value in the entry.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get(&self) -> &V {

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

@@ -395,42 +395,6 @@ fn test_variance() {
     fn vals<'a, 'new>(v: Values<'a, (), &'static str>) -> Values<'a, (), &'new str> { v }
 }
 
-#[test]
-fn test_occupied_entry_key() {
-    let mut a = BTreeMap::new();
-    let key = "hello there";
-    let value = "value goes here";
-    assert!(a.is_empty());
-    a.insert(key.clone(), value.clone());
-    assert_eq!(a.len(), 1);
-    assert_eq!(a[key], value);
-
-    match a.entry(key.clone()) {
-        Vacant(_) => panic!(),
-        Occupied(e) => assert_eq!(key, *e.key()),
-    }
-    assert_eq!(a.len(), 1);
-    assert_eq!(a[key], value);
-}
-
-#[test]
-fn test_vacant_entry_key() {
-    let mut a = BTreeMap::new();
-    let key = "hello there";
-    let value = "value goes here";
-
-    assert!(a.is_empty());
-    match a.entry(key.clone()) {
-        Occupied(_) => panic!(),
-        Vacant(e) => {
-            assert_eq!(key, *e.key());
-            e.insert(value.clone());
-        },
-    }
-    assert_eq!(a.len(), 1);
-    assert_eq!(a[key], value);
-}
-
 mod bench {
     use std::collections::BTreeMap;
     use std::__rand::{Rng, thread_rng};

branches/beta/src/libcollectionstest/lib.rs

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

branches/beta/src/libcore/intrinsics.rs

@@ -539,32 +539,6 @@ extern "rust-intrinsic" {
     /// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
     pub fn roundf64(x: f64) -> f64;
 
-    /// Float addition that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fadd_fast<T>(a: T, b: T) -> T;
-
-    /// Float subtraction that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fsub_fast<T>(a: T, b: T) -> T;
-
-    /// Float multiplication that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fmul_fast<T>(a: T, b: T) -> T;
-
-    /// Float division that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn fdiv_fast<T>(a: T, b: T) -> T;
-
-    /// Float remainder that allows optimizations based on algebraic rules.
-    /// May assume inputs are finite.
-    #[cfg(not(stage0))]
-    pub fn frem_fast<T>(a: T, b: T) -> T;
-
-
     /// Returns the number of bits set in an integer type `T`
     pub fn ctpop<T>(x: T) -> T;
 

branches/beta/src/libcore/lib.rs

@@ -72,7 +72,6 @@
 #![feature(reflect)]
 #![feature(unwind_attributes)]
 #![feature(repr_simd, platform_intrinsics)]
-#![feature(rustc_attrs)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 

branches/beta/src/libcore/num/mod.rs

@@ -1008,7 +1008,6 @@ macro_rules! int_impl {
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
         #[inline]
-        #[cfg_attr(not(stage0), rustc_no_mir)] // FIXME #29769 MIR overflow checking is TBD.
         pub fn pow(self, mut exp: u32) -> Self {
             let mut base = self;
             let mut acc = Self::one();
@@ -1050,7 +1049,6 @@ macro_rules! int_impl {
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
         #[inline]
-        #[cfg_attr(not(stage0), rustc_no_mir)] // FIXME #29769 MIR overflow checking is TBD.
         pub fn abs(self) -> Self {
             if self.is_negative() {
                 // Note that the #[inline] above means that the overflow
@@ -2015,7 +2013,6 @@ macro_rules! uint_impl {
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
         #[inline]
-        #[cfg_attr(not(stage0), rustc_no_mir)] // FIXME #29769 MIR overflow checking is TBD.
         pub fn pow(self, mut exp: u32) -> Self {
             let mut base = self;
             let mut acc = Self::one();

branches/beta/src/librustc/front/map/mod.rs

@@ -22,7 +22,6 @@ use middle::def_id::DefId;
 
 use syntax::abi::Abi;
 use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID};
-use syntax::attr::ThinAttributesExt;
 use syntax::codemap::{Span, Spanned};
 use syntax::parse::token;
 
@@ -719,8 +718,6 @@ impl<'ast> Map<'ast> {
             Some(NodeTraitItem(ref ti)) => Some(&ti.attrs[..]),
             Some(NodeImplItem(ref ii)) => Some(&ii.attrs[..]),
             Some(NodeVariant(ref v)) => Some(&v.node.attrs[..]),
-            Some(NodeExpr(ref e)) => Some(e.attrs.as_attr_slice()),
-            Some(NodeStmt(ref s)) => Some(s.node.attrs()),
             // unit/tuple structs take the attributes straight from
             // the struct definition.
             Some(NodeStructCtor(_)) => {

branches/beta/src/librustc/lib.rs

@@ -73,6 +73,7 @@ mod macros;
 pub mod diagnostics;
 
 pub mod back {
+    pub use rustc_back::abi;
     pub use rustc_back::rpath;
     pub use rustc_back::svh;
 }

branches/beta/src/librustc/lint/builtin.rs

@@ -154,12 +154,6 @@ declare_lint! {
     "transmute from function item type to pointer-sized type erroneously allowed"
 }
 
-declare_lint! {
-    pub OVERLAPPING_INHERENT_IMPLS,
-    Warn,
-    "two overlapping inherent impls define an item with the same name were erroneously allowed"
-}
-
 /// Does nothing as a lint pass, but registers some `Lint`s
 /// which are used by other parts of the compiler.
 #[derive(Copy, Clone)]
@@ -190,8 +184,7 @@ impl LintPass for HardwiredLints {
             MATCH_OF_UNIT_VARIANT_VIA_PAREN_DOTDOT,
             CONST_ERR,
             RAW_POINTER_DERIVE,
-            TRANSMUTE_FROM_FN_ITEM_TYPES,
-            OVERLAPPING_INHERENT_IMPLS
+            TRANSMUTE_FROM_FN_ITEM_TYPES
         )
     }
 }