#![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() }
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") {
}
}
-#[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
}
impl<'a, K: Ord, V> Entry<'a, K, V> {
- /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
#[unstable(feature = "std_misc",
reason = "will soon be replaced by or_insert")]
+ #[deprecated(since = "1.0",
+ reason = "replaced with more ergonomic `or_insert` and `or_insert_with`")]
+ /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
match self {
Occupied(entry) => Ok(entry.into_mut()),
Vacant(entry) => Err(entry),
}
}
+
+ #[unstable(feature = "collections",
+ reason = "matches entry v3 specification, waiting for dust to settle")]
+ /// Ensures a value is in the entry by inserting the default if empty, and returns
+ /// a mutable reference to the value in the entry.
+ pub fn or_insert(self, default: V) -> &'a mut V {
+ match self {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.insert(default),
+ }
+ }
+
+ #[unstable(feature = "collections",
+ reason = "matches entry v3 specification, waiting for dust to settle")]
+ /// Ensures a value is in the entry by inserting the result of the default function if empty,
+ /// and returns a mutable reference to the value in the entry.
+ pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
+ match self {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.insert(default()),
+ }
+ }
}
impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
/// ```
/// # #![feature(collections)]
/// use std::collections::BTreeMap;
- /// use std::collections::btree_map::Entry;
///
/// let mut count: BTreeMap<&str, usize> = BTreeMap::new();
///
/// // count the number of occurrences of letters in the vec
- /// for x in vec!["a","b","a","c","a","b"].iter() {
- /// match count.entry(*x) {
- /// Entry::Vacant(view) => {
- /// view.insert(1);
- /// },
- /// Entry::Occupied(mut view) => {
- /// let v = view.get_mut();
- /// *v += 1;
- /// },
- /// }
+ /// for x in vec!["a","b","a","c","a","b"] {
+ /// *count.entry(x).or_insert(0) += 1;
/// }
///
/// assert_eq!(count["a"], 3);
}
/// 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_|
}
/// 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_|
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]
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]
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]
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) }
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]`
#[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]`
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)
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)
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)
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
#[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)
#[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)
#[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)
#[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.as_mut_slice()
- }
-
- #[cfg(not(stage0))]
#[inline]
fn index_mut(&mut self, _index: ops::RangeFull) -> &mut [T] {
self.as_mut_slice()
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")
#[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")
/// ```
/// # #![feature(collections)]
/// use std::collections::VecMap;
- /// use std::collections::vec_map::Entry;
///
/// let mut count: VecMap<u32> = VecMap::new();
///
/// // count the number of occurrences of numbers in the vec
- /// for x in vec![1, 2, 1, 2, 3, 4, 1, 2, 4].iter() {
- /// match count.entry(*x) {
- /// Entry::Vacant(view) => {
- /// view.insert(1);
- /// },
- /// Entry::Occupied(mut view) => {
- /// let v = view.get_mut();
- /// *v += 1;
- /// },
- /// }
+ /// for x in vec![1, 2, 1, 2, 3, 4, 1, 2, 4] {
+ /// *count.entry(x).or_insert(0) += 1;
/// }
///
/// assert_eq!(count[1], 3);
impl<'a, V> Entry<'a, V> {
#[unstable(feature = "collections",
reason = "will soon be replaced by or_insert")]
+ #[deprecated(since = "1.0",
+ reason = "replaced with more ergonomic `or_insert` and `or_insert_with`")]
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, V>> {
match self {
Vacant(entry) => Err(entry),
}
}
+
+ #[unstable(feature = "collections",
+ reason = "matches entry v3 specification, waiting for dust to settle")]
+ /// Ensures a value is in the entry by inserting the default if empty, and returns
+ /// a mutable reference to the value in the entry.
+ pub fn or_insert(self, default: V) -> &'a mut V {
+ match self {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.insert(default),
+ }
+ }
+
+ #[unstable(feature = "collections",
+ reason = "matches entry v3 specification, waiting for dust to settle")]
+ /// Ensures a value is in the entry by inserting the result of the default function if empty,
+ /// and returns a mutable reference to the value in the entry.
+ pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
+ match self {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.insert(default()),
+ }
+ }
}
impl<'a, V> VacantEntry<'a, 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;
}
}
-#[cfg(not(stage0))]
impl<'a,V> Index<&'a usize> for VecMap<V> {
type Output = 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]
}
}
-#[cfg(not(stage0))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, V> IndexMut<&'a usize> for VecMap<V> {
#[inline]
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
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
/// }
/// ```
#[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.
///
/// }
/// ```
///
- #[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>()`
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;
}
#[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;
}
#[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;
#[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;
/// 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)
- }
-}
#[inline]
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 {
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());
#[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());
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);
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 })
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() })
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
#[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);
}
#[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 })
}
#[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();
}
#[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
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)
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)
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)
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()
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)
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)
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)
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)
#[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)
#[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)
#[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)
#[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)
#[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 {
}
}
-#[cfg(not(stage0))]
impl<'a> FnMut<(&'a u8,)> for BytesDeref {
#[inline]
extern "rust-call" fn call_mut(&mut self, (ptr,): (&'a u8,)) -> u8 {
}
}
-#[cfg(not(stage0))]
impl<'a> FnOnce<(&'a u8,)> for BytesDeref {
type Output = u8;
/// // 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;
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()]
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()]
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
#![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;
#[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;
info!("lib candidate: {}", path.display());
let hash_str = hash.to_string();
- let slot = candidates.entry(hash_str).get().unwrap_or_else(
- |vacant_entry| vacant_entry.insert((HashMap::new(), HashMap::new())));
+ let slot = candidates.entry(hash_str)
+ .or_insert_with(|| (HashMap::new(), HashMap::new()));
let (ref mut rlibs, ref mut dylibs) = *slot;
if rlib {
rlibs.insert(fs::realpath(path).unwrap(), kind);
cfg.graph.each_node(|node_idx, node| {
if let cfg::CFGNodeData::AST(id) = node.data {
- match index.entry(id).get() {
- Ok(v) => v.push(node_idx),
- Err(e) => {
- e.insert(vec![node_idx]);
- }
- }
+ index.entry(id).or_insert(vec![]).push(node_idx);
}
true
});
visit::walk_fn_decl(&mut formals, decl);
impl<'a, 'v> visit::Visitor<'v> for Formals<'a> {
fn visit_pat(&mut self, p: &ast::Pat) {
- match self.index.entry(p.id).get() {
- Ok(v) => v.push(self.entry),
- Err(e) => {
- e.insert(vec![self.entry]);
- }
- }
+ self.index.entry(p.id).or_insert(vec![]).push(self.entry);
visit::walk_pat(self, p)
}
}
use middle::infer::{InferCtxt};
use middle::ty::{self, RegionEscape, Ty};
use std::collections::HashSet;
-use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::default::Default;
use syntax::ast;
use util::common::ErrorReported;
debug!("register_region_obligation({})",
region_obligation.repr(tcx));
- match region_obligations.entry(region_obligation.cause.body_id) {
- Vacant(entry) => { entry.insert(vec![region_obligation]); },
- Occupied(mut entry) => { entry.get_mut().push(region_obligation); },
- }
+ region_obligations.entry(region_obligation.cause.body_id).or_insert(vec![])
+ .push(region_obligation);
}
node_id_to_type(tcx, id.node)
} else {
let mut tcache = tcx.tcache.borrow_mut();
- let pty = tcache.entry(id).get().unwrap_or_else(
- |vacant_entry| vacant_entry.insert(csearch::get_field_type(tcx, struct_id, id)));
- pty.ty
+ tcache.entry(id).or_insert_with(|| csearch::get_field_type(tcx, struct_id, id)).ty
};
ty.subst(tcx, substs)
}
debug!("region={}", region.repr(tcx));
match region {
ty::ReLateBound(debruijn, br) if debruijn.depth == current_depth => {
- let region =
- * map.entry(br).get().unwrap_or_else(
- |vacant_entry| vacant_entry.insert(mapf(br)));
+ let region = *map.entry(br).or_insert_with(|| mapf(br));
if let ty::ReLateBound(debruijn1, br) = region {
// If the callback returns a late-bound region,
use getopts;
use std::collections::HashMap;
-use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::env;
use std::fmt;
use std::path::PathBuf;
None => early_error("--extern value must be of the format `foo=bar`"),
};
- match externs.entry(name.to_string()) {
- Vacant(entry) => { entry.insert(vec![location.to_string()]); },
- Occupied(mut entry) => { entry.get_mut().push(location.to_string()); },
- }
+ externs.entry(name.to_string()).or_insert(vec![]).push(location.to_string());
}
let crate_name = matches.opt_str("crate-name");
// 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;
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;
#![feature(rustc_diagnostic_macros)]
#![feature(rustc_private)]
#![feature(staged_api)]
-#![feature(std_misc)]
#[macro_use] extern crate log;
#[macro_use] extern crate syntax;
let is_public = import_directive.is_public;
let mut import_resolutions = module_.import_resolutions.borrow_mut();
- let dest_import_resolution = import_resolutions.entry(name).get().unwrap_or_else(
- |vacant_entry| {
- // Create a new import resolution from this child.
- vacant_entry.insert(ImportResolution::new(id, is_public))
- });
+ let dest_import_resolution = import_resolutions.entry(name)
+ .or_insert_with(|| ImportResolution::new(id, is_public));
debug!("(resolving glob import) writing resolution `{}` in `{}` \
to `{}`",
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;
use util::lev_distance::lev_distance;
use std::cell::{Cell, Ref, RefCell};
-use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::mem::replace;
use std::rc::Rc;
use std::iter::repeat;
closure_def_id: ast::DefId,
r: DeferredCallResolutionHandler<'tcx>) {
let mut deferred_call_resolutions = self.inh.deferred_call_resolutions.borrow_mut();
- let mut vec = match deferred_call_resolutions.entry(closure_def_id) {
- Occupied(entry) => entry.into_mut(),
- Vacant(entry) => entry.insert(Vec::new()),
- };
- vec.push(r);
+ deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
}
fn remove_deferred_call_resolutions(&self,
if let clean::ImplItem(ref i) = item.inner {
match i.trait_ {
Some(clean::ResolvedPath{ did, .. }) => {
- let v = self.implementors.entry(did).get().unwrap_or_else(
- |vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
- v.push(Implementor {
+ self.implementors.entry(did).or_insert(vec![]).push(Implementor {
def_id: item.def_id,
generics: i.generics.clone(),
trait_: i.trait_.as_ref().unwrap().clone(),
};
if let Some(did) = did {
- let v = self.impls.entry(did).get().unwrap_or_else(
- |vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
- v.push(Impl {
+ self.impls.entry(did).or_insert(vec![]).push(Impl {
impl_: i,
dox: dox,
stability: item.stability.clone(),
Some(ref s) => s.to_string(),
};
let short = short.to_string();
- let v = map.entry(short).get().unwrap_or_else(
- |vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
- v.push((myname, Some(plain_summary_line(item.doc_value()))));
+ map.entry(short).or_insert(vec![])
+ .push((myname, Some(plain_summary_line(item.doc_value()))));
}
for (_, items) in &mut map {
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;
}
};
let name = name.to_string();
- let locs = externs.entry(name).get().unwrap_or_else(
- |vacant_entry| vacant_entry.insert(Vec::with_capacity(1)));
- locs.push(location.to_string());
+ externs.entry(name).or_insert(vec![]).push(location.to_string());
}
Ok(externs)
}
}
}
-#[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;
}
}
-#[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;
use iter::{self, Iterator, ExactSizeIterator, IntoIterator, IteratorExt, FromIterator, Extend, Map};
use marker::Sized;
use mem::{self, replace};
-use ops::{Deref, FnMut, Index};
+use ops::{Deref, FnMut, FnOnce, Index};
use option::Option::{self, Some, None};
use rand::{self, Rng};
use result::Result::{self, Ok, Err};
}
}
-#[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>,
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant.
#[unstable(feature = "std_misc",
reason = "will soon be replaced by or_insert")]
+ #[deprecated(since = "1.0",
+ reason = "replaced with more ergonomic `or_insert` and `or_insert_with`")]
+ /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
match self {
Occupied(entry) => Ok(entry.into_mut()),
Vacant(entry) => Err(entry),
}
}
+
+ #[unstable(feature = "collections",
+ reason = "matches entry v3 specification, waiting for dust to settle")]
+ /// Ensures a value is in the entry by inserting the default if empty, and returns
+ /// a mutable reference to the value in the entry.
+ pub fn or_insert(self, default: V) -> &'a mut V {
+ match self {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.insert(default),
+ }
+ }
+
+ #[unstable(feature = "collections",
+ reason = "matches entry v3 specification, waiting for dust to settle")]
+ /// Ensures a value is in the entry by inserting the result of the default function if empty,
+ /// and returns a mutable reference to the value in the entry.
+ pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
+ match self {
+ Occupied(entry) => entry.into_mut(),
+ Vacant(entry) => entry.insert(default()),
+ }
+ }
}
impl<'a, K, V> OccupiedEntry<'a, K, V> {
//! let message = "she sells sea shells by the sea shore";
//!
//! for c in message.chars() {
-//! match count.entry(c) {
-//! Entry::Vacant(entry) => { entry.insert(1); },
-//! Entry::Occupied(mut entry) => *entry.get_mut() += 1,
-//! }
+//! *count.entry(c).or_insert(0) += 1;
//! }
//!
//! assert_eq!(count.get(&'s'), Some(&8));
//! for id in orders.into_iter() {
//! // If this is the first time we've seen this customer, initialize them
//! // with no blood alcohol. Otherwise, just retrieve them.
-//! let person = match blood_alcohol.entry(id) {
-//! Entry::Vacant(entry) => entry.insert(Person{id: id, blood_alcohol: 0.0}),
-//! Entry::Occupied(entry) => entry.into_mut(),
-//! };
+//! let person = blood_alcohol.entry(id).or_insert(Person{id: id, blood_alcohol: 0.0});
//!
//! // Reduce their blood alcohol level. It takes time to order and drink a beer!
//! person.blood_alcohol *= 0.9;
}
}
-#[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;
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, R: Read + ?Sized> Read for &'a mut R {
+ #[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
(**self).read(buf)
}
+
+ #[inline]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
(**self).read_to_end(buf)
}
+
+ #[inline]
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
(**self).read_to_string(buf)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, W: Write + ?Sized> Write for &'a mut W {
+ #[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
+
+ #[inline]
fn flush(&mut self) -> io::Result<()> { (**self).flush() }
+
+ #[inline]
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
(**self).write_all(buf)
}
+
+ #[inline]
fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
(**self).write_fmt(fmt)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, S: Seek + ?Sized> Seek for &'a mut S {
+ #[inline]
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {
+ #[inline]
fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
+
+ #[inline]
fn consume(&mut self, amt: usize) { (**self).consume(amt) }
+
+ #[inline]
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
(**self).read_until(byte, buf)
}
+
+ #[inline]
fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
(**self).read_line(buf)
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<R: Read + ?Sized> Read for Box<R> {
+ #[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
(**self).read(buf)
}
+
+ #[inline]
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
(**self).read_to_end(buf)
}
+
+ #[inline]
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
(**self).read_to_string(buf)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write + ?Sized> Write for Box<W> {
+ #[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }
+
+ #[inline]
fn flush(&mut self) -> io::Result<()> { (**self).flush() }
+
+ #[inline]
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
(**self).write_all(buf)
}
+
+ #[inline]
fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {
(**self).write_fmt(fmt)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<S: Seek + ?Sized> Seek for Box<S> {
+ #[inline]
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<B: BufRead + ?Sized> BufRead for Box<B> {
+ #[inline]
fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }
+
+ #[inline]
fn consume(&mut self, amt: usize) { (**self).consume(amt) }
+
+ #[inline]
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
(**self).read_until(byte, buf)
}
+
+ #[inline]
fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
(**self).read_line(buf)
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Read for &'a [u8] {
+ #[inline]
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let amt = cmp::min(buf.len(), self.len());
let (a, b) = self.split_at(amt);
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> BufRead for &'a [u8] {
+ #[inline]
fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
+
+ #[inline]
fn consume(&mut self, amt: usize) { *self = &self[amt..]; }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Write for &'a mut [u8] {
+ #[inline]
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
let amt = cmp::min(data.len(), self.len());
let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
Ok(amt)
}
+ #[inline]
fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
if try!(self.write(data)) == data.len() {
Ok(())
}
}
+ #[inline]
fn flush(&mut self) -> io::Result<()> { Ok(()) }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl Write for Vec<u8> {
+ #[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.push_all(buf);
Ok(buf.len())
}
+ #[inline]
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
self.push_all(buf);
Ok(())
}
+ #[inline]
fn flush(&mut self) -> io::Result<()> { Ok(()) }
}
+
+#[cfg(test)]
+mod tests {
+ use io::prelude::*;
+ use vec::Vec;
+ use test;
+
+ #[bench]
+ fn bench_read_slice(b: &mut test::Bencher) {
+ let buf = [5; 1024];
+ let mut dst = [0; 128];
+
+ b.iter(|| {
+ let mut rd = &buf[..];
+ for _ in (0 .. 8) {
+ let _ = rd.read(&mut dst);
+ test::black_box(&dst);
+ }
+ })
+ }
+
+ #[bench]
+ fn bench_write_slice(b: &mut test::Bencher) {
+ let mut buf = [0; 1024];
+ let src = [5; 128];
+
+ b.iter(|| {
+ let mut wr = &mut buf[..];
+ for _ in (0 .. 8) {
+ let _ = wr.write_all(&src);
+ test::black_box(&wr);
+ }
+ })
+ }
+
+ #[bench]
+ fn bench_read_vec(b: &mut test::Bencher) {
+ let buf = vec![5; 1024];
+ let mut dst = [0; 128];
+
+ b.iter(|| {
+ let mut rd = &buf[..];
+ for _ in (0 .. 8) {
+ let _ = rd.read(&mut dst);
+ test::black_box(&dst);
+ }
+ })
+ }
+
+ #[bench]
+ fn bench_write_vec(b: &mut test::Bencher) {
+ let mut buf = Vec::with_capacity(1024);
+ let src = [5; 128];
+
+ b.iter(|| {
+ let mut wr = &mut buf[..];
+ for _ in (0 .. 8) {
+ let _ = wr.write_all(&src);
+ test::black_box(&wr);
+ }
+ })
+ }
+}
#[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;
#[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;
#[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;
///
/// 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;
///
/// 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;
///
/// 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;
}
}
-#[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;
RefCell::new(f)
}
+/// This method helps to extract all the type parameters referenced from a
+/// type. For a type parameter `<T>`, it looks for either a `TyPath` that
+/// is not global and starts with `T`, or a `TyQPath`.
+fn find_type_parameters(ty: &ast::Ty, ty_param_names: &[ast::Name]) -> Vec<P<ast::Ty>> {
+ use visit;
+
+ struct Visitor<'a> {
+ ty_param_names: &'a [ast::Name],
+ types: Vec<P<ast::Ty>>,
+ }
+
+ impl<'a> visit::Visitor<'a> for Visitor<'a> {
+ fn visit_ty(&mut self, ty: &'a ast::Ty) {
+ match ty.node {
+ ast::TyPath(_, ref path) if !path.global => {
+ match path.segments.first() {
+ Some(segment) => {
+ if self.ty_param_names.contains(&segment.identifier.name) {
+ self.types.push(P(ty.clone()));
+ }
+ }
+ None => {}
+ }
+ }
+ _ => {}
+ }
+
+ visit::walk_ty(self, ty)
+ }
+ }
+
+ let mut visitor = Visitor {
+ ty_param_names: ty_param_names,
+ types: Vec::new(),
+ };
+
+ visit::Visitor::visit_ty(&mut visitor, ty);
+
+ visitor.types
+}
impl<'a> TraitDef<'a> {
pub fn expand<F>(&self,
}))
}
- /// Given that we are deriving a trait `Tr` for a type `T<'a, ...,
- /// 'z, A, ..., Z>`, creates an impl like:
+ /// Given that we are deriving a trait `DerivedTrait` for a type like:
///
/// ```ignore
- /// impl<'a, ..., 'z, A:Tr B1 B2, ..., Z: Tr B1 B2> Tr for T<A, ..., Z> { ... }
+ /// struct Struct<'a, ..., 'z, A, B: DeclaredTrait, C, ..., Z> where C: WhereTrait {
+ /// a: A,
+ /// b: B::Item,
+ /// b1: <B as DeclaredTrait>::Item,
+ /// c1: <C as WhereTrait>::Item,
+ /// c2: Option<<C as WhereTrait>::Item>,
+ /// ...
+ /// }
+ /// ```
+ ///
+ /// create an impl like:
+ ///
+ /// ```ignore
+ /// impl<'a, ..., 'z, A, B: DeclaredTrait, C, ... Z> where
+ /// C: WhereTrait,
+ /// A: DerivedTrait + B1 + ... + BN,
+ /// B: DerivedTrait + B1 + ... + BN,
+ /// C: DerivedTrait + B1 + ... + BN,
+ /// B::Item: DerivedTrait + B1 + ... + BN,
+ /// <C as WhereTrait>::Item: DerivedTrait + B1 + ... + BN,
+ /// ...
+ /// {
+ /// ...
+ /// }
/// ```
///
- /// where B1, B2, ... are the bounds given by `bounds_paths`.'
+ /// where B1, ..., BN are the bounds given by `bounds_paths`.'. Z is a phantom type, and
+ /// therefore does not get bound by the derived trait.
fn create_derived_impl(&self,
cx: &mut ExtCtxt,
type_ident: Ident,
generics: &Generics,
+ field_tys: Vec<P<ast::Ty>>,
methods: Vec<P<ast::ImplItem>>) -> P<ast::Item> {
let trait_path = self.path.to_path(cx, self.span, type_ident, generics);
}
}));
+ if !ty_params.is_empty() {
+ let ty_param_names: Vec<ast::Name> = ty_params.iter()
+ .map(|ty_param| ty_param.ident.name)
+ .collect();
+
+ for field_ty in field_tys.into_iter() {
+ let tys = find_type_parameters(&*field_ty, &ty_param_names);
+
+ for ty in tys.into_iter() {
+ let mut bounds: Vec<_> = self.additional_bounds.iter().map(|p| {
+ cx.typarambound(p.to_path(cx, self.span, type_ident, generics))
+ }).collect();
+
+ // require the current trait
+ bounds.push(cx.typarambound(trait_path.clone()));
+
+ let predicate = ast::WhereBoundPredicate {
+ span: self.span,
+ bound_lifetimes: vec![],
+ bounded_ty: ty,
+ bounds: OwnedSlice::from_vec(bounds),
+ };
+
+ let predicate = ast::WherePredicate::BoundPredicate(predicate);
+ where_clause.predicates.push(predicate);
+ }
+ }
+ }
+
let trait_generics = Generics {
lifetimes: lifetimes,
ty_params: OwnedSlice::from_vec(ty_params),
struct_def: &StructDef,
type_ident: Ident,
generics: &Generics) -> P<ast::Item> {
+ let field_tys: Vec<P<ast::Ty>> = struct_def.fields.iter()
+ .map(|field| field.node.ty.clone())
+ .collect();
+
let methods = self.methods.iter().map(|method_def| {
let (explicit_self, self_args, nonself_args, tys) =
method_def.split_self_nonself_args(
body)
}).collect();
- self.create_derived_impl(cx, type_ident, generics, methods)
+ self.create_derived_impl(cx, type_ident, generics, field_tys, methods)
}
fn expand_enum_def(&self,
enum_def: &EnumDef,
type_ident: Ident,
generics: &Generics) -> P<ast::Item> {
+ let mut field_tys = Vec::new();
+
+ for variant in enum_def.variants.iter() {
+ match variant.node.kind {
+ ast::VariantKind::TupleVariantKind(ref args) => {
+ field_tys.extend(args.iter()
+ .map(|arg| arg.ty.clone()));
+ }
+ ast::VariantKind::StructVariantKind(ref args) => {
+ field_tys.extend(args.fields.iter()
+ .map(|field| field.node.ty.clone()));
+ }
+ }
+ }
+
let methods = self.methods.iter().map(|method_def| {
let (explicit_self, self_args, nonself_args, tys) =
method_def.split_self_nonself_args(cx, self,
body)
}).collect();
- self.create_derived_impl(cx, type_ident, generics, methods)
+ self.create_derived_impl(cx, type_ident, generics, field_tys, methods)
}
}
/// Extend a syntax context with a given mark and sctable (explicit memoization)
fn apply_mark_internal(m: Mrk, ctxt: SyntaxContext, table: &SCTable) -> SyntaxContext {
let key = (ctxt, m);
- * table.mark_memo.borrow_mut().entry(key).get().unwrap_or_else(
- |vacant_entry|
- vacant_entry.insert(idx_push(&mut *table.table.borrow_mut(), Mark(m, ctxt))))
+ * table.mark_memo.borrow_mut().entry(key)
+ .or_insert_with(|| idx_push(&mut *table.table.borrow_mut(), Mark(m, ctxt)))
}
/// Extend a syntax context with a given rename
table: &SCTable) -> SyntaxContext {
let key = (ctxt, id, to);
- * table.rename_memo.borrow_mut().entry(key).get().unwrap_or_else(
- |vacant_entry|
- vacant_entry.insert(idx_push(&mut *table.table.borrow_mut(), Rename(id, to, ctxt))))
+ * table.rename_memo.borrow_mut().entry(key)
+ .or_insert_with(|| idx_push(&mut *table.table.borrow_mut(), Rename(id, to, ctxt)))
}
/// Apply a list of renamings to a context
}
}
+ impl_to_source! { ast::Path, path_to_string }
impl_to_source! { ast::Ty, ty_to_string }
impl_to_source! { ast::Block, block_to_string }
impl_to_source! { ast::Arg, arg_to_string }
impl_to_source! { Generics, generics_to_string }
+ impl_to_source! { ast::WhereClause, where_clause_to_string }
impl_to_source! { P<ast::Item>, item_to_string }
impl_to_source! { P<ast::ImplItem>, impl_item_to_string }
impl_to_source! { P<ast::TraitItem>, trait_item_to_string }
}
impl_to_tokens! { ast::Ident }
+ impl_to_tokens! { ast::Path }
impl_to_tokens! { P<ast::Item> }
impl_to_tokens! { P<ast::ImplItem> }
impl_to_tokens! { P<ast::TraitItem> }
impl_to_tokens! { ast::Ty }
impl_to_tokens_lifetime! { &'a [ast::Ty] }
impl_to_tokens! { Generics }
+ impl_to_tokens! { ast::WhereClause }
impl_to_tokens! { P<ast::Stmt> }
impl_to_tokens! { P<ast::Expr> }
impl_to_tokens! { ast::Block }
#![feature(quote, unsafe_destructor)]
#![feature(rustc_private)]
#![feature(staged_api)]
-#![feature(std_misc)]
#![feature(unicode)]
#![feature(path_ext)]
#![feature(str_char)]
#[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;
p.parse_arg_general(false)
});
- p.parse_where_clause(&mut generics);
+ generics.where_clause = p.parse_where_clause();
let sig = ast::MethodSig {
unsafety: style,
decl: d,
/// ```
/// where T : Trait<U, V> + 'b, 'a : 'b
/// ```
- fn parse_where_clause(&mut self, generics: &mut ast::Generics) {
+ fn parse_where_clause(&mut self) -> ast::WhereClause {
+ let mut where_clause = WhereClause {
+ id: ast::DUMMY_NODE_ID,
+ predicates: Vec::new(),
+ };
+
if !self.eat_keyword(keywords::Where) {
- return
+ return where_clause;
}
let mut parsed_something = false;
let hi = self.span.hi;
let span = mk_sp(lo, hi);
- generics.where_clause.predicates.push(ast::WherePredicate::RegionPredicate(
+ where_clause.predicates.push(ast::WherePredicate::RegionPredicate(
ast::WhereRegionPredicate {
span: span,
lifetime: bounded_lifetime,
at least one bound in it");
}
- generics.where_clause.predicates.push(ast::WherePredicate::BoundPredicate(
+ where_clause.predicates.push(ast::WherePredicate::BoundPredicate(
ast::WhereBoundPredicate {
span: span,
bound_lifetimes: bound_lifetimes,
// let ty = self.parse_ty();
let hi = self.span.hi;
let span = mk_sp(lo, hi);
- // generics.where_clause.predicates.push(
+ // where_clause.predicates.push(
// ast::WherePredicate::EqPredicate(ast::WhereEqPredicate {
// id: ast::DUMMY_NODE_ID,
// span: span,
"a `where` clause must have at least one predicate \
in it");
}
+
+ where_clause
}
fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool)
fn parse_item_fn(&mut self, unsafety: Unsafety, abi: abi::Abi) -> ItemInfo {
let (ident, mut generics) = self.parse_fn_header();
let decl = self.parse_fn_decl(false);
- self.parse_where_clause(&mut generics);
+ generics.where_clause = self.parse_where_clause();
let (inner_attrs, body) = self.parse_inner_attrs_and_block();
(ident, ItemFn(decl, unsafety, abi, generics, body), Some(inner_attrs))
}
let (explicit_self, decl) = self.parse_fn_decl_with_self(|p| {
p.parse_arg()
});
- self.parse_where_clause(&mut generics);
+ generics.where_clause = self.parse_where_clause();
let (inner_attrs, body) = self.parse_inner_attrs_and_block();
(ident, inner_attrs, MethodImplItem(ast::MethodSig {
generics: generics,
// Parse supertrait bounds.
let bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare);
- self.parse_where_clause(&mut tps);
+ tps.where_clause = self.parse_where_clause();
let meths = self.parse_trait_items();
(ident, ItemTrait(unsafety, tps, bounds, meths), None)
if opt_trait.is_some() {
ty = self.parse_ty_sum();
}
- self.parse_where_clause(&mut generics);
+ generics.where_clause = self.parse_where_clause();
self.expect(&token::OpenDelim(token::Brace));
let attrs = self.parse_inner_attributes();
// struct.
let (fields, ctor_id) = if self.token.is_keyword(keywords::Where) {
- self.parse_where_clause(&mut generics);
+ generics.where_clause = self.parse_where_clause();
if self.eat(&token::Semi) {
// If we see a: `struct Foo<T> where T: Copy;` style decl.
(Vec::new(), Some(ast::DUMMY_NODE_ID))
token::get_ident(class_name.clone())));
}
- self.parse_where_clause(generics);
+ generics.where_clause = self.parse_where_clause();
self.expect(&token::Semi);
fields
// This is the case where we just see struct Foo<T> where T: Copy;
} else if self.token.is_keyword(keywords::Where) {
- self.parse_where_clause(generics);
+ generics.where_clause = self.parse_where_clause();
self.expect(&token::Semi);
Vec::new()
// This case is where we see: `struct Foo<T>;`
let (ident, mut generics) = self.parse_fn_header();
let decl = self.parse_fn_decl(true);
- self.parse_where_clause(&mut generics);
+ generics.where_clause = self.parse_where_clause();
let hi = self.span.hi;
self.expect(&token::Semi);
P(ast::ForeignItem {
fn parse_item_type(&mut self) -> ItemInfo {
let ident = self.parse_ident();
let mut tps = self.parse_generics();
- self.parse_where_clause(&mut tps);
+ tps.where_clause = self.parse_where_clause();
self.expect(&token::Eq);
let ty = self.parse_ty_sum();
self.expect(&token::Semi);
fn parse_item_enum(&mut self) -> ItemInfo {
let id = self.parse_ident();
let mut generics = self.parse_generics();
- self.parse_where_clause(&mut generics);
+ generics.where_clause = self.parse_where_clause();
self.expect(&token::OpenDelim(token::Brace));
let enum_definition = self.parse_enum_def(&generics);
$to_string(|s| s.print_generics(generics))
}
+pub fn where_clause_to_string(i: &ast::WhereClause) -> String {
+ $to_string(|s| s.print_where_clause(i))
+}
+
pub fn fn_block_to_string(p: &ast::FnDecl) -> String {
$to_string(|s| s.print_fn_block_args(p))
}
try!(space(&mut self.s));
try!(self.word_space("="));
try!(self.print_type(&**ty));
- try!(self.print_where_clause(params));
+ try!(self.print_where_clause(¶ms.where_clause));
try!(word(&mut self.s, ";"));
try!(self.end()); // end the outer ibox
}
}
try!(self.print_type(&**ty));
- try!(self.print_where_clause(generics));
+ try!(self.print_where_clause(&generics.where_clause));
try!(space(&mut self.s));
try!(self.bopen());
}
}
try!(self.print_bounds(":", &real_bounds[..]));
- try!(self.print_where_clause(generics));
+ try!(self.print_where_clause(&generics.where_clause));
try!(word(&mut self.s, " "));
try!(self.bopen());
for trait_item in trait_items {
try!(self.head(&visibility_qualified(visibility, "enum")));
try!(self.print_ident(ident));
try!(self.print_generics(generics));
- try!(self.print_where_clause(generics));
+ try!(self.print_where_clause(&generics.where_clause));
try!(space(&mut self.s));
self.print_variants(&enum_definition.variants, span)
}
));
try!(self.pclose());
}
- try!(self.print_where_clause(generics));
+ try!(self.print_where_clause(&generics.where_clause));
try!(word(&mut self.s, ";"));
try!(self.end());
self.end() // close the outer-box
} else {
- try!(self.print_where_clause(generics));
+ try!(self.print_where_clause(&generics.where_clause));
try!(self.nbsp());
try!(self.bopen());
try!(self.hardbreak_if_not_bol());
}
try!(self.print_generics(generics));
try!(self.print_fn_args_and_ret(decl, opt_explicit_self));
- self.print_where_clause(generics)
+ self.print_where_clause(&generics.where_clause)
}
pub fn print_fn_args(&mut self, decl: &ast::FnDecl,
}
}
- pub fn print_where_clause(&mut self, generics: &ast::Generics)
+ pub fn print_where_clause(&mut self, where_clause: &ast::WhereClause)
-> io::Result<()> {
- if generics.where_clause.predicates.len() == 0 {
+ if where_clause.predicates.len() == 0 {
return Ok(())
}
try!(space(&mut self.s));
try!(self.word_space("where"));
- for (i, predicate) in generics.where_clause
- .predicates
- .iter()
- .enumerate() {
+ for (i, predicate) in where_clause.predicates.iter().enumerate() {
if i != 0 {
try!(self.word_space(","));
}
extern crate getopts;
extern crate serialize;
-extern crate "serialize" as rustc_serialize;
+extern crate serialize as rustc_serialize;
extern crate term;
extern crate libc;
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.
+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
#![crate_name="struct_variant_xc_aux"]
#![crate_type = "lib"]
+#[derive(Copy)]
pub enum Enum {
Variant(u8),
StructVariant { arg: u8 }
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;
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+trait Foo {
+ type X;
+ fn method(&self) {}
+}
+
+#[derive(Clone)]
+struct Bar<T: Foo> {
+ x: T::X,
+}
+
+struct NotClone;
+
+impl Foo for NotClone {
+ type X = i8;
+}
+
+fn main() {
+ Bar::<NotClone> { x: 1 }.clone(); //~ ERROR
+}
--- /dev/null
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(core, debug_builders)]
+
+pub trait DeclaredTrait {
+ type Type;
+}
+
+impl DeclaredTrait for i32 {
+ type Type = i32;
+}
+
+pub trait WhereTrait {
+ type Type;
+}
+
+impl WhereTrait for i32 {
+ type Type = i32;
+}
+
+// Make sure we don't add a bound that just shares a name with an associated
+// type.
+pub mod module {
+ pub type Type = i32;
+}
+
+#[derive(PartialEq, Debug)]
+struct PrivateStruct<T>(T);
+
+#[derive(PartialEq, Debug)]
+struct TupleStruct<A, B: DeclaredTrait, C>(
+ module::Type,
+ Option<module::Type>,
+ A,
+ PrivateStruct<A>,
+ B,
+ B::Type,
+ Option<B::Type>,
+ <B as DeclaredTrait>::Type,
+ Option<<B as DeclaredTrait>::Type>,
+ C,
+ C::Type,
+ Option<C::Type>,
+ <C as WhereTrait>::Type,
+ Option<<C as WhereTrait>::Type>,
+ <i32 as DeclaredTrait>::Type,
+) where C: WhereTrait;
+
+#[derive(PartialEq, Debug)]
+pub struct Struct<A, B: DeclaredTrait, C> where C: WhereTrait {
+ m1: module::Type,
+ m2: Option<module::Type>,
+ a1: A,
+ a2: PrivateStruct<A>,
+ b: B,
+ b1: B::Type,
+ b2: Option<B::Type>,
+ b3: <B as DeclaredTrait>::Type,
+ b4: Option<<B as DeclaredTrait>::Type>,
+ c: C,
+ c1: C::Type,
+ c2: Option<C::Type>,
+ c3: <C as WhereTrait>::Type,
+ c4: Option<<C as WhereTrait>::Type>,
+ d: <i32 as DeclaredTrait>::Type,
+}
+
+#[derive(PartialEq, Debug)]
+enum Enum<A, B: DeclaredTrait, C> where C: WhereTrait {
+ Unit,
+ Seq(
+ module::Type,
+ Option<module::Type>,
+ A,
+ PrivateStruct<A>,
+ B,
+ B::Type,
+ Option<B::Type>,
+ <B as DeclaredTrait>::Type,
+ Option<<B as DeclaredTrait>::Type>,
+ C,
+ C::Type,
+ Option<C::Type>,
+ <C as WhereTrait>::Type,
+ Option<<C as WhereTrait>::Type>,
+ <i32 as DeclaredTrait>::Type,
+ ),
+ Map {
+ m1: module::Type,
+ m2: Option<module::Type>,
+ a1: A,
+ a2: PrivateStruct<A>,
+ b: B,
+ b1: B::Type,
+ b2: Option<B::Type>,
+ b3: <B as DeclaredTrait>::Type,
+ b4: Option<<B as DeclaredTrait>::Type>,
+ c: C,
+ c1: C::Type,
+ c2: Option<C::Type>,
+ c3: <C as WhereTrait>::Type,
+ c4: Option<<C as WhereTrait>::Type>,
+ d: <i32 as DeclaredTrait>::Type,
+ },
+}
+
+fn main() {
+ let e: TupleStruct<
+ i32,
+ i32,
+ i32,
+ > = TupleStruct(
+ 0,
+ None,
+ 0,
+ PrivateStruct(0),
+ 0,
+ 0,
+ None,
+ 0,
+ None,
+ 0,
+ 0,
+ None,
+ 0,
+ None,
+ 0,
+ );
+ assert_eq!(e, e);
+
+ let e: Struct<
+ i32,
+ i32,
+ i32,
+ > = Struct {
+ m1: 0,
+ m2: None,
+ a1: 0,
+ a2: PrivateStruct(0),
+ b: 0,
+ b1: 0,
+ b2: None,
+ b3: 0,
+ b4: None,
+ c: 0,
+ c1: 0,
+ c2: None,
+ c3: 0,
+ c4: None,
+ d: 0,
+ };
+ assert_eq!(e, e);
+
+ let e = Enum::Unit::<i32, i32, i32>;
+ assert_eq!(e, e);
+
+ let e: Enum<
+ i32,
+ i32,
+ i32,
+ > = Enum::Seq(
+ 0,
+ None,
+ 0,
+ PrivateStruct(0),
+ 0,
+ 0,
+ None,
+ 0,
+ None,
+ 0,
+ 0,
+ None,
+ 0,
+ None,
+ 0,
+ );
+ assert_eq!(e, e);
+
+ let e: Enum<
+ i32,
+ i32,
+ i32,
+ > = Enum::Map {
+ m1: 0,
+ m2: None,
+ a1: 0,
+ a2: PrivateStruct(0),
+ b: 0,
+ b1: 0,
+ b2: None,
+ b3: 0,
+ b4: None,
+ c: 0,
+ c1: 0,
+ c2: None,
+ c3: 0,
+ c4: None,
+ d: 0,
+ };
+ assert_eq!(e, e);
+}
projects / rust.git / commitdiff