---

yaml
---
r: 194025
b: refs/heads/beta
c: c48bb85
h: refs/heads/master
i:
  194023: 0102a9a
v: v3

Author: fhahn

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: d8baa010ab2257982437c06493e0cfe242dd3697
+refs/heads/beta: c48bb85702aaf8966b0d1c050a7152dce5ac6afa
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/src/compiletest/header.rs

@@ -163,9 +163,6 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
     fn ignore_target(config: &Config) -> String {
         format!("ignore-{}", util::get_os(&config.target))
     }
-    fn ignore_architecture(config: &Config) -> String {
-        format!("ignore-{}", util::get_arch(&config.target))
-    }
     fn ignore_stage(config: &Config) -> String {
         format!("ignore-{}",
                 config.stage_id.split('-').next().unwrap())
@@ -229,7 +226,6 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
     let val = iter_header(testfile, &mut |ln| {
         !parse_name_directive(ln, "ignore-test") &&
         !parse_name_directive(ln, &ignore_target(config)) &&
-        !parse_name_directive(ln, &ignore_architecture(config)) &&
         !parse_name_directive(ln, &ignore_stage(config)) &&
         !(config.mode == common::Pretty && parse_name_directive(ln, "ignore-pretty")) &&
         !(config.target != config.host && parse_name_directive(ln, "ignore-cross-compile")) &&

branches/beta/src/compiletest/procsrv.rs

@@ -10,10 +10,9 @@
 
 #![allow(deprecated)] // for old path, for dynamic_lib
 
-use std::dynamic_lib::DynamicLibrary;
-use std::io::prelude::*;
-use std::old_path::Path;
 use std::process::{ExitStatus, Command, Child, Output, Stdio};
+use std::io::prelude::*;
+use std::dynamic_lib::DynamicLibrary;
 
 fn add_target_env(cmd: &mut Command, lib_path: &str, aux_path: Option<&str>) {
     // Need to be sure to put both the lib_path and the aux path in the dylib

branches/beta/src/compiletest/util.rs

@@ -25,23 +25,6 @@ const OS_TABLE: &'static [(&'static str, &'static str)] = &[
     ("openbsd", "openbsd"),
 ];
 
-const ARCH_TABLE: &'static [(&'static str, &'static str)] = &[
-    ("i386", "x86"),
-    ("i686", "x86"),
-    ("amd64", "x86_64"),
-    ("x86_64", "x86_64"),
-    ("sparc", "sparc"),
-    ("powerpc", "powerpc"),
-    ("arm64", "aarch64"),
-    ("arm", "arm"),
-    ("aarch64", "aarch64"),
-    ("mips", "mips"),
-    ("xcore", "xcore"),
-    ("msp430", "msp430"),
-    ("hexagon", "hexagon"),
-    ("s390x", "systemz"),
-];
-
 pub fn get_os(triple: &str) -> &'static str {
     for &(triple_os, os) in OS_TABLE {
         if triple.contains(triple_os) {
@@ -50,14 +33,6 @@ pub fn get_os(triple: &str) -> &'static str {
     }
     panic!("Cannot determine OS from triple");
 }
-pub fn get_arch(triple: &str) -> &'static str {
-    for &(triple_arch, arch) in ARCH_TABLE {
-        if triple.contains(triple_arch) {
-            return arch
-        }
-    }
-    panic!("Cannot determine Architecture from triple");
-}
 
 pub fn make_new_path(path: &str) -> String {
     assert!(cfg!(windows));

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

@@ -24,7 +24,7 @@ use core::default::Default;
 use core::fmt::Debug;
 use core::hash::{Hash, Hasher};
 use core::iter::{Map, FromIterator, IntoIterator};
-use core::ops::{Index};
+use core::ops::{Index, IndexMut};
 use core::{iter, fmt, mem, usize};
 use Bound::{self, Included, Excluded, Unbounded};
 
@@ -925,6 +925,15 @@ impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<K: Ord, Q: ?Sized, V> IndexMut<Q> for BTreeMap<K, V>
+    where K: Borrow<Q>, Q: Ord
+{
+    fn index_mut(&mut self, key: &Q) -> &mut V {
+        self.get_mut(key).expect("no entry found for key")
+    }
+}
+
 /// Genericises over how to get the correct type of iterator from the correct type
 /// of Node ownership.
 trait Traverse<N> {

branches/beta/src/libcollections/fmt.rs

@@ -262,7 +262,6 @@
 //!
 //! ```
 //! # #![allow(unused_must_use)]
-//! use std::io::Write;
 //! let mut w = Vec::new();
 //! write!(&mut w, "Hello {}!", "world");
 //! ```
@@ -289,15 +288,15 @@
 //!
 //! ```
 //! use std::fmt;
-//! use std::io::{self, Write};
+//! use std::old_io;
 //!
 //! fmt::format(format_args!("this returns {}", "String"));
 //!
-//! let mut some_writer = io::stdout();
+//! let mut some_writer = old_io::stdout();
 //! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro"));
 //!
 //! fn my_fmt_fn(args: fmt::Arguments) {
-//!     write!(&mut io::stdout(), "{}", args);
+//!     write!(&mut old_io::stdout(), "{}", args);
 //! }
 //! my_fmt_fn(format_args!("or a {} too", "function"));
 //! ```

branches/beta/src/libcore/macros.rs

@@ -176,7 +176,6 @@ macro_rules! try {
 ///
 /// ```
 /// # #![allow(unused_must_use)]
-/// use std::io::Write;
 ///
 /// let mut w = Vec::new();
 /// write!(&mut w, "test");

branches/beta/src/libcore/prelude.rs

@@ -29,6 +29,8 @@ pub use marker::{Copy, Send, Sized, Sync};
 pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // Reexported functions
+#[allow(deprecated)]
+pub use iter::range;
 pub use mem::drop;
 
 // Reexported types and traits

branches/beta/src/libcore/result.rs

@@ -78,7 +78,7 @@
 //! let bad_result: Result<int, int> = bad_result.or_else(|i| Ok(11));
 //!
 //! // Consume the result and return the contents with `unwrap`.
-//! let final_awesome_result = good_result.unwrap();
+//! let final_awesome_result = good_result.ok().unwrap();
 //! ```
 //!
 //! # Results must be used
@@ -110,8 +110,7 @@
 //! something like this:
 //!
 //! ```{.ignore}
-//! use std::old_io::*;
-//! use std::old_path::Path;
+//! use std::old_io::{File, Open, Write};
 //!
 //! let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //! // If `write_line` errors, then we'll never know, because the return
@@ -129,8 +128,7 @@
 //! a marginally useful message indicating why:
 //!
 //! ```{.no_run}
-//! use std::old_io::*;
-//! use std::old_path::Path;
+//! use std::old_io::{File, Open, Write};
 //!
 //! let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //! file.write_line("important message").ok().expect("failed to write message");
@@ -140,8 +138,7 @@
 //! You might also simply assert success:
 //!
 //! ```{.no_run}
-//! # use std::old_io::*;
-//! # use std::old_path::Path;
+//! # use std::old_io::{File, Open, Write};
 //!
 //! # let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //! assert!(file.write_line("important message").is_ok());
@@ -151,8 +148,7 @@
 //! Or propagate the error up the call stack with `try!`:
 //!
 //! ```
-//! # use std::old_io::*;
-//! # use std::old_path::Path;
+//! # use std::old_io::{File, Open, Write, IoError};
 //! fn write_message() -> Result<(), IoError> {
 //!     let mut file = File::open_mode(&Path::new("valuable_data.txt"), Open, Write);
 //!     try!(file.write_line("important message"));
@@ -171,8 +167,7 @@
 //! It replaces this:
 //!
 //! ```
-//! use std::old_io::*;
-//! use std::old_path::Path;
+//! use std::old_io::{File, Open, Write, IoError};
 //!
 //! struct Info {
 //!     name: String,
@@ -196,8 +191,7 @@
 //! With this:
 //!
 //! ```
-//! use std::old_io::*;
-//! use std::old_path::Path;
+//! use std::old_io::{File, Open, Write, IoError};
 //!
 //! struct Info {
 //!     name: String,
@@ -452,7 +446,7 @@ impl<T, E> Result<T, E> {
     /// ignoring I/O and parse errors:
     ///
     /// ```
-    /// use std::old_io::*;
+    /// use std::old_io::IoResult;
     ///
     /// let mut buffer: &[u8] = b"1\n2\n3\n4\n";
     /// let mut buffer = &mut buffer;
@@ -466,7 +460,7 @@ impl<T, E> Result<T, E> {
     ///         line.trim_right().parse::<int>().unwrap_or(0)
     ///     });
     ///     // Add the value if there were no errors, otherwise add 0
-    ///     sum += val.unwrap_or(0);
+    ///     sum += val.ok().unwrap_or(0);
     /// }
     ///
     /// assert!(sum == 10);

branches/beta/src/libcoretest/str.rs

@@ -35,7 +35,7 @@ fn test_bool_from_str() {
 fn check_contains_all_substrings(s: &str) {
     assert!(s.contains(""));
     for i in 0..s.len() {
-        for j in i+1..s.len() + 1 {
+        for j in range(i+1, s.len() + 1) {
             assert!(s.contains(&s[i..j]));
         }
     }

branches/beta/src/liblog/lib.rs

@@ -183,9 +183,10 @@ use std::io::{self, Stderr};
 use std::io::prelude::*;
 use std::mem;
 use std::env;
+use std::ptr;
 use std::rt;
 use std::slice;
-use std::sync::{Once, ONCE_INIT, StaticMutex, MUTEX_INIT};
+use std::sync::{Once, ONCE_INIT};
 
 use directive::LOG_LEVEL_NAMES;
 
@@ -201,8 +202,6 @@ pub const MAX_LOG_LEVEL: u32 = 255;
 /// The default logging level of a crate if no other is specified.
 const DEFAULT_LOG_LEVEL: u32 = 1;
 
-static LOCK: StaticMutex = MUTEX_INIT;
-
 /// An unsafe constant that is the maximum logging level of any module
 /// specified. This is the first line of defense to determining whether a
 /// logging statement should be run.
@@ -287,18 +286,9 @@ impl Drop for DefaultLogger {
 pub fn log(level: u32, loc: &'static LogLocation, args: fmt::Arguments) {
     // Test the literal string from args against the current filter, if there
     // is one.
-    unsafe {
-        let _g = LOCK.lock();
-        match FILTER as uint {
-            0 => {}
-            1 => panic!("cannot log after main thread has exited"),
-            n => {
-                let filter = mem::transmute::<_, &String>(n);
-                if !args.to_string().contains(&filter[..]) {
-                    return
-                }
-            }
-        }
+    match unsafe { FILTER.as_ref() } {
+        Some(filter) if !args.to_string().contains(&filter[..]) => return,
+        _ => {}
     }
 
     // Completely remove the local logger from TLS in case anyone attempts to
@@ -380,15 +370,9 @@ pub fn mod_enabled(level: u32, module: &str) -> bool {
 
     // This assertion should never get tripped unless we're in an at_exit
     // handler after logging has been torn down and a logging attempt was made.
+    assert!(unsafe { !DIRECTIVES.is_null() });
 
-    let _g = LOCK.lock();
-    unsafe {
-        assert!(DIRECTIVES as uint != 0);
-        assert!(DIRECTIVES as uint != 1,
-                "cannot log after the main thread has exited");
-
-        enabled(level, module, (*DIRECTIVES).iter())
-    }
+    enabled(level, module, unsafe { (*DIRECTIVES).iter() })
 }
 
 fn enabled(level: u32,
@@ -444,14 +428,14 @@ fn init() {
 
         // Schedule the cleanup for the globals for when the runtime exits.
         rt::at_exit(move || {
-            let _g = LOCK.lock();
             assert!(!DIRECTIVES.is_null());
-            let _directives = Box::from_raw(DIRECTIVES);
-            DIRECTIVES = 1 as *mut _;
+            let _directives: Box<Vec<directive::LogDirective>> =
+                Box::from_raw(DIRECTIVES);
+            DIRECTIVES = ptr::null_mut();
 
             if !FILTER.is_null() {
-                let _filter = Box::from_raw(FILTER);
-                FILTER = 1 as *mut _;
+                let _filter: Box<String> = Box::from_raw(FILTER);
+                FILTER = 0 as *mut _;
             }
         });
     }

branches/beta/src/librustc/middle/astencode.rs

@@ -43,7 +43,6 @@ use std::io::SeekFrom;
 use std::io::prelude::*;
 use std::num::FromPrimitive;
 use std::rc::Rc;
-use std::fmt::Debug;
 
 use rbml::reader;
 use rbml::writer::Encoder;
@@ -314,11 +313,9 @@ trait def_id_encoder_helpers {
     fn emit_def_id(&mut self, did: ast::DefId);
 }
 
-impl<S:serialize::Encoder> def_id_encoder_helpers for S
-    where <S as serialize::serialize::Encoder>::Error: Debug
-{
+impl<S:serialize::Encoder> def_id_encoder_helpers for S {
     fn emit_def_id(&mut self, did: ast::DefId) {
-        did.encode(self).unwrap()
+        did.encode(self).ok().unwrap()
     }
 }
 
@@ -328,18 +325,15 @@ trait def_id_decoder_helpers {
                          cdata: &cstore::crate_metadata) -> ast::DefId;
 }
 
-impl<D:serialize::Decoder> def_id_decoder_helpers for D
-    where <D as serialize::serialize::Decoder>::Error: Debug
-{
+impl<D:serialize::Decoder> def_id_decoder_helpers for D {
     fn read_def_id(&mut self, dcx: &DecodeContext) -> ast::DefId {
-        let did: ast::DefId = Decodable::decode(self).unwrap();
+        let did: ast::DefId = Decodable::decode(self).ok().unwrap();
         did.tr(dcx)
     }
 
     fn read_def_id_nodcx(&mut self,
-                         cdata: &cstore::crate_metadata)
-                         -> ast::DefId {
-        let did: ast::DefId = Decodable::decode(self).unwrap();
+                         cdata: &cstore::crate_metadata) -> ast::DefId {
+        let did: ast::DefId = Decodable::decode(self).ok().unwrap();
         decoder::translate_def_id(cdata, did)
     }
 }
@@ -1790,7 +1784,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
     fn read_closure_kind<'b, 'c>(&mut self, _dcx: &DecodeContext<'b, 'c, 'tcx>)
                                  -> ty::ClosureKind
     {
-        Decodable::decode(self).unwrap()
+        Decodable::decode(self).ok().unwrap()
     }
 
     fn read_closure_ty<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)

branches/beta/src/librustc/middle/cfg/graphviz.rs

@@ -54,10 +54,10 @@ fn replace_newline_with_backslash_l(s: String) -> String {
 }
 
 impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {
-    fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(&self.name[..]).unwrap() }
+    fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(&self.name[..]).ok().unwrap() }
 
     fn node_id(&'a self, &(i,_): &Node<'a>) -> dot::Id<'a> {
-        dot::Id::new(format!("N{}", i.node_id())).unwrap()
+        dot::Id::new(format!("N{}", i.node_id())).ok().unwrap()
     }
 
     fn node_label(&'a self, &(i, n): &Node<'a>) -> dot::LabelText<'a> {