bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Merge remote-tracking branch 'nrc/sized-2' into rollup

Browse source 
Conflicts:
	src/liballoc/boxed.rs
	src/libcollections/btree/map.rs
	src/libcollections/slice.rs
	src/libcore/borrow.rs
	src/libcore/cmp.rs
	src/libcore/ops.rs
	src/libstd/c_str.rs
	src/libstd/collections/hash/map.rs
	src/libsyntax/parse/obsolete.rs
	src/test/compile-fail/unboxed-closure-sugar-default.rs
	src/test/compile-fail/unboxed-closure-sugar-equiv.rs
	src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs
	src/test/compile-fail/unboxed-closure-sugar-region.rs
	src/test/compile-fail/unsized3.rs
	src/test/run-pass/associated-types-conditional-dispatch.rs
This commit is contained in:
Alex Crichton 2015-01-05 18:55:41 -08:00
commit 384e218789
64 changed files with 251 additions and 245 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/liballoc/boxed.rs
View file

@ -75,14 +75,14 @@ impl<T: Clone> Clone for Box<T> {
} }
#[stable] #[stable]
impl<Sized? T: PartialEq> PartialEq for Box<T> { impl<T: ?Sized + PartialEq> PartialEq for Box<T> {
#[inline] #[inline]
fn eq(&self, other: &Box<T>) -> bool { PartialEq::eq(&**self, &**other) } fn eq(&self, other: &Box<T>) -> bool { PartialEq::eq(&**self, &**other) }
#[inline] #[inline]
fn ne(&self, other: &Box<T>) -> bool { PartialEq::ne(&**self, &**other) } fn ne(&self, other: &Box<T>) -> bool { PartialEq::ne(&**self, &**other) }
} }
#[stable] #[stable]
impl<Sized? T: PartialOrd> PartialOrd for Box<T> { impl<T: ?Sized + PartialOrd> PartialOrd for Box<T> {
#[inline] #[inline]
fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> { fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {
PartialOrd::partial_cmp(&**self, &**other) PartialOrd::partial_cmp(&**self, &**other)
@ -97,16 +97,16 @@ impl<Sized? T: PartialOrd> PartialOrd for Box<T> {
fn gt(&self, other: &Box<T>) -> bool { PartialOrd::gt(&**self, &**other) } fn gt(&self, other: &Box<T>) -> bool { PartialOrd::gt(&**self, &**other) }
} }
#[stable] #[stable]
impl<Sized? T: Ord> Ord for Box<T> { impl<T: ?Sized + Ord> Ord for Box<T> {
#[inline] #[inline]
fn cmp(&self, other: &Box<T>) -> Ordering { fn cmp(&self, other: &Box<T>) -> Ordering {
Ord::cmp(&**self, &**other) Ord::cmp(&**self, &**other)
} }
#[stable]} #[stable]}
impl<Sized? T: Eq> Eq for Box<T> {} impl<T: ?Sized + Eq> Eq for Box<T> {}
impl<S: hash::Writer, Sized? T: Hash<S>> Hash<S> for Box<T> { impl<S: hash::Writer, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
#[inline] #[inline]
fn hash(&self, state: &mut S) { fn hash(&self, state: &mut S) {
(**self).hash(state); (**self).hash(state);
@ -143,7 +143,7 @@ impl BoxAny for Box<Any> {
} }
} }
impl<Sized? T: fmt::Show> fmt::Show for Box<T> { impl<T: ?Sized + fmt::Show> fmt::Show for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
(**self).fmt(f) (**self).fmt(f)
} }
@ -156,14 +156,14 @@ impl fmt::Show for Box<Any> {
} }
#[stable] #[stable]
impl<Sized? T> Deref for Box<T> { impl<T: ?Sized> Deref for Box<T> {
type Target = T; type Target = T;
fn deref(&self) -> &T { &**self } fn deref(&self) -> &T { &**self }
} }
#[stable] #[stable]
impl<Sized? T> DerefMut for Box<T> { impl<T: ?Sized> DerefMut for Box<T> {
fn deref_mut(&mut self) -> &mut T { &mut **self } fn deref_mut(&mut self) -> &mut T { &mut **self }
} }

22
src/libcollections/btree/map.rs
View file

@ -130,7 +130,7 @@ pub struct Values<'a, K: 'a, V: 'a> {
#[stable] #[stable]
/// A view into a single entry in a map, which may either be vacant or occupied. /// A view into a single entry in a map, which may either be vacant or occupied.
pub enum Entry<'a, Sized? Q:'a, K:'a, V:'a> { pub enum Entry<'a, Q: ?Sized +'a, K:'a, V:'a> {
/// A vacant Entry /// A vacant Entry
Vacant(VacantEntry<'a, Q, K, V>), Vacant(VacantEntry<'a, Q, K, V>),
/// An occupied Entry /// An occupied Entry
@ -139,7 +139,7 @@ pub enum Entry<'a, Sized? Q:'a, K:'a, V:'a> {
#[stable] #[stable]
/// A vacant Entry. /// A vacant Entry.
pub struct VacantEntry<'a, Sized? Q:'a, K:'a, V:'a> { pub struct VacantEntry<'a, Q: ?Sized +'a, K:'a, V:'a> {
key: &'a Q, key: &'a Q,
stack: stack::SearchStack<'a, K, V, node::handle::Edge, node::handle::Leaf>, stack: stack::SearchStack<'a, K, V, node::handle::Edge, node::handle::Leaf>,
} }
@ -214,7 +214,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map.get(&2), None); /// assert_eq!(map.get(&2), None);
/// ``` /// ```
#[stable] #[stable]
pub fn get<Sized? Q>(&self, key: &Q) -> Option<&V> where Q: BorrowFrom<K> + Ord { pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where Q: BorrowFrom<K> + Ord {
let mut cur_node = &self.root; let mut cur_node = &self.root;
loop { loop {
match Node::search(cur_node, key) { match Node::search(cur_node, key) {
@ -246,7 +246,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map.contains_key(&2), false); /// assert_eq!(map.contains_key(&2), false);
/// ``` /// ```
#[stable] #[stable]
pub fn contains_key<Sized? Q>(&self, key: &Q) -> bool where Q: BorrowFrom<K> + Ord { pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where Q: BorrowFrom<K> + Ord {
self.get(key).is_some() self.get(key).is_some()
} }
@ -270,7 +270,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// ``` /// ```
// See `get` for implementation notes, this is basically a copy-paste with mut's added // See `get` for implementation notes, this is basically a copy-paste with mut's added
#[stable] #[stable]
pub fn get_mut<Sized? Q>(&mut self, key: &Q) -> Option<&mut V> where Q: BorrowFrom<K> + Ord { pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where Q: BorrowFrom<K> + Ord {
// temp_node is a Borrowck hack for having a mutable value outlive a loop iteration // temp_node is a Borrowck hack for having a mutable value outlive a loop iteration
let mut temp_node = &mut self.root; let mut temp_node = &mut self.root;
loop { loop {
@ -440,7 +440,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(map.remove(&1), None); /// assert_eq!(map.remove(&1), None);
/// ``` /// ```
#[stable] #[stable]
pub fn remove<Sized? Q>(&mut self, key: &Q) -> Option<V> where Q: BorrowFrom<K> + Ord { pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where Q: BorrowFrom<K> + Ord {
// See `swap` for a more thorough description of the stuff going on in here // See `swap` for a more thorough description of the stuff going on in here
let mut stack = stack::PartialSearchStack::new(self); let mut stack = stack::PartialSearchStack::new(self);
loop { loop {
@ -878,7 +878,7 @@ impl<K: Show, V: Show> Show for BTreeMap<K, V> {
} }
#[stable] #[stable]
impl<K: Ord, Sized? Q, V> Index<Q> for BTreeMap<K, V> impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
where Q: BorrowFrom<K> + Ord where Q: BorrowFrom<K> + Ord
{ {
type Output = V; type Output = V;
@ -889,7 +889,7 @@ impl<K: Ord, Sized? Q, V> Index<Q> for BTreeMap<K, V>
} }
#[stable] #[stable]
impl<K: Ord, Sized? Q, V> IndexMut<Q> for BTreeMap<K, V> impl<K: Ord, Q: ?Sized, V> IndexMut<Q> for BTreeMap<K, V>
where Q: BorrowFrom<K> + Ord where Q: BorrowFrom<K> + Ord
{ {
type Output = V; type Output = V;
@ -1111,7 +1111,7 @@ impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
#[stable] #[stable]
impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {} impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
impl<'a, Sized? Q, K: Ord, V> Entry<'a, Q, K, V> { impl<'a, Q: ?Sized, K: Ord, V> Entry<'a, Q, K, V> {
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"] #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> { pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> {
@ -1122,7 +1122,7 @@ impl<'a, Sized? Q, K: Ord, V> Entry<'a, Q, K, V> {
} }
} }
impl<'a, Sized? Q: ToOwned<K>, K: Ord, V> VacantEntry<'a, Q, K, V> { impl<'a, Q: ?Sized + ToOwned<K>, K: Ord, V> VacantEntry<'a, Q, K, V> {
#[stable] #[stable]
/// Sets the value of the entry with the VacantEntry's key, /// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it. /// and returns a mutable reference to it.
@ -1362,7 +1362,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// ``` /// ```
/// The key must have the same ordering before or after `.to_owned()` is called. /// The key must have the same ordering before or after `.to_owned()` is called.
#[stable] #[stable]
pub fn entry<'a, Sized? Q>(&'a mut self, mut key: &'a Q) -> Entry<'a, Q, K, V> pub fn entry<'a, Q: ?Sized>(&'a mut self, mut key: &'a Q) -> Entry<'a, Q, K, V>
where Q: Ord + ToOwned<K> where Q: Ord + ToOwned<K>
{ {
// same basic logic of `swap` and `pop`, blended together // same basic logic of `swap` and `pop`, blended together

4
src/libcollections/btree/node.rs
View file

@ -517,7 +517,7 @@ impl<K: Ord, V> Node<K, V> {
/// Searches for the given key in the node. If it finds an exact match, /// Searches for the given key in the node. If it finds an exact match,
/// `Found` will be yielded with the matching index. If it doesn't find an exact match, /// `Found` will be yielded with the matching index. If it doesn't find an exact match,
/// `GoDown` will be yielded with the index of the subtree the key must lie in. /// `GoDown` will be yielded with the index of the subtree the key must lie in.
pub fn search<Sized? Q, NodeRef: Deref<Target=Node<K, V>>>(node: NodeRef, key: &Q) pub fn search<Q: ?Sized, NodeRef: Deref<Target=Node<K, V>>>(node: NodeRef, key: &Q)
-> SearchResult<NodeRef> where Q: BorrowFrom<K> + Ord { -> SearchResult<NodeRef> where Q: BorrowFrom<K> + Ord {
// FIXME(Gankro): Tune when to search linear or binary based on B (and maybe K/V). // FIXME(Gankro): Tune when to search linear or binary based on B (and maybe K/V).
// For the B configured as of this writing (B = 6), binary search was *significantly* // For the B configured as of this writing (B = 6), binary search was *significantly*
@ -536,7 +536,7 @@ impl<K: Ord, V> Node<K, V> {
} }
} }
fn search_linear<Sized? Q>(&self, key: &Q) -> (bool, uint) where Q: BorrowFrom<K> + Ord { fn search_linear<Q: ?Sized>(&self, key: &Q) -> (bool, uint) where Q: BorrowFrom<K> + Ord {
for (i, k) in self.keys().iter().enumerate() { for (i, k) in self.keys().iter().enumerate() {
match key.cmp(BorrowFrom::borrow_from(k)) { match key.cmp(BorrowFrom::borrow_from(k)) {
Greater => {}, Greater => {},

4
src/libcollections/btree/set.rs
View file

@ -299,7 +299,7 @@ impl<T: Ord> BTreeSet<T> {
/// assert_eq!(set.contains(&4), false); /// assert_eq!(set.contains(&4), false);
/// ``` /// ```
#[stable] #[stable]
pub fn contains<Sized? Q>(&self, value: &Q) -> bool where Q: BorrowFrom<T> + Ord { pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool where Q: BorrowFrom<T> + Ord {
self.map.contains_key(value) self.map.contains_key(value)
} }
@ -429,7 +429,7 @@ impl<T: Ord> BTreeSet<T> {
/// assert_eq!(set.remove(&2), false); /// assert_eq!(set.remove(&2), false);
/// ``` /// ```
#[stable] #[stable]
pub fn remove<Sized? Q>(&mut self, value: &Q) -> bool where Q: BorrowFrom<T> + Ord { pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool where Q: BorrowFrom<T> + Ord {
self.map.remove(value).is_some() self.map.remove(value).is_some()
} }
} }

2
src/libcollections/slice.rs
View file

@ -1008,7 +1008,7 @@ impl<T: Ord> OrdSliceExt<T> for [T] {
#[unstable = "U should be an associated type"] #[unstable = "U should be an associated type"]
/// An extension trait for concatenating slices /// An extension trait for concatenating slices
pub trait SliceConcatExt<Sized? T, U> { pub trait SliceConcatExt<T: ?Sized, U> {
/// Flattens a slice of `T` into a single value `U`. /// Flattens a slice of `T` into a single value `U`.
#[stable] #[stable]
fn concat(&self) -> U; fn concat(&self) -> U;

38
src/libcore/borrow.rs
View file

@ -54,39 +54,39 @@ use self::Cow::*;
/// A trait for borrowing data. /// A trait for borrowing data.
#[old_orphan_check] #[old_orphan_check]
pub trait BorrowFrom<Sized? Owned> { pub trait BorrowFrom<Owned: ?Sized> {
/// Immutably borrow from an owned value. /// Immutably borrow from an owned value.
fn borrow_from(owned: &Owned) -> &Self; fn borrow_from(owned: &Owned) -> &Self;
} }
/// A trait for mutably borrowing data. /// A trait for mutably borrowing data.
#[old_orphan_check] #[old_orphan_check]
pub trait BorrowFromMut<Sized? Owned> : BorrowFrom<Owned> { pub trait BorrowFromMut<Owned: ?Sized> : BorrowFrom<Owned> {
/// Mutably borrow from an owned value. /// Mutably borrow from an owned value.
fn borrow_from_mut(owned: &mut Owned) -> &mut Self; fn borrow_from_mut(owned: &mut Owned) -> &mut Self;
} }
impl<Sized? T> BorrowFrom<T> for T { impl<T: ?Sized> BorrowFrom<T> for T {
fn borrow_from(owned: &T) -> &T { owned } fn borrow_from(owned: &T) -> &T { owned }
} }
impl<Sized? T> BorrowFromMut<T> for T { impl<T: ?Sized> BorrowFromMut<T> for T {
fn borrow_from_mut(owned: &mut T) -> &mut T { owned } fn borrow_from_mut(owned: &mut T) -> &mut T { owned }
} }
impl<'a, Sized? T> BorrowFrom<&'a T> for T { impl<'a, T: ?Sized> BorrowFrom<&'a T> for T {
fn borrow_from<'b>(owned: &'b &'a T) -> &'b T { &**owned } fn borrow_from<'b>(owned: &'b &'a T) -> &'b T { &**owned }
} }
impl<'a, Sized? T> BorrowFrom<&'a mut T> for T { impl<'a, T: ?Sized> BorrowFrom<&'a mut T> for T {
fn borrow_from<'b>(owned: &'b &'a mut T) -> &'b T { &**owned } fn borrow_from<'b>(owned: &'b &'a mut T) -> &'b T { &**owned }
} }
impl<'a, Sized? T> BorrowFromMut<&'a mut T> for T { impl<'a, T: ?Sized> BorrowFromMut<&'a mut T> for T {
fn borrow_from_mut<'b>(owned: &'b mut &'a mut T) -> &'b mut T { &mut **owned } fn borrow_from_mut<'b>(owned: &'b mut &'a mut T) -> &'b mut T { &mut **owned }
} }
impl<'a, T, Sized? B> BorrowFrom<Cow<'a, T, B>> for B where B: ToOwned<T> { impl<'a, T, B: ?Sized> BorrowFrom<Cow<'a, T, B>> for B where B: ToOwned<T> {
fn borrow_from<'b>(owned: &'b Cow<'a, T, B>) -> &'b B { fn borrow_from<'b>(owned: &'b Cow<'a, T, B>) -> &'b B {
&**owned &**owned
} }
@ -94,12 +94,12 @@ impl<'a, T, Sized? B> BorrowFrom<Cow<'a, T, B>> for B where B: ToOwned<T> {
/// Trait for moving into a `Cow` /// Trait for moving into a `Cow`
#[old_orphan_check] #[old_orphan_check]
pub trait IntoCow<'a, T, Sized? B> { pub trait IntoCow<'a, T, B: ?Sized> {
/// Moves `self` into `Cow` /// Moves `self` into `Cow`
fn into_cow(self) -> Cow<'a, T, B>; fn into_cow(self) -> Cow<'a, T, B>;
} }
impl<'a, T, Sized? B> IntoCow<'a, T, B> for Cow<'a, T, B> where B: ToOwned<T> { impl<'a, T, B: ?Sized> IntoCow<'a, T, B> for Cow<'a, T, B> where B: ToOwned<T> {
fn into_cow(self) -> Cow<'a, T, B> { fn into_cow(self) -> Cow<'a, T, B> {
self self
} }
@ -133,7 +133,7 @@ impl<T> ToOwned<T> for T where T: Clone {
/// } /// }
/// } /// }
/// ``` /// ```
pub enum Cow<'a, T, Sized? B: 'a> where B: ToOwned<T> { pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
/// Borrowed data. /// Borrowed data.
Borrowed(&'a B), Borrowed(&'a B),
@ -142,7 +142,7 @@ pub enum Cow<'a, T, Sized? B: 'a> where B: ToOwned<T> {
} }
#[stable] #[stable]
impl<'a, T, Sized? B> Clone for Cow<'a, T, B> where B: ToOwned<T> { impl<'a, T, B: ?Sized> Clone for Cow<'a, T, B> where B: ToOwned<T> {
fn clone(&self) -> Cow<'a, T, B> { fn clone(&self) -> Cow<'a, T, B> {
match *self { match *self {
Borrowed(b) => Borrowed(b), Borrowed(b) => Borrowed(b),
@ -154,7 +154,7 @@ impl<'a, T, Sized? B> Clone for Cow<'a, T, B> where B: ToOwned<T> {
} }
} }
impl<'a, T, Sized? B> Cow<'a, T, B> where B: ToOwned<T> { impl<'a, T, B: ?Sized> Cow<'a, T, B> where B: ToOwned<T> {
/// Acquire a mutable reference to the owned form of the data. /// Acquire a mutable reference to the owned form of the data.
/// ///
/// Copies the data if it is not already owned. /// Copies the data if it is not already owned.
@ -196,7 +196,7 @@ impl<'a, T, Sized? B> Cow<'a, T, B> where B: ToOwned<T> {
} }
#[stable] #[stable]
impl<'a, T, Sized? B> Deref for Cow<'a, T, B> where B: ToOwned<T> { impl<'a, T, B: ?Sized> Deref for Cow<'a, T, B> where B: ToOwned<T> {
type Target = B; type Target = B;
fn deref(&self) -> &B { fn deref(&self) -> &B {
@ -208,10 +208,10 @@ impl<'a, T, Sized? B> Deref for Cow<'a, T, B> where B: ToOwned<T> {
} }
#[stable] #[stable]
impl<'a, T, Sized? B> Eq for Cow<'a, T, B> where B: Eq + ToOwned<T> {} impl<'a, T, B: ?Sized> Eq for Cow<'a, T, B> where B: Eq + ToOwned<T> {}
#[stable] #[stable]
impl<'a, T, Sized? B> Ord for Cow<'a, T, B> where B: Ord + ToOwned<T> { impl<'a, T, B: ?Sized> Ord for Cow<'a, T, B> where B: Ord + ToOwned<T> {
#[inline] #[inline]
fn cmp(&self, other: &Cow<'a, T, B>) -> Ordering { fn cmp(&self, other: &Cow<'a, T, B>) -> Ordering {
Ord::cmp(&**self, &**other) Ord::cmp(&**self, &**other)
@ -219,7 +219,7 @@ impl<'a, T, Sized? B> Ord for Cow<'a, T, B> where B: Ord + ToOwned<T> {
} }
#[stable] #[stable]
impl<'a, 'b, T, U, Sized? B, Sized? C> PartialEq<Cow<'b, U, C>> for Cow<'a, T, B> where impl<'a, 'b, T, U, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, U, C>> for Cow<'a, T, B> where
B: PartialEq<C> + ToOwned<T>, B: PartialEq<C> + ToOwned<T>,
C: ToOwned<U>, C: ToOwned<U>,
{ {
@ -230,14 +230,14 @@ impl<'a, 'b, T, U, Sized? B, Sized? C> PartialEq<Cow<'b, U, C>> for Cow<'a, T, B
} }
#[stable] #[stable]
impl<'a, T, Sized? B> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwned<T> { impl<'a, T, B: ?Sized> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwned<T> {
#[inline] #[inline]
fn partial_cmp(&self, other: &Cow<'a, T, B>) -> Option<Ordering> { fn partial_cmp(&self, other: &Cow<'a, T, B>) -> Option<Ordering> {
PartialOrd::partial_cmp(&**self, &**other) PartialOrd::partial_cmp(&**self, &**other)
} }
} }
impl<'a, T, Sized? B> fmt::Show for Cow<'a, T, B> where B: fmt::Show + ToOwned<T>, T: fmt::Show { impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where B: fmt::Show + ToOwned<T>, T: fmt::Show {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self { match *self {
Borrowed(ref b) => fmt::Show::fmt(b, f), Borrowed(ref b) => fmt::Show::fmt(b, f),

2
src/libcore/clone.rs
View file

@ -43,7 +43,7 @@ pub trait Clone : Sized {
} }
#[stable] #[stable]
impl<'a, Sized? T> Clone for &'a T { impl<'a, T: ?Sized> Clone for &'a T {
/// Return a shallow copy of the reference. /// Return a shallow copy of the reference.
#[inline] #[inline]
fn clone(&self) -> &'a T { *self } fn clone(&self) -> &'a T { *self }

24
src/libcore/cmp.rs
View file

@ -70,7 +70,7 @@ use option::Option::{self, Some, None};
#[lang="eq"] #[lang="eq"]
#[stable] #[stable]
#[old_orphan_check] #[old_orphan_check]
pub trait PartialEq<Sized? Rhs = Self> { pub trait PartialEq<Rhs: ?Sized = Self> {
/// This method tests for `self` and `other` values to be equal, and is used by `==`. /// This method tests for `self` and `other` values to be equal, and is used by `==`.
#[stable] #[stable]
fn eq(&self, other: &Rhs) -> bool; fn eq(&self, other: &Rhs) -> bool;
@ -225,7 +225,7 @@ impl PartialOrd for Ordering {
/// 5.11). /// 5.11).
#[lang="ord"] #[lang="ord"]
#[stable] #[stable]
pub trait PartialOrd<Sized? Rhs = Self>: PartialEq<Rhs> { pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
/// This method returns an ordering between `self` and `other` values /// This method returns an ordering between `self` and `other` values
/// if one exists. /// if one exists.
#[stable] #[stable]
@ -429,14 +429,14 @@ mod impls {
// & pointers // & pointers
#[stable] #[stable]
impl<'a, 'b, Sized? A, Sized? B> PartialEq<&'b B> for &'a A where A: PartialEq<B> { impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a A where A: PartialEq<B> {
#[inline] #[inline]
fn eq(&self, other: & &'b B) -> bool { PartialEq::eq(*self, *other) } fn eq(&self, other: & &'b B) -> bool { PartialEq::eq(*self, *other) }
#[inline] #[inline]
fn ne(&self, other: & &'b B) -> bool { PartialEq::ne(*self, *other) } fn ne(&self, other: & &'b B) -> bool { PartialEq::ne(*self, *other) }
} }
#[stable] #[stable]
impl<'a, 'b, Sized? A, Sized? B> PartialOrd<&'b B> for &'a A where A: PartialOrd<B> { impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b B> for &'a A where A: PartialOrd<B> {
#[inline] #[inline]
fn partial_cmp(&self, other: &&'b B) -> Option<Ordering> { fn partial_cmp(&self, other: &&'b B) -> Option<Ordering> {
PartialOrd::partial_cmp(*self, *other) PartialOrd::partial_cmp(*self, *other)
@ -451,24 +451,24 @@ mod impls {
fn gt(&self, other: & &'b B) -> bool { PartialOrd::gt(*self, *other) } fn gt(&self, other: & &'b B) -> bool { PartialOrd::gt(*self, *other) }
} }
#[stable] #[stable]
impl<'a, Sized? A> Ord for &'a A where A: Ord { impl<'a, A: ?Sized> Ord for &'a A where A: Ord {
#[inline] #[inline]
fn cmp(&self, other: & &'a A) -> Ordering { Ord::cmp(*self, *other) } fn cmp(&self, other: & &'a A) -> Ordering { Ord::cmp(*self, *other) }
} }
#[stable] #[stable]
impl<'a, Sized? A> Eq for &'a A where A: Eq {} impl<'a, A: ?Sized> Eq for &'a A where A: Eq {}
// &mut pointers // &mut pointers
#[stable] #[stable]
impl<'a, 'b, Sized? A, Sized? B> PartialEq<&'b mut B> for &'a mut A where A: PartialEq<B> { impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a mut A where A: PartialEq<B> {
#[inline] #[inline]
fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) } fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) }
#[inline] #[inline]
fn ne(&self, other: &&'b mut B) -> bool { PartialEq::ne(*self, *other) } fn ne(&self, other: &&'b mut B) -> bool { PartialEq::ne(*self, *other) }
} }
#[stable] #[stable]
impl<'a, 'b, Sized? A, Sized? B> PartialOrd<&'b mut B> for &'a mut A where A: PartialOrd<B> { impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b mut B> for &'a mut A where A: PartialOrd<B> {
#[inline] #[inline]
fn partial_cmp(&self, other: &&'b mut B) -> Option<Ordering> { fn partial_cmp(&self, other: &&'b mut B) -> Option<Ordering> {
PartialOrd::partial_cmp(*self, *other) PartialOrd::partial_cmp(*self, *other)
@ -483,15 +483,15 @@ mod impls {
fn gt(&self, other: &&'b mut B) -> bool { PartialOrd::gt(*self, *other) } fn gt(&self, other: &&'b mut B) -> bool { PartialOrd::gt(*self, *other) }
} }
#[stable] #[stable]
impl<'a, Sized? A> Ord for &'a mut A where A: Ord { impl<'a, A: ?Sized> Ord for &'a mut A where A: Ord {
#[inline] #[inline]
fn cmp(&self, other: &&'a mut A) -> Ordering { Ord::cmp(*self, *other) } fn cmp(&self, other: &&'a mut A) -> Ordering { Ord::cmp(*self, *other) }
} }
#[stable] #[stable]
impl<'a, Sized? A> Eq for &'a mut A where A: Eq {} impl<'a, A: ?Sized> Eq for &'a mut A where A: Eq {}
#[stable] #[stable]
impl<'a, 'b, Sized? A, Sized? B> PartialEq<&'b mut B> for &'a A where A: PartialEq<B> { impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a A where A: PartialEq<B> {
#[inline] #[inline]
fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) } fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) }
#[inline] #[inline]
@ -499,7 +499,7 @@ mod impls {
} }
#[stable] #[stable]
impl<'a, 'b, Sized? A, Sized? B> PartialEq<&'b B> for &'a mut A where A: PartialEq<B> { impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a mut A where A: PartialEq<B> {
#[inline] #[inline]
fn eq(&self, other: &&'b B) -> bool { PartialEq::eq(*self, *other) } fn eq(&self, other: &&'b B) -> bool { PartialEq::eq(*self, *other) }
#[inline] #[inline]

8
src/libcore/fmt/mod.rs
View file

@ -78,9 +78,9 @@ pub trait Writer {
// This Adapter is needed to allow `self` (of type `&mut // This Adapter is needed to allow `self` (of type `&mut
// Self`) to be cast to a FormatWriter (below) without // Self`) to be cast to a FormatWriter (below) without
// requiring a `Sized` bound. // requiring a `Sized` bound.
struct Adapter<'a,Sized? T:'a>(&'a mut T); struct Adapter<'a,T: ?Sized +'a>(&'a mut T);
impl<'a, Sized? T> Writer for Adapter<'a, T> impl<'a, T: ?Sized> Writer for Adapter<'a, T>
where T: Writer where T: Writer
{ {
fn write_str(&mut self, s: &str) -> Result { fn write_str(&mut self, s: &str) -> Result {
@ -592,10 +592,10 @@ pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
// Implementations of the core formatting traits // Implementations of the core formatting traits
impl<'a, Sized? T: Show> Show for &'a T { impl<'a, T: ?Sized + Show> Show for &'a T {
fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) } fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) }
} }
impl<'a, Sized? T: Show> Show for &'a mut T { impl<'a, T: ?Sized + Show> Show for &'a mut T {
fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) } fn fmt(&self, f: &mut Formatter) -> Result { (**self).fmt(f) }
} }

8
src/libcore/hash/mod.rs
View file

@ -85,7 +85,7 @@ pub trait Hash<S = sip::SipState> {
/// containers like `HashMap`, which need a generic way hash multiple types. /// containers like `HashMap`, which need a generic way hash multiple types.
pub trait Hasher<S> { pub trait Hasher<S> {
/// Compute the hash of a value. /// Compute the hash of a value.
fn hash<Sized? T: Hash<S>>(&self, value: &T) -> u64; fn hash<T: ?Sized + Hash<S>>(&self, value: &T) -> u64;
} }
#[allow(missing_docs)] #[allow(missing_docs)]
@ -194,14 +194,14 @@ impl<S: Writer, T: Hash<S>> Hash<S> for [T] {
} }
impl<'a, S: Writer, Sized? T: Hash<S>> Hash<S> for &'a T { impl<'a, S: Writer, T: ?Sized + Hash<S>> Hash<S> for &'a T {
#[inline] #[inline]
fn hash(&self, state: &mut S) { fn hash(&self, state: &mut S) {
(**self).hash(state); (**self).hash(state);
} }
} }
impl<'a, S: Writer, Sized? T: Hash<S>> Hash<S> for &'a mut T { impl<'a, S: Writer, T: ?Sized + Hash<S>> Hash<S> for &'a mut T {
#[inline] #[inline]
fn hash(&self, state: &mut S) { fn hash(&self, state: &mut S) {
(**self).hash(state); (**self).hash(state);
@ -233,7 +233,7 @@ impl<S: Writer> Hash<S> for TypeId {
} }
} }
impl<'a, T, Sized? B, S> Hash<S> for Cow<'a, T, B> where B: Hash<S> + ToOwned<T> { impl<'a, T, B: ?Sized, S> Hash<S> for Cow<'a, T, B> where B: Hash<S> + ToOwned<T> {
#[inline] #[inline]
fn hash(&self, state: &mut S) { fn hash(&self, state: &mut S) {
Hash::hash(&**self, state) Hash::hash(&**self, state)

6
src/libcore/hash/sip.rs
View file

@ -239,7 +239,7 @@ impl SipHasher {
impl Hasher<SipState> for SipHasher { impl Hasher<SipState> for SipHasher {
#[inline] #[inline]
fn hash<Sized? T: Hash<SipState>>(&self, value: &T) -> u64 { fn hash<T: ?Sized + Hash<SipState>>(&self, value: &T) -> u64 {
let mut state = SipState::new_with_keys(self.k0, self.k1); let mut state = SipState::new_with_keys(self.k0, self.k1);
value.hash(&mut state); value.hash(&mut state);
state.result() state.result()
@ -255,7 +255,7 @@ impl Default for SipHasher {
/// Hashes a value using the SipHash algorithm. /// Hashes a value using the SipHash algorithm.
#[inline] #[inline]
pub fn hash<Sized? T: Hash<SipState>>(value: &T) -> u64 { pub fn hash<T: ?Sized + Hash<SipState>>(value: &T) -> u64 {
let mut state = SipState::new(); let mut state = SipState::new();
value.hash(&mut state); value.hash(&mut state);
state.result() state.result()
@ -263,7 +263,7 @@ pub fn hash<Sized? T: Hash<SipState>>(value: &T) -> u64 {
/// Hashes a value with the SipHash algorithm with the provided keys. /// Hashes a value with the SipHash algorithm with the provided keys.
#[inline] #[inline]
pub fn hash_with_keys<Sized? T: Hash<SipState>>(k0: u64, k1: u64, value: &T) -> u64 { pub fn hash_with_keys<T: ?Sized + Hash<SipState>>(k0: u64, k1: u64, value: &T) -> u64 {
let mut state = SipState::new_with_keys(k0, k1); let mut state = SipState::new_with_keys(k0, k1);
value.hash(&mut state); value.hash(&mut state);
state.result() state.result()

18
src/libcore/kinds.rs
View file

@ -133,10 +133,10 @@ pub mod marker {
/// for some lifetime `'a`, but not the other way around). /// for some lifetime `'a`, but not the other way around).
#[lang="covariant_type"] #[lang="covariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)] #[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct CovariantType<Sized? T>; pub struct CovariantType<T: ?Sized>;
impl<Sized? T> Copy for CovariantType<T> {} impl<T: ?Sized> Copy for CovariantType<T> {}
impl<Sized? T> Clone for CovariantType<T> { impl<T: ?Sized> Clone for CovariantType<T> {
fn clone(&self) -> CovariantType<T> { *self } fn clone(&self) -> CovariantType<T> { *self }
} }
@ -181,10 +181,10 @@ pub mod marker {
/// arguments of type `U`, hence such a conversion is safe. /// arguments of type `U`, hence such a conversion is safe.
#[lang="contravariant_type"] #[lang="contravariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)] #[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct ContravariantType<Sized? T>; pub struct ContravariantType<T: ?Sized>;
impl<Sized? T> Copy for ContravariantType<T> {} impl<T: ?Sized> Copy for ContravariantType<T> {}
impl<Sized? T> Clone for ContravariantType<T> { impl<T: ?Sized> Clone for ContravariantType<T> {
fn clone(&self) -> ContravariantType<T> { *self } fn clone(&self) -> ContravariantType<T> { *self }
} }
@ -211,10 +211,10 @@ pub mod marker {
/// interior mutability. /// interior mutability.
#[lang="invariant_type"] #[lang="invariant_type"]
#[derive(PartialEq, Eq, PartialOrd, Ord)] #[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct InvariantType<Sized? T>; pub struct InvariantType<T: ?Sized>;
impl<Sized? T> Copy for InvariantType<T> {} impl<T: ?Sized> Copy for InvariantType<T> {}
impl<Sized? T> Clone for InvariantType<T> { impl<T: ?Sized> Clone for InvariantType<T> {
fn clone(&self) -> InvariantType<T> { *self } fn clone(&self) -> InvariantType<T> { *self }
} }

4
src/libcore/mem.rs
View file

@ -320,7 +320,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
#[inline] #[inline]
#[unstable = "this function may be removed in the future due to its \ #[unstable = "this function may be removed in the future due to its \
questionable utility"] questionable utility"]
pub unsafe fn copy_lifetime<'a, Sized? S, Sized? T: 'a>(_ptr: &'a S, pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
ptr: &T) -> &'a T { ptr: &T) -> &'a T {
transmute(ptr) transmute(ptr)
} }
@ -329,7 +329,7 @@ pub unsafe fn copy_lifetime<'a, Sized? S, Sized? T: 'a>(_ptr: &'a S,
#[inline] #[inline]
#[unstable = "this function may be removed in the future due to its \ #[unstable = "this function may be removed in the future due to its \
questionable utility"] questionable utility"]
pub unsafe fn copy_mut_lifetime<'a, Sized? S, Sized? T: 'a>(_ptr: &'a mut S, pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S,
ptr: &mut T) ptr: &mut T)
-> &'a mut T { -> &'a mut T {
transmute(ptr) transmute(ptr)

24
src/libcore/ops.rs
View file

@ -802,8 +802,8 @@ shr_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
/// } /// }
/// ``` /// ```
#[lang="index"] #[lang="index"]
pub trait Index<Sized? Index> { pub trait Index<Index: ?Sized> {
type Sized? Output; type Output: ?Sized;
/// The method for the indexing (`Foo[Bar]`) operation /// The method for the indexing (`Foo[Bar]`) operation
fn index<'a>(&'a self, index: &Index) -> &'a Self::Output; fn index<'a>(&'a self, index: &Index) -> &'a Self::Output;
@ -839,8 +839,8 @@ pub trait Index<Sized? Index> {
/// } /// }
/// ``` /// ```
#[lang="index_mut"] #[lang="index_mut"]
pub trait IndexMut<Sized? Index> { pub trait IndexMut<Index: ?Sized> {
type Sized? Output; type Output: ?Sized;
/// The method for the indexing (`Foo[Bar]`) operation /// The method for the indexing (`Foo[Bar]`) operation
fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Self::Output; fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Self::Output;
@ -884,7 +884,7 @@ pub trait IndexMut<Sized? Index> {
/// } /// }
/// ``` /// ```
#[lang="slice"] #[lang="slice"]
pub trait Slice<Sized? Idx, Sized? Result> { pub trait Slice<Idx: ?Sized, Result: ?Sized> {
/// The method for the slicing operation foo[] /// The method for the slicing operation foo[]
fn as_slice_<'a>(&'a self) -> &'a Result; fn as_slice_<'a>(&'a self) -> &'a Result;
/// The method for the slicing operation foo[from..] /// The method for the slicing operation foo[from..]
@ -933,7 +933,7 @@ pub trait Slice<Sized? Idx, Sized? Result> {
/// } /// }
/// ``` /// ```
#[lang="slice_mut"] #[lang="slice_mut"]
pub trait SliceMut<Sized? Idx, Sized? Result> { pub trait SliceMut<Idx: ?Sized, Result: ?Sized> {
/// The method for the slicing operation foo[] /// The method for the slicing operation foo[]
fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Result; fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Result;
/// The method for the slicing operation foo[from..] /// The method for the slicing operation foo[from..]
@ -1071,7 +1071,7 @@ pub struct RangeTo<Idx> {
#[stable] #[stable]
pub trait Deref { pub trait Deref {
#[stable] #[stable]
type Sized? Target; type Target: ?Sized;
/// The method called to dereference a value /// The method called to dereference a value
#[stable] #[stable]
@ -1079,14 +1079,14 @@ pub trait Deref {
} }
#[stable] #[stable]
impl<'a, Sized? T> Deref for &'a T { impl<'a, T: ?Sized> Deref for &'a T {
type Target = T; type Target = T;
fn deref(&self) -> &T { *self } fn deref(&self) -> &T { *self }
} }
#[stable] #[stable]
impl<'a, Sized? T> Deref for &'a mut T { impl<'a, T: ?Sized> Deref for &'a mut T {
type Target = T; type Target = T;
fn deref(&self) -> &T { *self } fn deref(&self) -> &T { *self }
@ -1138,7 +1138,7 @@ pub trait DerefMut: Deref {
} }
#[stable] #[stable]
impl<'a, Sized? T> DerefMut for &'a mut T { impl<'a, T: ?Sized> DerefMut for &'a mut T {
fn deref_mut(&mut self) -> &mut T { *self } fn deref_mut(&mut self) -> &mut T { *self }
} }
@ -1166,8 +1166,8 @@ pub trait FnOnce<Args,Result> {
extern "rust-call" fn call_once(self, args: Args) -> Result; extern "rust-call" fn call_once(self, args: Args) -> Result;
} }
impl<Sized? F,A,R> FnMut<A,R> for F impl<F: ?Sized, A, R> FnMut<A, R> for F
where F : Fn<A,R> where F : Fn<A, R>
{ {
extern "rust-call" fn call_mut(&mut self, args: A) -> R { extern "rust-call" fn call_mut(&mut self, args: A) -> R {
self.call(args) self.call(args)

4
src/libcore/slice.rs
View file

@ -626,13 +626,13 @@ impl<T> AsSlice<T> for [T] {
} }
#[experimental = "trait is experimental"] #[experimental = "trait is experimental"]
impl<'a, T, Sized? U: AsSlice<T>> AsSlice<T> for &'a U { impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U {
#[inline(always)] #[inline(always)]
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
} }
#[experimental = "trait is experimental"] #[experimental = "trait is experimental"]
impl<'a, T, Sized? U: AsSlice<T>> AsSlice<T> for &'a mut U { impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U {
#[inline(always)] #[inline(always)]
fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
} }

2
src/libcore/str/mod.rs
View file

@ -1155,7 +1155,7 @@ impl Str for str {
fn as_slice<'a>(&'a self) -> &'a str { self } fn as_slice<'a>(&'a self) -> &'a str { self }
} }
impl<'a, Sized? S> Str for &'a S where S: Str { impl<'a, S: ?Sized> Str for &'a S where S: Str {
#[inline] #[inline]
fn as_slice(&self) -> &str { Str::as_slice(*self) } fn as_slice(&self) -> &str { Str::as_slice(*self) }
} }

2
src/libcoretest/hash/mod.rs
View file

@ -16,7 +16,7 @@ use core::hash::{Hash, Hasher, Writer};
struct MyWriterHasher; struct MyWriterHasher;
impl Hasher<MyWriter> for MyWriterHasher { impl Hasher<MyWriter> for MyWriterHasher {
fn hash<Sized? T: Hash<MyWriter>>(&self, value: &T) -> u64 { fn hash<T: ?Sized + Hash<MyWriter>>(&self, value: &T) -> u64 {
let mut state = MyWriter { hash: 0 }; let mut state = MyWriter { hash: 0 };
value.hash(&mut state); value.hash(&mut state);
state.hash state.hash

2
src/libgraphviz/maybe_owned_vec.rs
View file

@ -25,7 +25,7 @@ use std::slice;
// Note 2: Once Dynamically Sized Types (DST) lands, it might be // Note 2: Once Dynamically Sized Types (DST) lands, it might be
// reasonable to replace this with something like `enum MaybeOwned<'a, // reasonable to replace this with something like `enum MaybeOwned<'a,
// Sized? U>{ Owned(Box<U>), Borrowed(&'a U) }`; and then `U` could be // U: ?Sized>{ Owned(Box<U>), Borrowed(&'a U) }`; and then `U` could be
// instantiated with `[T]` or `str`, etc. Of course, that would imply // instantiated with `[T]` or `str`, etc. Of course, that would imply
// removing the `Growable` variant, which relates to note 1 above. // removing the `Growable` variant, which relates to note 1 above.
// Alternatively, we might add `MaybeOwned` for the general case but // Alternatively, we might add `MaybeOwned` for the general case but

8
src/librustc/middle/intrinsicck.rs
View file

@ -121,7 +121,7 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> {
// However, it's not as simple as checking whether `T : // However, it's not as simple as checking whether `T :
// Sized`, because even if `T : Sized` does not hold, that // Sized`, because even if `T : Sized` does not hold, that
// just means that `T` *may* not be sized. After all, even a // just means that `T` *may* not be sized. After all, even a
// type parameter `Sized? T` could be bound to a sized // type parameter `T: ?Sized` could be bound to a sized
// type. (Issue #20116) // type. (Issue #20116)
// //
// To handle this, we first check for "interior" type // To handle this, we first check for "interior" type
@ -139,16 +139,16 @@ impl<'a, 'tcx> IntrinsicCheckingVisitor<'a, 'tcx> {
// exhaustively checking all possible combinations. Here are some examples: // exhaustively checking all possible combinations. Here are some examples:
// //
// ``` // ```
// fn foo<T,U>() { // fn foo<T, U>() {
// // T=int, U=int // // T=int, U=int
// } // }
// //
// fn bar<Sized? T,U>() { // fn bar<T: ?Sized, U>() {
// // T=int, U=int // // T=int, U=int
// // T=[int], U=int // // T=[int], U=int
// } // }
// //
// fn baz<Sized? T, Sized?U>() { // fn baz<T: ?Sized, U: ?Sized>() {
// // T=int, U=int // // T=int, U=int
// // T=[int], U=int // // T=[int], U=int
// // T=int, U=[int] // // T=int, U=[int]

2
src/librustc/util/nodemap.rs
View file

@ -75,7 +75,7 @@ pub struct FnvHasher;
pub struct FnvState(u64); pub struct FnvState(u64);
impl Hasher<FnvState> for FnvHasher { impl Hasher<FnvState> for FnvHasher {
fn hash<Sized? T: Hash<FnvState>>(&self, t: &T) -> u64 { fn hash<T: ?Sized + Hash<FnvState>>(&self, t: &T) -> u64 {
let mut state = FnvState(0xcbf29ce484222325); let mut state = FnvState(0xcbf29ce484222325);
t.hash(&mut state); t.hash(&mut state);
let FnvState(ret) = state; let FnvState(ret) = state;

2
src/librustc/util/ppaux.rs
View file

@ -601,7 +601,7 @@ impl<'tcx> Repr<'tcx> for () {
} }
} }
impl<'a, 'tcx, Sized? T:Repr<'tcx>> Repr<'tcx> for &'a T { impl<'a, 'tcx, T: ?Sized +Repr<'tcx>> Repr<'tcx> for &'a T {
fn repr(&self, tcx: &ctxt<'tcx>) -> String { fn repr(&self, tcx: &ctxt<'tcx>) -> String {
Repr::repr(*self, tcx) Repr::repr(*self, tcx)
} }

4
src/libserialize/serialize.rs
View file

@ -396,13 +396,13 @@ impl Decodable for () {
} }
} }
impl<'a, Sized? T: Encodable> Encodable for &'a T { impl<'a, T: ?Sized + Encodable> Encodable for &'a T {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s) (**self).encode(s)
} }
} }
impl<Sized? T: Encodable> Encodable for Box<T> { impl<T: ?Sized + Encodable> Encodable for Box<T> {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
(**self).encode(s) (**self).encode(s)
} }

4
src/libserialize/serialize_stage0.rs
View file

@ -378,13 +378,13 @@ impl<E, D:Decoder<E>> Decodable<D, E> for () {
} }
} }
impl<'a, E, S: Encoder<E>, Sized? T: Encodable<S, E>> Encodable<S, E> for &'a T { impl<'a, E, S: Encoder<E>, T: ?Sized + Encodable<S, E>> Encodable<S, E> for &'a T {
fn encode(&self, s: &mut S) -> Result<(), E> { fn encode(&self, s: &mut S) -> Result<(), E> {
(**self).encode(s) (**self).encode(s)
} }
} }
impl<E, S: Encoder<E>, Sized? T: Encodable<S, E>> Encodable<S, E> for Box<T> { impl<E, S: Encoder<E>, T: ?Sized + Encodable<S, E>> Encodable<S, E> for Box<T> {
fn encode(&self, s: &mut S) -> Result<(), E> { fn encode(&self, s: &mut S) -> Result<(), E> {
(**self).encode(s) (**self).encode(s)
} }

30
src/libstd/collections/hash/map.rs
View file

@ -440,14 +440,14 @@ impl<K, V, M> SearchResult<K, V, M> {
} }
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
fn make_hash<Sized? X: Hash<S>>(&self, x: &X) -> SafeHash { fn make_hash<X: ?Sized + Hash<S>>(&self, x: &X) -> SafeHash {
table::make_hash(&self.hasher, x) table::make_hash(&self.hasher, x)
} }
/// Search for a key, yielding the index if it's found in the hashtable. /// Search for a key, yielding the index if it's found in the hashtable.
/// If you already have the hash for the key lying around, use /// If you already have the hash for the key lying around, use
/// search_hashed. /// search_hashed.
fn search<'a, Sized? Q>(&'a self, q: &Q) -> Option<FullBucketImm<'a, K, V>> fn search<'a, Q: ?Sized>(&'a self, q: &Q) -> Option<FullBucketImm<'a, K, V>>
where Q: BorrowFrom<K> + Eq + Hash<S> where Q: BorrowFrom<K> + Eq + Hash<S>
{ {
let hash = self.make_hash(q); let hash = self.make_hash(q);
@ -455,7 +455,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
.into_option() .into_option()
} }
fn search_mut<'a, Sized? Q>(&'a mut self, q: &Q) -> Option<FullBucketMut<'a, K, V>> fn search_mut<'a, Q: ?Sized>(&'a mut self, q: &Q) -> Option<FullBucketMut<'a, K, V>>
where Q: BorrowFrom<K> + Eq + Hash<S> where Q: BorrowFrom<K> + Eq + Hash<S>
{ {
let hash = self.make_hash(q); let hash = self.make_hash(q);
@ -923,7 +923,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
#[stable] #[stable]
/// Gets the given key's corresponding entry in the map for in-place manipulation. /// Gets the given key's corresponding entry in the map for in-place manipulation.
/// Regardless of whether or not `to_owned()` has been called, the key must hash the same way. /// Regardless of whether or not `to_owned()` has been called, the key must hash the same way.
pub fn entry<'a, Sized? Q>(&'a mut self, key: &'a Q) -> Entry<'a, Q, K, V> pub fn entry<'a, Q: ?Sized>(&'a mut self, key: &'a Q) -> Entry<'a, Q, K, V>
where Q: Eq + Hash<S> + ToOwned<K> where Q: Eq + Hash<S> + ToOwned<K>
{ {
// Gotta resize now. // Gotta resize now.
@ -1030,7 +1030,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
/// assert_eq!(map.get(&2), None); /// assert_eq!(map.get(&2), None);
/// ``` /// ```
#[stable] #[stable]
pub fn get<Sized? Q>(&self, k: &Q) -> Option<&V> pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
where Q: Hash<S> + Eq + BorrowFrom<K> where Q: Hash<S> + Eq + BorrowFrom<K>
{ {
self.search(k).map(|bucket| bucket.into_refs().1) self.search(k).map(|bucket| bucket.into_refs().1)
@ -1053,7 +1053,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
/// assert_eq!(map.contains_key(&2), false); /// assert_eq!(map.contains_key(&2), false);
/// ``` /// ```
#[stable] #[stable]
pub fn contains_key<Sized? Q>(&self, k: &Q) -> bool pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
where Q: Hash<S> + Eq + BorrowFrom<K> where Q: Hash<S> + Eq + BorrowFrom<K>
{ {
self.search(k).is_some() self.search(k).is_some()
@ -1079,7 +1079,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
/// assert_eq!(map[1], "b"); /// assert_eq!(map[1], "b");
/// ``` /// ```
#[stable] #[stable]
pub fn get_mut<Sized? Q>(&mut self, k: &Q) -> Option<&mut V> pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>
where Q: Hash<S> + Eq + BorrowFrom<K> where Q: Hash<S> + Eq + BorrowFrom<K>
{ {
self.search_mut(k).map(|bucket| bucket.into_mut_refs().1) self.search_mut(k).map(|bucket| bucket.into_mut_refs().1)
@ -1131,7 +1131,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
/// assert_eq!(map.remove(&1), None); /// assert_eq!(map.remove(&1), None);
/// ``` /// ```
#[stable] #[stable]
pub fn remove<Sized? Q>(&mut self, k: &Q) -> Option<V> pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V>
where Q: Hash<S> + Eq + BorrowFrom<K> where Q: Hash<S> + Eq + BorrowFrom<K>
{ {
if self.table.size() == 0 { if self.table.size() == 0 {
@ -1142,7 +1142,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
} }
} }
fn search_entry_hashed<'a, K, V, Sized? Q>(table: &'a mut RawTable<K,V>, hash: SafeHash, k: &'a Q) fn search_entry_hashed<'a, K, V, Q: ?Sized>(table: &'a mut RawTable<K,V>, hash: SafeHash, k: &'a Q)
-> Entry<'a, Q, K, V> -> Entry<'a, Q, K, V>
where Q: Eq + ToOwned<K> where Q: Eq + ToOwned<K>
{ {
@ -1227,7 +1227,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H>
} }
#[stable] #[stable]
impl<K: Hash<S> + Eq, Sized? Q, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V, H> impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V, H>
where Q: BorrowFrom<K> + Hash<S> + Eq where Q: BorrowFrom<K> + Hash<S> + Eq
{ {
type Output = V; type Output = V;
@ -1239,7 +1239,7 @@ impl<K: Hash<S> + Eq, Sized? Q, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V, H
} }
#[stable] #[stable]
impl<K: Hash<S> + Eq, Sized? Q, V, S, H: Hasher<S>> IndexMut<Q> for HashMap<K, V, H> impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> IndexMut<Q> for HashMap<K, V, H>
where Q: BorrowFrom<K> + Hash<S> + Eq where Q: BorrowFrom<K> + Hash<S> + Eq
{ {
type Output = V; type Output = V;
@ -1331,7 +1331,7 @@ pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
#[stable] #[stable]
/// A view into a single empty location in a HashMap /// A view into a single empty location in a HashMap
pub struct VacantEntry<'a, Sized? Q: 'a, K: 'a, V: 'a> { pub struct VacantEntry<'a, Q: ?Sized + 'a, K: 'a, V: 'a> {
hash: SafeHash, hash: SafeHash,
key: &'a Q, key: &'a Q,
elem: VacantEntryState<K, V, &'a mut RawTable<K, V>>, elem: VacantEntryState<K, V, &'a mut RawTable<K, V>>,
@ -1339,7 +1339,7 @@ pub struct VacantEntry<'a, Sized? Q: 'a, K: 'a, V: 'a> {
#[stable] #[stable]
/// A view into a single location in a map, which may be vacant or occupied /// A view into a single location in a map, which may be vacant or occupied
pub enum Entry<'a, Sized? Q: 'a, K: 'a, V: 'a> { pub enum Entry<'a, Q: ?Sized + 'a, K: 'a, V: 'a> {
/// An occupied Entry /// An occupied Entry
Occupied(OccupiedEntry<'a, K, V>), Occupied(OccupiedEntry<'a, K, V>),
/// A vacant Entry /// A vacant Entry
@ -1409,7 +1409,7 @@ impl<'a, K: 'a, V: 'a> Iterator for Drain<'a, K, V> {
} }
} }
impl<'a, Sized? Q, K, V> Entry<'a, Q, K, V> { impl<'a, Q: ?Sized, K, V> Entry<'a, Q, K, V> {
#[unstable = "matches collection reform v2 specification, waiting for dust to settle"] #[unstable = "matches collection reform v2 specification, waiting for dust to settle"]
/// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> { pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, Q, K, V>> {
@ -1455,7 +1455,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
} }
} }
impl<'a, Sized? Q: 'a + ToOwned<K>, K: 'a, V: 'a> VacantEntry<'a, Q, K, V> { impl<'a, Q: ?Sized + 'a + ToOwned<K>, K: 'a, V: 'a> VacantEntry<'a, Q, K, V> {
#[stable] #[stable]
/// Sets the value of the entry with the VacantEntry's key, /// Sets the value of the entry with the VacantEntry's key,
/// and returns a mutable reference to it /// and returns a mutable reference to it

4
src/libstd/collections/hash/set.rs
View file

@ -451,7 +451,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
/// assert_eq!(set.contains(&4), false); /// assert_eq!(set.contains(&4), false);
/// ``` /// ```
#[stable] #[stable]
pub fn contains<Sized? Q>(&self, value: &Q) -> bool pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool
where Q: BorrowFrom<T> + Hash<S> + Eq where Q: BorrowFrom<T> + Hash<S> + Eq
{ {
self.map.contains_key(value) self.map.contains_key(value)
@ -561,7 +561,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
/// assert_eq!(set.remove(&2), false); /// assert_eq!(set.remove(&2), false);
/// ``` /// ```
#[stable] #[stable]
pub fn remove<Sized? Q>(&mut self, value: &Q) -> bool pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
where Q: BorrowFrom<T> + Hash<S> + Eq where Q: BorrowFrom<T> + Hash<S> + Eq
{ {
self.map.remove(value).is_some() self.map.remove(value).is_some()

2
src/libstd/collections/hash/table.rs
View file

@ -138,7 +138,7 @@ impl SafeHash {
/// We need to remove hashes of 0. That's reserved for empty buckets. /// We need to remove hashes of 0. That's reserved for empty buckets.
/// This function wraps up `hash_keyed` to be the only way outside this /// This function wraps up `hash_keyed` to be the only way outside this
/// module to generate a SafeHash. /// module to generate a SafeHash.
pub fn make_hash<Sized? T: Hash<S>, S, H: Hasher<S>>(hasher: &H, t: &T) -> SafeHash { pub fn make_hash<T: ?Sized + Hash<S>, S, H: Hasher<S>>(hasher: &H, t: &T) -> SafeHash {
// We need to avoid 0u64 in order to prevent collisions with // We need to avoid 0u64 in order to prevent collisions with
// EMPTY_HASH. We can maintain our precious uniform distribution // EMPTY_HASH. We can maintain our precious uniform distribution
// of initial indexes by unconditionally setting the MSB, // of initial indexes by unconditionally setting the MSB,

2
src/libstd/hash.rs
View file

@ -90,7 +90,7 @@ impl RandomSipHasher {
impl Hasher<sip::SipState> for RandomSipHasher { impl Hasher<sip::SipState> for RandomSipHasher {
#[inline] #[inline]
fn hash<Sized? T: Hash<sip::SipState>>(&self, value: &T) -> u64 { fn hash<T: ?Sized + Hash<sip::SipState>>(&self, value: &T) -> u64 {
self.hasher.hash(value) self.hasher.hash(value)
} }
} }

8
src/libstd/io/mod.rs
View file

@ -1012,12 +1012,12 @@ pub trait Writer {
fn write_fmt(&mut self, fmt: fmt::Arguments) -> IoResult<()> { fn write_fmt(&mut self, fmt: fmt::Arguments) -> IoResult<()> {
// Create a shim which translates a Writer to a fmt::Writer and saves // Create a shim which translates a Writer to a fmt::Writer and saves
// off I/O errors. instead of discarding them // off I/O errors. instead of discarding them
struct Adaptor<'a, Sized? T:'a> { struct Adaptor<'a, T: ?Sized +'a> {
inner: &'a mut T, inner: &'a mut T,
error: IoResult<()>, error: IoResult<()>,
} }
impl<'a, Sized? T: Writer> fmt::Writer for Adaptor<'a, T> { impl<'a, T: ?Sized + Writer> fmt::Writer for Adaptor<'a, T> {
fn write_str(&mut self, s: &str) -> fmt::Result { fn write_str(&mut self, s: &str) -> fmt::Result {
match self.inner.write(s.as_bytes()) { match self.inner.write(s.as_bytes()) {
Ok(()) => Ok(()), Ok(()) => Ok(()),
@ -1597,11 +1597,11 @@ pub trait Acceptor<T> {
/// `Some`. The `Some` contains the `IoResult` representing whether the /// `Some`. The `Some` contains the `IoResult` representing whether the
/// connection attempt was successful. A successful connection will be wrapped /// connection attempt was successful. A successful connection will be wrapped
/// in `Ok`. A failed connection is represented as an `Err`. /// in `Ok`. A failed connection is represented as an `Err`.
pub struct IncomingConnections<'a, Sized? A:'a> { pub struct IncomingConnections<'a, A: ?Sized +'a> {
inc: &'a mut A, inc: &'a mut A,
} }
impl<'a, T, Sized? A: Acceptor<T>> Iterator for IncomingConnections<'a, A> { impl<'a, T, A: ?Sized + Acceptor<T>> Iterator for IncomingConnections<'a, A> {
type Item = IoResult<T>; type Item = IoResult<T>;
fn next(&mut self) -> Option<IoResult<T>> { fn next(&mut self) -> Option<IoResult<T>> {

2
src/libstd/path/mod.rs
View file

@ -896,7 +896,7 @@ impl BytesContainer for CString {
} }
} }
impl<'a, Sized? T: BytesContainer> BytesContainer for &'a T { impl<'a, T: ?Sized + BytesContainer> BytesContainer for &'a T {
#[inline] #[inline]
fn container_as_bytes(&self) -> &[u8] { fn container_as_bytes(&self) -> &[u8] {
(**self).container_as_bytes() (**self).container_as_bytes()

2
src/libstd/path/posix.rs
View file

@ -321,7 +321,7 @@ impl Path {
/// Returns a normalized byte vector representation of a path, by removing all empty /// Returns a normalized byte vector representation of a path, by removing all empty
/// components, and unnecessary . and .. components. /// components, and unnecessary . and .. components.
fn normalize<Sized? V: AsSlice<u8>>(v: &V) -> Vec<u8> { fn normalize<V: ?Sized + AsSlice<u8>>(v: &V) -> Vec<u8> {
// borrowck is being very picky // borrowck is being very picky
let val = { let val = {
let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE; let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;

57
src/libsyntax/parse/obsolete.rs
View file

@ -13,8 +13,6 @@
//! //!
//! Obsolete syntax that becomes too hard to parse can be removed. //! Obsolete syntax that becomes too hard to parse can be removed.
pub use self::ObsoleteSyntax::*;
use ast::{Expr, ExprTup}; use ast::{Expr, ExprTup};
use codemap::Span; use codemap::Span;
use parse::parser; use parse::parser;
@ -24,18 +22,19 @@ use ptr::P;
/// The specific types of unsupported syntax /// The specific types of unsupported syntax
#[derive(Copy, PartialEq, Eq, Hash)] #[derive(Copy, PartialEq, Eq, Hash)]
pub enum ObsoleteSyntax { pub enum ObsoleteSyntax {
ObsoleteForSized, Sized,
ObsoleteOwnedType, ForSized,
ObsoleteOwnedExpr, OwnedType,
ObsoleteOwnedPattern, OwnedExpr,
ObsoleteOwnedVector, OwnedPattern,
ObsoleteOwnedSelf, OwnedVector,
ObsoleteImportRenaming, OwnedSelf,
ObsoleteSubsliceMatch, ImportRenaming,
ObsoleteExternCrateRenaming, SubsliceMatch,
ObsoleteProcType, ExternCrateRenaming,
ObsoleteProcExpr, ProcType,
ObsoleteClosureType, ProcExpr,
ClosureType,
} }
pub trait ParserObsoleteMethods { pub trait ParserObsoleteMethods {
@ -57,55 +56,59 @@ impl<'a> ParserObsoleteMethods for parser::Parser<'a> {
/// Reports an obsolete syntax non-fatal error. /// Reports an obsolete syntax non-fatal error.
fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax) { fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax) {
let (kind_str, desc) = match kind { let (kind_str, desc) = match kind {
ObsoleteForSized => ( ObsoleteSyntax::ForSized => (
"for Sized?", "for Sized?",
"no longer required. Traits (and their `Self` type) do not have the `Sized` bound \ "no longer required. Traits (and their `Self` type) do not have the `Sized` bound \
by default", by default",
), ),
ObsoleteProcType => ( ObsoleteSyntax::ProcType => (
"the `proc` type", "the `proc` type",
"use unboxed closures instead", "use unboxed closures instead",
), ),
ObsoleteProcExpr => ( ObsoleteSyntax::ProcExpr => (
"`proc` expression", "`proc` expression",
"use a `move ||` expression instead", "use a `move ||` expression instead",
), ),
ObsoleteOwnedType => ( ObsoleteSyntax::OwnedType => (
"`~` notation for owned pointers", "`~` notation for owned pointers",
"use `Box<T>` in `std::owned` instead" "use `Box<T>` in `std::owned` instead"
), ),
ObsoleteOwnedExpr => ( ObsoleteSyntax::OwnedExpr => (
"`~` notation for owned pointer allocation", "`~` notation for owned pointer allocation",
"use the `box` operator instead of `~`" "use the `box` operator instead of `~`"
), ),
ObsoleteOwnedPattern => ( ObsoleteSyntax::OwnedPattern => (
"`~` notation for owned pointer patterns", "`~` notation for owned pointer patterns",
"use the `box` operator instead of `~`" "use the `box` operator instead of `~`"
), ),
ObsoleteOwnedVector => ( ObsoleteSyntax::OwnedVector => (
"`~[T]` is no longer a type", "`~[T]` is no longer a type",
"use the `Vec` type instead" "use the `Vec` type instead"
), ),
ObsoleteOwnedSelf => ( ObsoleteSyntax::OwnedSelf => (
"`~self` is no longer supported", "`~self` is no longer supported",
"write `self: Box<Self>` instead" "write `self: Box<Self>` instead"
), ),
ObsoleteImportRenaming => ( ObsoleteSyntax::ImportRenaming => (
"`use foo = bar` syntax", "`use foo = bar` syntax",
"write `use bar as foo` instead" "write `use bar as foo` instead"
), ),
ObsoleteSubsliceMatch => ( ObsoleteSyntax::SubsliceMatch => (
"subslice match syntax", "subslice match syntax",
"instead of `..xs`, write `xs..` in a pattern" "instead of `..xs`, write `xs..` in a pattern"
), ),
ObsoleteExternCrateRenaming => ( ObsoleteSyntax::ExternCrateRenaming => (
"`extern crate foo = bar` syntax", "`extern crate foo = bar` syntax",
"write `extern crate bar as foo` instead" "write `extern crate bar as foo` instead"
), ),
ObsoleteClosureType => ( ObsoleteSyntax::ClosureType => (
"`|uint| -> bool` closure type syntax", "`|uint| -> bool` closure type syntax",
"use unboxed closures instead, no type annotation needed" "use unboxed closures instead, no type annotation needed"
) ),
ObsoleteSyntax::Sized => (
"`Sized? T` syntax for removing the `Sized` bound",
"write `T: ?Sized` instead"
),
}; };
self.report(sp, kind, kind_str, desc); self.report(sp, kind, kind_str, desc);

31
src/libsyntax/parse/parser.rs
View file

@ -1155,7 +1155,7 @@ impl<'a> Parser<'a> {
let _ = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare); let _ = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare);
let _ = self.parse_ret_ty(); let _ = self.parse_ret_ty();
self.obsolete(proc_span, ObsoleteProcType); self.obsolete(proc_span, ObsoleteSyntax::ProcType);
TyInfer TyInfer
} }
@ -1511,8 +1511,10 @@ impl<'a> Parser<'a> {
self.bump(); self.bump();
let last_span = self.last_span; let last_span = self.last_span;
match self.token { match self.token {
token::OpenDelim(token::Bracket) => self.obsolete(last_span, ObsoleteOwnedVector), token::OpenDelim(token::Bracket) => {
_ => self.obsolete(last_span, ObsoleteOwnedType) self.obsolete(last_span, ObsoleteSyntax::OwnedVector)
}
_ => self.obsolete(last_span, ObsoleteSyntax::OwnedType)
} }
TyTup(vec![self.parse_ty()]) TyTup(vec![self.parse_ty()])
} else if self.check(&token::BinOp(token::Star)) { } else if self.check(&token::BinOp(token::Star)) {
@ -2275,7 +2277,7 @@ impl<'a> Parser<'a> {
let span = self.last_span; let span = self.last_span;
let _ = self.parse_proc_decl(); let _ = self.parse_proc_decl();
let _ = self.parse_expr(); let _ = self.parse_expr();
return self.obsolete_expr(span, ObsoleteProcExpr); return self.obsolete_expr(span, ObsoleteSyntax::ProcExpr);
} }
if self.eat_keyword(keywords::If) { if self.eat_keyword(keywords::If) {
return self.parse_if_expr(); return self.parse_if_expr();
@ -2850,9 +2852,9 @@ impl<'a> Parser<'a> {
let last_span = self.last_span; let last_span = self.last_span;
match self.token { match self.token {
token::OpenDelim(token::Bracket) => { token::OpenDelim(token::Bracket) => {
self.obsolete(last_span, ObsoleteOwnedVector) self.obsolete(last_span, ObsoleteSyntax::OwnedVector)
}, },
_ => self.obsolete(last_span, ObsoleteOwnedExpr) _ => self.obsolete(last_span, ObsoleteSyntax::OwnedExpr)
} }
let e = self.parse_prefix_expr(); let e = self.parse_prefix_expr();
@ -3227,7 +3229,7 @@ impl<'a> Parser<'a> {
} else { } else {
let _ = self.parse_pat(); let _ = self.parse_pat();
let span = self.span; let span = self.span;
self.obsolete(span, ObsoleteSubsliceMatch); self.obsolete(span, ObsoleteSyntax::SubsliceMatch);
} }
continue continue
} }
@ -3343,7 +3345,7 @@ impl<'a> Parser<'a> {
pat = PatBox(sub); pat = PatBox(sub);
let last_span = self.last_span; let last_span = self.last_span;
hi = last_span.hi; hi = last_span.hi;
self.obsolete(last_span, ObsoleteOwnedPattern); self.obsolete(last_span, ObsoleteSyntax::OwnedPattern);
return P(ast::Pat { return P(ast::Pat {
id: ast::DUMMY_NODE_ID, id: ast::DUMMY_NODE_ID,
node: pat, node: pat,
@ -4090,8 +4092,8 @@ impl<'a> Parser<'a> {
// unbound, and it may only be `Sized`. To avoid backtracking and other // unbound, and it may only be `Sized`. To avoid backtracking and other
// complications, we parse an ident, then check for `?`. If we find it, // complications, we parse an ident, then check for `?`. If we find it,
// we use the ident as the unbound, otherwise, we use it as the name of // we use the ident as the unbound, otherwise, we use it as the name of
// type param. Even worse, for now, we need to check for `?` before or // type param. Even worse, we need to check for `?` before or after the
// after the bound. // bound.
let mut span = self.span; let mut span = self.span;
let mut ident = self.parse_ident(); let mut ident = self.parse_ident();
let mut unbound = None; let mut unbound = None;
@ -4100,6 +4102,7 @@ impl<'a> Parser<'a> {
unbound = Some(tref); unbound = Some(tref);
span = self.span; span = self.span;
ident = self.parse_ident(); ident = self.parse_ident();
self.obsolete(span, ObsoleteSyntax::Sized);
} }
let mut bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Modified); let mut bounds = self.parse_colon_then_ty_param_bounds(BoundParsingMode::Modified);
@ -4463,7 +4466,7 @@ impl<'a> Parser<'a> {
self.bump(); self.bump();
drop(self.expect_self_ident()); drop(self.expect_self_ident());
let last_span = self.last_span; let last_span = self.last_span;
self.obsolete(last_span, ObsoleteOwnedSelf) self.obsolete(last_span, ObsoleteSyntax::OwnedSelf)
} }
SelfStatic SelfStatic
} }
@ -4514,7 +4517,7 @@ impl<'a> Parser<'a> {
self.bump(); self.bump();
drop(self.expect_self_ident()); drop(self.expect_self_ident());
let last_span = self.last_span; let last_span = self.last_span;
self.obsolete(last_span, ObsoleteOwnedSelf); self.obsolete(last_span, ObsoleteSyntax::OwnedSelf);
SelfStatic SelfStatic
} else { } else {
SelfStatic SelfStatic
@ -5396,7 +5399,7 @@ impl<'a> Parser<'a> {
self.bump(); self.bump();
let path = self.parse_str(); let path = self.parse_str();
let span = self.span; let span = self.span;
self.obsolete(span, ObsoleteExternCrateRenaming); self.obsolete(span, ObsoleteSyntax::ExternCrateRenaming);
Some(path) Some(path)
} else if self.eat_keyword(keywords::As) { } else if self.eat_keyword(keywords::As) {
// skip the ident if there is one // skip the ident if there is one
@ -6053,7 +6056,7 @@ impl<'a> Parser<'a> {
path.push(id); path.push(id);
} }
let span = mk_sp(path_lo, self.span.hi); let span = mk_sp(path_lo, self.span.hi);
self.obsolete(span, ObsoleteImportRenaming); self.obsolete(span, ObsoleteSyntax::ImportRenaming);
let path = ast::Path { let path = ast::Path {
span: span, span: span,
global: false, global: false,

4
src/libsyntax/util/interner.rs
View file

@ -77,7 +77,7 @@ impl<T: Eq + Hash + Clone + 'static> Interner<T> {
(*vect).len() (*vect).len()
} }
pub fn find<Sized? Q>(&self, val: &Q) -> Option<Name> pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name>
where Q: BorrowFrom<T> + Eq + Hash { where Q: BorrowFrom<T> + Eq + Hash {
let map = self.map.borrow(); let map = self.map.borrow();
match (*map).get(val) { match (*map).get(val) {
@ -202,7 +202,7 @@ impl StrInterner {
self.vect.borrow().len() self.vect.borrow().len()
} }
pub fn find<Sized? Q>(&self, val: &Q) -> Option<Name> pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name>
where Q: BorrowFrom<RcStr> + Eq + Hash { where Q: BorrowFrom<RcStr> + Eq + Hash {
match (*self.map.borrow()).get(val) { match (*self.map.borrow()).get(val) {
Some(v) => Some(*v), Some(v) => Some(*v),

2
src/test/compile-fail/associated-types-unsized.rs
View file

@ -9,7 +9,7 @@
// except according to those terms. // except according to those terms.
trait Get { trait Get {
type Sized? Value; type Value: ?Sized;
fn get(&self) -> <Self as Get>::Value; fn get(&self) -> <Self as Get>::Value;
} }

2
src/test/compile-fail/dst-bad-assign-2.rs
View file

@ -10,7 +10,7 @@
// Forbid assignment into a dynamically sized type. // Forbid assignment into a dynamically sized type.
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
f1: int, f1: int,
f2: &'static str, f2: &'static str,
ptr: T ptr: T

2
src/test/compile-fail/dst-bad-assign.rs
View file

@ -10,7 +10,7 @@
// Forbid assignment into a dynamically sized type. // Forbid assignment into a dynamically sized type.
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
f1: int, f1: int,
f2: &'static str, f2: &'static str,
ptr: T ptr: T

2
src/test/compile-fail/dst-bad-coerce1.rs
View file

@ -10,7 +10,7 @@
// Attempt to change the type as well as unsizing. // Attempt to change the type as well as unsizing.
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
ptr: T ptr: T
} }

2
src/test/compile-fail/dst-bad-coerce2.rs
View file

@ -10,7 +10,7 @@
// Attempt to change the mutability as well as unsizing. // Attempt to change the mutability as well as unsizing.
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
ptr: T ptr: T
} }

2
src/test/compile-fail/dst-bad-coerce3.rs
View file

@ -10,7 +10,7 @@
// Attempt to extend the lifetime as well as unsizing. // Attempt to extend the lifetime as well as unsizing.
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
ptr: T ptr: T
} }

2
src/test/compile-fail/dst-bad-coerce4.rs
View file

@ -10,7 +10,7 @@
// Attempt to coerce from unsized to sized. // Attempt to coerce from unsized to sized.
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
ptr: T ptr: T
} }

2
src/test/compile-fail/dst-bad-coercions.rs
View file

@ -14,7 +14,7 @@ struct S;
trait T {} trait T {}
impl T for S {} impl T for S {}
struct Foo<Sized? T> { struct Foo<T: ?Sized> {
f: T f: T
} }

2
src/test/compile-fail/dst-bad-deep.rs
View file

@ -13,7 +13,7 @@
// because it would require stack allocation of an unsized temporary (*g in the // because it would require stack allocation of an unsized temporary (*g in the
// test). // test).
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
ptr: T ptr: T
} }

4
src/test/compile-fail/dst-object-from-unsized-type.rs
View file

@ -13,12 +13,12 @@
trait Foo {} trait Foo {}
impl Foo for str {} impl Foo for str {}
fn test1<Sized? T: Foo>(t: &T) { fn test1<T: ?Sized + Foo>(t: &T) {
let u: &Foo = t; let u: &Foo = t;
//~^ ERROR `core::kinds::Sized` is not implemented for the type `T` //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
} }
fn test2<Sized? T: Foo>(t: &T) { fn test2<T: ?Sized + Foo>(t: &T) {
let v: &Foo = t as &Foo; let v: &Foo = t as &Foo;
//~^ ERROR `core::kinds::Sized` is not implemented for the type `T` //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
} }

8
src/test/compile-fail/transmute-fat-pointers.rs
View file

@ -14,11 +14,11 @@
use std::mem::transmute; use std::mem::transmute;
fn a<T, Sized? U>(x: &[T]) -> &U { fn a<T, U: ?Sized>(x: &[T]) -> &U {
unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes
} }
fn b<Sized? T, Sized? U>(x: &T) -> &U { fn b<T: ?Sized, U: ?Sized>(x: &T) -> &U {
unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes
} }
@ -30,11 +30,11 @@ fn d<T, U>(x: &[T]) -> &[U] {
unsafe { transmute(x) } unsafe { transmute(x) }
} }
fn e<Sized? T, U>(x: &T) -> &U { fn e<T: ?Sized, U>(x: &T) -> &U {
unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes
} }
fn f<T, Sized? U>(x: &T) -> &U { fn f<T, U: ?Sized>(x: &T) -> &U {
unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes
} }

4
src/test/compile-fail/transmute-impl.rs
View file

@ -14,11 +14,11 @@
use std::mem::transmute; use std::mem::transmute;
struct Foo<Sized? T> { struct Foo<T: ?Sized> {
t: Box<T> t: Box<T>
} }
impl<Sized? T> Foo<T> { impl<T: ?Sized> Foo<T> {
fn m(x: &T) -> &int where T : Sized { fn m(x: &T) -> &int where T : Sized {
// OK here, because T : Sized is in scope. // OK here, because T : Sized is in scope.
unsafe { transmute(x) } unsafe { transmute(x) }

6
src/test/compile-fail/unboxed-closure-sugar-default.rs
View file

@ -18,9 +18,9 @@ trait Foo<T,U,V=T> {
fn dummy(&self, t: T, u: U, v: V); fn dummy(&self, t: T, u: U, v: V);
} }
trait Eq<Sized? X> { } trait Eq<X: ?Sized> { }
impl<Sized? X> Eq<X> for X { } impl<X: ?Sized> Eq<X> for X { }
fn eq<Sized? A,Sized? B>() where A : Eq<B> { } fn eq<A: ?Sized,B: ?Sized>() where A : Eq<B> { }
fn test<'a,'b>() { fn test<'a,'b>() {
// Parens are equivalent to omitting default in angle. // Parens are equivalent to omitting default in angle.

6
src/test/compile-fail/unboxed-closure-sugar-equiv.rs
View file

@ -20,9 +20,9 @@ trait Foo<T,U> {
fn dummy(&self, t: T, u: U); fn dummy(&self, t: T, u: U);
} }
trait Eq<Sized? X> { } trait Eq<X: ?Sized> { }
impl<Sized? X> Eq<X> for X { } impl<X: ?Sized> Eq<X> for X { }
fn eq<Sized? A,Sized? B:Eq<A>>() { } fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { }
fn test<'a,'b>() { fn test<'a,'b>() {
// No errors expected: // No errors expected:

6
src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs
View file

@ -20,9 +20,9 @@ trait Foo<T,U> {
fn dummy(&self, t: T, u: U); fn dummy(&self, t: T, u: U);
} }
trait Eq<Sized? X> { } trait Eq<X: ?Sized> { }
impl<Sized? X> Eq<X> for X { } impl<X: ?Sized> Eq<X> for X { }
fn eq<Sized? A,Sized? B:Eq<A>>() { } fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { }
fn main() { fn main() {
eq::< for<'a> Foo<(&'a int,), &'a int>, eq::< for<'a> Foo<(&'a int,), &'a int>,

6
src/test/compile-fail/unboxed-closure-sugar-region.rs
View file

@ -21,9 +21,9 @@ trait Foo<'a,T,U> {
fn dummy(&'a self) -> &'a (T,U); fn dummy(&'a self) -> &'a (T,U);
} }
trait Eq<Sized? X> { } trait Eq<X: ?Sized> { }
impl<Sized? X> Eq<X> for X { } impl<X: ?Sized> Eq<X> for X { }
fn eq<Sized? A,Sized? B:Eq<A>>() { } fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { }
fn same_type<A,B:Eq<A>>(a: A, b: B) { } fn same_type<A,B:Eq<A>>(a: A, b: B) { }

2
src/test/compile-fail/unsized-bare-typaram.rs
View file

@ -9,5 +9,5 @@
// except according to those terms. // except according to those terms.
fn bar<T: Sized>() { } fn bar<T: Sized>() { }
fn foo<Sized? T>() { bar::<T>() } //~ ERROR the trait `core::kinds::Sized` is not implemented fn foo<T: ?Sized>() { bar::<T>() } //~ ERROR the trait `core::kinds::Sized` is not implemented
fn main() { } fn main() { }

10
src/test/compile-fail/unsized-enum.rs
View file

@ -10,18 +10,18 @@
fn is_sized<T:Sized>() { } fn is_sized<T:Sized>() { }
fn not_sized<Sized? T>() { } fn not_sized<T: ?Sized>() { }
enum Foo<U> { FooSome(U), FooNone } enum Foo<U> { FooSome(U), FooNone }
fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory. fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
fn foo2<Sized? T>() { not_sized::<Foo<T>>() } fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
// //
// Not OK: `T` is not sized. // Not OK: `T` is not sized.
enum Bar<Sized? U> { BarSome(U), BarNone } enum Bar<U: ?Sized> { BarSome(U), BarNone }
fn bar1<Sized? T>() { not_sized::<Bar<T>>() } fn bar1<T: ?Sized>() { not_sized::<Bar<T>>() }
fn bar2<Sized? T>() { is_sized::<Bar<T>>() } fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
// //
// Not OK: `Bar<T>` is not sized, but it should be. // Not OK: `Bar<T>` is not sized, but it should be.

2
src/test/compile-fail/unsized-inherent-impl-self-type.rs
View file

@ -14,7 +14,7 @@
struct S5<Y>; struct S5<Y>;
impl<Sized? X> S5<X> { //~ ERROR not implemented impl<X: ?Sized> S5<X> { //~ ERROR not implemented
} }
fn main() { } fn main() { }

10
src/test/compile-fail/unsized-struct.rs
View file

@ -10,18 +10,18 @@
fn is_sized<T:Sized>() { } fn is_sized<T:Sized>() { }
fn not_sized<Sized? T>() { } fn not_sized<T: ?Sized>() { }
struct Foo<T> { data: T } struct Foo<T> { data: T }
fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory. fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
fn foo2<Sized? T>() { not_sized::<Foo<T>>() } fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
// //
// Not OK: `T` is not sized. // Not OK: `T` is not sized.
struct Bar<Sized? T> { data: T } struct Bar<T: ?Sized> { data: T }
fn bar1<Sized? T>() { not_sized::<Bar<T>>() } fn bar1<T: ?Sized>() { not_sized::<Bar<T>>() }
fn bar2<Sized? T>() { is_sized::<Bar<T>>() } fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
// //
// Not OK: `Bar<T>` is not sized, but it should be. // Not OK: `Bar<T>` is not sized, but it should be.

4
src/test/compile-fail/unsized-trait-impl-self-type.rs
View file

@ -11,12 +11,12 @@
// Test sized-ness checking in substitution in impls. // Test sized-ness checking in substitution in impls.
// impl - struct // impl - struct
trait T3<Sized? Z> { trait T3<Z: ?Sized> {
} }
struct S5<Y>; struct S5<Y>;
impl<Sized? X> T3<X> for S5<X> { //~ ERROR not implemented impl<X: ?Sized> T3<X> for S5<X> { //~ ERROR not implemented
} }
fn main() { } fn main() { }

4
src/test/compile-fail/unsized-trait-impl-trait-arg.rs
View file

@ -13,8 +13,8 @@
// impl - unbounded // impl - unbounded
trait T2<Z> { trait T2<Z> {
} }
struct S4<Sized? Y>; struct S4<Y: ?Sized>;
impl<Sized? X> T2<X> for S4<X> { impl<X: ?Sized> T2<X> for S4<X> {
//~^ ERROR `core::kinds::Sized` is not implemented for the type `X` //~^ ERROR `core::kinds::Sized` is not implemented for the type `X`
} }

20
src/test/compile-fail/unsized3.rs
View file

@ -12,7 +12,7 @@
// Unbounded. // Unbounded.
fn f1<Sized? X>(x: &X) { fn f1<X: ?Sized>(x: &X) {
f2::<X>(x); f2::<X>(x);
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
} }
@ -20,8 +20,8 @@ fn f2<X>(x: &X) {
} }
// Bounded. // Bounded.
trait T {} trait T for {}
fn f3<Sized? X: T>(x: &X) { fn f3<X: ?Sized + T>(x: &X) {
f4::<X>(x); f4::<X>(x);
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
} }
@ -29,13 +29,13 @@ fn f4<X: T>(x: &X) {
} }
// Test with unsized enum. // Test with unsized enum.
enum E<Sized? X> { enum E<X: ?Sized> {
V(X), V(X),
} }
fn f5<Y>(x: &Y) {} fn f5<Y>(x: &Y) {}
fn f6<Sized? X>(x: &X) {} fn f6<X: ?Sized>(x: &X) {}
fn f7<Sized? X>(x1: &E<X>, x2: &E<X>) { fn f7<X: ?Sized>(x1: &E<X>, x2: &E<X>) {
f5(x1); f5(x1);
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
f6(x2); // ok f6(x2); // ok
@ -43,23 +43,23 @@ fn f7<Sized? X>(x1: &E<X>, x2: &E<X>) {
// Test with unsized struct. // Test with unsized struct.
struct S<Sized? X> { struct S<X: ?Sized> {
x: X, x: X,
} }
fn f8<Sized? X>(x1: &S<X>, x2: &S<X>) { fn f8<X: ?Sized>(x1: &S<X>, x2: &S<X>) {
f5(x1); f5(x1);
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
f6(x2); // ok f6(x2); // ok
} }
// Test some tuples. // Test some tuples.
fn f9<Sized? X>(x1: Box<S<X>>, x2: Box<E<X>>) { fn f9<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) {
f5(&(*x1, 34i)); f5(&(*x1, 34i));
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
} }
fn f10<Sized? X>(x1: Box<S<X>>, x2: Box<E<X>>) { fn f10<X: ?Sized>(x1: Box<S<X>>, x2: Box<E<X>>) {
f5(&(32i, *x2)); f5(&(32i, *x2));
//~^ ERROR the trait `core::kinds::Sized` is not implemented //~^ ERROR the trait `core::kinds::Sized` is not implemented
} }

2
src/test/compile-fail/unsized4.rs
View file

@ -11,7 +11,7 @@
// Test that bounds are sized-compatible. // Test that bounds are sized-compatible.
trait T : Sized {} trait T : Sized {}
fn f<Sized? Y: T>() { fn f<Y: ?Sized + T>() {
//~^ERROR incompatible bounds on `Y`, bound `T` does not allow unsized type //~^ERROR incompatible bounds on `Y`, bound `T` does not allow unsized type
} }

8
src/test/compile-fail/unsized5.rs
View file

@ -10,11 +10,11 @@
// Test `Sized?` types not allowed in fields (except the last one). // Test `Sized?` types not allowed in fields (except the last one).
struct S1<Sized? X> { struct S1<X: ?Sized> {
f1: X, //~ ERROR `core::kinds::Sized` is not implemented f1: X, //~ ERROR `core::kinds::Sized` is not implemented
f2: int, f2: int,
} }
struct S2<Sized? X> { struct S2<X: ?Sized> {
f: int, f: int,
g: X, //~ ERROR `core::kinds::Sized` is not implemented g: X, //~ ERROR `core::kinds::Sized` is not implemented
h: int, h: int,
@ -27,10 +27,10 @@ struct S4 {
f: str, //~ ERROR `core::kinds::Sized` is not implemented f: str, //~ ERROR `core::kinds::Sized` is not implemented
g: uint g: uint
} }
enum E<Sized? X> { enum E<X: ?Sized> {
V1(X, int), //~ERROR `core::kinds::Sized` is not implemented V1(X, int), //~ERROR `core::kinds::Sized` is not implemented
} }
enum F<Sized? X> { enum F<X: ?Sized> {
V2{f1: X, f: int}, //~ERROR `core::kinds::Sized` is not implemented V2{f1: X, f: int}, //~ERROR `core::kinds::Sized` is not implemented
} }

12
src/test/compile-fail/unsized6.rs
View file

@ -13,30 +13,30 @@
trait T {} trait T {}
fn f1<Sized? X>(x: &X) { fn f1<X: ?Sized>(x: &X) {
let _: X; // <-- this is OK, no bindings created, no initializer. let _: X; // <-- this is OK, no bindings created, no initializer.
let _: (int, (X, int)); // same let _: (int, (X, int)); // same
let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented
let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented
} }
fn f2<Sized? X: T>(x: &X) { fn f2<X: ?Sized + T>(x: &X) {
let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented let y: X; //~ERROR the trait `core::kinds::Sized` is not implemented
let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented let y: (int, (X, int)); //~ERROR the trait `core::kinds::Sized` is not implemented
} }
fn f3<Sized? X>(x1: Box<X>, x2: Box<X>, x3: Box<X>) { fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented
let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented
let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented
} }
fn f4<Sized? X: T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) { fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented let y: X = *x1; //~ERROR the trait `core::kinds::Sized` is not implemented
let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented let y = *x2; //~ERROR the trait `core::kinds::Sized` is not implemented
let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented let (y, z) = (*x3, 4i); //~ERROR the trait `core::kinds::Sized` is not implemented
} }
fn g1<Sized? X>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented fn g1<X: ?Sized>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented
fn g2<Sized? X: T>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented fn g2<X: ?Sized + T>(x: X) {} //~ERROR the trait `core::kinds::Sized` is not implemented
pub fn main() { pub fn main() {
} }

4
src/test/compile-fail/unsized7.rs
View file

@ -16,8 +16,8 @@ trait T {}
// impl - bounded // impl - bounded
trait T1<Z: T> { trait T1<Z: T> {
} }
struct S3<Sized? Y>; struct S3<Y: ?Sized>;
impl<Sized? X: T> T1<X> for S3<X> { impl<X: ?Sized + T> T1<X> for S3<X> {
//~^ ERROR `core::kinds::Sized` is not implemented for the type `X` //~^ ERROR `core::kinds::Sized` is not implemented for the type `X`
} }

2
src/test/run-pass-valgrind/dst-dtor-1.rs
View file

@ -20,7 +20,7 @@ impl Drop for Foo {
trait Trait {} trait Trait {}
impl Trait for Foo {} impl Trait for Foo {}
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
f: T f: T
} }

2
src/test/run-pass-valgrind/dst-dtor-2.rs
View file

@ -17,7 +17,7 @@ impl Drop for Foo {
} }
} }
struct Fat<Sized? T> { struct Fat<T: ?Sized> {
f: T f: T
} }

2
src/test/run-pass/associated-types-conditional-dispatch.rs
View file

@ -16,7 +16,7 @@
use std::ops::Deref; use std::ops::Deref;
pub trait MyEq<Sized? U=Self> { pub trait MyEq<U: ?Sized=Self> {
fn eq(&self, u: &U) -> bool; fn eq(&self, u: &U) -> bool;
} }

2
src/test/run-pass/issue-18906.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
pub trait Borrow<Sized? Borrowed> { pub trait Borrow<Borrowed: ?Sized> {
fn borrow(&self) -> &Borrowed; fn borrow(&self) -> &Borrowed;
} }