OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rollup merge of #23738: alexcrichton/snapshots

Browse Source 
Conflicts:
	src/libcollections/vec.rs
This commit is contained in:
Alex Crichton 2015-03-27 10:08:40 -07:00
commit 956c2eb257
29 changed files with 25 additions and 1166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/driver/driver.rs
View File

@ -12,9 +12,9 @@
#![cfg_attr(rustdoc, feature(rustdoc))]
#[cfg(rustdoc)]
extern crate "rustdoc" as this;
extern crate rustdoc as this;
#[cfg(rustc)]
extern crate "rustc_driver" as this;
extern crate rustc_driver as this;
fn main() { this::main() }

12
src/libcollections/bit.rs
View File

@ -171,18 +171,6 @@ pub struct BitVec {
impl Index<usize> for BitVec {
type Output = bool;
#[cfg(stage0)]
#[inline]
fn index(&self, i: &usize) -> &bool {
if self.get(*i).expect("index out of bounds") {
&TRUE
} else {
&FALSE
}
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, i: usize) -> &bool {
if self.get(i).expect("index out of bounds") {

14
src/libcollections/btree/map.rs
View File

@ -915,20 +915,6 @@ impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {
}
}
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
where K: Borrow<Q>, Q: Ord
{
type Output = V;
#[inline]
fn index(&self, key: &Q) -> &V {
self.get(key).expect("no entry found for key")
}
}
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>
where K: Borrow<Q>, Q: Ord

61
src/libcollections/btree/node.rs
View File

@ -1526,36 +1526,6 @@ macro_rules! node_slice_impl {
}
/// Returns a sub-slice with elements starting with `min_key`.
#[cfg(stage0)]
pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|
// | | | | |
// 0 0 1 1 2 2 3 3 4 index
// | | | | |
// \___|___|___|___/ slice_from(&0); pos = 0
// \___|___|___/ slice_from(&2); pos = 1
// |___|___|___/ slice_from(&3); pos = 1; result.head_is_edge = false
// \___|___/ slice_from(&4); pos = 2
// \___/ slice_from(&6); pos = 3
// \|/ slice_from(&999); pos = 4
let (pos, pos_is_kv) = self.search_linear(min_key);
$NodeSlice {
has_edges: self.has_edges,
edges: if !self.has_edges {
self.edges
} else {
self.edges.$index(&(pos ..))
},
keys: &self.keys[pos ..],
vals: self.vals.$index(&(pos ..)),
head_is_edge: !pos_is_kv,
tail_is_edge: self.tail_is_edge,
}
}
/// Returns a sub-slice with elements starting with `min_key`.
#[cfg(not(stage0))]
pub fn slice_from(self, min_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|
@ -1584,37 +1554,6 @@ macro_rules! node_slice_impl {
}
/// Returns a sub-slice with elements up to and including `max_key`.
#[cfg(stage0)]
pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|
// | | | | |
// 0 0 1 1 2 2 3 3 4 index
// | | | | |
//\|/ | | | | slice_to(&0); pos = 0
// \___/ | | | slice_to(&2); pos = 1
// \___|___| | | slice_to(&3); pos = 1; result.tail_is_edge = false
// \___|___/ | | slice_to(&4); pos = 2
// \___|___|___/ | slice_to(&6); pos = 3
// \___|___|___|___/ slice_to(&999); pos = 4
let (pos, pos_is_kv) = self.search_linear(max_key);
let pos = pos + if pos_is_kv { 1 } else { 0 };
$NodeSlice {
has_edges: self.has_edges,
edges: if !self.has_edges {
self.edges
} else {
self.edges.$index(&(.. (pos + 1)))
},
keys: &self.keys[..pos],
vals: self.vals.$index(&(.. pos)),
head_is_edge: self.head_is_edge,
tail_is_edge: !pos_is_kv,
}
}
/// Returns a sub-slice with elements up to and including `max_key`.
#[cfg(not(stage0))]
pub fn slice_to(self, max_key: &K) -> $NodeSlice<'a, K, V> {
// _______________
// |_1_|_3_|_5_|_7_|

28
src/libcollections/string.rs
View File

@ -903,13 +903,6 @@ impl<'a> Add<&'a str> for String {
impl ops::Index<ops::Range<usize>> for String {
type Output = str;
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::Range<usize>) -> &str {
&self[..][*index]
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &str {
&self[..][index]
@ -919,13 +912,6 @@ impl ops::Index<ops::Range<usize>> for String {
impl ops::Index<ops::RangeTo<usize>> for String {
type Output = str;
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeTo<usize>) -> &str {
&self[..][*index]
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &str {
&self[..][index]
@ -935,13 +921,6 @@ impl ops::Index<ops::RangeTo<usize>> for String {
impl ops::Index<ops::RangeFrom<usize>> for String {
type Output = str;
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
&self[..][*index]
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &str {
&self[..][index]
@ -951,13 +930,6 @@ impl ops::Index<ops::RangeFrom<usize>> for String {
impl ops::Index<ops::RangeFull> for String {
type Output = str;
#[cfg(stage0)]
#[inline]
fn index(&self, _index: &ops::RangeFull) -> &str {
unsafe { mem::transmute(&*self.vec) }
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &str {
unsafe { mem::transmute(&*self.vec) }

74
src/libcollections/vec.rs
View File

@ -1332,15 +1332,6 @@ impl<T: Hash> Hash for Vec<T> {
impl<T> Index<usize> for Vec<T> {
type Output = T;
#[cfg(stage0)]
#[inline]
fn index(&self, index: &usize) -> &T {
// NB built-in indexing via `&[T]`
&(**self)[*index]
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: usize) -> &T {
// NB built-in indexing via `&[T]`
@ -1350,15 +1341,6 @@ impl<T> Index<usize> for Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> IndexMut<usize> for Vec<T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &usize) -> &mut T {
// NB built-in indexing via `&mut [T]`
&mut (**self)[*index]
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: usize) -> &mut T {
// NB built-in indexing via `&mut [T]`
@ -1371,13 +1353,6 @@ impl<T> IndexMut<usize> for Vec<T> {
impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::Range<usize>) -> &[T] {
Index::index(&**self, index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
Index::index(&**self, index)
@ -1387,13 +1362,6 @@ impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
Index::index(&**self, index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
Index::index(&**self, index)
@ -1403,13 +1371,6 @@ impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
Index::index(&**self, index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
Index::index(&**self, index)
@ -1419,13 +1380,6 @@ impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
impl<T> ops::Index<ops::RangeFull> for Vec<T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, _index: &ops::RangeFull) -> &[T] {
self
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &[T] {
self
@ -1435,13 +1389,6 @@ impl<T> ops::Index<ops::RangeFull> for Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
@ -1450,13 +1397,6 @@ impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
@ -1465,13 +1405,6 @@ impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
IndexMut::index_mut(&mut **self, index)
@ -1480,13 +1413,6 @@ impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {
self
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: ops::RangeFull) -> &mut [T] {
self

14
src/libcollections/vec_deque.rs
View File

@ -1705,13 +1705,6 @@ impl<A: Hash> Hash for VecDeque<A> {
impl<A> Index<usize> for VecDeque<A> {
type Output = A;
#[cfg(stage0)]
#[inline]
fn index(&self, i: &usize) -> &A {
self.get(*i).expect("Out of bounds access")
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, i: usize) -> &A {
self.get(i).expect("Out of bounds access")
@ -1720,13 +1713,6 @@ impl<A> Index<usize> for VecDeque<A> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<A> IndexMut<usize> for VecDeque<A> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, i: &usize) -> &mut A {
self.get_mut(*i).expect("Out of bounds access")
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, i: usize) -> &mut A {
self.get_mut(i).expect("Out of bounds access")

23
src/libcollections/vec_map.rs
View File

@ -836,17 +836,6 @@ impl<V> Extend<(usize, V)> for VecMap<V> {
}
}
#[cfg(stage0)]
impl<V> Index<usize> for VecMap<V> {
type Output = V;
#[inline]
fn index<'a>(&'a self, i: &usize) -> &'a V {
self.get(i).expect("key not present")
}
}
#[cfg(not(stage0))]
impl<V> Index<usize> for VecMap<V> {
type Output = V;
@ -856,7 +845,6 @@ impl<V> Index<usize> for VecMap<V> {
}
}
#[cfg(not(stage0))]
impl<'a,V> Index<&'a usize> for VecMap<V> {
type Output = V;
@ -866,16 +854,6 @@ impl<'a,V> Index<&'a usize> for VecMap<V> {
}
}
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> IndexMut<usize> for VecMap<V> {
#[inline]
fn index_mut(&mut self, i: &usize) -> &mut V {
self.get_mut(&i).expect("key not present")
}
}
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<V> IndexMut<usize> for VecMap<V> {
#[inline]
@ -884,7 +862,6 @@ impl<V> IndexMut<usize> for VecMap<V> {
}
}
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> IndexMut<&'a usize> for VecMap<V> {
#[inline]

23
src/libcore/intrinsics.rs
View File

@ -44,10 +44,6 @@
use marker::Sized;
#[cfg(stage0)] pub use self::copy_memory as copy;
#[cfg(stage0)] pub use self::set_memory as write_bytes;
#[cfg(stage0)] pub use self::copy_nonoverlapping_memory as copy_nonoverlapping;
extern "rust-intrinsic" {
// NB: These intrinsics take unsafe pointers because they mutate aliased
@ -183,7 +179,6 @@ extern "rust-intrinsic" {
pub fn pref_align_of<T>() -> usize;
/// Gets a static string slice containing the name of a type.
#[cfg(not(stage0))]
pub fn type_name<T: ?Sized>() -> &'static str;
/// Gets an identifier which is globally unique to the specified type. This
@ -309,14 +304,8 @@ extern "rust-intrinsic" {
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(not(stage0))]
pub fn copy_nonoverlapping<T>(dst: *mut T, src: *const T, count: usize);
/// dox
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(stage0)]
pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: usize);
/// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
/// and destination may overlap.
///
@ -345,26 +334,14 @@ extern "rust-intrinsic" {
/// }
/// ```
///
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn copy<T>(dst: *mut T, src: *const T, count: usize);
/// dox
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn copy_memory<T>(dst: *mut T, src: *const T, count: usize);
/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
/// bytes of memory starting at `dst` to `c`.
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
/// dox
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn set_memory<T>(dst: *mut T, val: u8, count: usize);
/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
/// a size of `count` * `size_of::<T>()` and an alignment of
/// `min_align_of::<T>()`

62
src/libcore/ops.rs
View File

@ -917,12 +917,6 @@ pub trait Index<Idx: ?Sized> {
type Output: ?Sized;
/// The method for the indexing (`Foo[Bar]`) operation
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
fn index<'a>(&'a self, index: &Idx) -> &'a Self::Output;
/// The method for the indexing (`Foo[Bar]`) operation
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
fn index<'a>(&'a self, index: Idx) -> &'a Self::Output;
}
@ -966,12 +960,6 @@ pub trait Index<Idx: ?Sized> {
#[stable(feature = "rust1", since = "1.0.0")]
pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
/// The method for the indexing (`Foo[Bar]`) operation
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
fn index_mut<'a>(&'a mut self, index: &Idx) -> &'a mut Self::Output;
/// The method for the indexing (`Foo[Bar]`) operation
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
fn index_mut<'a>(&'a mut self, index: Idx) -> &'a mut Self::Output;
}
@ -1149,20 +1137,6 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T {
#[lang="fn"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
#[cfg(stage0)]
pub trait Fn<Args> {
/// The returned type after the call operator is used.
type Output;
/// This is called when the call operator is used.
extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}
/// A version of the call operator that takes an immutable receiver.
#[lang="fn"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
#[cfg(not(stage0))]
pub trait Fn<Args> : FnMut<Args> {
/// This is called when the call operator is used.
extern "rust-call" fn call(&self, args: Args) -> Self::Output;
@ -1172,20 +1146,6 @@ pub trait Fn<Args> : FnMut<Args> {
#[lang="fn_mut"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
#[cfg(stage0)]
pub trait FnMut<Args> {
/// The returned type after the call operator is used.
type Output;
/// This is called when the call operator is used.
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}
/// A version of the call operator that takes a mutable receiver.
#[lang="fn_mut"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_paren_sugar]
#[cfg(not(stage0))]
pub trait FnMut<Args> : FnOnce<Args> {
/// This is called when the call operator is used.
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
@ -1202,25 +1162,3 @@ pub trait FnOnce<Args> {
/// This is called when the call operator is used.
extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}
#[cfg(stage0)]
impl<F: ?Sized, A> FnMut<A> for F
where F : Fn<A>
{
type Output = <F as Fn<A>>::Output;
extern "rust-call" fn call_mut(&mut self, args: A) -> <F as Fn<A>>::Output {
self.call(args)
}
}
#[cfg(stage0)]
impl<F,A> FnOnce<A> for F
where F : FnMut<A>
{
type Output = <F as FnMut<A>>::Output;
extern "rust-call" fn call_once(mut self, args: A) -> <F as FnMut<A>>::Output {
self.call_mut(args)
}
}

185
src/libcore/slice.rs
View File

@ -269,18 +269,6 @@ impl<T> SliceExt for [T] {
#[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")]
fn as_mut_slice(&mut self) -> &mut [T] { self }
#[cfg(stage0)]
#[inline]
fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
unsafe {
let self2: &mut [T] = mem::transmute_copy(&self);
(ops::IndexMut::index_mut(self, &ops::RangeTo { end: mid } ),
ops::IndexMut::index_mut(self2, &ops::RangeFrom { start: mid } ))
}
}
#[cfg(not(stage0))]
#[inline]
fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
unsafe {
@ -513,14 +501,6 @@ impl<T> SliceExt for [T] {
impl<T> ops::Index<usize> for [T] {
type Output = T;
#[cfg(stage0)]
fn index(&self, &index: &usize) -> &T {
assert!(index < self.len());
unsafe { mem::transmute(self.repr().data.offset(index as isize)) }
}
#[cfg(not(stage0))]
fn index(&self, index: usize) -> &T {
assert!(index < self.len());
@ -530,15 +510,6 @@ impl<T> ops::Index<usize> for [T] {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<usize> for [T] {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, &index: &usize) -> &mut T {
assert!(index < self.len());
unsafe { mem::transmute(self.repr().data.offset(index as isize)) }
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: usize) -> &mut T {
assert!(index < self.len());
@ -551,20 +522,6 @@ impl<T> ops::IndexMut<usize> for [T] {
impl<T> ops::Index<ops::Range<usize>> for [T] {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::Range<usize>) -> &[T] {
assert!(index.start <= index.end);
assert!(index.end <= self.len());
unsafe {
from_raw_parts (
self.as_ptr().offset(index.start as isize),
index.end - index.start
)
}
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
assert!(index.start <= index.end);
@ -581,13 +538,6 @@ impl<T> ops::Index<ops::Range<usize>> for [T] {
impl<T> ops::Index<ops::RangeTo<usize>> for [T] {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
self.index(&ops::Range{ start: 0, end: index.end })
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.index(ops::Range{ start: 0, end: index.end })
@ -597,13 +547,6 @@ impl<T> ops::Index<ops::RangeTo<usize>> for [T] {
impl<T> ops::Index<ops::RangeFrom<usize>> for [T] {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
self.index(&ops::Range{ start: index.start, end: self.len() })
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.index(ops::Range{ start: index.start, end: self.len() })
@ -613,13 +556,6 @@ impl<T> ops::Index<ops::RangeFrom<usize>> for [T] {
impl<T> ops::Index<RangeFull> for [T] {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, _index: &RangeFull) -> &[T] {
self
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
self
@ -628,20 +564,6 @@ impl<T> ops::Index<RangeFull> for [T] {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::Range<usize>> for [T] {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
assert!(index.start <= index.end);
assert!(index.end <= self.len());
unsafe {
from_raw_parts_mut(
self.as_mut_ptr().offset(index.start as isize),
index.end - index.start
)
}
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
assert!(index.start <= index.end);
@ -656,13 +578,6 @@ impl<T> ops::IndexMut<ops::Range<usize>> for [T] {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeTo<usize>> for [T] {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(&ops::Range{ start: 0, end: index.end })
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(ops::Range{ start: 0, end: index.end })
@ -670,14 +585,6 @@ impl<T> ops::IndexMut<ops::RangeTo<usize>> for [T] {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<ops::RangeFrom<usize>> for [T] {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
let len = self.len();
self.index_mut(&ops::Range{ start: index.start, end: len })
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
let len = self.len();
@ -686,14 +593,6 @@ impl<T> ops::IndexMut<ops::RangeFrom<usize>> for [T] {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> ops::IndexMut<RangeFull> for [T] {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
self
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: RangeFull) -> &mut [T] {
self
@ -881,13 +780,6 @@ unsafe impl<'a, T: Sync> Send for Iter<'a, T> {}
impl<'a, T> ops::Index<ops::Range<usize>> for Iter<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::Range<usize>) -> &[T] {
self.as_slice().index(index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
self.as_slice().index(index)
@ -898,13 +790,6 @@ impl<'a, T> ops::Index<ops::Range<usize>> for Iter<'a, T> {
impl<'a, T> ops::Index<ops::RangeTo<usize>> for Iter<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
self.as_slice().index(index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.as_slice().index(index)
@ -915,13 +800,6 @@ impl<'a, T> ops::Index<ops::RangeTo<usize>> for Iter<'a, T> {
impl<'a, T> ops::Index<ops::RangeFrom<usize>> for Iter<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
self.as_slice().index(index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.as_slice().index(index)
@ -932,13 +810,6 @@ impl<'a, T> ops::Index<ops::RangeFrom<usize>> for Iter<'a, T> {
impl<'a, T> ops::Index<RangeFull> for Iter<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, _index: &RangeFull) -> &[T] {
self.as_slice()
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
self.as_slice()
@ -1006,13 +877,6 @@ unsafe impl<'a, T: Send> Send for IterMut<'a, T> {}
impl<'a, T> ops::Index<ops::Range<usize>> for IterMut<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::Range<usize>) -> &[T] {
self.index(&RangeFull).index(index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::Range<usize>) -> &[T] {
self.index(RangeFull).index(index)
@ -1022,13 +886,6 @@ impl<'a, T> ops::Index<ops::Range<usize>> for IterMut<'a, T> {
impl<'a, T> ops::Index<ops::RangeTo<usize>> for IterMut<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
self.index(&RangeFull).index(index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
self.index(RangeFull).index(index)
@ -1038,13 +895,6 @@ impl<'a, T> ops::Index<ops::RangeTo<usize>> for IterMut<'a, T> {
impl<'a, T> ops::Index<ops::RangeFrom<usize>> for IterMut<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
self.index(&RangeFull).index(index)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
self.index(RangeFull).index(index)
@ -1054,13 +904,6 @@ impl<'a, T> ops::Index<ops::RangeFrom<usize>> for IterMut<'a, T> {
impl<'a, T> ops::Index<RangeFull> for IterMut<'a, T> {
type Output = [T];
#[cfg(stage0)]
#[inline]
fn index(&self, _index: &RangeFull) -> &[T] {
make_slice!(T => &[T]: self.ptr, self.end)
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, _index: RangeFull) -> &[T] {
make_slice!(T => &[T]: self.ptr, self.end)
@ -1069,13 +912,6 @@ impl<'a, T> ops::Index<RangeFull> for IterMut<'a, T> {
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::Range<usize>> for IterMut<'a, T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
self.index_mut(&RangeFull).index_mut(index)
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
@ -1084,13 +920,6 @@ impl<'a, T> ops::IndexMut<ops::Range<usize>> for IterMut<'a, T> {
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeTo<usize>> for IterMut<'a, T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(&RangeFull).index_mut(index)
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
@ -1099,13 +928,6 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<usize>> for IterMut<'a, T> {
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<ops::RangeFrom<usize>> for IterMut<'a, T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
self.index_mut(&RangeFull).index_mut(index)
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
self.index_mut(RangeFull).index_mut(index)
@ -1114,13 +936,6 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<usize>> for IterMut<'a, T> {
#[unstable(feature = "core")]
impl<'a, T> ops::IndexMut<RangeFull> for IterMut<'a, T> {
#[cfg(stage0)]
#[inline]
fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
make_mut_slice!(T => &mut [T]: self.ptr, self.end)
}
#[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: RangeFull) -> &mut [T] {
make_mut_slice!(T => &mut [T]: self.ptr, self.end)

88
src/libcore/str/mod.rs
View File

@ -541,17 +541,6 @@ delegate_iter!{exact u8 : Bytes<'a>}
#[derive(Copy, Clone)]
struct BytesDeref;
#[cfg(stage0)]
impl<'a> Fn<(&'a u8,)> for BytesDeref {
type Output = u8;
#[inline]
extern "rust-call" fn call(&self, (ptr,): (&'a u8,)) -> u8 {
*ptr
}
}
#[cfg(not(stage0))]
impl<'a> Fn<(&'a u8,)> for BytesDeref {
#[inline]
extern "rust-call" fn call(&self, (ptr,): (&'a u8,)) -> u8 {
@ -559,7 +548,6 @@ impl<'a> Fn<(&'a u8,)> for BytesDeref {
}
}
#[cfg(not(stage0))]
impl<'a> FnMut<(&'a u8,)> for BytesDeref {
#[inline]
extern "rust-call" fn call_mut(&mut self, (ptr,): (&'a u8,)) -> u8 {
@ -567,7 +555,6 @@ impl<'a> FnMut<(&'a u8,)> for BytesDeref {
}
}
#[cfg(not(stage0))]
impl<'a> FnOnce<(&'a u8,)> for BytesDeref {
type Output = u8;
@ -1319,50 +1306,6 @@ mod traits {
/// // byte 100 is outside the string
/// // &s[3 .. 100];
/// ```
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::Range<usize>> for str {
type Output = str;
#[inline]
fn index(&self, index: &ops::Range<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
if index.start <= index.end &&
self.is_char_boundary(index.start) &&
self.is_char_boundary(index.end) {
unsafe { self.slice_unchecked(index.start, index.end) }
} else {
super::slice_error_fail(self, index.start, index.end)
}
}
}
/// Returns a slice of the given string from the byte range
/// [`begin`..`end`).
///
/// This operation is `O(1)`.
///
/// Panics when `begin` and `end` do not point to valid characters
/// or point beyond the last character of the string.
///
/// # Examples
///
/// ```
/// let s = "Löwe 老虎 Léopard";
/// assert_eq!(&s[0 .. 1], "L");
///
/// assert_eq!(&s[1 .. 9], "öwe 老");
///
/// // these will panic:
/// // byte 2 lies within `ö`:
/// // &s[2 ..3];
///
/// // byte 8 lies within `老`
/// // &s[1 .. 8];
///
/// // byte 100 is outside the string
/// // &s[3 .. 100];
/// ```
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::Range<usize>> for str {
type Output = str;
@ -1390,18 +1333,6 @@ mod traits {
impl ops::Index<ops::RangeTo<usize>> for str {
type Output = str;
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeTo<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
if self.is_char_boundary(index.end) {
unsafe { self.slice_unchecked(0, index.end) }
} else {
super::slice_error_fail(self, 0, index.end)
}
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeTo<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
@ -1423,18 +1354,6 @@ mod traits {
impl ops::Index<ops::RangeFrom<usize>> for str {
type Output = str;
#[cfg(stage0)]
#[inline]
fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
if self.is_char_boundary(index.start) {
unsafe { self.slice_unchecked(index.start, self.len()) }
} else {
super::slice_error_fail(self, index.start, self.len())
}
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, index: ops::RangeFrom<usize>) -> &str {
// is_char_boundary checks that the index is in [0, .len()]
@ -1450,13 +1369,6 @@ mod traits {
impl ops::Index<ops::RangeFull> for str {
type Output = str;
#[cfg(stage0)]
#[inline]
fn index(&self, _index: &ops::RangeFull) -> &str {
self
}
#[cfg(not(stage0))]
#[inline]
fn index(&self, _index: ops::RangeFull) -> &str {
self

2
src/liblibc/lib.rs
View File

@ -76,7 +76,7 @@
#![allow(bad_style, raw_pointer_derive)]
#![cfg_attr(target_os = "nacl", allow(unused_imports))]
#[cfg(feature = "cargo-build")] extern crate "std" as core;
#[cfg(feature = "cargo-build")] extern crate std as core;
#[cfg(not(feature = "cargo-build"))] extern crate core;
#[cfg(test)] extern crate std;

2
src/librustc/lib.rs
View File

@ -64,7 +64,7 @@ extern crate collections;
#[macro_use] extern crate syntax;
#[macro_use] #[no_link] extern crate rustc_bitflags;
extern crate "serialize" as rustc_serialize; // used by deriving
extern crate serialize as rustc_serialize; // used by deriving
#[cfg(test)]
extern crate test;

2
src/librustc_borrowck/lib.rs
View File

@ -35,7 +35,7 @@
// for "clarity", rename the graphviz crate to dot; graphviz within `borrowck`
// refers to the borrowck-specific graphviz adapter traits.
extern crate "graphviz" as dot;
extern crate graphviz as dot;
extern crate rustc;
pub use borrowck::check_crate;

2
src/librustc_driver/lib.rs
View File

@ -55,7 +55,7 @@ extern crate rustc_resolve;
extern crate rustc_trans;
extern crate rustc_typeck;
extern crate serialize;
extern crate "rustc_llvm" as llvm;
extern crate rustc_llvm as llvm;
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;

2
src/librustc_trans/lib.rs
View File

@ -53,7 +53,7 @@ extern crate libc;
extern crate rustc;
extern crate rustc_back;
extern crate serialize;
extern crate "rustc_llvm" as llvm;
extern crate rustc_llvm as llvm;
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;

4
src/librustdoc/lib.rs
View File

@ -51,11 +51,11 @@ extern crate rustc_lint;
extern crate rustc_back;
extern crate serialize;
extern crate syntax;
extern crate "test" as testing;
extern crate test as testing;
extern crate unicode;
#[macro_use] extern crate log;
extern crate "serialize" as rustc_serialize; // used by deriving
extern crate serialize as rustc_serialize; // used by deriving
use std::cell::RefCell;
use std::collections::HashMap;

23
src/libserialize/json.rs
View File

@ -1218,16 +1218,6 @@ impl Json {
}
}
#[cfg(stage0)]
impl<'a> Index<&'a str> for Json {
type Output = Json;
fn index(&self, idx: & &str) -> &Json {
self.find(*idx).unwrap()
}
}
#[cfg(not(stage0))]
impl<'a> Index<&'a str> for Json {
type Output = Json;
@ -1236,19 +1226,6 @@ impl<'a> Index<&'a str> for Json {
}
}
#[cfg(stage0)]
impl Index<uint> for Json {
type Output = Json;
fn index<'a>(&'a self, idx: &uint) -> &'a Json {
match self {
&Json::Array(ref v) => &v[*idx],
_ => panic!("can only index Json with uint if it is an array")
}
}
}
#[cfg(not(stage0))]
impl Index<uint> for Json {
type Output = Json;

16
src/libstd/collections/hash/map.rs
View File

@ -1247,22 +1247,6 @@ impl<K, V, S> Default for HashMap<K, V, S>
}
}
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl<K, Q: ?Sized, V, S> Index<Q> for HashMap<K, V, S>
where K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash,
S: HashState,
{
type Output = V;
#[inline]
fn index<'a>(&'a self, index: &Q) -> &'a V {
self.get(index).expect("no entry found for key")
}
}
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, Q: ?Sized, V, S> Index<&'a Q> for HashMap<K, V, S>
where K: Eq + Hash + Borrow<Q>,

12
src/libstd/ffi/os_str.rs
View File

@ -119,18 +119,6 @@ impl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for OsString {
}
}
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::RangeFull> for OsString {
type Output = OsStr;
#[inline]
fn index(&self, _index: &ops::RangeFull) -> &OsStr {
unsafe { mem::transmute(self.inner.as_slice()) }
}
}
#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Index<ops::RangeFull> for OsString {
type Output = OsStr;

6
src/libstd/lib.rs
View File

@ -147,9 +147,9 @@ extern crate core;
#[macro_use]
#[macro_reexport(vec, format)]
extern crate "collections" as core_collections;
extern crate collections as core_collections;
#[allow(deprecated)] extern crate "rand" as core_rand;
#[allow(deprecated)] extern crate rand as core_rand;
extern crate alloc;
extern crate unicode;
extern crate libc;
@ -157,7 +157,7 @@ extern crate libc;
#[macro_use] #[no_link] extern crate rustc_bitflags;
// Make std testable by not duplicating lang items. See #2912
#[cfg(test)] extern crate "std" as realstd;
#[cfg(test)] extern crate std as realstd;
#[cfg(test)] pub use realstd::marker;
#[cfg(test)] pub use realstd::ops;
#[cfg(test)] pub use realstd::cmp;

2
src/libstd/old_io/mem.rs
View File

@ -397,7 +397,7 @@ impl<'a> Buffer for BufReader<'a> {
#[cfg(test)]
mod test {
extern crate "test" as test_crate;
extern crate test as test_crate;
use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek, Buffer};
use prelude::v1::{Ok, Err, Vec, AsSlice};
use prelude::v1::IteratorExt;

79
src/libstd/sys/common/wtf8.rs
View File

@ -634,30 +634,6 @@ impl Wtf8 {
///
/// Panics when `begin` and `end` do not point to code point boundaries,
/// or point beyond the end of the string.
#[cfg(stage0)]
impl ops::Index<ops::Range<usize>> for Wtf8 {
type Output = Wtf8;
#[inline]
fn index(&self, range: &ops::Range<usize>) -> &Wtf8 {
// is_code_point_boundary checks that the index is in [0, .len()]
if range.start <= range.end &&
is_code_point_boundary(self, range.start) &&
is_code_point_boundary(self, range.end) {
unsafe { slice_unchecked(self, range.start, range.end) }
} else {
slice_error_fail(self, range.start, range.end)
}
}
}
/// Return a slice of the given string for the byte range [`begin`..`end`).
///
/// # Panics
///
/// Panics when `begin` and `end` do not point to code point boundaries,
/// or point beyond the end of the string.
#[cfg(not(stage0))]
impl ops::Index<ops::Range<usize>> for Wtf8 {
type Output = Wtf8;
@ -680,28 +656,6 @@ impl ops::Index<ops::Range<usize>> for Wtf8 {
///
/// Panics when `begin` is not at a code point boundary,
/// or is beyond the end of the string.
#[cfg(stage0)]
impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
type Output = Wtf8;
#[inline]
fn index(&self, range: &ops::RangeFrom<usize>) -> &Wtf8 {
// is_code_point_boundary checks that the index is in [0, .len()]
if is_code_point_boundary(self, range.start) {
unsafe { slice_unchecked(self, range.start, self.len()) }
} else {
slice_error_fail(self, range.start, self.len())
}
}
}
/// Return a slice of the given string from byte `begin` to its end.
///
/// # Panics
///
/// Panics when `begin` is not at a code point boundary,
/// or is beyond the end of the string.
#[cfg(not(stage0))]
impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
type Output = Wtf8;
@ -722,28 +676,6 @@ impl ops::Index<ops::RangeFrom<usize>> for Wtf8 {
///
/// Panics when `end` is not at a code point boundary,
/// or is beyond the end of the string.
#[cfg(stage0)]
impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
type Output = Wtf8;
#[inline]
fn index(&self, range: &ops::RangeTo<usize>) -> &Wtf8 {
// is_code_point_boundary checks that the index is in [0, .len()]
if is_code_point_boundary(self, range.end) {
unsafe { slice_unchecked(self, 0, range.end) }
} else {
slice_error_fail(self, 0, range.end)
}
}
}
/// Return a slice of the given string from its beginning to byte `end`.
///
/// # Panics
///
/// Panics when `end` is not at a code point boundary,
/// or is beyond the end of the string.
#[cfg(not(stage0))]
impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
type Output = Wtf8;
@ -758,17 +690,6 @@ impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
}
}
#[cfg(stage0)]
impl ops::Index<ops::RangeFull> for Wtf8 {
type Output = Wtf8;
#[inline]
fn index(&self, _range: &ops::RangeFull) -> &Wtf8 {
self
}
}
#[cfg(not(stage0))]
impl ops::Index<ops::RangeFull> for Wtf8 {
type Output = Wtf8;

2
src/libsyntax/lib.rs
View File

@ -49,7 +49,7 @@ extern crate libc;
#[macro_use] extern crate log;
#[macro_use] #[no_link] extern crate rustc_bitflags;
extern crate "serialize" as rustc_serialize; // used by deriving
extern crate serialize as rustc_serialize; // used by deriving
pub mod util {
pub mod interner;

2
src/libtest/lib.rs
View File

@ -50,7 +50,7 @@
extern crate getopts;
extern crate serialize;
extern crate "serialize" as rustc_serialize;
extern crate serialize as rustc_serialize;
extern crate term;
extern crate libc;

424
src/libunicode/char.rs
View File

@ -41,430 +41,6 @@ pub use normalize::{decompose_canonical, decompose_compatible, compose};
pub use tables::normalization::canonical_combining_class;
pub use tables::UNICODE_VERSION;
#[cfg(stage0)]
/// Functionality for manipulating `char`.
#[stable(feature = "rust1", since = "1.0.0")]
pub trait CharExt {
/// Checks if a `char` parses as a numeric digit in the given radix.
///
/// Compared to `is_numeric()`, this function only recognizes the characters
/// `0-9`, `a-z` and `A-Z`.
///
/// # Return value
///
/// Returns `true` if `c` is a valid digit under `radix`, and `false`
/// otherwise.
///
/// # Panics
///
/// Panics if given a radix > 36.
///
/// # Examples
///
/// ```
/// let c = '1';
///
/// assert!(c.is_digit(10));
///
/// assert!('f'.is_digit(16));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn is_digit(self, radix: u32) -> bool;
/// Converts a character to the corresponding digit.
///
/// # Return value
///
/// If `c` is between '0' and '9', the corresponding value between 0 and
/// 9. If `c` is 'a' or 'A', 10. If `c` is 'b' or 'B', 11, etc. Returns
/// none if the character does not refer to a digit in the given radix.
///
/// # Panics
///
/// Panics if given a radix outside the range [0..36].
///
/// # Examples
///
/// ```
/// let c = '1';
///
/// assert_eq!(c.to_digit(10), Some(1));
///
/// assert_eq!('f'.to_digit(16), Some(15));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn to_digit(self, radix: u32) -> Option<u32>;
/// Returns an iterator that yields the hexadecimal Unicode escape of a
/// character, as `char`s.
///
/// All characters are escaped with Rust syntax of the form `\\u{NNNN}`
/// where `NNNN` is the shortest hexadecimal representation of the code
/// point.
///
/// # Examples
///
/// ```
/// for i in '❤'.escape_unicode() {
/// println!("{}", i);
/// }
/// ```
///
/// This prints:
///
/// ```text
/// \
/// u
/// {
/// 2
/// 7
/// 6
/// 4
/// }
/// ```
///
/// Collecting into a `String`:
///
/// ```
/// let heart: String = '❤'.escape_unicode().collect();
///
/// assert_eq!(heart, r"\u{2764}");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn escape_unicode(self) -> EscapeUnicode;
/// Returns an iterator that yields the 'default' ASCII and
/// C++11-like literal escape of a character, as `char`s.
///
/// The default is chosen with a bias toward producing literals that are
/// legal in a variety of languages, including C++11 and similar C-family
/// languages. The exact rules are:
///
/// * Tab, CR and LF are escaped as '\t', '\r' and '\n' respectively.
/// * Single-quote, double-quote and backslash chars are backslash-
/// escaped.
/// * Any other chars in the range [0x20,0x7e] are not escaped.
/// * Any other chars are given hex Unicode escapes; see `escape_unicode`.
///
/// # Examples
///
/// ```
/// for i in '"'.escape_default() {
/// println!("{}", i);
/// }
/// ```
///
/// This prints:
///
/// ```text
/// \
/// "
/// ```
///
/// Collecting into a `String`:
///
/// ```
/// let quote: String = '"'.escape_default().collect();
///
/// assert_eq!(quote, "\\\"");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn escape_default(self) -> EscapeDefault;
/// Returns the number of bytes this character would need if encoded in
/// UTF-8.
///
/// # Examples
///
/// ```
/// let n = 'ß'.len_utf8();
///
/// assert_eq!(n, 2);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn len_utf8(self) -> usize;
/// Returns the number of 16-bit code units this character would need if
/// encoded in UTF-16.
///
/// # Examples
///
/// ```
/// let n = 'ß'.len_utf16();
///
/// assert_eq!(n, 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
fn len_utf16(self) -> usize;
/// Encodes this character as UTF-8 into the provided byte buffer, and then
/// returns the number of bytes written.
///
/// If the buffer is not large enough, nothing will be written into it and a
/// `None` will be returned. A buffer of length four is large enough to
/// encode any `char`.
///
/// # Examples
///
/// In both of these examples, 'ß' takes two bytes to encode.
///
/// ```
/// # #![feature(unicode)]
/// let mut b = [0; 2];
///
/// let result = 'ß'.encode_utf8(&mut b);
///
/// assert_eq!(result, Some(2));
/// ```
///
/// A buffer that's too small:
///
/// ```
/// # #![feature(unicode)]
/// let mut b = [0; 1];
///
/// let result = 'ß'.encode_utf8(&mut b);
///
/// assert_eq!(result, None);
/// ```
#[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf8(self, dst: &mut [u8]) -> Option<usize>;
/// Encodes this character as UTF-16 into the provided `u16` buffer, and
/// then returns the number of `u16`s written.
///
/// If the buffer is not large enough, nothing will be written into it and a
/// `None` will be returned. A buffer of length 2 is large enough to encode
/// any `char`.
///
/// # Examples
///
/// In both of these examples, 'ß' takes one `u16` to encode.
///
/// ```
/// # #![feature(unicode)]
/// let mut b = [0; 1];
///
/// let result = 'ß'.encode_utf16(&mut b);
///
/// assert_eq!(result, Some(1));
/// ```
///
/// A buffer that's too small:
///
/// ```
/// # #![feature(unicode)]
/// let mut b = [0; 0];
///
/// let result = 'ß'.encode_utf8(&mut b);
///
/// assert_eq!(result, None);
/// ```
#[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader")]
fn encode_utf16(self, dst: &mut [u16]) -> Option<usize>;
/// Returns whether the specified character is considered a Unicode
/// alphabetic code point.
#[stable(feature = "rust1", since = "1.0.0")]
fn is_alphabetic(self) -> bool;
/// Returns whether the specified character satisfies the 'XID_Start'
/// Unicode property.
///
/// 'XID_Start' is a Unicode Derived Property specified in
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
/// mostly similar to ID_Start but modified for closure under NFKx.
#[unstable(feature = "unicode",
reason = "mainly needed for compiler internals")]
fn is_xid_start(self) -> bool;
/// Returns whether the specified `char` satisfies the 'XID_Continue'
/// Unicode property.
///
/// 'XID_Continue' is a Unicode Derived Property specified in
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
/// mostly similar to 'ID_Continue' but modified for closure under NFKx.
#[unstable(feature = "unicode",
reason = "mainly needed for compiler internals")]
fn is_xid_continue(self) -> bool;
/// Indicates whether a character is in lowercase.
///
/// This is defined according to the terms of the Unicode Derived Core
/// Property `Lowercase`.
#[stable(feature = "rust1", since = "1.0.0")]
fn is_lowercase(self) -> bool;
/// Indicates whether a character is in uppercase.
///
/// This is defined according to the terms of the Unicode Derived Core
/// Property `Uppercase`.
#[stable(feature = "rust1", since = "1.0.0")]
fn is_uppercase(self) -> bool;
/// Indicates whether a character is whitespace.
///
/// Whitespace is defined in terms of the Unicode Property `White_Space`.
#[stable(feature = "rust1", since = "1.0.0")]
fn is_whitespace(self) -> bool;
/// Indicates whether a character is alphanumeric.
///
/// Alphanumericness is defined in terms of the Unicode General Categories
/// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
#[stable(feature = "rust1", since = "1.0.0")]
fn is_alphanumeric(self) -> bool;
/// Indicates whether a character is a control code point.
///
/// Control code points are defined in terms of the Unicode General
/// Category `Cc`.
#[stable(feature = "rust1", since = "1.0.0")]
fn is_control(self) -> bool;
/// Indicates whether the character is numeric (Nd, Nl, or No).
#[stable(feature = "rust1", since = "1.0.0")]
fn is_numeric(self) -> bool;
/// Converts a character to its lowercase equivalent.
///
/// The case-folding performed is the common or simple mapping. See
/// `to_uppercase()` for references and more information.
///
/// # Return value
///
/// Returns an iterator which yields the characters corresponding to the
/// lowercase equivalent of the character. If no conversion is possible then
/// the input character is returned.
#[stable(feature = "rust1", since = "1.0.0")]
fn to_lowercase(self) -> ToLowercase;
/// Converts a character to its uppercase equivalent.
///
/// The case-folding performed is the common or simple mapping: it maps
/// one Unicode codepoint to its uppercase equivalent according to the
/// Unicode database [1]. The additional [`SpecialCasing.txt`] is not yet
/// considered here, but the iterator returned will soon support this form
/// of case folding.
///
/// A full reference can be found here [2].
///
/// # Return value
///
/// Returns an iterator which yields the characters corresponding to the
/// uppercase equivalent of the character. If no conversion is possible then
/// the input character is returned.
///
/// [1]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
///
/// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
///
/// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
#[stable(feature = "rust1", since = "1.0.0")]
fn to_uppercase(self) -> ToUppercase;
/// Returns this character's displayed width in columns, or `None` if it is a
/// control character other than `'\x00'`.
///
/// `is_cjk` determines behavior for characters in the Ambiguous category:
/// if `is_cjk` is `true`, these are 2 columns wide; otherwise, they are 1.
/// In CJK contexts, `is_cjk` should be `true`, else it should be `false`.
/// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
/// recommends that these characters be treated as 1 column (i.e.,
/// `is_cjk` = `false`) if the context cannot be reliably determined.
#[unstable(feature = "unicode",
reason = "needs expert opinion. is_cjk flag stands out as ugly")]
fn width(self, is_cjk: bool) -> Option<usize>;
}
#[cfg(stage0)]
#[stable(feature = "rust1", since = "1.0.0")]
impl CharExt for char {
#[inline]
fn is_digit(self, radix: u32) -> bool { C::is_digit(self, radix) }
fn to_digit(self, radix: u32) -> Option<u32> { C::to_digit(self, radix) }
fn escape_unicode(self) -> EscapeUnicode { C::escape_unicode(self) }
fn escape_default(self) -> EscapeDefault { C::escape_default(self) }
fn len_utf8(self) -> usize { C::len_utf8(self) }
fn len_utf16(self) -> usize { C::len_utf16(self) }
fn encode_utf8(self, dst: &mut [u8]) -> Option<usize> { C::encode_utf8(self, dst) }
fn encode_utf16(self, dst: &mut [u16]) -> Option<usize> { C::encode_utf16(self, dst) }
#[inline]
fn is_alphabetic(self) -> bool {
match self {
'a' ... 'z' | 'A' ... 'Z' => true,
c if c > '\x7f' => derived_property::Alphabetic(c),
_ => false
}
}
#[inline]
fn is_xid_start(self) -> bool { derived_property::XID_Start(self) }
#[inline]
fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) }
#[inline]
fn is_lowercase(self) -> bool {
match self {
'a' ... 'z' => true,
c if c > '\x7f' => derived_property::Lowercase(c),
_ => false
}
}
#[inline]
fn is_uppercase(self) -> bool {
match self {
'A' ... 'Z' => true,
c if c > '\x7f' => derived_property::Uppercase(c),
_ => false
}
}
#[inline]
fn is_whitespace(self) -> bool {
match self {
' ' | '\x09' ... '\x0d' => true,
c if c > '\x7f' => property::White_Space(c),
_ => false
}
}
#[inline]
fn is_alphanumeric(self) -> bool {
self.is_alphabetic() || self.is_numeric()
}
#[inline]
fn is_control(self) -> bool { general_category::Cc(self) }
#[inline]
fn is_numeric(self) -> bool {
match self {
'0' ... '9' => true,
c if c > '\x7f' => general_category::N(c),
_ => false
}
}
#[inline]
fn to_lowercase(self) -> ToLowercase {
ToLowercase(Some(conversions::to_lower(self)))
}
#[inline]
fn to_uppercase(self) -> ToUppercase {
ToUppercase(Some(conversions::to_upper(self)))
}
#[inline]
fn width(self, is_cjk: bool) -> Option<usize> { charwidth::width(self, is_cjk) }
}
/// An iterator over the lowercase mapping of a given character, returned from
/// the [`to_lowercase` method](../primitive.char.html#method.to_lowercase) on
/// characters.

10
src/snapshots.txt
View File

@ -1,3 +1,13 @@
S 2015-03-25 a923278
bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163
freebsd-x86_64 cd02c86a9218da73b2a45aff293787010d33bf3e
linux-i386 da50141558eed6dabab97b79b2c6a7de4f2d2c5e
linux-x86_64 bca03458d28d07506bad4b80e5770b2117286244
macos-i386 522d59b23dd885a45e2c5b33e80e76240bb2d9af
macos-x86_64 82df09d51d73d119a2f4e4d8041879615cb22081
winnt-i386 5056e8def5ab4f4283b8f3aab160cc10231bb28d
winnt-x86_64 3f6b35ac12625b4b4b42dfd5eee5f6cbf122794e
S 2015-03-17 c64d671
bitrig-x86_64 41de2c7a69a1ac648d3fa3b65e96a29bdc122163
freebsd-x86_64 14ced24e1339a4dd8baa9db69995daa52a948d54

13
src/test/compile-fail/borrowck-overloaded-index-autoderef.rs
View File

@ -18,19 +18,6 @@ struct Foo {
y: isize,
}
#[cfg(stage0)]
impl Index<String> for Foo {
type Output = isize;
fn index<'a>(&'a self, z: &String) -> &'a isize {
if *z == "x" {
&self.x
} else {
&self.y
}
}
}
impl<'a> Index<&'a String> for Foo {
type Output = isize;