auto merge of #16433 : aturon/rust/deprecated-in-crate, r=alexcrichton

bors · bors · commit 51c7e20d539e · 2014-08-12T22:01:25.000Z
Previously the stability lint considered cross-crate items only. That's appropriate for unstable and experimental levels, but not for deprecation. In addition to changing the lint, this PR takes care of the fallout: a number of deprecated items that were being used throughout libstd. Closes #16409 Due to deny(deprecated), this is a: [breaking-change]
diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs
@@ -264,7 +264,7 @@ impl Bitv {
         assert!(i < self.nbits);
         let w = i / uint::BITS;
         let b = i % uint::BITS;
-        let x = self.storage.get(w) & (1 << b);
+        let x = self.storage[w] & (1 << b);
         x != 0
     }
 
@@ -289,8 +289,8 @@ impl Bitv {
         let w = i / uint::BITS;
         let b = i % uint::BITS;
         let flag = 1 << b;
-        *self.storage.get_mut(w) = if x { *self.storage.get(w) | flag }
-                          else { *self.storage.get(w) & !flag };
+        *self.storage.get_mut(w) = if x { self.storage[w] | flag }
+                          else { self.storage[w] & !flag };
     }
 
     /// Set all bits to 1.
@@ -827,7 +827,7 @@ impl Clone for Bitv {
     fn clone_from(&mut self, source: &Bitv) {
         self.nbits = source.nbits;
         self.storage.reserve(source.storage.len());
-        for (i, w) in self.storage.mut_iter().enumerate() { *w = *source.storage.get(i); }
+        for (i, w) in self.storage.mut_iter().enumerate() { *w = source.storage[i]; }
     }
 }
 
