---

yaml
---
r: 170326
b: refs/heads/auto
c: 9dea210
h: refs/heads/master
v: v3

Author: Zoxc

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 20bce44810eb5146f609b4362990ef8835e55bb5
+refs/heads/auto: 9dea210730f1e5f8de32302db786deca3381f2bb
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/dist.mk

@@ -59,7 +59,6 @@ PKG_FILES := \
       rustllvm                                 \
       snapshots.txt                            \
       rust-installer                           \
-      rustbook                                 \
       test)                                    \
     $(PKG_GITMODULES)                          \
     $(filter-out config.stamp, \

branches/auto/mk/main.mk

@@ -15,10 +15,8 @@
 # The version number
 CFG_RELEASE_NUM=1.0.0
 
-# An optional number to put after the label, e.g. '.2' -> '-beta.2'
-# NB Make sure it starts with a dot to conform to semver pre-release
-# versions (section 9)
-CFG_PRERELEASE_VERSION=
+# An optional number to put after the label, e.g. '2' -> '-beta2'
+CFG_BETA_CYCLE=
 
 CFG_FILENAME_EXTRA=4e7c5e5c
 
@@ -31,8 +29,8 @@ CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),beta)
 # The beta channel is temporarily called 'alpha'
-CFG_RELEASE=$(CFG_RELEASE_NUM)-alpha$(CFG_PRERELEASE_VERSION)
-CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-alpha$(CFG_PRERELEASE_VERSION)
+CFG_RELEASE=$(CFG_RELEASE_NUM)-alpha$(CFG_BETA_CYCLE)
+CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-alpha$(CFG_BETA_CYCLE)
 CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),nightly)

branches/auto/src/libcollections/bit.rs

@@ -134,7 +134,7 @@ static FALSE: bool = false;
 /// # Examples
 ///
 /// ```rust
-/// use std::collections::Bitv;
+/// use collections::Bitv;
 ///
 /// let mut bv = Bitv::from_elem(10, false);
 ///

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

