---

yaml
---
r: 155399
b: refs/heads/try2
c: 9ff3081
h: refs/heads/master
i:
  155397: ed25871
  155395: e863aed
  155391: 462693d
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: c8b767dd3d06fcabc2df753cbb9fd694ebc0eec6
+refs/heads/try2: 9ff308137afcacb4bc0d47e00d1dbb730229d932
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/fmt/float.rs

@@ -28,21 +28,12 @@ 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,
-    /// 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,
+    ExpDec
 }
 
 /// 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),
@@ -53,17 +44,11 @@ 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,
-    /// `+` will be printed for positive values, and `-` will be printed for
-    /// negative values.
-    SignAll,
+    SignNeg
 }
 
-static DIGIT_P_RADIX: uint = ('p' as uint) - ('a' as uint) + 11u;
 static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u;
 
 /**
@@ -111,9 +96,6 @@ 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),
         _ => ()
     }
 
@@ -123,16 +105,10 @@ 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 match sign {
-                SignAll => return f("+inf".as_bytes()),
-                _       => return f("inf".as_bytes()),
-            };
+            return f("inf".as_bytes());
         }
         FPInfinite if num < _0 => {
-            return match sign {
-                SignNone => return f("inf".as_bytes()),
-                _        => return f("-inf".as_bytes()),
-            };
+            return f("-inf".as_bytes());
         }
         _ => {}
     }
@@ -147,11 +123,10 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
 
     let (num, exp) = match exp_format {
         ExpNone => (num, 0i32),
-        ExpDec | ExpBin if num == _0 => (num, 0i32),
-        ExpDec | ExpBin => {
+        ExpDec if num == _0 => (num, 0i32),
+        ExpDec => {
             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"),
             };
 
@@ -185,21 +160,16 @@ 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 {
-        DigAll          => (false, 0u,      false),
-        DigMax(count)   => (true,  count+1, false),
-        DigExact(count) => (true,  count+1, true)
+        DigMax(count)   => (true, count + 1, false),
+        DigExact(count) => (true, count + 1, true)
     };
 
     // Decide what sign to put in front
     match sign {
-        SignNeg | SignAll if neg => {
+        SignNeg if neg => {
             buf[end] = b'-';
             end += 1;
         }
-        SignAll => {
-            buf[end] = b'+';
-            end += 1;
-        }
         _ => ()
     }
 
@@ -329,8 +299,6 @@ 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;
@@ -356,11 +324,6 @@ 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/try2/src/librustc/back/link.rs

@@ -397,13 +397,6 @@ 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/try2/src/librustc/diagnostics.rs

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

branches/try2/src/librustc/driver/config.rs

@@ -31,6 +31,7 @@ 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};
@@ -804,8 +805,11 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
             Some(s) => s,
             None => early_error("--extern value must be of the format `foo=bar`"),
         };
-        let locs = externs.find_or_insert(name.to_string(), Vec::new());
-        locs.push(location.to_string());
+
+        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 crate_name = matches.opt_str("crate-name");

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

@@ -36,6 +36,7 @@ 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;
@@ -1203,15 +1204,18 @@ 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("_") {
-                            mutables.insert_or_update_with(ident.name.uint(),
-                                vec!(id), |_, old| { old.push(id); });
+                            match mutables.entry(ident.name.uint()) {
+                                Vacant(entry) => { entry.set(vec![id]); },
+                                Occupied(mut entry) => { entry.get_mut().push(id); },
+                            }
                         }
                     }
                     _ => {
@@ -1269,11 +1273,6 @@ impl LintPass for UnusedMut {
     }
 }
 
-enum Allocation {
-    VectorAllocation,
-    BoxAllocation
-}
-
 declare_lint!(UNNECESSARY_ALLOCATION, Warn,
               "detects unnecessary allocations that can be eliminated")
 
@@ -1285,30 +1284,21 @@ impl LintPass for UnnecessaryAllocation {
     }
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
-        // Warn if boxing expressions are immediately borrowed.
-        let allocation = match e.node {
-            ast::ExprUnary(ast::UnUniq, _) |
-            ast::ExprUnary(ast::UnBox, _) => BoxAllocation,
-
+        match e.node {
+            ast::ExprUnary(ast::UnUniq, _) | ast::ExprUnary(ast::UnBox, _) => (),
             _ => return
-        };
+        }
 
         match cx.tcx.adjustments.borrow().find(&e.id) {
             Some(adjustment) => {
                 match *adjustment {
                     ty::AdjustDerefRef(ty::AutoDerefRef { ref autoref, .. }) => {
-                        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))) => {
+                        match autoref {
+                            &Some(ty::AutoPtr(_, ast::MutImmutable, None)) => {
                                 cx.span_lint(UNNECESSARY_ALLOCATION, e.span,
                                              "unnecessary allocation, use & instead");
                             }
-                            (BoxAllocation,
-                             &Some(ty::AutoPtr(_, ast::MutMutable, None))) => {
+                            &Some(ty::AutoPtr(_, ast::MutMutable, None)) => {
                                 cx.span_lint(UNNECESSARY_ALLOCATION, e.span,
                                              "unnecessary allocation, use &mut instead");
                             }

branches/try2/src/librustc/metadata/creader.rs

@@ -24,6 +24,7 @@ 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;
@@ -82,7 +83,10 @@ 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| {
-        map.find_or_insert_with(data.name(), |_| Vec::new()).push(cnum);
+        match map.entry(data.name()) {
+            Vacant(entry) => { entry.set(vec![cnum]); },
+            Occupied(mut entry) => { entry.get_mut().push(cnum); },
+        }
     });
 
     for (name, dupes) in map.into_iter() {

branches/try2/src/librustc/metadata/loader.rs

@@ -237,6 +237,7 @@ use std::slice;
 use std::string;
 
 use std::collections::{HashMap, HashSet};
+use std::collections::hashmap::{Occupied, Vacant};
 use flate;
 use time;
 
@@ -428,15 +429,18 @@ impl<'a> Context<'a> {
                 return FileDoesntMatch
             };
             info!("lib candidate: {}", path.display());
-            let slot = candidates.find_or_insert_with(hash.to_string(), |_| {
-                (HashSet::new(), HashSet::new())
-            });
+
+            let slot = match candidates.entry(hash.to_string()) {
+                Occupied(entry) => entry.into_mut(),
+                Vacant(entry) => entry.set((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
         });