diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index e2934efa43b65..c330d44dd964c 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -13,7 +13,7 @@ use std::cmp; use std::iter::RandomAccessIterator; -use std::iter::{Rev, Enumerate, Repeat, Map, Zip}; +use std::iter::{Enumerate, Repeat, Map, Zip}; use std::ops; use std::slice; use std::strbuf::StrBuf; @@ -466,12 +466,6 @@ impl Bitv { Bits {bitv: self, next_idx: 0, end_idx: self.nbits} } - #[inline] - #[deprecated = "replaced by .iter().rev()"] - pub fn rev_iter<'a>(&'a self) -> Rev> { - self.iter().rev() - } - /// Returns `true` if all bits are 0 pub fn none(&self) -> bool { match self.rep { diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 58ced1beeed60..c5fa8286f7db3 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -21,7 +21,6 @@ // Backlinks over DList::prev are raw pointers that form a full chain in // the reverse direction. -use std::iter::Rev; use std::iter; use std::mem; use std::ptr; @@ -369,12 +368,6 @@ impl DList { Items{nelem: self.len(), head: &self.list_head, tail: self.list_tail} } - #[inline] - #[deprecated = "replaced by .iter().rev()"] - pub fn rev_iter<'a>(&'a self) -> Rev> { - self.iter().rev() - } - /// Provide a forward iterator with mutable references #[inline] pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> { @@ -390,24 +383,12 @@ impl DList { } } - #[inline] - #[deprecated = "replaced by .mut_iter().rev()"] - pub fn mut_rev_iter<'a>(&'a mut self) -> Rev> { - self.mut_iter().rev() - } - /// Consume the list into an iterator yielding elements by value #[inline] pub fn move_iter(self) -> MoveItems { MoveItems{list: self} } - - #[inline] - #[deprecated = "replaced by .move_iter().rev()"] - pub fn move_rev_iter(self) -> Rev> { - self.move_iter().rev() - } } impl DList { diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index 12e4fa8b51f24..f45c9685be58b 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -14,7 +14,7 @@ //! collections::deque::Deque`. use std::cmp; -use std::iter::{Rev, RandomAccessIterator}; +use std::iter::RandomAccessIterator; use deque::Deque; @@ -190,11 +190,6 @@ impl RingBuf { Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()} } - #[deprecated = "replaced by .iter().rev()"] - pub fn rev_iter<'a>(&'a self) -> Rev> { - self.iter().rev() - } - /// Front-to-back iterator which returns mutable values. pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> { let start_index = raw_index(self.lo, self.elts.len(), 0); @@ -220,11 +215,6 @@ impl RingBuf { nelts: self.nelts } } } - - #[deprecated = "replaced by .mut_iter().rev()"] - pub fn mut_rev_iter<'a>(&'a mut self) -> Rev> { - self.mut_iter().rev() - } } /// RingBuf iterator diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs index fb02ddd6224c4..8e4e47405e71f 100644 --- a/src/libcollections/smallintmap.rs +++ b/src/libcollections/smallintmap.rs @@ -15,7 +15,7 @@ #![allow(missing_doc)] -use std::iter::{Enumerate, FilterMap, Rev}; +use std::iter::{Enumerate, FilterMap}; use std::mem::replace; use std::{vec, slice}; @@ -142,16 +142,6 @@ impl SmallIntMap { } } - #[deprecated = "replaced by .iter().rev()"] - pub fn rev_iter<'r>(&'r self) -> Rev> { - self.iter().rev() - } - - #[deprecated = "replaced by .mut_iter().rev()"] - pub fn mut_rev_iter<'r>(&'r mut self) -> Rev> { - self.mut_iter().rev() - } - /// Empties the hash map, moving all values into the specified closure pub fn move_iter(&mut self) -> FilterMap<(uint, Option), (uint, V), @@ -243,8 +233,6 @@ pub struct Entries<'a, T> { iterator!(impl Entries -> (uint, &'a T), get_ref) double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref) -#[deprecated = "replaced by Rev>"] -pub type RevEntries<'a, T> = Rev>; pub struct MutEntries<'a, T> { front: uint, @@ -254,8 +242,6 @@ pub struct MutEntries<'a, T> { iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref) double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref) -#[deprecated = "replaced by Rev"] -pub type RevMutEntries<'a, T> = Rev>; #[cfg(test)] mod test_map { diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 755c6738b4a62..3979a1ad8c833 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -386,9 +386,6 @@ pub trait ImmutableVector<'a, T> { fn slice_to(&self, end: uint) -> &'a [T]; /// Returns an iterator over the vector fn iter(self) -> Items<'a, T>; - /// Returns a reversed iterator over a vector - #[deprecated = "replaced by .iter().rev()"] - fn rev_iter(self) -> Rev>; /// Returns an iterator over the subslices of the vector which are /// separated by elements that match `pred`. The matched element /// is not contained in the subslices. @@ -399,12 +396,6 @@ pub trait ImmutableVector<'a, T> { /// the subslices. fn splitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T>; /// Returns an iterator over the subslices of the vector which are - /// separated by elements that match `pred`. This starts at the - /// end of the vector and works backwards. The matched element is - /// not contained in the subslices. - #[deprecated = "replaced by .split(pred).rev()"] - fn rsplit(self, pred: |&T|: 'a -> bool) -> Rev>; - /// Returns an iterator over the subslices of the vector which are /// separated by elements that match `pred` limited to splitting /// at most `n` times. This starts at the end of the vector and /// works backwards. The matched element is not contained in the @@ -580,12 +571,6 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] { } } - #[inline] - #[deprecated = "replaced by .iter().rev()"] - fn rev_iter(self) -> Rev> { - self.iter().rev() - } - #[inline] fn split(self, pred: |&T|: 'a -> bool) -> Splits<'a, T> { Splits { @@ -604,12 +589,6 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] { } } - #[inline] - #[deprecated = "replaced by .split(pred).rev()"] - fn rsplit(self, pred: |&T|: 'a -> bool) -> Rev> { - self.split(pred).rev() - } - #[inline] fn rsplitn(self, n: uint, pred: |&T|: 'a -> bool) -> SplitsN<'a, T> { SplitsN { @@ -806,10 +785,6 @@ pub trait MutableVector<'a, T> { /// Returns a mutable pointer to the last item in the vector. fn mut_last(self) -> Option<&'a mut T>; - /// Returns a reversed iterator that allows modifying each value - #[deprecated = "replaced by .mut_iter().rev()"] - fn mut_rev_iter(self) -> Rev>; - /// Returns an iterator over the mutable subslices of the vector /// which are separated by elements that match `pred`. The /// matched element is not contained in the subslices. @@ -1045,12 +1020,6 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] { Some(&mut self[len - 1]) } - #[inline] - #[deprecated = "replaced by .mut_iter().rev()"] - fn mut_rev_iter(self) -> Rev> { - self.mut_iter().rev() - } - #[inline] fn mut_split(self, pred: |&T|: 'a -> bool) -> MutSplits<'a, T> { MutSplits { v: self, pred: pred, finished: false } @@ -1354,8 +1323,6 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> { } iterator!{struct Items -> *T, &'a T} -#[deprecated = "replaced by Rev>"] -pub type RevItems<'a, T> = Rev>; impl<'a, T> ExactSize<&'a T> for Items<'a, T> {} impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {} @@ -1365,8 +1332,6 @@ impl<'a, T> Clone for Items<'a, T> { } iterator!{struct MutItems -> *mut T, &'a mut T} -#[deprecated = "replaced by Rev>"] -pub type RevMutItems<'a, T> = Rev>; /// An iterator over the subslices of the vector which are separated /// by elements that match `pred`. diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 0d820836377d3..d6a9b42522c29 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -20,7 +20,7 @@ use cmp::{Eq, TotalEq}; use container::Container; use default::Default; use iter::{Filter, Map, Iterator}; -use iter::{Rev, DoubleEndedIterator, ExactSize}; +use iter::{DoubleEndedIterator, ExactSize}; use iter::range; use num::Saturating; use option::{None, Option, Some}; @@ -174,20 +174,11 @@ impl<'a> DoubleEndedIterator<(uint, char)> for CharOffsets<'a> { } } -#[deprecated = "replaced by Rev>"] -pub type RevChars<'a> = Rev>; - -#[deprecated = "replaced by Rev>"] -pub type RevCharOffsets<'a> = Rev>; - /// External iterator for a string's bytes. /// Use with the `std::iter` module. pub type Bytes<'a> = Map<'a, &'a u8, u8, slice::Items<'a, u8>>; -#[deprecated = "replaced by Rev>"] -pub type RevBytes<'a> = Rev>; - /// An iterator over the substrings of a string, separated by `sep`. #[deriving(Clone)] pub struct CharSplits<'a, Sep> { @@ -200,9 +191,6 @@ pub struct CharSplits<'a, Sep> { finished: bool, } -#[deprecated = "replaced by Rev>"] -pub type RevCharSplits<'a, Sep> = Rev>; - /// An iterator over the substrings of a string, separated by `sep`, /// splitting at most `count` times. #[deriving(Clone)] @@ -1080,24 +1068,12 @@ pub trait StrSlice<'a> { /// ``` fn chars(&self) -> Chars<'a>; - /// Do not use this - it is deprecated. - #[deprecated = "replaced by .chars().rev()"] - fn chars_rev(&self) -> Rev>; - /// An iterator over the bytes of `self` fn bytes(&self) -> Bytes<'a>; - /// Do not use this - it is deprecated. - #[deprecated = "replaced by .bytes().rev()"] - fn bytes_rev(&self) -> Rev>; - /// An iterator over the characters of `self` and their byte offsets. fn char_indices(&self) -> CharOffsets<'a>; - /// Do not use this - it is deprecated. - #[deprecated = "replaced by .char_indices().rev()"] - fn char_indices_rev(&self) -> Rev>; - /// An iterator over substrings of `self`, separated by characters /// matched by `sep`. /// @@ -1159,10 +1135,6 @@ pub trait StrSlice<'a> { /// ``` fn split_terminator(&self, sep: Sep) -> CharSplits<'a, Sep>; - /// Do not use this - it is deprecated. - #[deprecated = "replaced by .split(sep).rev()"] - fn rsplit(&self, sep: Sep) -> Rev>; - /// An iterator over substrings of `self`, separated by characters /// matched by `sep`, starting from the end of the string. /// Restricted to splitting at most `count` times. @@ -1681,34 +1653,16 @@ impl<'a> StrSlice<'a> for &'a str { Chars{string: *self} } - #[inline] - #[deprecated = "replaced by .chars().rev()"] - fn chars_rev(&self) -> RevChars<'a> { - self.chars().rev() - } - #[inline] fn bytes(&self) -> Bytes<'a> { self.as_bytes().iter().map(|&b| b) } - #[inline] - #[deprecated = "replaced by .bytes().rev()"] - fn bytes_rev(&self) -> RevBytes<'a> { - self.bytes().rev() - } - #[inline] fn char_indices(&self) -> CharOffsets<'a> { CharOffsets{string: *self, iter: self.chars()} } - #[inline] - #[deprecated = "replaced by .char_indices().rev()"] - fn char_indices_rev(&self) -> RevCharOffsets<'a> { - self.char_indices().rev() - } - #[inline] fn split(&self, sep: Sep) -> CharSplits<'a, Sep> { CharSplits { @@ -1739,12 +1693,6 @@ impl<'a> StrSlice<'a> for &'a str { } } - #[inline] - #[deprecated = "replaced by .split(sep).rev()"] - fn rsplit(&self, sep: Sep) -> RevCharSplits<'a, Sep> { - self.split(sep).rev() - } - #[inline] fn rsplitn(&self, sep: Sep, count: uint) -> CharSplitsN<'a, Sep> { diff --git a/src/librand/lib.rs b/src/librand/lib.rs index c7a29ff728577..a2486b6e047f4 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -323,12 +323,6 @@ pub trait Rng { } } - /// Shuffle a mutable slice in place. - #[deprecated="renamed to `.shuffle`"] - fn shuffle_mut(&mut self, values: &mut [T]) { - self.shuffle(values) - } - /// Randomly sample up to `n` elements from an iterator. /// /// # Example @@ -387,23 +381,6 @@ pub trait SeedableRng: Rng { fn from_seed(seed: Seed) -> Self; } -/// Create a random number generator with a default algorithm and seed. -/// -/// It returns the strongest `Rng` algorithm currently implemented in -/// pure Rust. If you require a specifically seeded `Rng` for -/// consistency over time you should pick one algorithm and create the -/// `Rng` yourself. -/// -/// This is a very expensive operation as it has to read randomness -/// from the operating system and use this in an expensive seeding -/// operation. If one does not require high performance generation of -/// random numbers, `task_rng` and/or `random` may be more -/// appropriate. -#[deprecated="use `task_rng` or `StdRng::new`"] -pub fn rng() -> StdRng { - StdRng::new().unwrap() -} - /// The standard RNG. This is designed to be efficient on the current /// platform. #[cfg(not(target_word_size="64"))] diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index d7aba4208640a..3765f9f450e61 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -1094,7 +1094,10 @@ impl<'a> SanePrivacyVisitor<'a> { check_inherited(m.span, m.vis, "unnecessary visibility"); } - ast::Required(..) => {} + ast::Required(ref m) => { + check_inherited(m.span, m.vis, + "unnecessary visibility"); + } } } } diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index 5d4350f8fb5cd..7ac2db2184bf4 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -102,7 +102,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader, class: Option<& // miscellaneous, no highlighting t::DOT | t::DOTDOT | t::DOTDOTDOT | t::COMMA | t::SEMI | - t::COLON | t::MOD_SEP | t::LARROW | t::DARROW | t::LPAREN | + t::COLON | t::MOD_SEP | t::LARROW | t::LPAREN | t::RPAREN | t::LBRACKET | t::LBRACE | t::RBRACE => "", t::DOLLAR => { if t::is_ident(&lexer.peek().tok) { diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 2960d55f337c7..b6550a9d77bd6 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -96,28 +96,16 @@ pub use Path = self::windows::Path; /// Typedef for the platform-native component iterator #[cfg(unix)] pub use Components = self::posix::Components; -/// Typedef for the platform-native reverse component iterator -#[cfg(unix)] -pub use RevComponents = self::posix::RevComponents; /// Typedef for the platform-native component iterator #[cfg(windows)] pub use Components = self::windows::Components; -/// Typedef for the platform-native reverse component iterator -#[cfg(windows)] -pub use RevComponents = self::windows::RevComponents; /// Typedef for the platform-native str component iterator #[cfg(unix)] pub use StrComponents = self::posix::StrComponents; -/// Typedef for the platform-native reverse str component iterator -#[cfg(unix)] -pub use RevStrComponents = self::posix::RevStrComponents; /// Typedef for the platform-native str component iterator #[cfg(windows)] pub use StrComponents = self::windows::StrComponents; -/// Typedef for the platform-native reverse str component iterator -#[cfg(windows)] -pub use RevStrComponents = self::windows::RevStrComponents; /// Alias for the platform-native separator character. #[cfg(unix)] diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index 4f7132dc6e442..9517d6618a9b6 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -16,7 +16,7 @@ use clone::Clone; use cmp::{Eq, TotalEq}; use from_str::FromStr; use io::Writer; -use iter::{DoubleEndedIterator, Rev, AdditiveIterator, Extendable, Iterator, Map}; +use iter::{DoubleEndedIterator, AdditiveIterator, Extendable, Iterator, Map}; use option::{Option, None, Some}; use str; use str::Str; @@ -28,16 +28,10 @@ use super::{BytesContainer, GenericPath, GenericPathUnsafe}; /// Iterator that yields successive components of a Path as &[u8] pub type Components<'a> = Splits<'a, u8>; -/// Iterator that yields components of a Path in reverse as &[u8] -#[deprecated = "replaced by Rev>"] -pub type RevComponents<'a> = Rev>; /// Iterator that yields successive components of a Path as Option<&str> pub type StrComponents<'a> = Map<'a, &'a [u8], Option<&'a str>, Components<'a>>; -/// Iterator that yields components of a Path in reverse as Option<&str> -#[deprecated = "replaced by Rev>"] -pub type RevStrComponents<'a> = Rev>; /// Represents a POSIX file path #[deriving(Clone)] @@ -414,25 +408,11 @@ impl Path { ret } - /// Returns an iterator that yields each component of the path in reverse. - /// See components() for details. - #[deprecated = "replaced by .components().rev()"] - pub fn rev_components<'a>(&'a self) -> Rev> { - self.components().rev() - } - /// Returns an iterator that yields each component of the path as Option<&str>. /// See components() for details. pub fn str_components<'a>(&'a self) -> StrComponents<'a> { self.components().map(str::from_utf8) } - - /// Returns an iterator that yields each component of the path in reverse as Option<&str>. - /// See components() for details. - #[deprecated = "replaced by .str_components().rev()"] - pub fn rev_str_components<'a>(&'a self) -> Rev> { - self.str_components().rev() - } } // None result means the byte vector didn't need normalizing diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 176788edcc466..be9472338cdf0 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -17,7 +17,7 @@ use cmp::{Eq, TotalEq}; use container::Container; use from_str::FromStr; use io::Writer; -use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Rev, Iterator, Map}; +use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Iterator, Map}; use mem; use option::{Option, Some, None}; use slice::{Vector, OwnedVector, ImmutableVector}; @@ -33,19 +33,10 @@ use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe}; /// every component in WindowsPath is guaranteed to be Some. pub type StrComponents<'a> = Map<'a, &'a str, Option<&'a str>, CharSplits<'a, char>>; -/// Iterator that yields components of a Path in reverse as &str -/// -/// Each component is yielded as Option<&str> for compatibility with PosixPath, but -/// every component in WindowsPath is guaranteed to be Some. -#[deprecated = "replaced by Rev>"] -pub type RevStrComponents<'a> = Rev>; /// Iterator that yields successive components of a Path as &[u8] pub type Components<'a> = Map<'a, Option<&'a str>, &'a [u8], StrComponents<'a>>; -/// Iterator that yields components of a Path in reverse as &[u8] -#[deprecated = "replaced by Rev>"] -pub type RevComponents<'a> = Rev>; /// Represents a Windows path // Notes for Windows path impl: @@ -650,13 +641,6 @@ impl Path { ret } - /// Returns an iterator that yields each component of the path in reverse as an Option<&str> - /// See str_components() for details. - #[deprecated = "replaced by .str_components().rev()"] - pub fn rev_str_components<'a>(&'a self) -> Rev> { - self.str_components().rev() - } - /// Returns an iterator that yields each component of the path in turn as a &[u8]. /// See str_components() for details. pub fn components<'a>(&'a self) -> Components<'a> { @@ -667,13 +651,6 @@ impl Path { self.str_components().map(convert) } - /// Returns an iterator that yields each component of the path in reverse as a &[u8]. - /// See str_components() for details. - #[deprecated = "replaced by .components().rev()"] - pub fn rev_components<'a>(&'a self) -> Rev> { - self.components().rev() - } - fn equiv_prefix(&self, other: &Path) -> bool { let s_repr = self.repr.as_slice(); let o_repr = other.repr.as_slice(); diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs index e78122f699d40..4f7bb2aec087f 100644 --- a/src/libstd/slice.rs +++ b/src/libstd/slice.rs @@ -116,7 +116,7 @@ use vec::Vec; pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows}; pub use core::slice::{Chunks, Vector, ImmutableVector, ImmutableEqVector}; pub use core::slice::{ImmutableTotalOrdVector, MutableVector, Items, MutItems}; -pub use core::slice::{RevItems, RevMutItems, MutSplits, MutChunks}; +pub use core::slice::{MutSplits, MutChunks}; pub use core::slice::{bytes, MutableCloneableVector}; // Functional utilities @@ -403,10 +403,6 @@ pub trait OwnedVector { /// } /// ``` fn move_iter(self) -> MoveItems; - /// Creates a consuming iterator that moves out of the vector in - /// reverse order. - #[deprecated = "replaced by .move_iter().rev()"] - fn move_rev_iter(self) -> Rev>; /** * Partitions the vector into two vectors `(A,B)`, where all @@ -425,12 +421,6 @@ impl OwnedVector for ~[T] { } } - #[inline] - #[deprecated = "replaced by .move_iter().rev()"] - fn move_rev_iter(self) -> Rev> { - self.move_iter().rev() - } - #[inline] fn partition(self, f: |&T| -> bool) -> (Vec, Vec) { let mut lefts = Vec::new(); @@ -776,10 +766,6 @@ impl Drop for MoveItems { } } -/// An iterator that moves out of a vector in reverse order. -#[deprecated = "replaced by Rev>"] -pub type RevMoveItems = Rev>; - #[cfg(test)] mod tests { use prelude::*; diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 617887e8af3ea..0c77830ee86fd 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -93,8 +93,8 @@ use slice::{ImmutableVector, MutableVector, CloneableVector}; use strbuf::StrBuf; use vec::Vec; -pub use core::str::{from_utf8, CharEq, Chars, CharOffsets, RevChars}; -pub use core::str::{RevCharOffsets, Bytes, RevBytes, CharSplits, RevCharSplits}; +pub use core::str::{from_utf8, CharEq, Chars, CharOffsets}; +pub use core::str::{Bytes, CharSplits}; pub use core::str::{CharSplitsN, Words, AnyLines, MatchIndices, StrSplits}; pub use core::str::{eq_slice, eq, is_utf8, is_utf16, UTF16Items}; pub use core::str::{UTF16Item, ScalarValue, LoneSurrogate, utf16_items}; diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index e7f892d77ceaa..d4c01746098ea 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -689,6 +689,7 @@ pub struct TypeMethod { pub explicit_self: ExplicitSelf, pub id: NodeId, pub span: Span, + pub vis: Visibility, } // A trait method is either required (meaning it doesn't have an diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index ffb18e17bdaeb..370bc703b1069 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -305,6 +305,7 @@ pub fn trait_method_to_ty_method(method: &TraitMethod) -> TypeMethod { explicit_self: m.explicit_self, id: m.id, span: m.span, + vis: m.vis, } } } diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index b3eec136c7d69..e0561c77d59cd 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -543,7 +543,6 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr { MOD_SEP => "MOD_SEP", RARROW => "RARROW", LARROW => "LARROW", - DARROW => "DARROW", FAT_ARROW => "FAT_ARROW", LPAREN => "LPAREN", RPAREN => "RPAREN", diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 10df264676e33..9813e12de01ca 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -648,6 +648,7 @@ pub fn noop_fold_type_method(m: &TypeMethod, fld: &mut T) -> TypeMeth generics: fold_generics(&m.generics, fld), explicit_self: fld.fold_explicit_self(&m.explicit_self), span: fld.new_span(m.span), + vis: m.vis, } } diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index c78d2aaf3a7e8..317ba977c56b5 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -790,10 +790,7 @@ fn next_token_inner(rdr: &mut StringReader) -> token::Token { '<' => { return binop(rdr, token::SHL); } '-' => { bump(rdr); - match rdr.curr.unwrap_or('\x00') { - '>' => { bump(rdr); return token::DARROW; } - _ => { return token::LARROW; } - } + return token::LARROW; } _ => { return token::LT; } } diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index b6aa47128e630..130bbae5b797c 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -25,21 +25,6 @@ use parse::token; /// The specific types of unsupported syntax #[deriving(Eq, TotalEq, Hash)] pub enum ObsoleteSyntax { - ObsoleteSwap, - ObsoleteUnsafeBlock, - ObsoleteBareFnType, - ObsoleteMultipleLocalDecl, - ObsoleteUnsafeExternFn, - ObsoleteTraitFuncVisibility, - ObsoleteConstPointer, - ObsoleteLoopAsContinue, - ObsoleteEnumWildcard, - ObsoleteStructWildcard, - ObsoleteVecDotDotWildcard, - ObsoleteMultipleImport, - ObsoleteManagedPattern, - ObsoleteManagedString, - ObsoleteManagedVec, ObsoleteOwnedType, ObsoleteOwnedExpr, ObsoleteOwnedPattern, @@ -64,71 +49,6 @@ impl<'a> ParserObsoleteMethods for Parser<'a> { /// Reports an obsolete syntax non-fatal error. fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax) { let (kind_str, desc) = match kind { - ObsoleteSwap => ( - "swap", - "use std::mem::{swap, replace} instead" - ), - ObsoleteUnsafeBlock => ( - "non-standalone unsafe block", - "use an inner `unsafe { ... }` block instead" - ), - ObsoleteBareFnType => ( - "bare function type", - "use `|A| -> B` or `extern fn(A) -> B` instead" - ), - ObsoleteMultipleLocalDecl => ( - "declaration of multiple locals at once", - "instead of e.g. `let a = 1, b = 2`, write \ - `let (a, b) = (1, 2)`." - ), - ObsoleteUnsafeExternFn => ( - "unsafe external function", - "external functions are always unsafe; remove the `unsafe` \ - keyword" - ), - ObsoleteTraitFuncVisibility => ( - "visibility not necessary", - "trait functions inherit the visibility of the trait itself" - ), - ObsoleteConstPointer => ( - "const pointer", - "instead of `&const Foo` or `@const Foo`, write `&Foo` or \ - `@Foo`" - ), - ObsoleteLoopAsContinue => ( - "`loop` instead of `continue`", - "`loop` is now only used for loops and `continue` is used for \ - skipping iterations" - ), - ObsoleteEnumWildcard => ( - "enum wildcard", - "use `..` instead of `*` for matching all enum fields" - ), - ObsoleteStructWildcard => ( - "struct wildcard", - "use `..` instead of `_` for matching trailing struct fields" - ), - ObsoleteVecDotDotWildcard => ( - "vec slice wildcard", - "use `..` instead of `.._` for matching slices" - ), - ObsoleteMultipleImport => ( - "multiple imports", - "only one import is allowed per `use` statement" - ), - ObsoleteManagedPattern => ( - "managed pointer pattern", - "use a nested `match` expression instead of a managed box \ - pattern" - ), - ObsoleteManagedString => ( - "managed string", - "use `Rc` instead of a managed string" - ), - ObsoleteManagedVec => ( - "managed vector", - "use `Rc<~[T]>` instead of a managed vector" - ), ObsoleteOwnedType => ( "`~` notation for owned pointers", "use `Box` in `std::owned` instead" diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index c42febcd607a1..30a6c6c251604 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -1129,11 +1129,10 @@ impl<'a> Parser<'a> { let attrs = p.parse_outer_attributes(); let lo = p.span.lo; - let vis_span = p.span; - let vis = p.parse_visibility(); - let style = p.parse_fn_style(); // NB: at the moment, trait methods are public by default; this // could change. + let vis = p.parse_visibility(); + let style = p.parse_fn_style(); let ident = p.parse_ident(); let generics = p.parse_generics(); @@ -1149,11 +1148,6 @@ impl<'a> Parser<'a> { token::SEMI => { p.bump(); debug!("parse_trait_methods(): parsing required method"); - // NB: at the moment, visibility annotations on required - // methods are ignored; this could change. - if vis != ast::Inherited { - p.obsolete(vis_span, ObsoleteTraitFuncVisibility); - } Required(TypeMethod { ident: ident, attrs: attrs, @@ -1162,7 +1156,8 @@ impl<'a> Parser<'a> { generics: generics, explicit_self: explicit_self, id: ast::DUMMY_NODE_ID, - span: mk_sp(lo, hi) + span: mk_sp(lo, hi), + vis: vis, }) } token::LBRACE => { @@ -1682,9 +1677,6 @@ impl<'a> Parser<'a> { pub fn parse_mutability(&mut self) -> Mutability { if self.eat_keyword(keywords::Mut) { MutMutable - } else if self.eat_keyword(keywords::Const) { - self.obsolete(self.last_span, ObsoleteConstPointer); - MutImmutable } else { MutImmutable } @@ -2309,20 +2301,7 @@ impl<'a> Parser<'a> { let e = self.parse_prefix_expr(); hi = e.span.hi; // HACK: pretending @[] is a (removed) @-vec - ex = match e.node { - ExprVec(..) | - ExprRepeat(..) => { - self.obsolete(e.span, ObsoleteManagedVec); - // the above error means that no-one will know we're - // lying... hopefully. - ExprVstore(e, ExprVstoreUniq) - } - ExprLit(lit) if lit_is_str(lit) => { - self.obsolete(self.last_span, ObsoleteManagedString); - ExprVstore(e, ExprVstoreUniq) - } - _ => self.mk_unary(UnBox, e) - }; + ex = self.mk_unary(UnBox, e); } token::TILDE => { self.bump(); @@ -2460,13 +2439,6 @@ impl<'a> Parser<'a> { let assign_op = self.mk_assign_op(aop, lhs, rhs); self.mk_expr(lo, rhs.span.hi, assign_op) } - token::DARROW => { - self.obsolete(self.span, ObsoleteSwap); - self.bump(); - // Ignore what we get, this is an error anyway - self.parse_expr(); - self.mk_expr(lo, self.span.hi, ExprBreak(None)) - } _ => { lhs } @@ -2577,37 +2549,10 @@ impl<'a> Parser<'a> { } pub fn parse_loop_expr(&mut self, opt_ident: Option) -> @Expr { - // loop headers look like 'loop {' or 'loop unsafe {' - let is_loop_header = - self.token == token::LBRACE - || (is_ident(&self.token) - && self.look_ahead(1, |t| *t == token::LBRACE)); - - if is_loop_header { - // This is a loop body - let lo = self.last_span.lo; - let body = self.parse_block(); - let hi = body.span.hi; - return self.mk_expr(lo, hi, ExprLoop(body, opt_ident)); - } else { - // This is an obsolete 'continue' expression - if opt_ident.is_some() { - self.span_err(self.last_span, - "a label may not be used with a `loop` expression"); - } - - self.obsolete(self.last_span, ObsoleteLoopAsContinue); - let lo = self.span.lo; - let ex = if Parser::token_is_lifetime(&self.token) { - let lifetime = self.get_lifetime(); - self.bump(); - ExprAgain(Some(lifetime)) - } else { - ExprAgain(None) - }; - let hi = self.span.hi; - return self.mk_expr(lo, hi, ex); - } + let lo = self.last_span.lo; + let body = self.parse_block(); + let hi = body.span.hi; + self.mk_expr(lo, hi, ExprLoop(body, opt_ident)) } // For distingishing between struct literals and blocks @@ -2721,14 +2666,6 @@ impl<'a> Parser<'a> { } else { let subpat = self.parse_pat(); match *subpat { - ast::Pat { id, node: PatWild, span } => { - self.obsolete(self.span, ObsoleteVecDotDotWildcard); - slice = Some(@ast::Pat { - id: id, - node: PatWildMulti, - span: span - }) - }, ast::Pat { node: PatIdent(_, _, _), .. } => { slice = Some(subpat); } @@ -2764,11 +2701,7 @@ impl<'a> Parser<'a> { if self.token == token::RBRACE { break } } - etc = self.token == token::UNDERSCORE || self.token == token::DOTDOT; - if self.token == token::UNDERSCORE { - self.obsolete(self.span, ObsoleteStructWildcard); - } - if etc { + if self.token == token::DOTDOT { self.bump(); if self.token != token::RBRACE { let token_str = self.this_token_to_str(); @@ -2833,18 +2766,6 @@ impl<'a> Parser<'a> { span: mk_sp(lo, hi) } } - // parse @pat - token::AT => { - self.bump(); - let sub = self.parse_pat(); - self.obsolete(self.span, ObsoleteManagedPattern); - let hi = self.last_span.hi; - return @ast::Pat { - id: ast::DUMMY_NODE_ID, - node: PatUniq(sub), - span: mk_sp(lo, hi) - } - } token::TILDE => { // parse ~pat self.bump(); @@ -3001,24 +2922,15 @@ impl<'a> Parser<'a> { let mut args: Vec<@Pat> = Vec::new(); match self.token { token::LPAREN => { - let is_star = self.look_ahead(1, |t| { - match *t { - token::BINOP(token::STAR) => true, - _ => false, - } - }); let is_dotdot = self.look_ahead(1, |t| { match *t { token::DOTDOT => true, _ => false, } }); - if is_star | is_dotdot { + if is_dotdot { // This is a "top constructor only" pat self.bump(); - if is_star { - self.obsolete(self.span, ObsoleteEnumWildcard); - } self.bump(); self.expect(&token::RPAREN); pat = PatEnum(enum_path, None); @@ -3115,10 +3027,6 @@ impl<'a> Parser<'a> { fn parse_let(&mut self) -> @Decl { let lo = self.span.lo; let local = self.parse_local(); - while self.eat(&token::COMMA) { - let _ = self.parse_local(); - self.obsolete(self.span, ObsoleteMultipleLocalDecl); - } return @spanned(lo, self.last_span.hi, DeclLocal(local)); } @@ -3265,9 +3173,6 @@ impl<'a> Parser<'a> { maybe_whole!(no_clone self, NtBlock); let lo = self.span.lo; - if self.eat_keyword(keywords::Unsafe) { - self.obsolete(self.span, ObsoleteUnsafeBlock); - } self.expect(&token::LBRACE); return self.parse_block_tail_(lo, DefaultBlock, Vec::new()); @@ -3280,9 +3185,6 @@ impl<'a> Parser<'a> { maybe_whole!(pair_empty self, NtBlock); let lo = self.span.lo; - if self.eat_keyword(keywords::Unsafe) { - self.obsolete(self.span, ObsoleteUnsafeBlock); - } self.expect(&token::LBRACE); let (inner, next) = self.parse_inner_attrs_and_next(); @@ -4316,12 +4218,7 @@ impl<'a> Parser<'a> { fn parse_item_foreign_fn(&mut self, vis: ast::Visibility, attrs: Vec ) -> @ForeignItem { let lo = self.span.lo; - - // Parse obsolete purity. - let fn_style = self.parse_fn_style(); - if fn_style != NormalFn { - self.obsolete(self.last_span, ObsoleteUnsafeExternFn); - } + self.expect_keyword(keywords::Fn); let (ident, generics) = self.parse_fn_header(); let decl = self.parse_fn_decl(true); @@ -4898,7 +4795,7 @@ impl<'a> Parser<'a> { // parse, e.g., "use a::b::{z,y}" fn parse_use(&mut self) -> ViewItem_ { - return ViewItemUse(self.parse_view_paths()); + return ViewItemUse(self.parse_view_path()); } @@ -5029,17 +4926,6 @@ impl<'a> Parser<'a> { ViewPathSimple(last, path, ast::DUMMY_NODE_ID)); } - // matches view_paths = view_path | view_path , view_paths - fn parse_view_paths(&mut self) -> @ViewPath { - let vp = self.parse_view_path(); - while self.token == token::COMMA { - self.bump(); - self.obsolete(self.last_span, ObsoleteMultipleImport); - let _ = self.parse_view_path(); - } - return vp; - } - // Parses a sequence of items. Stops when it finds program // text that can't be parsed as an item // - mod_items uses extern_mod_allowed = true diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 8758f109042f0..17ce03ba213a2 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -67,7 +67,6 @@ pub enum Token { MOD_SEP, RARROW, LARROW, - DARROW, FAT_ARROW, LPAREN, RPAREN, @@ -183,7 +182,6 @@ pub fn to_str(t: &Token) -> StrBuf { MOD_SEP => "::".to_strbuf(), RARROW => "->".to_strbuf(), LARROW => "<-".to_strbuf(), - DARROW => "<->".to_strbuf(), FAT_ARROW => "=>".to_strbuf(), LPAREN => "(".to_strbuf(), RPAREN => ")".to_strbuf(), @@ -449,45 +447,45 @@ declare_special_idents_and_keywords! { 'strict: (9, As, "as"); (10, Break, "break"); - (11, Const, "const"); - (12, Crate, "crate"); - (13, Else, "else"); - (14, Enum, "enum"); - (15, Extern, "extern"); - (16, False, "false"); - (17, Fn, "fn"); - (18, For, "for"); - (19, If, "if"); - (20, Impl, "impl"); - (21, In, "in"); - (22, Let, "let"); - (23, Loop, "loop"); - (24, Match, "match"); - (25, Mod, "mod"); - (26, Mut, "mut"); - (27, Once, "once"); - (28, Pub, "pub"); - (29, Ref, "ref"); - (30, Return, "return"); + (11, Crate, "crate"); + (12, Else, "else"); + (13, Enum, "enum"); + (14, Extern, "extern"); + (15, False, "false"); + (16, Fn, "fn"); + (17, For, "for"); + (18, If, "if"); + (19, Impl, "impl"); + (20, In, "in"); + (21, Let, "let"); + (22, Loop, "loop"); + (23, Match, "match"); + (24, Mod, "mod"); + (25, Mut, "mut"); + (26, Once, "once"); + (27, Pub, "pub"); + (28, Ref, "ref"); + (29, Return, "return"); // Static and Self are also special idents (prefill de-dupes) (super::STATIC_KEYWORD_NAME, Static, "static"); (super::SELF_KEYWORD_NAME, Self, "self"); - (31, Struct, "struct"); - (32, Super, "super"); - (33, True, "true"); - (34, Trait, "trait"); - (35, Type, "type"); - (36, Unsafe, "unsafe"); - (37, Use, "use"); - (38, Virtual, "virtual"); - (39, While, "while"); - (40, Continue, "continue"); - (41, Proc, "proc"); - (42, Box, "box"); + (30, Struct, "struct"); + (31, Super, "super"); + (32, True, "true"); + (33, Trait, "trait"); + (34, Type, "type"); + (35, Unsafe, "unsafe"); + (36, Use, "use"); + (37, Virtual, "virtual"); + (38, While, "while"); + (39, Continue, "continue"); + (40, Proc, "proc"); + (41, Box, "box"); 'reserved: - (43, Alignof, "alignof"); - (44, Be, "be"); + (42, Alignof, "alignof"); + (43, Be, "be"); + (44, Const, "const"); (45, Offsetof, "offsetof"); (46, Priv, "priv"); (47, Pure, "pure"); diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs index 7e41fdea778de..27540cc5bbf94 100644 --- a/src/test/bench/noise.rs +++ b/src/test/bench/noise.rs @@ -52,7 +52,7 @@ impl Noise2DContext { for (i, x) in permutations.mut_iter().enumerate() { *x = i as i32; } - rng.shuffle_mut(permutations); + rng.shuffle(permutations); Noise2DContext { rgradients: rgradients, permutations: permutations } } diff --git a/src/test/compile-fail/loop-as-continue.rs b/src/test/compile-fail/loop-as-continue.rs deleted file mode 100644 index e4273fdfeff96..0000000000000 --- a/src/test/compile-fail/loop-as-continue.rs +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright 2013 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -fn main() { - loop { - loop //~ ERROR: `loop` instead of `continue` - } -} diff --git a/src/test/compile-fail/obsolete-syntax.rs b/src/test/compile-fail/obsolete-syntax.rs deleted file mode 100644 index 9fe5e2031bbf5..0000000000000 --- a/src/test/compile-fail/obsolete-syntax.rs +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright 2013 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -trait A { - pub fn foo(); //~ ERROR: visibility not necessary - pub fn bar(); //~ ERROR: visibility not necessary -} - -fn main() { } diff --git a/src/test/compile-fail/useless-priv2.rs b/src/test/compile-fail/useless-priv2.rs index 29c87e77ac02b..7125a66b294ce 100644 --- a/src/test/compile-fail/useless-priv2.rs +++ b/src/test/compile-fail/useless-priv2.rs @@ -9,6 +9,8 @@ // except according to those terms. pub trait E { - pub fn foo(); //~ ERROR: obsolete syntax + pub fn foo(); //~ ERROR: unnecessary visibility } -trait F { pub fn foo(); } //~ ERROR: obsolete syntax +trait F { pub fn foo(); } //~ ERROR: unnecessary visibility + +fn main() {}