@@ -409,6 +409,7 @@ impl<'a> CrateReader<'a> {
                     crate_name: name,
                     hash: hash.map(|a| &*a),
                     filesearch: self.sess.target_filesearch(kind),
+                    target: &self.sess.target.target,
                     triple: &self.sess.opts.target_triple[],
                     root: root,
                     rejected_via_hash: vec!(),
@@ -472,6 +473,7 @@ impl<'a> CrateReader<'a> {
             crate_name: &name[],
             hash: None,
             filesearch: self.sess.host_filesearch(PathKind::Crate),
+            target: &self.sess.host,
             triple: config::host_triple(),
             root: &None,
             rejected_via_hash: vec!(),
@@ -486,6 +488,7 @@ impl<'a> CrateReader<'a> {
                 target_only = true;
                 should_link = info.should_link;
 
+                load_ctxt.target = &self.sess.target.target;
                 load_ctxt.triple = target_triple;
                 load_ctxt.filesearch = self.sess.target_filesearch(PathKind::Crate);
                 load_ctxt.load_library_crate()

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

@@ -225,6 +225,7 @@ use metadata::filesearch::{FileSearch, FileMatches, FileDoesntMatch};
 use syntax::codemap::Span;
 use syntax::diagnostic::SpanHandler;
 use util::fs;
+use rustc_back::target::Target;
 
 use std::ffi::CString;
 use std::cmp;
@@ -248,6 +249,8 @@ pub struct Context<'a> {
     pub ident: &'a str,
     pub crate_name: &'a str,
     pub hash: Option<&'a Svh>,
+    // points to either self.sess.target.target or self.sess.host, must match triple
+    pub target: &'a Target,
     pub triple: &'a str,
     pub filesearch: FileSearch<'a>,
     pub root: &'a Option<CratePaths>,
@@ -499,7 +502,7 @@ impl<'a> Context<'a> {
 
         for lib in m.into_iter() {
             info!("{} reading metadata from: {}", flavor, lib.display());
-            let metadata = match get_metadata_section(self.sess.target.target.options.is_like_osx,
+            let metadata = match get_metadata_section(self.target.options.is_like_osx,
                                                       &lib) {
                 Ok(blob) => {
                     if self.crate_matches(blob.as_slice(), &lib) {
@@ -588,7 +591,7 @@ impl<'a> Context<'a> {
     // Returns the corresponding (prefix, suffix) that files need to have for
     // dynamic libraries
     fn dylibname(&self) -> (String, String) {
-        let t = &self.sess.target.target;
+        let t = &self.target;
         (t.options.dll_prefix.clone(), t.options.dll_suffix.clone())
     }
 

branches/auto/src/librustc/session/mod.rs

@@ -25,6 +25,8 @@ use syntax::parse::token;
 use syntax::parse::ParseSess;
 use syntax::{ast, codemap};
 
+use rustc_back::target::Target;
+
 use std::os;
 use std::cell::{Cell, RefCell};
 
@@ -35,6 +37,7 @@ pub mod search_paths;
 // session for a single crate.
 pub struct Session {
     pub target: config::Config,
+    pub host: Target,
     pub opts: config::Options,
     pub cstore: CStore,
     pub parse_sess: ParseSess,
@@ -243,6 +246,13 @@ pub fn build_session_(sopts: config::Options,
                       local_crate_source_file: Option<Path>,
                       span_diagnostic: diagnostic::SpanHandler)
                       -> Session {
+    let host = match Target::search(config::host_triple()) {
+        Ok(t) => t,
+        Err(e) => {
+            span_diagnostic.handler()
+                .fatal((format!("Error loading host specification: {}", e)).as_slice());
+    }
+    };
     let target_cfg = config::build_target_config(&sopts, &span_diagnostic);
     let p_s = parse::new_parse_sess_special_handler(span_diagnostic);
     let default_sysroot = match sopts.maybe_sysroot {
@@ -268,6 +278,7 @@ pub fn build_session_(sopts: config::Options,
 
     let sess = Session {
         target: target_cfg,
+        host: host,
         opts: sopts,
         cstore: CStore::new(token::get_ident_interner()),
         parse_sess: p_s,

branches/auto/src/librustdoc/test.rs

@@ -215,6 +215,7 @@ pub fn maketest(s: &str, cratename: Option<&str>, lints: bool, dont_insert_main:
     let mut prog = String::new();
     if lints {
         prog.push_str(r"
+#![deny(warnings)]
 #![allow(unused_variables, unused_assignments, unused_mut, unused_attributes, dead_code)]
 ");
     }

branches/auto/src/libstd/ffi/c_str.rs

@@ -84,7 +84,7 @@ impl CString {
         unsafe { CString::from_vec_unchecked(v) }
     }
 
-    /// Create a C-compatible string from a byte vector without checking for
+    /// Create a C-compatibel string from a byte vector without checking for
     /// interior 0 bytes.
     ///
     /// This method is equivalent to `from_vec` except that no runtime assertion

branches/auto/src/libstd/sys/unix/condvar.rs

@@ -76,20 +76,8 @@ impl Condvar {
     }
 
     #[inline]
-    #[cfg(not(target_os = "dragonfly"))]
     pub unsafe fn destroy(&self) {
         let r = ffi::pthread_cond_destroy(self.inner.get());
         debug_assert_eq!(r, 0);
     }
-
-    #[inline]
-    #[cfg(target_os = "dragonfly")]
-    pub unsafe fn destroy(&self) {
-        let r = ffi::pthread_cond_destroy(self.inner.get());
-        // On DragonFly pthread_cond_destroy() returns EINVAL if called on
-        // a condvar that was just initialized with
-        // ffi::PTHREAD_COND_INITIALIZER. Once it is used or
-        // pthread_cond_init() is called, this behaviour no longer occurs.
-        debug_assert!(r == 0 || r == libc::EINVAL);
-    }
 }

branches/auto/src/libstd/sys/unix/mutex.rs

@@ -48,20 +48,8 @@ impl Mutex {
         ffi::pthread_mutex_trylock(self.inner.get()) == 0
     }
     #[inline]
-    #[cfg(not(target_os = "dragonfly"))]
     pub unsafe fn destroy(&self) {
         let r = ffi::pthread_mutex_destroy(self.inner.get());
         debug_assert_eq!(r, 0);
     }
-    #[inline]
-    #[cfg(target_os = "dragonfly")]
-    pub unsafe fn destroy(&self) {
-        use libc;
-        let r = ffi::pthread_mutex_destroy(self.inner.get());
-        // On DragonFly pthread_mutex_destroy() returns EINVAL if called on a
-        // mutex that was just initialized with ffi::PTHREAD_MUTEX_INITIALIZER.
-        // Once it is used (locked/unlocked) or pthread_mutex_init() is called,
-        // this behaviour no longer occurs.
-        debug_assert!(r == 0 || r == libc::EINVAL);
-    }
 }

branches/auto/src/libstd/sys/unix/rwlock.rs

@@ -50,21 +50,8 @@ impl RWLock {
     #[inline]
     pub unsafe fn write_unlock(&self) { self.read_unlock() }
     #[inline]
-    #[cfg(not(target_os = "dragonfly"))]
     pub unsafe fn destroy(&self) {
         let r = ffi::pthread_rwlock_destroy(self.inner.get());
         debug_assert_eq!(r, 0);
     }
-
-    #[inline]
-    #[cfg(target_os = "dragonfly")]
-    pub unsafe fn destroy(&self) {
-        use libc;
-        let r = ffi::pthread_rwlock_destroy(self.inner.get());
-        // On DragonFly pthread_rwlock_destroy() returns EINVAL if called on a
-        // rwlock that was just initialized with
-        // ffi::PTHREAD_RWLOCK_INITIALIZER. Once it is used (locked/unlocked)
-        // or pthread_rwlock_init() is called, this behaviour no longer occurs.
-        debug_assert!(r == 0 || r == libc::EINVAL);
-    }
 }

branches/auto/src/test/bench/core-map.rs

@@ -14,6 +14,7 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 use std::os;
 use std::rand::{Rng, IsaacRng, SeedableRng};
 use std::time::Duration;
+use std::uint;
 
 fn timed<F>(label: &str, f: F) where F: FnMut() {
     println!("  {}: {}", label, Duration::span(f));

branches/auto/src/test/bench/core-set.rs

@@ -22,6 +22,7 @@ use std::collections::hash_map::Hasher;
 use std::hash::Hash;
 use std::os;
 use std::time::Duration;
+use std::uint;
 
 struct Results {
     sequential_ints: Duration,

branches/auto/src/test/bench/core-uint-to-str.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use std::os;
+use std::uint;
 
 fn main() {
     let args = os::args();

branches/auto/src/test/bench/msgsend-pipes-shared.rs

@@ -22,6 +22,7 @@ use std::sync::mpsc::{channel, Sender, Receiver};
 use std::os;
 use std::thread::Thread;
 use std::time::Duration;
+use std::uint;
 
 fn move_out<T>(_x: T) {}
 

branches/auto/src/test/bench/msgsend-pipes.rs

@@ -18,6 +18,9 @@ use std::sync::mpsc::{channel, Sender, Receiver};
 use std::os;
 use std::thread::Thread;
 use std::time::Duration;
+use std::uint;
+
+fn move_out<T>(_x: T) {}
 
 enum request {
     get_count,
@@ -39,7 +42,7 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
           _ => { }
         }
     }
-    responses.send(count).unwrap();
+    responses.send(count);
     //println!("server exiting");
 }
 

branches/auto/src/test/bench/msgsend-ring-mutex-arcs.rs

@@ -21,6 +21,7 @@
 use std::os;
 use std::sync::{Arc, Future, Mutex, Condvar};
 use std::time::Duration;
+use std::uint;
 
 // A poor man's pipe.
 type pipe = Arc<(Mutex<Vec<uint>>, Condvar)>;
@@ -75,7 +76,7 @@ fn main() {
     let num_tasks = args[1].parse::<uint>().unwrap();
     let msg_per_task = args[2].parse::<uint>().unwrap();
 
-    let (num_chan, num_port) = init();
+    let (mut num_chan, num_port) = init();
 
     let mut p = Some((num_chan, num_port));
     let dur = Duration::span(|| {

branches/auto/src/test/bench/rt-parfib.rs

@@ -11,22 +11,23 @@
 use std::sync::mpsc::channel;
 use std::os;
 use std::thread::Thread;
+use std::uint;
 
 // A simple implementation of parfib. One subtree is found in a new
 // task and communicated over a oneshot pipe, the other is found
 // locally. There is no sequential-mode threshold.
 
 fn parfib(n: uint) -> uint {
-    if n == 0 || n == 1 {
+    if(n == 0 || n == 1) {
         return 1;
     }
 
     let (tx, rx) = channel();
     Thread::spawn(move|| {
-        tx.send(parfib(n-1)).unwrap();
+        tx.send(parfib(n-1));
     });
     let m2 = parfib(n-2);
-    return rx.recv().unwrap() + m2;
+    return (rx.recv().unwrap() + m2);
 }
 
 fn main() {

branches/auto/src/test/bench/shootout-binarytrees.rs

@@ -92,7 +92,7 @@ fn main() {
     let long_lived_arena = TypedArena::new();
     let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);
 
-    let messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
+    let mut messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
             use std::num::Int;
             let iterations = 2i.pow((max_depth - depth + min_depth) as uint);
             Thread::scoped(move|| {

branches/auto/src/test/bench/shootout-chameneos-redux.rs

@@ -182,7 +182,7 @@ fn rendezvous(nn: uint, set: Vec<Color>) {
     let (to_rendezvous_log, from_creatures_log) = channel::<String>();
 
     // these channels will allow us to talk to each creature by 'name'/index
-    let to_creature: Vec<Sender<CreatureInfo>> =
+    let mut to_creature: Vec<Sender<CreatureInfo>> =
         set.iter().enumerate().map(|(ii, &col)| {
             // create each creature as a listener with a port, and
             // give us a channel to talk to each

branches/auto/src/test/bench/shootout-fannkuch-redux.rs

@@ -128,7 +128,7 @@ impl Perm {
 }
 
 
-fn reverse(tperm: &mut [i32], k: uint) {
+fn reverse(tperm: &mut [i32], mut k: uint) {
     tperm.slice_to_mut(k).reverse()
 }
 
@@ -163,7 +163,7 @@ fn fannkuch(n: i32) -> (i32, i32) {
     let mut futures = vec![];
     let k = perm.max() / N;
 
-    for (_, j) in range(0, N).zip(iter::count(0, k)) {
+    for (i, j) in range(0, N).zip(iter::count(0, k)) {
         let max = cmp::min(j+k, perm.max());
 
         futures.push(Thread::scoped(move|| {

branches/auto/src/test/bench/shootout-k-nucleotide.rs

@@ -43,6 +43,7 @@
 #![feature(box_syntax)]
 
 use std::ascii::OwnedAsciiExt;
+use std::iter::repeat;
 use std::slice;
 use std::sync::Arc;
 use std::thread::Thread;

branches/auto/src/test/bench/shootout-nbody.rs

@@ -202,6 +202,6 @@ fn shift_mut_ref<'a, T>(r: &mut &'a mut [T]) -> Option<&'a mut T> {
         raw.data = raw.data.offset(1);
         raw.len -= 1;
         *r = mem::transmute(raw);
-        Some({ &mut *ret })
+        Some(unsafe { &mut *ret })
     }
 }

branches/auto/src/test/bench/shootout-reverse-complement.rs

@@ -229,7 +229,7 @@ unsafe impl<T: 'static> Send for Racy<T> {}
 
 /// Executes a closure in parallel over the given iterator over mutable slice.
 /// The closure `f` is run in parallel with an element of `iter`.
-fn parallel<'a, I, T, F>(iter: I, f: F)
+fn parallel<'a, I, T, F>(mut iter: I, f: F)
         where T: 'a+Send + Sync,
               I: Iterator<Item=&'a mut [T]>,
               F: Fn(&mut [T]) + Sync {