---

yaml
---
r: 149549
b: refs/heads/try2
c: d222f03
h: refs/heads/master
i:
  149547: c129bf4
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: 3e531ed0edd44c5af714fdeaa0cddb9d5c8154a2
+refs/heads/try2: d222f03f42fe855d2fadc87010453bcfc2a669e1
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/.travis.yml

@@ -39,10 +39,13 @@ before_script:
 # manually disables bringing in these two libraries, but the stock LLVM was
 # apparently built with these options. We provide these options when building so
 # the `rustc` binary can successfully link.
-script:
-  - make tidy
-  - RUSTFLAGS="-C link-args='-lffi -lncurses'" make -j4 rustc-stage1
-  - make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail
+#
+# As a result of https://github.com/travis-ci/travis-ci/issues/1066, we run
+# everything in one large command instead of multiple commands.
+script: |
+  make tidy &&
+  RUSTFLAGS="-C link-args='-lffi -lncurses'" make -j4 rustc-stage1 &&
+  make check-stage1-std check-stage1-rpass check-stage1-cfail check-stage1-rfail
 
 env:
   - NO_BENCH=1

branches/try2/mk/crates.mk

@@ -65,18 +65,18 @@ DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
               collections time extra
 DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
                 test time
-DEPS_flate := std native:miniz
+DEPS_flate := std extra native:miniz
 DEPS_arena := std collections
 DEPS_glob := std
-DEPS_serialize := std
+DEPS_serialize := std collections
 DEPS_term := std collections
 DEPS_semver := std
 DEPS_uuid := std serialize
 DEPS_sync := std
 DEPS_getopts := std
-DEPS_collections := std serialize
+DEPS_collections := std
 DEPS_fourcc := syntax std
-DEPS_num := std extra
+DEPS_num := std
 DEPS_test := std extra collections getopts serialize term
 DEPS_time := std serialize
 

branches/try2/mk/tests.mk

@@ -171,7 +171,9 @@ endif
 # Main test targets
 ######################################################################
 
-check: cleantestlibs cleantmptestlogs tidy all check-stage2
+check: cleantmptestlogs cleantestlibs tidy check-notidy
+
+check-notidy: cleantmptestlogs cleantestlibs all check-stage2
 	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
 
 check-lite: cleantestlibs cleantmptestlogs \

branches/try2/src/README.md

@@ -10,6 +10,21 @@ Source layout:
 | `libgreen/`         | The M:N runtime library                                   |
 | `libnative/`        | The 1:1 runtime library                                   |
 | `libsyntax/`        | The Rust parser and pretty-printer                        |
+| `libcollections/`   | A collection of useful data structures and containers     |
+| `libnum/`           | Extended number support library (complex, rational, etc)  |
+| `libtest/`          | Rust's test-runner code                                   |
+| ------------------- | --------------------------------------------------------- |
+| `libarena/`         | The arena (a fast but limited) memory allocator           |
+| `libflate/`         | Simple compression library                                |
+| `libfourcc/`        | Data format identifier library                            |
+| `libgetopts/`       | Get command-line-options library                          |
+| `libglob/`          | Unix glob patterns library                                |
+| `libsemver/`        | Rust's semantic versioning library                        |
+| `libserialize/`     | Encode-Decode types library                               |
+| `libsync/`          | Concurrency mechanisms and primitives                     |
+| `libterm/`          | ANSI color library for terminals                          |
+| `libtime/`          | Time operations library                                   |
+| `libuuid/`          | UUID's handling code                                      |
 | ------------------- | --------------------------------------------------------- |
 | `rt/`               | The runtime system                                        |
 | `rt/rust_*.c`       | - Some of the runtime services                            |
@@ -31,8 +46,13 @@ Source layout:
 | ------------------- | --------------------------------------------------------- |
 | `librustdoc/`       | The Rust API documentation tool                           |
 | `libuv/`            | The libuv submodule                                       |
+| `librustuv/`        | Rust libuv support code                                   |
 | ------------------- | --------------------------------------------------------- |
 | `llvm/`             | The LLVM submodule                                        |
 | `rustllvm/`         | LLVM support code                                         |
 | ------------------- | --------------------------------------------------------- |
 | `etc/`              | Scripts, editors support, misc                            |
