---

yaml
---
r: 136669
b: refs/heads/dist-snap
c: 9a01da9
h: refs/heads/master
i:
  136667: c0ee820
v: v3

Author: fhahn

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 189b7332968972f34cdbbbd9b62d97ababf53059
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 5e13d3aa00e8cfdf1a64f58f6c649460400231c0
+refs/heads/dist-snap: 9a01da9460a9e7a8be88896e9da0306fd47823a1
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/doc/guide-unsafe.md

@@ -573,8 +573,8 @@ pub extern fn dot_product(a: *const u32, a_len: u32,
     return ret;
 }
 
-#[lang = "begin_unwind"]
-extern fn begin_unwind(args: &core::fmt::Arguments,
+#[lang = "fail_fmt"]
+extern fn fail_fmt(args: &core::fmt::Arguments,
                        file: &str,
                        line: uint) -> ! {
     loop {}
@@ -587,8 +587,8 @@ extern fn begin_unwind(args: &core::fmt::Arguments,
 ```
 
 Note that there is one extra lang item here which differs from the examples
-above, `begin_unwind`. This must be defined by consumers of libcore because the
-core library declares failure, but it does not define it. The `begin_unwind`
+above, `fail_fmt`. This must be defined by consumers of libcore because the
+core library declares failure, but it does not define it. The `fail_fmt`
 lang item is this crate's definition of failure, and it must be guaranteed to
 never return.
 

branches/dist-snap/src/libcore/failure.rs

@@ -64,9 +64,17 @@ pub fn begin_unwind_string(msg: &str, file: &(&'static str, uint)) -> ! {
 pub fn begin_unwind(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
     #[allow(ctypes)]
     extern {
+
+        #[cfg(stage0)]
         #[lang = "begin_unwind"]
         fn begin_unwind(fmt: &fmt::Arguments, file: &'static str,
                         line: uint) -> !;
+
+        #[cfg(not(stage0))]
+        #[lang = "fail_fmt"]
+        fn begin_unwind(fmt: &fmt::Arguments, file: &'static str,
+                        line: uint) -> !;
+
     }
     let (file, line) = *file_line;
     unsafe { begin_unwind(fmt, file, line) }

branches/dist-snap/src/libcore/fmt/float.rs

@@ -28,12 +28,21 @@ pub enum ExponentFormat {
     /// Use exponential notation with the exponent having a base of 10 and the
     /// exponent sign being `e` or `E`. For example, 1000 would be printed
     /// 1e3.
-    ExpDec
+    ExpDec,
+    /// Use exponential notation with the exponent having a base of 2 and the
+    /// exponent sign being `p` or `P`. For example, 8 would be printed 1p3.
+    ExpBin,
 }
 
 /// The number of digits used for emitting the fractional part of a number, if
 /// any.
 pub enum SignificantDigits {
+    /// All calculable digits will be printed.
+    ///
+    /// Note that bignums or fractions may cause a surprisingly large number
+    /// of digits to be printed.
+    DigAll,
+
     /// At most the given number of digits will be printed, truncating any
     /// trailing zeroes.
     DigMax(uint),
@@ -44,11 +53,17 @@ pub enum SignificantDigits {
 
 /// How to emit the sign of a number.
 pub enum SignFormat {
+    /// No sign will be printed. The exponent sign will also be emitted.
+    SignNone,
     /// `-` will be printed for negative values, but no sign will be emitted
     /// for positive numbers.
-    SignNeg
+    SignNeg,
+    /// `+` will be printed for positive values, and `-` will be printed for
+    /// negative values.
+    SignAll,
 }
 
+static DIGIT_P_RADIX: uint = ('p' as uint) - ('a' as uint) + 11u;
 static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u;
 
 /**
@@ -96,6 +111,9 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
         ExpDec if radix >= DIGIT_E_RADIX       // decimal exponent 'e'
           => fail!("float_to_str_bytes_common: radix {} incompatible with \
                     use of 'e' as decimal exponent", radix),
+        ExpBin if radix >= DIGIT_P_RADIX       // binary exponent 'p'
+          => fail!("float_to_str_bytes_common: radix {} incompatible with \
+                    use of 'p' as binary exponent", radix),
         _ => ()
     }
 
@@ -105,10 +123,16 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
     match num.classify() {
         FPNaN => return f("NaN".as_bytes()),
         FPInfinite if num > _0 => {
-            return f("inf".as_bytes());
+            return match sign {
+                SignAll => return f("+inf".as_bytes()),
+                _       => return f("inf".as_bytes()),
+            };
         }
         FPInfinite if num < _0 => {
-            return f("-inf".as_bytes());
+            return match sign {
+                SignNone => return f("inf".as_bytes()),
+                _        => return f("-inf".as_bytes()),
+            };
         }
         _ => {}
     }
@@ -123,10 +147,11 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
 
     let (num, exp) = match exp_format {
         ExpNone => (num, 0i32),
-        ExpDec if num == _0 => (num, 0i32),
-        ExpDec => {
+        ExpDec | ExpBin if num == _0 => (num, 0i32),
+        ExpDec | ExpBin => {
             let (exp, exp_base) = match exp_format {
                 ExpDec => (num.abs().log10().floor(), cast::<f64, T>(10.0f64).unwrap()),
+                ExpBin => (num.abs().log2().floor(), cast::<f64, T>(2.0f64).unwrap()),
                 ExpNone => fail!("unreachable"),
             };
 
@@ -160,16 +185,21 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
 
     // If limited digits, calculate one digit more for rounding.
     let (limit_digits, digit_count, exact) = match digits {
-        DigMax(count)   => (true, count + 1, false),
-        DigExact(count) => (true, count + 1, true)
+        DigAll          => (false, 0u,      false),
+        DigMax(count)   => (true,  count+1, false),
+        DigExact(count) => (true,  count+1, true)
     };
 
     // Decide what sign to put in front
     match sign {
-        SignNeg if neg => {
+        SignNeg | SignAll if neg => {
             buf[end] = b'-';
             end += 1;
         }
+        SignAll => {
+            buf[end] = b'+';
+            end += 1;
+        }
         _ => ()
     }
 
@@ -299,6 +329,8 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
             buf[end] = match exp_format {
                 ExpDec if exp_upper => 'E',
                 ExpDec if !exp_upper => 'e',
+                ExpBin if exp_upper => 'P',
+                ExpBin if !exp_upper => 'p',
                 _ => fail!("unreachable"),
             } as u8;
             end += 1;
@@ -324,6 +356,11 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
                         fmt::write(&mut filler, args)
                     }, "{:-}", exp);
                 }
+                SignNone | SignAll => {
+                    let _ = format_args!(|args| {
+                        fmt::write(&mut filler, args)
+                    }, "{}", exp);
+                }
             }
         }
     }

branches/dist-snap/src/librustc/back/link.rs

@@ -397,6 +397,13 @@ pub fn get_cc_prog(sess: &Session) -> String {
     }.to_string()
 }
 
+pub fn get_ar_prog(sess: &Session) -> String {
+    match sess.opts.cg.ar {
+        Some(ref ar) => (*ar).clone(),
+        None => "ar".to_string()
+    }
+}
+
 pub fn remove(sess: &Session, path: &Path) {
     match fs::unlink(path) {
         Ok(..) => {}

branches/dist-snap/src/librustc/diagnostics.rs

@@ -114,6 +114,7 @@ register_diagnostics!(
     E0102,
     E0103,
     E0104,
+    E0105,
     E0106,
     E0107,
     E0108,
@@ -151,6 +152,7 @@ register_diagnostics!(
     E0144,
     E0145,
     E0146,
+    E0147,
     E0148,
     E0151,
     E0152,

branches/dist-snap/src/librustc/driver/config.rs

@@ -31,7 +31,6 @@ use syntax::parse;
 use syntax::parse::token::InternedString;
 
 use std::collections::HashMap;
-use std::collections::hashmap::{Occupied, Vacant};
 use getopts::{optopt, optmulti, optflag, optflagopt};
 use getopts;
 use std::cell::{RefCell};
@@ -805,11 +804,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
             Some(s) => s,
             None => early_error("--extern value must be of the format `foo=bar`"),
         };
-
-        match externs.entry(name.to_string()) {
-            Vacant(entry) => { entry.set(vec![location.to_string()]); },
-            Occupied(mut entry) => { entry.get_mut().push(location.to_string()); },
-        }
+        let locs = externs.find_or_insert(name.to_string(), Vec::new());
+        locs.push(location.to_string());
     }
 
     let crate_name = matches.opt_str("crate-name");

branches/dist-snap/src/librustc/lint/builtin.rs

@@ -36,7 +36,6 @@ use lint::{Context, LintPass, LintArray};
 
 use std::cmp;
 use std::collections::HashMap;
-use std::collections::hashmap::{Occupied, Vacant};
 use std::slice;
 use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64};
 use syntax::abi;
@@ -1204,18 +1203,15 @@ impl UnusedMut {
     fn check_unused_mut_pat(&self, cx: &Context, pats: &[P<ast::Pat>]) {
         // collect all mutable pattern and group their NodeIDs by their Identifier to
         // avoid false warnings in match arms with multiple patterns
-
         let mut mutables = HashMap::new();
         for p in pats.iter() {
             pat_util::pat_bindings(&cx.tcx.def_map, &**p, |mode, id, _, path1| {
                 let ident = path1.node;
                 match mode {
                     ast::BindByValue(ast::MutMutable) => {
                         if !token::get_ident(ident).get().starts_with("_") {
-                            match mutables.entry(ident.name.uint()) {
-                                Vacant(entry) => { entry.set(vec![id]); },
-                                Occupied(mut entry) => { entry.get_mut().push(id); },
-                            }
+                            mutables.insert_or_update_with(ident.name.uint(),
+                                vec!(id), |_, old| { old.push(id); });
                         }
                     }
                     _ => {
@@ -1273,6 +1269,11 @@ impl LintPass for UnusedMut {
     }
 }
 
+enum Allocation {
+    VectorAllocation,
+    BoxAllocation
+}
+
 declare_lint!(UNNECESSARY_ALLOCATION, Warn,
               "detects unnecessary allocations that can be eliminated")
 
@@ -1284,21 +1285,30 @@ impl LintPass for UnnecessaryAllocation {
     }
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
-        match e.node {
-            ast::ExprUnary(ast::UnUniq, _) | ast::ExprUnary(ast::UnBox, _) => (),
+        // Warn if boxing expressions are immediately borrowed.
+        let allocation = match e.node {
+            ast::ExprUnary(ast::UnUniq, _) |
+            ast::ExprUnary(ast::UnBox, _) => BoxAllocation,
+
             _ => return
-        }
+        };
 
         match cx.tcx.adjustments.borrow().find(&e.id) {
             Some(adjustment) => {
                 match *adjustment {
                     ty::AdjustDerefRef(ty::AutoDerefRef { ref autoref, .. }) => {
-                        match autoref {
-                            &Some(ty::AutoPtr(_, ast::MutImmutable, None)) => {
+                        match (allocation, autoref) {
+                            (VectorAllocation, &Some(ty::AutoPtr(_, _, None))) => {
+                                cx.span_lint(UNNECESSARY_ALLOCATION, e.span,
+                                             "unnecessary allocation, the sigil can be removed");
+                            }
+                            (BoxAllocation,
+                             &Some(ty::AutoPtr(_, ast::MutImmutable, None))) => {
                                 cx.span_lint(UNNECESSARY_ALLOCATION, e.span,
                                              "unnecessary allocation, use & instead");
                             }
-                            &Some(ty::AutoPtr(_, ast::MutMutable, None)) => {
+                            (BoxAllocation,
+                             &Some(ty::AutoPtr(_, ast::MutMutable, None))) => {
                                 cx.span_lint(UNNECESSARY_ALLOCATION, e.span,
                                              "unnecessary allocation, use &mut instead");
                             }

branches/dist-snap/src/librustc/metadata/creader.rs

@@ -24,7 +24,6 @@ use plugin::load::PluginMetadata;
 
 use std::rc::Rc;
 use std::collections::HashMap;
-use std::collections::hashmap::{Occupied, Vacant};
 use syntax::ast;
 use syntax::abi;
 use syntax::attr;
@@ -83,10 +82,7 @@ fn dump_crates(cstore: &CStore) {
 fn warn_if_multiple_versions(diag: &SpanHandler, cstore: &CStore) {
     let mut map = HashMap::new();
     cstore.iter_crate_data(|cnum, data| {
-        match map.entry(data.name()) {
-            Vacant(entry) => { entry.set(vec![cnum]); },
-            Occupied(mut entry) => { entry.get_mut().push(cnum); },
-        }
+        map.find_or_insert_with(data.name(), |_| Vec::new()).push(cnum);
     });
 
     for (name, dupes) in map.into_iter() {

branches/dist-snap/src/librustc/metadata/loader.rs

@@ -237,7 +237,6 @@ use std::slice;
 use std::string;
 
 use std::collections::{HashMap, HashSet};
-use std::collections::hashmap::{Occupied, Vacant};
 use flate;
 use time;
 
@@ -429,18 +428,15 @@ impl<'a> Context<'a> {
                 return FileDoesntMatch
             };
             info!("lib candidate: {}", path.display());
-
-            let slot = match candidates.entry(hash.to_string()) {
-                Occupied(entry) => entry.into_mut(),
-                Vacant(entry) => entry.set((HashSet::new(), HashSet::new())),
-            };
+            let slot = candidates.find_or_insert_with(hash.to_string(), |_| {
+                (HashSet::new(), HashSet::new())
+            });
             let (ref mut rlibs, ref mut dylibs) = *slot;
             if rlib {
                 rlibs.insert(fs::realpath(path).unwrap());
             } else {
                 dylibs.insert(fs::realpath(path).unwrap());
             }
-
             FileMatches
         });