---

yaml
---
r: 232318
b: refs/heads/try
c: 43f6c2f
h: refs/heads/master
v: v3

Author: wthrowe

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 021389f6adbb215bb8fe267c93bc1a9daeb2ec14
+refs/heads/try: 43f6c2fab76fc7cf92876a7de70579e5b781196d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/libcore/slice.rs

@@ -50,7 +50,6 @@ use ptr;
 use mem;
 use mem::size_of;
 use marker::{Send, Sync, self};
-use num::wrapping::OverflowingOps;
 use raw::Repr;
 // Avoid conflicts with *both* the Slice trait (buggy) and the `slice::raw` module.
 use raw::Slice as RawSlice;
@@ -1181,34 +1180,6 @@ impl<'a, T> Iterator for Windows<'a, T> {
             (size, Some(size))
         }
     }
-
-    #[inline]
-    fn count(self) -> usize {
-        self.size_hint().0
-    }
-
-    #[inline]
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        let (end, overflow) = self.size.overflowing_add(n);
-        if end > self.v.len() || overflow {
-            self.v = &[];
-            None
-        } else {
-            let nth = &self.v[n..end];
-            self.v = &self.v[n+1..];
-            Some(nth)
-        }
-    }
-
-    #[inline]
-    fn last(self) -> Option<Self::Item> {
-        if self.size > self.v.len() {
-            None
-        } else {
-            let start = self.v.len() - self.size;
-            Some(&self.v[start..])
-        }
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1295,38 +1266,6 @@ impl<'a, T> Iterator for Chunks<'a, T> {
             (n, Some(n))
         }
     }
-
-    #[inline]
-    fn count(self) -> usize {
-        self.size_hint().0
-    }
-
-    #[inline]
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        let (start, overflow) = n.overflowing_mul(self.size);
-        if start >= self.v.len() || overflow {
-            self.v = &[];
-            None
-        } else {
-            let end = match start.checked_add(self.size) {
-                Some(sum) => cmp::min(self.v.len(), sum),
-                None => self.v.len(),
-            };
-            let nth = &self.v[start..end];
-            self.v = &self.v[end..];
-            Some(nth)
-        }
-    }
-
-    #[inline]
-    fn last(self) -> Option<Self::Item> {
-        if self.v.is_empty() {
-            None
-        } else {
-            let start = (self.v.len() - 1) / self.size * self.size;
-            Some(&self.v[start..])
-        }
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1407,40 +1346,6 @@ impl<'a, T> Iterator for ChunksMut<'a, T> {
             (n, Some(n))
         }
     }
