From 0dd4c1e7bd0178ca91ea13dfad6efc4cce728302 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 22 May 2014 10:40:07 -0700 Subject: [PATCH 1/2] Remove a slew of old deprecated functions --- src/libcollections/bitv.rs | 8 +---- src/libcollections/dlist.rs | 19 ----------- src/libcollections/ringbuf.rs | 12 +------ src/libcollections/smallintmap.rs | 16 +-------- src/libcore/slice.rs | 35 -------------------- src/libcore/str.rs | 54 +------------------------------ src/librand/lib.rs | 23 ------------- src/libstd/path/mod.rs | 12 ------- src/libstd/path/posix.rs | 22 +------------ src/libstd/path/windows.rs | 25 +------------- src/libstd/slice.rs | 16 +-------- src/libstd/str.rs | 4 +-- 12 files changed, 9 insertions(+), 237 deletions(-) diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index e2934efa43b..c330d44dd96 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 58ced1beeed..c5fa8286f7d 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 12e4fa8b51f..f45c9685be5 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 fb02ddd6224..8e4e47405e7 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 755c6738b4a..3979a1ad8c8 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 0d820836377..d6a9b42522c 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 c7a29ff7285..a2486b6e047 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/libstd/path/mod.rs b/src/libstd/path/mod.rs index 2960d55f337..b6550a9d77b 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 4f7132dc6e4..9517d6618a9 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 176788edcc4..be9472338cd 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 e78122f699d..4f7bb2aec08 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 617887e8af3..0c77830ee86 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}; From 33573bc0aaec14c55adbe6be314f761f34f8cdd0 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 22 May 2014 10:49:26 -0700 Subject: [PATCH 2/2] syntax: Clean out obsolete syntax parsing All of these features have been obsolete since February 2014, where most have been obsolete since 2013. There shouldn't be any more need to keep around the parser hacks after this length of time. --- src/librustc/middle/privacy.rs | 5 +- src/librustdoc/html/highlight.rs | 2 +- src/libsyntax/ast.rs | 1 + src/libsyntax/ast_util.rs | 1 + src/libsyntax/ext/quote.rs | 1 - src/libsyntax/fold.rs | 1 + src/libsyntax/parse/lexer.rs | 5 +- src/libsyntax/parse/obsolete.rs | 80 ------------- src/libsyntax/parse/parser.rs | 140 ++-------------------- src/libsyntax/parse/token.rs | 70 ++++++----- src/test/bench/noise.rs | 2 +- src/test/compile-fail/loop-as-continue.rs | 15 --- src/test/compile-fail/obsolete-syntax.rs | 16 --- src/test/compile-fail/useless-priv2.rs | 6 +- 14 files changed, 61 insertions(+), 284 deletions(-) delete mode 100644 src/test/compile-fail/loop-as-continue.rs delete mode 100644 src/test/compile-fail/obsolete-syntax.rs diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index d7aba420864..3765f9f450e 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 5d4350f8fb5..7ac2db2184b 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/libsyntax/ast.rs b/src/libsyntax/ast.rs index e7f892d77ce..d4c01746098 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 ffb18e17bda..370bc703b10 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 b3eec136c7d..e0561c77d59 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 10df264676e..9813e12de01 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 c78d2aaf3a7..317ba977c56 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 b6aa47128e6..130bbae5b79 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 c42febcd607..30a6c6c2516 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 8758f109042..17ce03ba213 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 7e41fdea778..27540cc5bbf 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 e4273fdfeff..00000000000 --- 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 9fe5e2031bb..00000000000 --- 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 29c87e77ac0..7125a66b294 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() {}