@@ -1146,7 +1146,7 @@ impl BitvSet {
         self_bitv.reserve(other_bitv.capacity());
         // Apply values
         for (i, w) in other_bitv.mask_words(0) {
-            let old = *self_bitv.storage.get(i);
+            let old = self_bitv.storage[i];
             let new = f(old, w);
             *self_bitv.storage.get_mut(i) = new;
         }
@@ -1573,10 +1573,10 @@ impl<'a> Iterator<uint> for TwoBitPositions<'a> {
                 // one Bitv might be longer than the other
                 let word_idx = self.next_idx / uint::BITS;
                 let w1 = if word_idx < s_bitv.storage.len() {
-                             *s_bitv.storage.get(word_idx)
+                             s_bitv.storage[word_idx]
                          } else { 0 };
                 let w2 = if word_idx < o_bitv.storage.len() {
-                             *o_bitv.storage.get(word_idx)
+                             o_bitv.storage[word_idx]
                          } else { 0 };
                 self.current_word = (self.merge)(w1, w2);
             }
diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs
@@ -299,14 +299,14 @@ impl<K: Ord, V> Leaf<K, V> {
             midpoint = 0;
         }
         loop {
-            let order = self.elts.get(midpoint).key.cmp(&k);
+            let order = self.elts[midpoint].key.cmp(&k);
             match order {
                 Equal => {
                     return None;
                 }
                 Greater => {
                     if midpoint > 0 {
-                        if self.elts.get(midpoint - 1).key.cmp(&k) == Less {
+                        if self.elts[midpoint - 1].key.cmp(&k) == Less {
                             return Some(midpoint);
                         }
                         else {
@@ -322,7 +322,7 @@ impl<K: Ord, V> Leaf<K, V> {
                 }
                 Less => {
                     if midpoint + 1 < self.elts.len() {
-                        if self.elts.get(midpoint + 1).key.cmp(&k) == Greater {
+                        if self.elts[midpoint + 1].key.cmp(&k) == Greater {
                             return Some(midpoint);
                         }
                         else {
@@ -422,7 +422,7 @@ impl<K: Ord, V: Eq> Ord for Leaf<K, V> {
         if self.elts.len() < other.elts.len() {
             return Less;
         }
-        self.elts.get(0).cmp(other.elts.get(0))
+        self.elts[0].cmp(&other.elts[0])
     }
 }
 
@@ -457,14 +457,14 @@ impl<K: Ord, V> Branch<K, V> {
             midpoint = 0u;
         }
         loop {
-            let order = self.elts.get(midpoint).key.cmp(&k);
+            let order = self.elts[midpoint].key.cmp(&k);
             match order {
                 Equal => {
                     return None;
                 }
                 Greater => {
                     if midpoint > 0 {
-                        if self.elts.get(midpoint - 1).key.cmp(&k) == Less {
+                        if self.elts[midpoint - 1].key.cmp(&k) == Less {
                             return Some(midpoint);
                         }
                         else {
@@ -480,7 +480,7 @@ impl<K: Ord, V> Branch<K, V> {
                 }
                 Less => {
                     if midpoint + 1 < self.elts.len() {
-                        if self.elts.get(midpoint + 1).key.cmp(&k) == Greater {
+                        if self.elts[midpoint + 1].key.cmp(&k) == Greater {
                             return Some(midpoint);
                         }
                         else {
@@ -529,15 +529,15 @@ impl<K: Clone + Ord, V: Clone> Branch<K, V> {
             Some(i) => {
                 if i == self.elts.len() {
                     let new_outcome = self.clone().rightmost_child.insert(k.clone(),
-                                                                       v.clone(),
-                                                                       ub.clone());
+                                                                          v.clone(),
+                                                                          ub.clone());
                     new_branch = new_outcome.clone().val0();
                     outcome = new_outcome.val1();
                 }
                 else {
-                    let new_outcome = self.elts.get(i).left.clone().insert(k.clone(),
-                                                                                 v.clone(),
-                                                                                 ub.clone());
+                    let new_outcome = self.elts[i].left.clone().insert(k.clone(),
+                                                                       v.clone(),
+                                                                       ub.clone());
                     new_branch = new_outcome.clone().val0();
                     outcome = new_outcome.val1();
                 }
@@ -581,7 +581,7 @@ impl<K: Clone + Ord, V: Clone> Branch<K, V> {
                 //If we have a new branch node, attempt to insert it into the tree
                 //as with the key-value pair, then check to see if the node is overfull.
                 BranchNode(branch) => {
-                    let new_elt = branch.elts.get(0).clone();
+                    let new_elt = branch.elts[0].clone();
                     let new_elt_index = self.bsearch_branch(new_elt.clone().key);
                     match new_elt_index {
                         None => {
@@ -652,7 +652,7 @@ impl<K: Ord, V: Eq> Ord for Branch<K, V> {
         if self.elts.len() < other.elts.len() {
             return Less;
         }
-        self.elts.get(0).cmp(other.elts.get(0))
+        self.elts[0].cmp(&other.elts[0])
     }
 }
 
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
@@ -654,7 +654,7 @@ impl<A> Iterator<A> for MoveItems<A> {
 
 impl<A> DoubleEndedIterator<A> for MoveItems<A> {
     #[inline]
-    fn next_back(&mut self) -> Option<A> { self.list.pop_back() }
+    fn next_back(&mut self) -> Option<A> { self.list.pop() }
 }
 
 impl<A> FromIterator<A> for DList<A> {
@@ -667,7 +667,7 @@ impl<A> FromIterator<A> for DList<A> {
 
 impl<A> Extendable<A> for DList<A> {
     fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
-        for elt in iterator { self.push_back(elt); }
+        for elt in iterator { self.push(elt); }
     }
 }
 
diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs
@@ -261,7 +261,7 @@ impl<T: Ord> PriorityQueue<T> {
     ///
     /// ```
     pub fn top<'a>(&'a self) -> Option<&'a T> {
-        if self.is_empty() { None } else { Some(self.data.get(0)) }
+        if self.is_empty() { None } else { Some(&self.data[0]) }
     }
 
     #[deprecated="renamed to `top`"]
@@ -473,7 +473,7 @@ impl<T: Ord> PriorityQueue<T> {
 
             while pos > start {
                 let parent = (pos - 1) >> 1;
-                if new > *self.data.get(parent) {
+                if new > self.data[parent] {
                     let x = replace(self.data.get_mut(parent), zeroed());
                     ptr::write(self.data.get_mut(pos), x);
                     pos = parent;
@@ -493,7 +493,7 @@ impl<T: Ord> PriorityQueue<T> {
             let mut child = 2 * pos + 1;
             while child < end {
                 let right = child + 1;
-                if right < end && !(*self.data.get(child) > *self.data.get(right)) {
+                if right < end && !(self.data[child] > self.data[right]) {
                     child = right;
                 }
                 let x = replace(self.data.get_mut(child), zeroed());
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
@@ -53,7 +53,7 @@ impl<T> Mutable for RingBuf<T> {
 impl<T> Deque<T> for RingBuf<T> {
     /// Return a reference to the first element in the RingBuf
     fn front<'a>(&'a self) -> Option<&'a T> {
-        if self.nelts > 0 { Some(self.get(0)) } else { None }
+        if self.nelts > 0 { Some(&self[0]) } else { None }
     }
 
     /// Return a mutable reference to the first element in the RingBuf
@@ -63,7 +63,7 @@ impl<T> Deque<T> for RingBuf<T> {
 
     /// Return a reference to the last element in the RingBuf
     fn back<'a>(&'a self) -> Option<&'a T> {
-        if self.nelts > 0 { Some(self.get(self.nelts - 1)) } else { None }
+        if self.nelts > 0 { Some(&self[self.nelts - 1]) } else { None }
     }
 
     /// Return a mutable reference to the last element in the RingBuf
@@ -152,7 +152,7 @@ impl<T> RingBuf<T> {
     #[deprecated = "prefer using indexing, e.g., ringbuf[0]"]
     pub fn get<'a>(&'a self, i: uint) -> &'a T {
         let idx = self.raw_index(i);
-        match *self.elts.get(idx) {
+        match self.elts[idx] {
             None => fail!(),
             Some(ref v) => v
         }
@@ -481,6 +481,7 @@ impl<S: Writer, A: Hash<S>> Hash<S> for RingBuf<A> {
 
 impl<A> Index<uint, A> for RingBuf<A> {
     #[inline]
+    #[allow(deprecated)]
     fn index<'a>(&'a self, i: &uint) -> &'a A {
         self.get(*i)
     }
@@ -506,7 +507,7 @@ impl<A> FromIterator<A> for RingBuf<A> {
 impl<A> Extendable<A> for RingBuf<A> {
     fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
         for elt in iterator {
-            self.push_back(elt);
+            self.push(elt);
         }
     }
 }
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
@@ -190,7 +190,7 @@ impl Iterator<(uint, uint)> for ElementSwaps {
         let max = self.sdir.iter().map(|&x| x).enumerate()
                            .filter(|&(i, sd)|
                                 new_pos(i, sd.dir) < self.sdir.len() &&
-                                self.sdir.get(new_pos(i, sd.dir)).size < sd.size)
+                                self.sdir[new_pos(i, sd.dir)].size < sd.size)
                            .max_by(|&(_, sd)| sd.size);
         match max {
             Some((i, sd)) => {
diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs
@@ -86,7 +86,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
     /// Return a reference to the value corresponding to the key.
     fn find<'a>(&'a self, key: &uint) -> Option<&'a V> {
         if *key < self.v.len() {
-            match *self.v.get(*key) {
+            match self.v[*key] {
               Some(ref value) => Some(value),
               None => None
             }
@@ -421,6 +421,7 @@ impl<V> Extendable<(uint, V)> for SmallIntMap<V> {
 
 impl<V> Index<uint, V> for SmallIntMap<V> {
     #[inline]
+    #[allow(deprecated)]
     fn index<'a>(&'a self, i: &uint) -> &'a V {
         self.get(i)
     }
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
@@ -251,11 +251,11 @@ impl<'a> Iterator<char> for Decompositions<'a> {
         match self.buffer.as_slice().head() {
             Some(&(c, 0)) => {
                 self.sorted = false;
-                self.buffer.shift();
+                self.buffer.remove(0);
                 return Some(c);
             }
             Some(&(c, _)) if self.sorted => {
-                self.buffer.shift();
+                self.buffer.remove(0);
                 return Some(c);
             }
             _ => self.sorted = false
@@ -287,7 +287,7 @@ impl<'a> Iterator<char> for Decompositions<'a> {
             self.sorted = true;
         }
 
-        match self.buffer.shift() {
+        match self.buffer.remove(0) {
             Some((c, 0)) => {
                 self.sorted = false;
                 Some(c)
@@ -805,21 +805,21 @@ pub trait StrAllocating: Str {
 
             for (j, tc) in t.chars().enumerate() {
 
-                let next = *dcol.get(j + 1);
+                let next = dcol[j + 1];
 
                 if sc == tc {
                     *dcol.get_mut(j + 1) = current;
                 } else {
                     *dcol.get_mut(j + 1) = cmp::min(current, next);
-                    *dcol.get_mut(j + 1) = cmp::min(*dcol.get(j + 1),
-                                                    *dcol.get(j)) + 1;
+                    *dcol.get_mut(j + 1) = cmp::min(dcol[j + 1],
+                                                    dcol[j]) + 1;
                 }
 
                 current = next;
             }
         }
 
-        return *dcol.get(tlen);
+        return dcol[tlen];
     }
 
     /// An Iterator over the string in Unicode Normalization Form D
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
@@ -669,7 +669,7 @@ impl String {
     /// }
     /// ```
     pub unsafe fn shift_byte(&mut self) -> Option<u8> {
-        self.vec.shift()
+        self.vec.remove(0)
     }
 
     /// Removes the first character from the string buffer and returns it.
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
@@ -453,6 +453,7 @@ impl<T:Clone> Clone for Vec<T> {
 
 impl<T> Index<uint,T> for Vec<T> {
     #[inline]
+    #[allow(deprecated)] // allow use of get
     fn index<'a>(&'a self, index: &uint) -> &'a T {
         self.get(*index)
     }
diff --git a/src/libfourcc/lib.rs b/src/libfourcc/lib.rs
@@ -42,6 +42,7 @@ fn main() {
 #![crate_name = "fourcc"]
 #![deprecated = "This is now a cargo package located at: \
                  https://github.com/rust-lang/fourcc"]
+#![allow(deprecated)]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![license = "MIT/ASL2"]
diff --git a/src/libhexfloat/lib.rs b/src/libhexfloat/lib.rs
@@ -39,6 +39,7 @@ fn main() {
 #![crate_name = "hexfloat"]
 #![deprecated = "This is now a cargo package located at: \
                  https://github.com/rust-lang/hexfloat"]
+#![allow(deprecated)]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![license = "MIT/ASL2"]
diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
@@ -1479,20 +1479,20 @@ impl LintPass for Stability {
             _ => return
         };
 
-        // stability attributes are promises made across crates; do not
-        // check anything for crate-local usage.
-        if ast_util::is_local(id) { return }
-
         let stability = stability::lookup(cx.tcx, id);
+        let cross_crate = !ast_util::is_local(id);
+
+        // stability attributes are promises made across crates; only
+        // check DEPRECATED for crate-local usage.
         let (lint, label) = match stability {
             // no stability attributes == Unstable
-            None => (UNSTABLE, "unmarked"),
-            Some(attr::Stability { level: attr::Unstable, .. }) =>
-                    (UNSTABLE, "unstable"),
-            Some(attr::Stability { level: attr::Experimental, .. }) =>
-                    (EXPERIMENTAL, "experimental"),
+            None if cross_crate => (UNSTABLE, "unmarked"),
+            Some(attr::Stability { level: attr::Unstable, .. }) if cross_crate =>
+                (UNSTABLE, "unstable"),
+            Some(attr::Stability { level: attr::Experimental, .. }) if cross_crate =>
+                (EXPERIMENTAL, "experimental"),
             Some(attr::Stability { level: attr::Deprecated, .. }) =>
-                    (DEPRECATED, "deprecated"),
+                (DEPRECATED, "deprecated"),
             _ => return
         };
 
diff --git a/src/libsemver/lib.rs b/src/libsemver/lib.rs
@@ -31,6 +31,7 @@
 #![crate_name = "semver"]
 #![deprecated = "This is now a cargo package located at: \
                  https://github.com/rust-lang/semver"]
+#![allow(deprecated)]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![license = "MIT/ASL2"]
diff --git a/src/libsync/atomic.rs b/src/libsync/atomic.rs
@@ -101,6 +101,8 @@
 //! }
 //! ```
 
+#![allow(deprecated)]
+
 use core::prelude::*;
 
 use alloc::boxed::Box;
diff --git a/src/libsync/comm/duplex.rs b/src/libsync/comm/duplex.rs
diff --git a/src/liburl/lib.rs b/src/liburl/lib.rs
diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs
diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs

Original file line number	Diff line number	Diff line change
`@@ -299,14 +299,14 @@ impl<K: Ord, V> Leaf<K, V> {`
`299`	`299`	`midpoint = 0;`
`300`	`300`	`}`
`301`	`301`	`loop {`
`302`		`- let order = self.elts.get(midpoint).key.cmp(&k);`
	`302`	`+ let order = self.elts[midpoint].key.cmp(&k);`
`303`	`303`	`match order {`
`304`	`304`	`Equal => {`
`305`	`305`	`return None;`
`306`	`306`	`}`
`307`	`307`	`Greater => {`
`308`	`308`	`if midpoint > 0 {`
`309`		`- if self.elts.get(midpoint - 1).key.cmp(&k) == Less {`
	`309`	`+ if self.elts[midpoint - 1].key.cmp(&k) == Less {`
`310`	`310`	`return Some(midpoint);`
`311`	`311`	`}`
`312`	`312`	`else {`
`@@ -322,7 +322,7 @@ impl<K: Ord, V> Leaf<K, V> {`
`322`	`322`	`}`
`323`	`323`	`Less => {`
`324`	`324`	`if midpoint + 1 < self.elts.len() {`
`325`		`- if self.elts.get(midpoint + 1).key.cmp(&k) == Greater {`
	`325`	`+ if self.elts[midpoint + 1].key.cmp(&k) == Greater {`
`326`	`326`	`return Some(midpoint);`
`327`	`327`	`}`
`328`	`328`	`else {`
`@@ -422,7 +422,7 @@ impl<K: Ord, V: Eq> Ord for Leaf<K, V> {`
`422`	`422`	`if self.elts.len() < other.elts.len() {`
`423`	`423`	`return Less;`
`424`	`424`	`}`
`425`		`- self.elts.get(0).cmp(other.elts.get(0))`
	`425`	`+ self.elts[0].cmp(&other.elts[0])`
`426`	`426`	`}`
`427`	`427`	`}`
`428`	`428`
`@@ -457,14 +457,14 @@ impl<K: Ord, V> Branch<K, V> {`
`457`	`457`	`midpoint = 0u;`
`458`	`458`	`}`
`459`	`459`	`loop {`
`460`		`- let order = self.elts.get(midpoint).key.cmp(&k);`
	`460`	`+ let order = self.elts[midpoint].key.cmp(&k);`
`461`	`461`	`match order {`
`462`	`462`	`Equal => {`
`463`	`463`	`return None;`
`464`	`464`	`}`
`465`	`465`	`Greater => {`
`466`	`466`	`if midpoint > 0 {`
`467`		`- if self.elts.get(midpoint - 1).key.cmp(&k) == Less {`
	`467`	`+ if self.elts[midpoint - 1].key.cmp(&k) == Less {`
`468`	`468`	`return Some(midpoint);`
`469`	`469`	`}`
`470`	`470`	`else {`
`@@ -480,7 +480,7 @@ impl<K: Ord, V> Branch<K, V> {`
`480`	`480`	`}`
`481`	`481`	`Less => {`
`482`	`482`	`if midpoint + 1 < self.elts.len() {`
`483`		`- if self.elts.get(midpoint + 1).key.cmp(&k) == Greater {`
	`483`	`+ if self.elts[midpoint + 1].key.cmp(&k) == Greater {`
`484`	`484`	`return Some(midpoint);`
`485`	`485`	`}`
`486`	`486`	`else {`
`@@ -529,15 +529,15 @@ impl<K: Clone + Ord, V: Clone> Branch<K, V> {`
`529`	`529`	`Some(i) => {`
`530`	`530`	`if i == self.elts.len() {`
`531`	`531`	`let new_outcome = self.clone().rightmost_child.insert(k.clone(),`
`532`		`- v.clone(),`
`533`		`- ub.clone());`
	`532`	`+ v.clone(),`
	`533`	`+ ub.clone());`
`534`	`534`	`new_branch = new_outcome.clone().val0();`
`535`	`535`	`outcome = new_outcome.val1();`
`536`	`536`	`}`
`537`	`537`	`else {`
`538`		`- let new_outcome = self.elts.get(i).left.clone().insert(k.clone(),`
`539`		`- v.clone(),`
`540`		`- ub.clone());`
	`538`	`+ let new_outcome = self.elts[i].left.clone().insert(k.clone(),`
	`539`	`+ v.clone(),`
	`540`	`+ ub.clone());`
`541`	`541`	`new_branch = new_outcome.clone().val0();`
`542`	`542`	`outcome = new_outcome.val1();`
`543`	`543`	`}`
`@@ -581,7 +581,7 @@ impl<K: Clone + Ord, V: Clone> Branch<K, V> {`
`581`	`581`	`//If we have a new branch node, attempt to insert it into the tree`
`582`	`582`	`//as with the key-value pair, then check to see if the node is overfull.`
`583`	`583`	`BranchNode(branch) => {`
`584`		`- let new_elt = branch.elts.get(0).clone();`
	`584`	`+ let new_elt = branch.elts[0].clone();`
`585`	`585`	`let new_elt_index = self.bsearch_branch(new_elt.clone().key);`
`586`	`586`	`match new_elt_index {`
`587`	`587`	`None => {`
`@@ -652,7 +652,7 @@ impl<K: Ord, V: Eq> Ord for Branch<K, V> {`
`652`	`652`	`if self.elts.len() < other.elts.len() {`
`653`	`653`	`return Less;`
`654`	`654`	`}`
`655`		`- self.elts.get(0).cmp(other.elts.get(0))`
	`655`	`+ self.elts[0].cmp(&other.elts[0])`
`656`	`656`	`}`
`657`	`657`	`}`
`658`	`658`
Original file line number	Diff line number	Diff line change
`@@ -654,7 +654,7 @@ impl<A> Iterator<A> for MoveItems<A> {`
`654`	`654`
`655`	`655`	`impl<A> DoubleEndedIterator<A> for MoveItems<A> {`
`656`	`656`	`#[inline]`
`657`		`- fn next_back(&mut self) -> Option<A> { self.list.pop_back() }`
	`657`	`+ fn next_back(&mut self) -> Option<A> { self.list.pop() }`
`658`	`658`	`}`
`659`	`659`
`660`	`660`	`impl<A> FromIterator<A> for DList<A> {`
`@@ -667,7 +667,7 @@ impl<A> FromIterator<A> for DList<A> {`
`667`	`667`
`668`	`668`	`impl<A> Extendable<A> for DList<A> {`
`669`	`669`	`fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {`
`670`		`- for elt in iterator { self.push_back(elt); }`
	`670`	`+ for elt in iterator { self.push(elt); }`
`671`	`671`	`}`
`672`	`672`	`}`
`673`	`673`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<T> Mutable for RingBuf<T> {`
`53`	`53`	`impl<T> Deque<T> for RingBuf<T> {`
`54`	`54`	`/// Return a reference to the first element in the RingBuf`
`55`	`55`	`fn front<'a>(&'a self) -> Option<&'a T> {`
`56`		`- if self.nelts > 0 { Some(self.get(0)) } else { None }`
	`56`	`+ if self.nelts > 0 { Some(&self[0]) } else { None }`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`/// Return a mutable reference to the first element in the RingBuf`
`@@ -63,7 +63,7 @@ impl<T> Deque<T> for RingBuf<T> {`
`63`	`63`
`64`	`64`	`/// Return a reference to the last element in the RingBuf`
`65`	`65`	`fn back<'a>(&'a self) -> Option<&'a T> {`
`66`		`- if self.nelts > 0 { Some(self.get(self.nelts - 1)) } else { None }`
	`66`	`+ if self.nelts > 0 { Some(&self[self.nelts - 1]) } else { None }`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/// Return a mutable reference to the last element in the RingBuf`
`@@ -152,7 +152,7 @@ impl<T> RingBuf<T> {`
`152`	`152`	`#[deprecated = "prefer using indexing, e.g., ringbuf[0]"]`
`153`	`153`	`pub fn get<'a>(&'a self, i: uint) -> &'a T {`
`154`	`154`	`let idx = self.raw_index(i);`
`155`		`- match *self.elts.get(idx) {`
	`155`	`+ match self.elts[idx] {`
`156`	`156`	`None => fail!(),`
`157`	`157`	`Some(ref v) => v`
`158`	`158`	`}`
`@@ -481,6 +481,7 @@ impl<S: Writer, A: Hash<S>> Hash<S> for RingBuf<A> {`
`481`	`481`
`482`	`482`	`impl<A> Index<uint, A> for RingBuf<A> {`
`483`	`483`	`#[inline]`
	`484`	`+ #[allow(deprecated)]`
`484`	`485`	`fn index<'a>(&'a self, i: &uint) -> &'a A {`
`485`	`486`	`self.get(*i)`
`486`	`487`	`}`
`@@ -506,7 +507,7 @@ impl<A> FromIterator<A> for RingBuf<A> {`
`506`	`507`	`impl<A> Extendable<A> for RingBuf<A> {`
`507`	`508`	`fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {`
`508`	`509`	`for elt in iterator {`
`509`		`- self.push_back(elt);`
	`510`	`+ self.push(elt);`
`510`	`511`	`}`
`511`	`512`	`}`
`512`	`513`	`}`
Original file line number	Diff line number	Diff line change
`@@ -669,7 +669,7 @@ impl String {`
`669`	`669`	`/// }`
`670`	`670`	/// ```
`671`	`671`	`pub unsafe fn shift_byte(&mut self) -> Option<u8> {`
`672`		`- self.vec.shift()`
	`672`	`+ self.vec.remove(0)`
`673`	`673`	`}`
`674`	`674`
`675`	`675`	`/// Removes the first character from the string buffer and returns it.`
Original file line number	Diff line number	Diff line change
`@@ -453,6 +453,7 @@ impl<T:Clone> Clone for Vec<T> {`
`453`	`453`
`454`	`454`	`impl<T> Index<uint,T> for Vec<T> {`
`455`	`455`	`#[inline]`
	`456`	`+ #[allow(deprecated)] // allow use of get`
`456`	`457`	`fn index<'a>(&'a self, index: &uint) -> &'a T {`
`457`	`458`	`self.get(*index)`
`458`	`459`	`}`