---

yaml
---
r: 162590
b: refs/heads/try
c: f5b795d
h: refs/heads/master
v: v3

Author: pnkfelix

[refs]

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

branches/try/src/compiletest/errors.rs

@@ -7,6 +7,7 @@
 // <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};
@@ -18,28 +19,74 @@ pub struct ExpectedError {
     pub msg: String,
 }
 
-pub static EXPECTED_PATTERN : &'static str = r"//~(?P<adjusts>\^*)\s*(?P<kind>\S*)\s*(?P<msg>.*)";
+/// 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) }
 
 // 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(line_no + 1, ln.unwrap().as_slice(), re)
+        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
+            })
     }).collect()
 }
 
-fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
+fn parse_expected(last_nonfollow_error: Option<uint>,
+                  line_num: uint,
+                  line: &str,
+                  re: &Regex) -> Option<(WhichLine, 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={} kind={} msg={}", line_num, kind, msg);
-        Some(ExpectedError {
-            line: line_num - adjusts,
-            kind: kind,
-            msg: msg,
-        })
+        debug!("line={} which={} kind={} msg={}", line_num, which, kind, msg);
+        Some((which, ExpectedError { line: line,
+                                     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/libcollections/vec.rs

@@ -1248,18 +1248,14 @@ pub struct MoveItems<T> {
 impl<T> MoveItems<T> {
     #[inline]
     /// Drops all items that have not yet been moved and returns the empty vector.
-    pub fn into_inner(mut self) -> Vec<T> {
+    pub fn unwrap(mut self) -> Vec<T> {
         unsafe {
             for _x in self { }
             let MoveItems { allocation, cap, ptr: _ptr, end: _end } = self;
             mem::forget(self);
             Vec { ptr: allocation, cap: cap, len: 0 }
         }
     }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> Vec<T> { self.into_inner() }
 }
 
 impl<T> Iterator<T> for MoveItems<T> {

branches/try/src/libcore/cell.rs

@@ -256,19 +256,15 @@ impl<T> RefCell<T> {
     }
 
     /// Consumes the `RefCell`, returning the wrapped value.
-    #[unstable = "recently renamed per RFC 430"]
-    pub fn into_inner(self) -> T {
+    #[unstable = "may be renamed, depending on global conventions"]
+    pub fn unwrap(self) -> T {
         // Since this function takes `self` (the `RefCell`) by value, the
         // compiler statically verifies that it is not currently borrowed.
         // Therefore the following assertion is just a `debug_assert!`.
         debug_assert!(self.borrow.get() == UNUSED);
-        unsafe { self.value.into_inner() }
+        unsafe{self.value.unwrap()}
     }
 
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> T { self.into_inner() }
-
     /// Attempts to immutably borrow the wrapped value.
     ///
     /// The borrow lasts until the returned `Ref` exits scope. Multiple
@@ -522,9 +518,5 @@ impl<T> UnsafeCell<T> {
     #[inline]
     #[unstable = "conventions around the name `unwrap` are still under \
                   development"]
-    pub unsafe fn into_inner(self) -> T { self.value }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub unsafe fn unwrap(self) -> T { self.into_inner() }
+    pub unsafe fn unwrap(self) -> T { self.value }
 }

branches/try/src/libcore/slice.rs

@@ -1104,21 +1104,6 @@ macro_rules! iterator {
     }
 }
 
-macro_rules! make_slice {
-    ($t: ty -> $result: ty: $start: expr, $end: expr) => {{
-        let diff = $end as uint - $start as uint;
-        let len = if mem::size_of::<T>() == 0 {
-            diff
-        } else {
-            diff / mem::size_of::<$t>()
-        };
-        unsafe {
-            transmute::<_, $result>(RawSlice { data: $start as *const T, len: len })
-        }
-    }}
-}
-
-
 /// Immutable slice iterator
 #[experimental = "needs review"]
 pub struct Items<'a, T: 'a> {
@@ -1127,36 +1112,6 @@ pub struct Items<'a, T: 'a> {
     marker: marker::ContravariantLifetime<'a>
 }
 
-#[experimental]
-impl<'a, T> ops::Slice<uint, [T]> for Items<'a, T> {
-    fn as_slice_(&self) -> &[T] {
-        self.as_slice()
-    }
-    fn slice_from_or_fail<'b>(&'b self, from: &uint) -> &'b [T] {
-        use ops::Slice;
-        self.as_slice().slice_from_or_fail(from)
-    }
-    fn slice_to_or_fail<'b>(&'b self, to: &uint) -> &'b [T] {
-        use ops::Slice;
-        self.as_slice().slice_to_or_fail(to)
-    }
-    fn slice_or_fail<'b>(&'b self, from: &uint, to: &uint) -> &'b [T] {
-        use ops::Slice;
-        self.as_slice().slice_or_fail(from, to)
-    }
-}
-
-impl<'a, T> Items<'a, T> {
-    /// View the underlying data as a subslice of the original data.
-    ///
-    /// This has the same lifetime as the original slice, and so the
-    /// iterator can continue to be used while this exists.
-    #[experimental]
-    pub fn as_slice(&self) -> &'a [T] {
-        make_slice!(T -> &'a [T]: self.ptr, self.end)
-    }
-}
-
 iterator!{struct Items -> *const T, &'a T}
 
 #[experimental = "needs review"]
@@ -1201,57 +1156,6 @@ pub struct MutItems<'a, T: 'a> {
     marker2: marker::NoCopy
 }
 
-#[experimental]
-impl<'a, T> ops::Slice<uint, [T]> for MutItems<'a, T> {
-    fn as_slice_<'b>(&'b self) -> &'b [T] {
-        make_slice!(T -> &'b [T]: self.ptr, self.end)
-    }
-    fn slice_from_or_fail<'b>(&'b self, from: &uint) -> &'b [T] {
-        use ops::Slice;
-        self.as_slice_().slice_from_or_fail(from)
-    }
-    fn slice_to_or_fail<'b>(&'b self, to: &uint) -> &'b [T] {
-        use ops::Slice;
-        self.as_slice_().slice_to_or_fail(to)
-    }
-    fn slice_or_fail<'b>(&'b self, from: &uint, to: &uint) -> &'b [T] {
-        use ops::Slice;
-        self.as_slice_().slice_or_fail(from, to)
-    }
-}
-
-#[experimental]
-impl<'a, T> ops::SliceMut<uint, [T]> for MutItems<'a, T> {
-    fn as_mut_slice_<'b>(&'b mut self) -> &'b mut [T] {
-        make_slice!(T -> &'b mut [T]: self.ptr, self.end)
-    }
-    fn slice_from_or_fail_mut<'b>(&'b mut self, from: &uint) -> &'b mut [T] {
-        use ops::SliceMut;
-        self.as_mut_slice_().slice_from_or_fail_mut(from)
-    }
-    fn slice_to_or_fail_mut<'b>(&'b mut self, to: &uint) -> &'b mut [T] {
-        use ops::SliceMut;
-        self.as_mut_slice_().slice_to_or_fail_mut(to)
-    }
-    fn slice_or_fail_mut<'b>(&'b mut self, from: &uint, to: &uint) -> &'b mut [T] {
-        use ops::SliceMut;
-        self.as_mut_slice_().slice_or_fail_mut(from, to)
-    }
-}
-
-impl<'a, T> MutItems<'a, T> {
-    /// View the underlying data as a subslice of the original data.
-    ///
-    /// To avoid creating `&mut` references that alias, this is forced
-    /// to consume the iterator. Consider using the `Slice` and
-    /// `SliceMut` implementations for obtaining slices with more
-    /// restricted lifetimes that do not consume the iterator.
-    #[experimental]
-    pub fn into_slice(self) -> &'a mut [T] {
-        make_slice!(T -> &'a mut [T]: self.ptr, self.end)
-    }
-}
-
 iterator!{struct MutItems -> *mut T, &'a mut T}
 
 #[experimental = "needs review"]

branches/try/src/libcore/str.rs

@@ -1277,19 +1277,14 @@ pub mod traits {
 }
 
 /// Any string that can be represented as a slice
-pub trait Str for Sized? {
+pub trait Str {
     /// Work with `self` as a slice.
     fn as_slice<'a>(&'a self) -> &'a str;
 }
 
-impl Str for str {
+impl<'a> Str for &'a str {
     #[inline]
-    fn as_slice<'a>(&'a self) -> &'a str { self }
-}
-
-impl<'a, Sized? S> Str for &'a S where S: Str {
-    #[inline]
-    fn as_slice(&self) -> &str { Str::as_slice(*self) }
+    fn as_slice<'a>(&'a self) -> &'a str { *self }
 }
 
 /// Methods for string slices