-
-    #[inline]
-    fn count(self) -> usize {
-        self.size_hint().0
-    }
-
-    #[inline]
-    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {
-        let (start, overflow) = n.overflowing_mul(self.chunk_size);
-        if start >= self.v.len() || overflow {
-            self.v = &mut [];
-            None
-        } else {
-            let end = match start.checked_add(self.chunk_size) {
-                Some(sum) => cmp::min(self.v.len(), sum),
-                None => self.v.len(),
-            };
-            let tmp = mem::replace(&mut self.v, &mut []);
-            let (head, tail) = tmp.split_at_mut(end);
-            let (_, nth) =  head.split_at_mut(start);
-            self.v = tail;
-            Some(nth)
-        }
-    }
-
-    #[inline]
-    fn last(self) -> Option<Self::Item> {
-        if self.v.is_empty() {
-            None
-        } else {
-            let start = (self.v.len() - 1) / self.chunk_size * self.chunk_size;
-            Some(&mut self.v[start..])
-        }
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

branches/try/src/libcoretest/slice.rs

@@ -64,123 +64,3 @@ fn test_iterator_count() {
     iter2.next();
     assert_eq!(iter2.count(), 3);
 }
-
-#[test]
-fn test_chunks_count() {
-    let v: &[i32] = &[0, 1, 2, 3, 4, 5];
-    let c = v.chunks(3);
-    assert_eq!(c.count(), 2);
-
-    let v2: &[i32] = &[0, 1, 2, 3, 4];
-    let c2 = v2.chunks(2);
-    assert_eq!(c2.count(), 3);
-
-    let v3: &[i32] = &[];
-    let c3 = v3.chunks(2);
-    assert_eq!(c3.count(), 0);
-}
-
-#[test]
-fn test_chunks_nth() {
-    let v: &[i32] = &[0, 1, 2, 3, 4, 5];
-    let mut c = v.chunks(2);
-    assert_eq!(c.nth(1).unwrap()[1], 3);
-    assert_eq!(c.next().unwrap()[0], 4);
-
-    let v2: &[i32] = &[0, 1, 2, 3, 4];
-    let mut c2 = v2.chunks(3);
-    assert_eq!(c2.nth(1).unwrap()[1], 4);
-    assert_eq!(c2.next(), None);
-}
-
-#[test]
-fn test_chunks_last() {
-    let v: &[i32] = &[0, 1, 2, 3, 4, 5];
-    let c = v.chunks(2);
-    assert_eq!(c.last().unwrap()[1], 5);
-
-    let v2: &[i32] = &[0, 1, 2, 3, 4];
-    let c2 = v2.chunks(2);
-    assert_eq!(c2.last().unwrap()[0], 4);
-}
-
-#[test]
-fn test_chunks_mut_count() {
-    let mut v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
-    let c = v.chunks_mut(3);
-    assert_eq!(c.count(), 2);
-
-    let mut v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
-    let c2 = v2.chunks_mut(2);
-    assert_eq!(c2.count(), 3);
-
-    let mut v3: &mut [i32] = &mut [];
-    let c3 = v3.chunks_mut(2);
-    assert_eq!(c3.count(), 0);
-}
-
-#[test]
-fn test_chunks_mut_nth() {
-    let mut v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
-    let mut c = v.chunks_mut(2);
-    assert_eq!(c.nth(1).unwrap()[1], 3);
-    assert_eq!(c.next().unwrap()[0], 4);
-
-    let mut v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
-    let mut c2 = v2.chunks_mut(3);
-    assert_eq!(c2.nth(1).unwrap()[1], 4);
-    assert_eq!(c2.next(), None);
-}
-
-#[test]
-fn test_chunks_mut_last() {
-    let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
-    let c = v.chunks_mut(2);
-    assert_eq!(c.last().unwrap()[1], 5);
-
-    let v2: &mut [i32] = &mut [0, 1, 2, 3, 4];
-    let c2 = v2.chunks_mut(2);
-    assert_eq!(c2.last().unwrap()[0], 4);
-}
-
-
-
-
-#[test]
-fn test_windows_count() {
-    let v: &[i32] = &[0, 1, 2, 3, 4, 5];
-    let c = v.windows(3);
-    assert_eq!(c.count(), 4);
-
-    let v2: &[i32] = &[0, 1, 2, 3, 4];
-    let c2 = v2.windows(6);
-    assert_eq!(c2.count(), 0);
-
-    let v3: &[i32] = &[];
-    let c3 = v3.windows(2);
-    assert_eq!(c3.count(), 0);
-}
-
-#[test]
-fn test_windows_nth() {
-    let v: &[i32] = &[0, 1, 2, 3, 4, 5];
-    let mut c = v.windows(2);
-    assert_eq!(c.nth(2).unwrap()[1], 3);
-    assert_eq!(c.next().unwrap()[0], 3);
-
-    let v2: &[i32] = &[0, 1, 2, 3, 4];
-    let mut c2 = v2.windows(4);
-    assert_eq!(c2.nth(1).unwrap()[1], 2);
-    assert_eq!(c2.next(), None);
-}
-
-#[test]
-fn test_windows_last() {
-    let v: &[i32] = &[0, 1, 2, 3, 4, 5];
-    let c = v.windows(2);
-    assert_eq!(c.last().unwrap()[1], 5);
-
-    let v2: &[i32] = &[0, 1, 2, 3, 4];
-    let c2 = v2.windows(2);
-    assert_eq!(c2.last().unwrap()[0], 3);
-}

branches/try/src/liblog/macros.rs

@@ -135,9 +135,9 @@ macro_rules! info {
     ($($arg:tt)*) => (log!(::log::INFO, $($arg)*))
 }
 
-/// A convenience macro for logging at the debug log level. This macro can also
-/// be omitted at compile time by passing `-C debug-assertions` to the compiler. If
-/// this option is not passed, then debug statements will be compiled.
+/// A convenience macro for logging at the debug log level. This macro will
+/// be omitted at compile time in an optimized build unless `-C debug-assertions`
+/// is passed to the compiler.
 ///
 /// # Examples
 ///

branches/try/src/librustc_resolve/build_reduced_graph.rs

@@ -785,11 +785,6 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
               debug!("(building reduced graph for external \
                       crate) building type {}", final_ident);
 
-              let modifiers = match new_parent.kind.get() {
-                  NormalModuleKind => modifiers,
-                  _ => modifiers & !DefModifiers::IMPORTABLE
-              };
-
               child_name_bindings.define_type(def, DUMMY_SP, modifiers);
           }
           DefStruct(def_id) => {

branches/try/src/test/auxiliary/use_from_trait_xc.rs

@@ -8,22 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(associated_consts)]
-
 pub use self::sub::{Bar, Baz};
 
 pub trait Trait {
     fn foo(&self);
-    type Assoc;
-    const CONST: u32;
 }
 
 struct Foo;
 
 impl Foo {
     pub fn new() {}
-
-    pub const C: u32 = 0;
 }
 
 mod sub {

branches/try/src/test/compile-fail/use-from-trait-xc.rs

@@ -15,18 +15,9 @@ extern crate use_from_trait_xc;
 use use_from_trait_xc::Trait::foo;
 //~^ ERROR `foo` is not directly importable
 
-use use_from_trait_xc::Trait::Assoc;
-//~^ ERROR `Assoc` is not directly importable
-
-use use_from_trait_xc::Trait::CONST;
-//~^ ERROR `CONST` is not directly importable
-
 use use_from_trait_xc::Foo::new;
 //~^ ERROR `new` is not directly importable
 
-use use_from_trait_xc::Foo::C;
-//~^ ERROR unresolved import `use_from_trait_xc::Foo::C`
-
 use use_from_trait_xc::Bar::new as bnew;
 //~^ ERROR `bnew` is not directly importable
 

branches/try/src/test/compile-fail/use-from-trait.rs

@@ -8,32 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(associated_consts)]
-
 use Trait::foo;
 //~^ ERROR `foo` is not directly importable
-use Trait::Assoc;
-//~^ ERROR `Assoc` is not directly importable
-use Trait::C;
-//~^ ERROR `C` is not directly importable
-
 use Foo::new;
 //~^ ERROR unresolved import `Foo::new`. Not a module `Foo`
 
-use Foo::C2;
-//~^ ERROR unresolved import `Foo::C2`. Not a module `Foo`
-
 pub trait Trait {
     fn foo();
-    type Assoc;
-    const C: u32;
 }
 
 struct Foo;
 
 impl Foo {
     fn new() {}
-    const C2: u32 = 0;
 }
 
 fn main() {}