---

yaml
---
r: 162613
b: refs/heads/try
c: a95c71e
h: refs/heads/master
i:
  162611: cb2543f
v: v3

Author: murarth

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
-refs/heads/try: 8fb027e398ef756b7b02a270ef0304be92e70f4d
+refs/heads/try: a95c71e0ac3dc97468d7432d5011fbb413ba9263
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/crates.mk

@@ -50,7 +50,7 @@
 ################################################################################
 
 TARGET_CRATES := libc std flate arena term \
-                 serialize getopts collections test time rand \
+                 serialize sync getopts collections test time rand \
                  log regex graphviz core rbml alloc rustrt \
                  unicode
 HOST_CRATES := syntax rustc rustc_trans rustdoc regex_macros fmt_macros \
@@ -63,7 +63,7 @@ DEPS_libc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
 DEPS_rustrt := alloc core libc collections native:rustrt_native
-DEPS_std := core libc rand alloc collections rustrt unicode \
+DEPS_std := core libc rand alloc collections rustrt sync unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
@@ -81,6 +81,7 @@ DEPS_glob := std
 DEPS_serialize := std log
 DEPS_rbml := std log serialize
 DEPS_term := std log
+DEPS_sync := core alloc rustrt collections
 DEPS_getopts := std
 DEPS_collections := core alloc unicode
 DEPS_num := std

branches/try/src/compiletest/errors.rs

@@ -7,7 +7,6 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-use self::WhichLine::*;
 
 use std::ascii::AsciiExt;
 use std::io::{BufferedReader, File};
@@ -19,74 +18,28 @@ pub struct ExpectedError {
     pub msg: String,
 }
 
-/// Looks for either "//~| KIND MESSAGE" or "//~^^... KIND MESSAGE"
-/// The former is a "follow" that inherits its target from the preceding line;
-/// the latter is an "adjusts" that goes that many lines up.
-///
-/// Goal is to enable tests both like: //~^^^ ERROR go up three
-/// and also //~^ ERROR message one for the preceding line, and
-///          //~| ERROR message two for that same line.
-
-pub static EXPECTED_PATTERN : &'static str =
-    r"//~(?P<follow>\|)?(?P<adjusts>\^*)\s*(?P<kind>\S*)\s*(?P<msg>.*)";
-
-#[deriving(PartialEq, Show)]
-enum WhichLine { ThisLine, FollowPrevious(uint), AdjustBackward(uint) }
+pub static EXPECTED_PATTERN : &'static str = r"//~(?P<adjusts>\^*)\s*(?P<kind>\S*)\s*(?P<msg>.*)";
 
 // Load any test directives embedded in the file
 pub fn load_errors(re: &Regex, testfile: &Path) -> Vec<ExpectedError> {
     let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
 
-    // `last_nonfollow_error` tracks the most recently seen
-    // line with an error template that did not use the
-    // follow-syntax, "//~| ...".
-    //
-    // (pnkfelix could not find an easy way to compose Iterator::scan
-    // and Iterator::filter_map to pass along this information into
-    // `parse_expected`. So instead I am storing that state here and
-    // updating it in the map callback below.)
-    let mut last_nonfollow_error = None;
-
     rdr.lines().enumerate().filter_map(|(line_no, ln)| {
-        parse_expected(last_nonfollow_error,
-                       line_no + 1,
-                       ln.unwrap().as_slice(), re)
-            .map(|(which, error)| {
-                match which {
-                    FollowPrevious(_) => {}
-                    _ => last_nonfollow_error = Some(error.line),
-                }
-                error
-            })
+        parse_expected(line_no + 1, ln.unwrap().as_slice(), re)
     }).collect()
 }
 
-fn parse_expected(last_nonfollow_error: Option<uint>,
-                  line_num: uint,
-                  line: &str,
-                  re: &Regex) -> Option<(WhichLine, ExpectedError)> {
+fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
     re.captures(line).and_then(|caps| {
         let adjusts = caps.name("adjusts").len();
         let kind = caps.name("kind").to_ascii_lower();
         let msg = caps.name("msg").trim().to_string();
-        let follow = caps.name("follow").len() > 0;
-
-        let (which, line) = if follow {
-            assert!(adjusts == 0, "use either //~| or //~^, not both.");
-            let line = last_nonfollow_error.unwrap_or_else(|| {
-                panic!("encountered //~| without preceding //~^ line.")
-            });
-            (FollowPrevious(line), line)
-        } else {
-            let which =
-                if adjusts > 0 { AdjustBackward(adjusts) } else { ThisLine };
-            let line = line_num - adjusts;
-            (which, line)
-        };
 
-        debug!("line={} which={} kind={} msg={}", line_num, which, kind, msg);
-        Some((which, ExpectedError { line: line,
-                                     kind: kind,
-                                     msg: msg, }))
+        debug!("line={} kind={} msg={}", line_num, kind, msg);
+        Some(ExpectedError {
+            line: line_num - adjusts,
+            kind: kind,
+            msg: msg,
+        })
     })
 }

branches/try/src/doc/reference.md

@@ -1689,20 +1689,7 @@ methods in such an implementation can only be used as direct calls on the
 values of the type that the implementation targets. In such an implementation,
 the trait type and `for` after `impl` are omitted. Such implementations are
 limited to nominal types (enums, structs), and the implementation must appear
-in the same module or a sub-module as the `self` type:
-
-```
-struct Point {x: int, y: int}
-
-impl Point {
-    fn log(&self) {
-        println!("Point is at ({}, {})", self.x, self.y);
-    }
-}
-
-let my_point = Point {x: 10, y:11};
-my_point.log();
-```
+in the same module or a sub-module as the `self` type.
 
 When a trait _is_ specified in an `impl`, all methods declared as part of the
 trait must be implemented, with matching types and type parameter counts.