branches/try/src/libcoretest/slice.rs

@@ -33,52 +33,3 @@ fn binary_search_not_found() {
     let b = [1i, 2, 4, 5, 6, 8];
     assert!(b.binary_search(|v| v.cmp(&9)) == NotFound(6));
 }
-
-#[test]
-fn iterator_to_slice() {
-    macro_rules! test {
-        ($data: expr) => {{
-            let data: &mut [_] = &mut $data;
-            let other_data: &mut [_] = &mut $data;
-
-            {
-                let mut iter = data.iter();
-                assert_eq!(iter[], other_data[]);
-
-                iter.next();
-                assert_eq!(iter[], other_data[1..]);
-
-                iter.next_back();
-                assert_eq!(iter[], other_data[1..2]);
-
-                let s = iter.as_slice();
-                iter.next();
-                assert_eq!(s, other_data[1..2]);
-            }
-            {
-                let mut iter = data.iter_mut();
-                assert_eq!(iter[], other_data[]);
-                // mutability:
-                assert!(iter[mut] == other_data);
-
-                iter.next();
-                assert_eq!(iter[], other_data[1..]);
-                assert!(iter[mut] == other_data[mut 1..]);
-
-                iter.next_back();
-
-                assert_eq!(iter[], other_data[1..2]);
-                assert!(iter[mut] == other_data[mut 1..2]);
-
-                let s = iter.into_slice();
-                assert!(s == other_data[mut 1..2]);
-            }
-        }}
-    }
-
-    // try types of a variety of sizes
-    test!([(1u64, 1u64, 1u8), (2, 2, 2), (3, 3, 3)]);
-    test!([1u64,2,3]);
-    test!([1u8,2,3]);
-    test!([(),(),()]);
-}

branches/try/src/librustc/lint/context.rs

@@ -827,5 +827,5 @@ pub fn check_crate(tcx: &ty::ctxt,
     }
 
     tcx.sess.abort_if_errors();
-    *tcx.node_lint_levels.borrow_mut() = cx.node_levels.into_inner();
+    *tcx.node_lint_levels.borrow_mut() = cx.node_levels.unwrap();
 }