+
+
+NOTE: This list (especially the second part of the table which contains modules and libraries)
+is highly volatile and subject to change.

branches/try2/src/doc/rust.md

@@ -875,16 +875,16 @@ An example of what will and will not work for `use` items:
 
 ~~~~
 # #[allow(unused_imports)];
-use foo::extra::json;    // good: foo is at the root of the crate
+use foo::native::start;  // good: foo is at the root of the crate
 use foo::baz::foobaz;    // good: foo is at the root of the crate
 
 mod foo {
-    extern crate extra;
+    extern crate native;
 
-    use foo::extra::json;  // good: foo is at crate root
-//  use extra::json::*;    // bad:  extra is not at the crate root
-    use self::baz::foobaz; // good: self refers to module 'foo'
-    use foo::bar::foobar;  // good: foo is at crate root
+    use foo::native::start; // good: foo is at crate root
+//  use native::start;      // bad:  native is not at the crate root
+    use self::baz::foobaz;  // good: self refers to module 'foo'
+    use foo::bar::foobar;   // good: foo is at crate root
 
     pub mod bar {
         pub fn foobar() { }

branches/try2/src/doc/tutorial.md

@@ -1420,8 +1420,8 @@ bad, but often copies are expensive. So we’d like to define a function
 that takes the points by pointer. We can use references to do this:
 
 ~~~
+use std::num::sqrt;
 # struct Point { x: f64, y: f64 }
-# fn sqrt(f: f64) -> f64 { 0.0 }
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;

branches/try2/src/libarena/lib.rs

@@ -167,13 +167,12 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
 // is necessary in order to properly do cleanup if a failure occurs
 // during an initializer.
 #[inline]
-unsafe fn bitpack_tydesc_ptr(p: *TyDesc, is_done: bool) -> uint {
-    let p_bits: uint = transmute(p);
-    p_bits | (is_done as uint)
+fn bitpack_tydesc_ptr(p: *TyDesc, is_done: bool) -> uint {
+    p as uint | (is_done as uint)
 }
 #[inline]
-unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TyDesc, bool) {
-    (transmute(p & !1), p & 1 == 1)
+fn un_bitpack_tydesc_ptr(p: uint) -> (*TyDesc, bool) {
+    ((p & !1) as *TyDesc, p & 1 == 1)
 }
 
 impl Arena {

branches/try2/src/libcollections/dlist.rs

@@ -30,8 +30,6 @@ use std::iter;
 
 use deque::Deque;
 
-use serialize::{Encodable, Decodable, Encoder, Decoder};
-
 /// A doubly-linked list.
 pub struct DList<T> {
     priv length: uint,
@@ -630,31 +628,6 @@ impl<A: Clone> Clone for DList<A> {
     }
 }
 
-impl<
-    S: Encoder,
-    T: Encodable<S>
-> Encodable<S> for DList<T> {
-    fn encode(&self, s: &mut S) {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                s.emit_seq_elt(i, |s| e.encode(s));
-            }
-        })
-    }
-}
-
-impl<D:Decoder,T:Decodable<D>> Decodable<D> for DList<T> {
-    fn decode(d: &mut D) -> DList<T> {
-        let mut list = DList::new();
-        d.read_seq(|d, len| {
-            for i in range(0u, len) {
-                list.push_back(d.read_seq_elt(i, |d| Decodable::decode(d)));
-            }
-        });
-        list
-    }
-}
-
 #[cfg(test)]
 mod tests {
     extern crate test;

branches/try2/src/libcollections/enum_set.rs

@@ -15,7 +15,7 @@
 
 use std::num::Bitwise;
 
-#[deriving(Clone, Eq, Hash, Show, Encodable, Decodable)]
+#[deriving(Clone, Eq, Hash, Show)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set

branches/try2/src/libcollections/hashmap.rs

@@ -53,6 +53,7 @@
 //! ```
 
 use std::cmp::max;
+use std::default::Default;
 use std::fmt;
 use std::hash::{Hash, Hasher, sip};
 use std::iter::{FilterMap, Chain, Repeat, Zip};
@@ -65,8 +66,6 @@ use std::vec::{Items, MutItems};
 use std::vec_ng::Vec;
 use std::vec_ng;
 
-use serialize::{Encodable, Decodable, Encoder, Decoder};
-
 static INITIAL_CAPACITY: uint = 32u; // 2^5
 
 struct Bucket<K,V> {
@@ -912,71 +911,6 @@ pub type SetAlgebraItems<'a, T> =
     FilterMap<'static,(&'a HashSet<T>, &'a T), &'a T,
               Zip<Repeat<&'a HashSet<T>>,SetItems<'a,T>>>;
 
-impl<
-    E: Encoder,
-    K: Encodable<E> + Hash + Eq,
-    V: Encodable<E>
-> Encodable<E> for HashMap<K, V> {
-    fn encode(&self, e: &mut E) {
-        e.emit_map(self.len(), |e| {
-            let mut i = 0;
-            for (key, val) in self.iter() {
-                e.emit_map_elt_key(i, |e| key.encode(e));
-                e.emit_map_elt_val(i, |e| val.encode(e));
-                i += 1;
-            }
-        })
-    }
-}
-
-impl<
-    D: Decoder,
-    K: Decodable<D> + Hash + Eq,
-    V: Decodable<D>
-> Decodable<D> for HashMap<K, V> {
-    fn decode(d: &mut D) -> HashMap<K, V> {
-        d.read_map(|d, len| {
-            let mut map = HashMap::with_capacity(len);
-            for i in range(0u, len) {
-                let key = d.read_map_elt_key(i, |d| Decodable::decode(d));
-                let val = d.read_map_elt_val(i, |d| Decodable::decode(d));
-                map.insert(key, val);
-            }
-            map
-        })
-    }
-}
-
-impl<
-    S: Encoder,
-    T: Encodable<S> + Hash + Eq
-> Encodable<S> for HashSet<T> {
-    fn encode(&self, s: &mut S) {
-        s.emit_seq(self.len(), |s| {
-            let mut i = 0;
-            for e in self.iter() {
-                s.emit_seq_elt(i, |s| e.encode(s));
-                i += 1;
-            }
-        })
-    }
-}
-
-impl<
-    D: Decoder,
-    T: Decodable<D> + Hash + Eq
-> Decodable<D> for HashSet<T> {
-    fn decode(d: &mut D) -> HashSet<T> {
-        d.read_seq(|d, len| {
-            let mut set = HashSet::with_capacity(len);
-            for i in range(0u, len) {
-                set.insert(d.read_seq_elt(i, |d| Decodable::decode(d)));
-            }
-            set
-        })
-    }
-}
-
 #[cfg(test)]
 mod test_map {
     use super::{HashMap, HashSet};

branches/try2/src/libcollections/lib.rs

@@ -19,7 +19,6 @@
 
 #[feature(macro_rules, managed_boxes)];
 
-extern crate serialize;
 #[cfg(test)] extern crate test;
 
 pub use bitv::Bitv;

branches/try2/src/libcollections/ringbuf.rs

@@ -19,8 +19,6 @@ use std::iter::{Rev, RandomAccessIterator};
 
 use deque::Deque;
 
-use serialize::{Encodable, Decodable, Encoder, Decoder};
-
 static INITIAL_CAPACITY: uint = 8u; // 2^3
 static MINIMUM_CAPACITY: uint = 2u;
 
@@ -404,31 +402,6 @@ impl<A> Extendable<A> for RingBuf<A> {
     }
 }
 
-impl<
-    S: Encoder,
-    T: Encodable<S>
-> Encodable<S> for RingBuf<T> {
-    fn encode(&self, s: &mut S) {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                s.emit_seq_elt(i, |s| e.encode(s));
-            }
-        })
-    }
-}
-
-impl<D:Decoder,T:Decodable<D>> Decodable<D> for RingBuf<T> {
-    fn decode(d: &mut D) -> RingBuf<T> {
-        let mut deque = RingBuf::new();
-        d.read_seq(|d, len| {
-            for i in range(0u, len) {
-                deque.push_back(d.read_seq_elt(i, |d| Decodable::decode(d)));
-            }
-        });
-        deque
-    }
-}
-
 #[cfg(test)]
 mod tests {
     extern crate test;