---

yaml
---
r: 161278
b: refs/heads/snap-stage3
c: dd4c7c0
h: refs/heads/master
v: v3

Author: tomjakubowski

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4eb72d268f337a8f117c86a2ac1b98336cab9e9d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2264049577e1d64a2a863a9b9f2b7d94f6b90e15
+refs/heads/snap-stage3: dd4c7c00d85a82d3ddda1b453ba2ce649a4d1b41
 refs/heads/try: 0f0d21c1eb5c7be04d323e0b06faf252ad790af6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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();
 }

branches/snap-stage3/src/librustc_llvm/lib.rs

@@ -2148,7 +2148,7 @@ pub unsafe extern "C" fn rust_llvm_string_write_impl(sr: RustStringRef,
 pub fn build_string(f: |RustStringRef|) -> Option<String> {
     let mut buf = RefCell::new(Vec::new());
     f(&mut buf as RustStringRepr as RustStringRef);
-    String::from_utf8(buf.into_inner()).ok()
+    String::from_utf8(buf.unwrap()).ok()
 }
 
 pub unsafe fn twine_to_string(tr: TwineRef) -> String {

branches/snap-stage3/src/librustc_trans/back/write.rs

@@ -899,7 +899,7 @@ fn run_work_multithreaded(sess: &Session,
 
     let mut panicked = false;
     for future in futures.into_iter() {
-        match future.into_inner() {
+        match future.unwrap() {
             Ok(()) => {},
             Err(_) => {
                 panicked = true;

branches/snap-stage3/src/librustc_trans/save/recorder.rs

@@ -171,7 +171,7 @@ impl<'a> FmtStrs<'a> {
 
         let pairs = fields.iter().zip(values);
         let mut strs = pairs.map(|(f, v)| format!(",{},\"{}\"", f, escape(
-            if *f == "qualname" && v.len() > 0 {
+            if *f == "qualname" {
                 let mut n = self.krate.clone();
                 n.push_str("::");
                 n.push_str(v);

branches/snap-stage3/src/librustc_trans/save/span_utils.rs

@@ -293,6 +293,7 @@ impl<'a> SpanUtils<'a> {
                 if ts.tok == token::Eof {
                     return None
                 } else {
+                    println!("found keyword: {} at {}", ts, ts.sp);
                     return self.make_sub_span(span, Some(ts.sp));
                 }
             }

branches/snap-stage3/src/librustdoc/clean/mod.rs

@@ -336,7 +336,7 @@ pub enum ItemEnum {
     ForeignStaticItem(Static),
     MacroItem(Macro),
     PrimitiveItem(PrimitiveType),
-    AssociatedTypeItem,
+    AssociatedTypeItem(TyParam),
 }
 
 #[deriving(Clone, Encodable, Decodable)]
@@ -982,6 +982,8 @@ impl Clean<Type> for ast::PolyTraitRef {
     }
 }
 
+/// An item belonging to a trait, whether a method or associated. Could be named
+/// TraitItem except that's already taken by an exported enum variant.
 #[deriving(Clone, Encodable, Decodable)]
 pub enum TraitMethod {
     RequiredMethod(Item),
@@ -1002,6 +1004,12 @@ impl TraitMethod {
             _ => false,
         }
     }
+    pub fn is_type(&self) -> bool {
+        match self {
+            &TypeTraitItem(..) => true,
+            _ => false,
+        }
+    }
     pub fn item<'a>(&'a self) -> &'a Item {
         match *self {
             RequiredMethod(ref item) => item,
@@ -2211,7 +2219,7 @@ impl Clean<Item> for ast::AssociatedType {
             source: self.ty_param.span.clean(cx),
             name: Some(self.ty_param.ident.clean(cx)),
             attrs: self.attrs.clean(cx),
-            inner: AssociatedTypeItem,
+            inner: AssociatedTypeItem(self.ty_param.clean(cx)),
             visibility: None,
             def_id: ast_util::local_def(self.ty_param.id),
             stability: None,
@@ -2225,7 +2233,17 @@ impl Clean<Item> for ty::AssociatedType {
             source: DUMMY_SP.clean(cx),
             name: Some(self.name.clean(cx)),
             attrs: Vec::new(),
-            inner: AssociatedTypeItem,
+            // FIXME(#18048): this is wrong, but cross-crate associated types are broken
+            // anyway, for the time being.
+            inner: AssociatedTypeItem(TyParam {
+                name: self.name.clean(cx),
+                did: ast::DefId {
+                    krate: 0,
+                    node: ast::DUMMY_NODE_ID
+                },
+                bounds: vec![],
+                default: None
+            }),
             visibility: None,
             def_id: self.def_id,
             stability: None,