branches/try/src/etc/emacs/rust-mode.el

@@ -31,6 +31,9 @@
     (modify-syntax-entry ?\" "\"" table)
     (modify-syntax-entry ?\\ "\\" table)
 
+    ;; _ is a word-char
+    (modify-syntax-entry ?_ "w" table)
+
     ;; Comments
     (modify-syntax-entry ?/  ". 124b" table)
     (modify-syntax-entry ?*  ". 23"   table)
@@ -394,7 +397,7 @@ This is written mainly to be used as `beginning-of-defun-function' for Rust.
 Don't move to the beginning of the line. `beginning-of-defun',
 which calls this, does that afterwards."
   (interactive "p")
-  (re-search-backward (concat "^\\(" rust-top-item-beg-re "\\)\\_>")
+  (re-search-backward (concat "^\\(" rust-top-item-beg-re "\\)\\b")
                       nil 'move (or arg 1)))
 
 (defun rust-end-of-defun ()

branches/try/src/etc/licenseck.py

@@ -38,9 +38,10 @@
     "rt/isaac/randport.cpp", # public domain
     "rt/isaac/rand.h", # public domain
     "rt/isaac/standard.h", # public domain
-    "libstd/sync/mpsc_queue.rs", # BSD
-    "libstd/sync/spsc_queue.rs", # BSD
-    "libstd/sync/mpmc_bounded_queue.rs", # BSD
+    "libsync/mpsc_queue.rs", # BSD
+    "libsync/spsc_queue.rs", # BSD
+    "libsync/mpmc_bounded_queue.rs", # BSD
+    "libsync/mpsc_intrusive.rs", # BSD
     "test/bench/shootout-binarytrees.rs", # BSD
     "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD

branches/try/src/libcollections/binary_heap.rs

@@ -160,7 +160,9 @@ use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
 use slice;
-use vec::{mod, Vec};
+use vec::Vec;
+
+// FIXME(conventions): implement into_iter
 
 /// A priority queue implemented with a binary heap.
 ///
@@ -241,27 +243,6 @@ impl<T: Ord> BinaryHeap<T> {
         Items { iter: self.data.iter() }
     }
 
-    /// Creates a consuming iterator, that is, one that moves each value out of
-    /// the binary heap in arbitrary order.  The binary heap cannot be used
-    /// after calling this.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let pq = BinaryHeap::from_vec(vec![1i, 2, 3, 4]);
-    ///
-    /// // Print 1, 2, 3, 4 in arbitrary order
-    /// for x in pq.into_iter() {
-    ///     // x has type int, not &int
-    ///     println!("{}", x);
-    /// }
-    /// ```
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn into_iter(self) -> MoveItems<T> {
-        MoveItems { iter: self.data.into_iter() }
-    }
-
     /// Returns the greatest item in a queue, or `None` if it is empty.
     ///
     /// # Example
@@ -567,26 +548,6 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
-/// An iterator that moves out of a `BinaryHeap`.
-pub struct MoveItems<T> {
-    iter: vec::MoveItems<T>,
-}
-
-impl<T> Iterator<T> for MoveItems<T> {
-    #[inline]
-    fn next(&mut self) -> Option<T> { self.iter.next() }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
-}
-
-impl<T> DoubleEndedIterator<T> for MoveItems<T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> { self.iter.next_back() }
-}
-
-impl<T> ExactSize<T> for MoveItems<T> {}
-
 impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
     fn from_iter<Iter: Iterator<T>>(mut iter: Iter) -> BinaryHeap<T> {
         let vec: Vec<T> = iter.collect();
@@ -625,43 +586,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_move_iter() {
-        let data = vec!(5i, 9, 3);
-        let iterout = vec!(9i, 5, 3);
-        let pq = BinaryHeap::from_vec(data);
-
-        let v: Vec<int> = pq.into_iter().collect();
-        assert_eq!(v, iterout);
-    }
-
-    #[test]
-    fn test_move_iter_size_hint() {
-        let data = vec!(5i, 9);
-        let pq = BinaryHeap::from_vec(data);
-
-        let mut it = pq.into_iter();
-
-        assert_eq!(it.size_hint(), (2, Some(2)));
-        assert_eq!(it.next(), Some(9i));
-
-        assert_eq!(it.size_hint(), (1, Some(1)));
-        assert_eq!(it.next(), Some(5i));
-
-        assert_eq!(it.size_hint(), (0, Some(0)));
-        assert_eq!(it.next(), None);
-    }
-
-    #[test]
-    fn test_move_iter_reverse() {
-        let data = vec!(5i, 9, 3);
-        let iterout = vec!(3i, 5, 9);
-        let pq = BinaryHeap::from_vec(data);
-
-        let v: Vec<int> = pq.into_iter().rev().collect();
-        assert_eq!(v, iterout);
-    }
-
     #[test]
     fn test_top_and_pop() {
         let data = vec!(2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1);

branches/try/src/libcollections/hash/mod.rs

@@ -67,7 +67,6 @@ use core::prelude::*;
 
 use alloc::boxed::Box;
 use alloc::rc::Rc;
-use core::borrow::{Cow, ToOwned};
 use core::intrinsics::TypeId;
 use core::mem;
 use core::num::Int;
@@ -285,13 +284,6 @@ impl<S: Writer, T: Hash<S>, U: Hash<S>> Hash<S> for Result<T, U> {
     }
 }
 
-impl<'a, T, Sized? B, S> Hash<S> for Cow<'a, T, B> where B: Hash<S> + ToOwned<T> {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        Hash::hash(&**self, state)
-    }
-}
-
 //////////////////////////////////////////////////////////////////////////////
 
 #[cfg(test)]