diff options
| author | bors <bors@rust-lang.org> | 2014-10-31 02:27:15 +0000 |
|---|---|---|
| committer | bors <bors@rust-lang.org> | 2014-10-31 02:27:15 +0000 |
| commit | 221fc1e3cdcc208e1bb7debcc2de27d47c847747 (patch) | |
| tree | 5e2d393fe5a4a94cd6a09d93f4ddcf5a4f6aecaa /src | |
| parent | a12d06b73fcb38cf23dfe71da725428a1094395f (diff) | |
| parent | 6fcba8826fd26028341a35d88b07208378ac05ea (diff) | |
| download | rust-221fc1e3cdcc208e1bb7debcc2de27d47c847747.tar.gz rust-221fc1e3cdcc208e1bb7debcc2de27d47c847747.zip | |
auto merge of #18459 : alexcrichton/rust/rollup, r=alexcrichton
Diffstat (limited to 'src')
257 files changed, 1170 insertions, 1439 deletions
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index a9edad3add6..a40913a5db2 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -1013,7 +1013,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> , if prefix_matches(line, prefixes[i].as_slice()) && line.contains(ee.kind.as_slice()) && line.contains(ee.msg.as_slice()) { - *found_flags.get_mut(i) = true; + found_flags[i] = true; was_expected = true; break; } diff --git a/src/doc/complement-bugreport.md b/src/doc/complement-bugreport.md index 1afd17d77d5..940a4ca6db7 100644 --- a/src/doc/complement-bugreport.md +++ b/src/doc/complement-bugreport.md @@ -47,7 +47,7 @@ release: 0.12.0 ``` Finally, if you can run the offending command under gdb, pasting a stack trace can be -useful; to do so, you will need to set a breakpoint on `rust_fail`. +useful; to do so, you will need to set a breakpoint on `rust_panic`. # I submitted a bug, but nobody has commented on it! diff --git a/src/doc/guide-lifetimes.md b/src/doc/guide-lifetimes.md index dd79d63d514..b6ea1ddb394 100644 --- a/src/doc/guide-lifetimes.md +++ b/src/doc/guide-lifetimes.md @@ -56,7 +56,7 @@ a reference. fn compute_distance(p1: &Point, p2: &Point) -> f64 { let x_d = p1.x - p2.x; let y_d = p1.y - p2.y; - sqrt(x_d * x_d + y_d * y_d) + (x_d * x_d + y_d * y_d).sqrt() } ~~~ diff --git a/src/doc/reference.md b/src/doc/reference.md index 44705123ed8..084309e9978 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -1153,7 +1153,7 @@ exposing an API making it possible for it to occur in safe code. * Data races * Dereferencing a null/dangling raw pointer -* Mutating an immutable value/reference +* Mutating an immutable value/reference without `UnsafeCell` * Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values) (uninitialized) memory * Breaking the [pointer aliasing @@ -1166,11 +1166,14 @@ exposing an API making it possible for it to occur in safe code. * Using `std::ptr::copy_nonoverlapping_memory` (`memcpy32`/`memcpy64` instrinsics) on overlapping buffers * Invalid values in primitive types, even in private fields/locals: - * Dangling/null pointers in non-raw pointers, or slices + * Dangling/null references or boxes * A value other than `false` (0) or `true` (1) in a `bool` * A discriminant in an `enum` not included in the type definition * A value in a `char` which is a surrogate or above `char::MAX` * non-UTF-8 byte sequences in a `str` +* Unwinding into Rust from foreign code or unwinding from Rust into foreign + code. Rust's failure system is not compatible with exception handling in + other languages. Unwinding must be caught and handled at FFI boundaries. ##### Behaviour not considered unsafe diff --git a/src/grammar/verify.rs b/src/grammar/verify.rs index a4345e06164..a4641c40165 100644 --- a/src/grammar/verify.rs +++ b/src/grammar/verify.rs @@ -59,7 +59,7 @@ fn parse_token_list(file: &str) -> HashMap<String, Token> { "FLOAT_SUFFIX" => id(), "INT_SUFFIX" => id(), "SHL" => token::BinOp(token::Shl), - "LBRACE" => token::LBrace, + "LBRACE" => token::OpenDelim(token::Brace), "RARROW" => token::Rarrow, "LIT_STR" => token::LitStr(Name(0)), "DOTDOT" => token::DotDot, @@ -67,12 +67,12 @@ fn parse_token_list(file: &str) -> HashMap<String, Token> { "DOTDOTDOT" => token::DotDotDot, "NOT" => token::Not, "AND" => token::BinOp(token::And), - "LPAREN" => token::LParen, + "LPAREN" => token::OpenDelim(token::Paren), "ANDAND" => token::AndAnd, "AT" => token::At, - "LBRACKET" => token::LBracket, + "LBRACKET" => token::OpenDelim(token::Bracket), "LIT_STR_RAW" => token::LitStrRaw(Name(0), 0), - "RPAREN" => token::RParen, + "RPAREN" => token::CloseDelim(token::Paren), "SLASH" => token::BinOp(token::Slash), "COMMA" => token::Comma, "LIFETIME" => token::Lifetime(ast::Ident { name: Name(0), ctxt: 0 }), @@ -83,7 +83,7 @@ fn parse_token_list(file: &str) -> HashMap<String, Token> { "LIT_CHAR" => token::LitChar(Name(0)), "LIT_BYTE" => token::LitByte(Name(0)), "EQ" => token::Eq, - "RBRACKET" => token::RBracket, + "RBRACKET" => token::CloseDelim(token::Bracket), "COMMENT" => token::Comment, "DOC_COMMENT" => token::DocComment(Name(0)), "DOT" => token::Dot, @@ -91,7 +91,7 @@ fn parse_token_list(file: &str) -> HashMap<String, Token> { "NE" => token::Ne, "GE" => token::Ge, "PERCENT" => token::BinOp(token::Percent), - "RBRACE" => token::RBrace, + "RBRACE" => token::CloseDelim(token::Brace), "BINOP" => token::BinOp(token::Plus), "POUND" => token::Pound, "OROR" => token::OrOr, diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index 924dd5ffed6..0e3010ad30a 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -29,7 +29,7 @@ html_root_url = "http://doc.rust-lang.org/nightly/")] #![feature(unsafe_destructor)] -#![allow(missing_doc)] +#![allow(missing_docs)] use std::cell::{Cell, RefCell}; use std::cmp; @@ -208,13 +208,13 @@ impl Arena { } #[inline] - fn alloc_copy<T>(&self, op: || -> T) -> &T { + fn alloc_copy<T>(&self, op: || -> T) -> &mut T { unsafe { let ptr = self.alloc_copy_inner(mem::size_of::<T>(), mem::min_align_of::<T>()); let ptr = ptr as *mut T; ptr::write(&mut (*ptr), op()); - return &*ptr; + return &mut *ptr; } } @@ -262,7 +262,7 @@ impl Arena { } #[inline] - fn alloc_noncopy<T>(&self, op: || -> T) -> &T { + fn alloc_noncopy<T>(&self, op: || -> T) -> &mut T { unsafe { let tydesc = get_tydesc::<T>(); let (ty_ptr, ptr) = @@ -279,14 +279,14 @@ impl Arena { // the object is there. *ty_ptr = bitpack_tydesc_ptr(tydesc, true); - return &*ptr; + return &mut *ptr; } } /// Allocates a new item in the arena, using `op` to initialize the value, /// and returns a reference to it. #[inline] - pub fn alloc<T>(&self, op: || -> T) -> &T { + pub fn alloc<T>(&self, op: || -> T) -> &mut T { unsafe { if intrinsics::needs_drop::<T>() { self.alloc_noncopy(op) @@ -458,12 +458,12 @@ impl<T> TypedArena<T> { /// Allocates an object in the `TypedArena`, returning a reference to it. #[inline] - pub fn alloc(&self, object: T) -> &T { + pub fn alloc(&self, object: T) -> &mut T { if self.ptr == self.end { self.grow() } - let ptr: &T = unsafe { + let ptr: &mut T = unsafe { let ptr: &mut T = mem::transmute(self.ptr); ptr::write(ptr, object); self.ptr.set(self.ptr.get().offset(1)); diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs index 1e081ae8a4b..1b12fdcb8dc 100644 --- a/src/libcollections/bitv.rs +++ b/src/libcollections/bitv.rs @@ -243,7 +243,7 @@ impl Bitv { let used_bits = bitv.nbits % u32::BITS; if init && used_bits != 0 { let largest_used_word = (bitv.nbits + u32::BITS - 1) / u32::BITS - 1; - *bitv.storage.get_mut(largest_used_word) &= (1 << used_bits) - 1; + bitv.storage[largest_used_word] &= (1 << used_bits) - 1; } bitv @@ -297,8 +297,9 @@ impl Bitv { let w = i / u32::BITS; let b = i % u32::BITS; let flag = 1 << b; - *self.storage.get_mut(w) = if x { self.storage[w] | flag } - else { self.storage[w] & !flag }; + let val = if x { self.storage[w] | flag } + else { self.storage[w] & !flag }; + self.storage[w] = val; } /// Sets all bits to 1. @@ -617,7 +618,7 @@ impl Bitv { self.storage.truncate(word_len); if len % u32::BITS > 0 { let mask = (1 << len % u32::BITS) - 1; - *self.storage.get_mut(word_len - 1) &= mask; + self.storage[word_len - 1] &= mask; } } } @@ -681,15 +682,15 @@ impl Bitv { let overhang = self.nbits % u32::BITS; // # of already-used bits let mask = !((1 << overhang) - 1); // e.g. 5 unused bits => 111110....0 if value { - *self.storage.get_mut(old_last_word) |= mask; + self.storage[old_last_word] |= mask; } else { - *self.storage.get_mut(old_last_word) &= !mask; + self.storage[old_last_word] &= !mask; } } // Fill in words after the old tail word let stop_idx = cmp::min(self.storage.len(), new_nwords); for idx in range(old_last_word + 1, stop_idx) { - *self.storage.get_mut(idx) = full_value; + self.storage[idx] = full_value; } // Allocate new words, if needed if new_nwords > self.storage.len() { @@ -700,7 +701,7 @@ impl Bitv { if value { let tail_word = new_nwords - 1; let used_bits = new_nbits % u32::BITS; - *self.storage.get_mut(tail_word) &= (1 << used_bits) - 1; + self.storage[tail_word] &= (1 << used_bits) - 1; } } // Adjust internal bit count @@ -728,7 +729,7 @@ impl Bitv { let ret = self.get(self.nbits - 1); // If we are unusing a whole word, make sure it is zeroed out if self.nbits % u32::BITS == 1 { - *self.storage.get_mut(self.nbits / u32::BITS) = 0; + self.storage[self.nbits / u32::BITS] = 0; } self.nbits -= 1; ret @@ -1184,7 +1185,7 @@ impl BitvSet { for (i, w) in other_words { let old = self_bitv.storage[i]; let new = f(old, w); - *self_bitv.storage.get_mut(i) = new; + self_bitv.storage[i] = new; } } diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 77fb6d4a120..dc7d935619f 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -690,6 +690,12 @@ impl<K: Ord, V> Index<K, V> for BTreeMap<K, V> { } } +impl<K: Ord, V> IndexMut<K, V> for BTreeMap<K, V> { + fn index_mut(&mut self, key: &K) -> &mut V { + self.find_mut(key).expect("no entry found for key") + } +} + /// Genericises over how to get the correct type of iterator from the correct type /// of Node ownership. trait Traverse<N> { diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs index 16e04b93777..65fd8ce4f54 100644 --- a/src/libcollections/priority_queue.rs +++ b/src/libcollections/priority_queue.rs @@ -71,7 +71,7 @@ //! let mut pq = PriorityQueue::new(); //! //! // We're at `start`, with a zero cost -//! *dist.get_mut(start) = 0u; +//! dist[start] = 0u; //! pq.push(State { cost: 0u, position: start }); //! //! // Examine the frontier with lower cost nodes first (min-heap) @@ -96,7 +96,7 @@ //! if next.cost < dist[next.position] { //! pq.push(next); //! // Relaxation, we have now found a better way -//! *dist.get_mut(next.position) = next.cost; +//! dist[next.position] = next.cost; //! } //! } //! } @@ -151,7 +151,7 @@ //! } //! ``` -#![allow(missing_doc)] +#![allow(missing_docs)] use core::prelude::*; @@ -330,7 +330,7 @@ impl<T: Ord> PriorityQueue<T> { None => { None } Some(mut item) => { if !self.is_empty() { - swap(&mut item, self.data.get_mut(0)); + swap(&mut item, &mut self.data[0]); self.siftdown(0); } Some(item) @@ -378,7 +378,7 @@ impl<T: Ord> PriorityQueue<T> { /// ``` pub fn push_pop(&mut self, mut item: T) -> T { if !self.is_empty() && *self.top().unwrap() > item { - swap(&mut item, self.data.get_mut(0)); + swap(&mut item, &mut self.data[0]); self.siftdown(0); } item @@ -402,7 +402,7 @@ impl<T: Ord> PriorityQueue<T> { /// ``` pub fn replace(&mut self, mut item: T) -> Option<T> { if !self.is_empty() { - swap(&mut item, self.data.get_mut(0)); + swap(&mut item, &mut self.data[0]); self.siftdown(0); Some(item) } else { @@ -462,26 +462,26 @@ impl<T: Ord> PriorityQueue<T> { // compared to using swaps, which involves twice as many moves. fn siftup(&mut self, start: uint, mut pos: uint) { unsafe { - let new = replace(self.data.get_mut(pos), zeroed()); + let new = replace(&mut self.data[pos], zeroed()); while pos > start { let parent = (pos - 1) >> 1; if new > self.data[parent] { - let x = replace(self.data.get_mut(parent), zeroed()); - ptr::write(self.data.get_mut(pos), x); + let x = replace(&mut self.data[parent], zeroed()); + ptr::write(&mut self.data[pos], x); pos = parent; continue } break } - ptr::write(self.data.get_mut(pos), new); + ptr::write(&mut self.data[pos], new); } } fn siftdown_range(&mut self, mut pos: uint, end: uint) { unsafe { let start = pos; - let new = replace(self.data.get_mut(pos), zeroed()); + let new = replace(&mut self.data[pos], zeroed()); let mut child = 2 * pos + 1; while child < end { @@ -489,13 +489,13 @@ impl<T: Ord> PriorityQueue<T> { if right < end && !(self.data[child] > self.data[right]) { child = right; } - let x = replace(self.data.get_mut(child), zeroed()); - ptr::write(self.data.get_mut(pos), x); + let x = replace(&mut self.data[child], zeroed()); + ptr::write(&mut self.data[pos], x); pos = child; child = 2 * pos + 1; } - ptr::write(self.data.get_mut(pos), new); + ptr::write(&mut self.data[pos], new); self.siftup(start, pos); } } diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index 5f05ab7a906..81e4361ec39 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -58,7 +58,7 @@ impl<T> Deque<T> for RingBuf<T> { /// Returns a mutable reference to the first element in the `RingBuf`. fn front_mut<'a>(&'a mut self) -> Option<&'a mut T> { - if self.nelts > 0 { Some(self.get_mut(0)) } else { None } + if self.nelts > 0 { Some(&mut self[0]) } else { None } } /// Returns a reference to the last element in the `RingBuf`. @@ -69,13 +69,13 @@ impl<T> Deque<T> for RingBuf<T> { /// Returns a mutable reference to the last element in the `RingBuf`. fn back_mut<'a>(&'a mut self) -> Option<&'a mut T> { let nelts = self.nelts; - if nelts > 0 { Some(self.get_mut(nelts - 1)) } else { None } + if nelts > 0 { Some(&mut self[nelts - 1]) } else { None } } /// Removes and returns the first element in the `RingBuf`, or `None` if it /// is empty. fn pop_front(&mut self) -> Option<T> { - let result = self.elts.get_mut(self.lo).take(); + let result = self.elts[self.lo].take(); if result.is_some() { self.lo = (self.lo + 1u) % self.elts.len(); self.nelts -= 1u; @@ -91,7 +91,7 @@ impl<T> Deque<T> for RingBuf<T> { if self.lo == 0u { self.lo = self.elts.len() - 1u; } else { self.lo -= 1u; } - *self.elts.get_mut(self.lo) = Some(t); + self.elts[self.lo] = Some(t); self.nelts += 1u; } } @@ -102,14 +102,14 @@ impl<T> MutableSeq<T> for RingBuf<T> { grow(self.nelts, &mut self.lo, &mut self.elts); } let hi = self.raw_index(self.nelts); - *self.elts.get_mut(hi) = Some(t); + self.elts[hi] = Some(t); self.nelts += 1u; } fn pop(&mut self) -> Option<T> { if self.nelts > 0 { self.nelts -= 1; let hi = self.raw_index(self.nelts); - self.elts.get_mut(hi).take() + self.elts[hi].take() } else { None } @@ -140,6 +140,7 @@ impl<T> RingBuf<T> { /// # Example /// /// ```rust + /// # #![allow(deprecated)] /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); @@ -149,12 +150,9 @@ impl<T> RingBuf<T> { /// *buf.get_mut(1) = 7; /// assert_eq!(buf[1], 7); /// ``` + #[deprecated = "use indexing instead: `buf[index] = value`"] pub fn get_mut<'a>(&'a mut self, i: uint) -> &'a mut T { - let idx = self.raw_index(i); - match *self.elts.get_mut(idx) { - None => panic!(), - Some(ref mut v) => v - } + &mut self[i] } /// Swaps elements at indices `i` and `j`. @@ -466,13 +464,16 @@ impl<A> Index<uint, A> for RingBuf<A> { } } -// FIXME(#12825) Indexing will always try IndexMut first and that causes issues. -/*impl<A> IndexMut<uint, A> for RingBuf<A> { +impl<A> IndexMut<uint, A> for RingBuf<A> { #[inline] - fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut A { - self.get_mut(*index) + fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut A { + let idx = self.raw_index(*i); + match *(&mut self.elts[idx]) { + None => panic!(), + Some(ref mut v) => v + } } -}*/ +} impl<A> FromIterator<A> for RingBuf<A> { fn from_iter<T: Iterator<A>>(iterator: T) -> RingBuf<A> { diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 3f60a6d6330..a552e4caa2d 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -109,7 +109,7 @@ pub use core::slice::{Found, NotFound}; // Functional utilities -#[allow(missing_doc)] +#[allow(missing_docs)] pub trait VectorVector<T> for Sized? { // FIXME #5898: calling these .concat and .connect conflicts with // StrVector::con{cat,nect}, since they have generic contents. diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs index 3b509f37c47..9e6485103e1 100644 --- a/src/libcollections/smallintmap.rs +++ b/src/libcollections/smallintmap.rs @@ -11,7 +11,7 @@ //! A simple map based on a vector for small integer keys. Space requirements //! are O(highest integer key). -#![allow(missing_doc)] +#![allow(missing_docs)] use core::prelude::*; @@ -100,7 +100,7 @@ impl<V> MutableMap<uint, V> for SmallIntMap<V> { /// Returns a mutable reference to the value corresponding to the key. fn find_mut<'a>(&'a mut self, key: &uint) -> Option<&'a mut V> { if *key < self.v.len() { - match *self.v.get_mut(*key) { + match *self.v.index_mut(key) { Some(ref mut value) => Some(value), None => None } @@ -118,7 +118,7 @@ impl<V> MutableMap<uint, V> for SmallIntMap<V> { if len <= key { self.v.grow_fn(key - len + 1, |_| None); } - *self.v.get_mut(key) = Some(value); + self.v[key] = Some(value); !exists } @@ -145,7 +145,7 @@ impl<V> MutableMap<uint, V> for SmallIntMap<V> { if *key >= self.v.len() { return None; } - self.v.get_mut(*key).take() + self.v[*key].take() } } @@ -405,13 +405,12 @@ impl<V> Index<uint, V> for SmallIntMap<V> { } } -// FIXME(#12825) Indexing will always try IndexMut first and that causes issues. -/*impl<V> IndexMut<uint, V> for SmallIntMap<V> { +impl<V> IndexMut<uint, V> for SmallIntMap<V> { #[inline] fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut V { self.find_mut(i).expect("key not present") } -}*/ +} macro_rules! iterator { (impl $name:ident -> $elem:ty, $($getter:ident),+) => { diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index 5dd3be4ec8f..86a640d1aeb 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -692,17 +692,17 @@ pub trait StrAllocating: Str { for (i, sc) in me.chars().enumerate() { let mut current = i; - *dcol.get_mut(0) = current + 1; + dcol[0] = current + 1; for (j, tc) in t.chars().enumerate() { let next = dcol[j + 1]; if sc == tc { - *dcol.get_mut(j + 1) = current; + dcol[j + 1] = current; } else { - *dcol.get_mut(j + 1) = cmp::min(current, next); - *dcol.get_mut(j + 1) = cmp::min(dcol[j + 1], dcol[j]) + 1; + dcol[j + 1] = cmp::min(current, next); + dcol[j + 1] = cmp::min(dcol[j + 1], dcol[j]) + 1; } current = next; @@ -1678,40 +1678,6 @@ mod tests { } #[test] - fn test_split_char_iterator() { - let data = "\nMäry häd ä little lämb\nLittle lämb\n"; - - let split: Vec<&str> = data.split(' ').collect(); - assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); - - let mut rsplit: Vec<&str> = data.split(' ').rev().collect(); - rsplit.reverse(); - assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); - - let split: Vec<&str> = data.split(|c: char| c == ' ').collect(); - assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); - - let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect(); - rsplit.reverse(); - assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); - - // Unicode - let split: Vec<&str> = data.split('ä').collect(); - assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); - - let mut rsplit: Vec<&str> = data.split('ä').rev().collect(); - rsplit.reverse(); - assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); - - let split: Vec<&str> = data.split(|c: char| c == 'ä').collect(); - assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); - - let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect(); - rsplit.reverse(); - assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); - } - - #[test] fn test_splitn_char_iterator() { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; @@ -1730,28 +1696,6 @@ mod tests { } #[test] - fn test_rsplitn_char_iterator() { - let data = "\nMäry häd ä little lämb\nLittle lämb\n"; - - let mut split: Vec<&str> = data.rsplitn(3, ' ').collect(); - split.reverse(); - assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); - - let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == ' ').collect(); - split.reverse(); - assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); - - // Unicode - let mut split: Vec<&str> = data.rsplitn(3, 'ä').collect(); - split.reverse(); - assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); - - let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == 'ä').collect(); - split.reverse(); - assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); - } - - #[test] fn test_split_char_iterator_no_trailing() { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; @@ -1763,19 +1707,6 @@ mod tests { } #[test] - fn test_rev_split_char_iterator_no_trailing() { - let data = "\nMäry häd ä little lämb\nLittle lämb\n"; - - let mut split: Vec<&str> = data.split('\n').rev().collect(); - split.reverse(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb", ""]); - - let mut split: Vec<&str> = data.split_terminator('\n').rev().collect(); - split.reverse(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb"]); - } - - #[test] fn test_words() { let data = "\n \tMäry häd\tä little lämb\nLittle lämb\n"; let words: Vec<&str> = data.words().collect(); diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index b61f26688a2..507cfbf191c 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -744,6 +744,11 @@ impl ops::Slice<uint, str> for String { } } +#[experimental = "waiting on Deref stabilization"] +impl ops::Deref<str> for String { + fn deref<'a>(&'a self) -> &'a str { self.as_slice() } +} + /// Wrapper type providing a `&String` reference via `Deref`. #[experimental] pub struct DerefString<'a> { diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs index feb4c11a061..ea4d541aab9 100644 --- a/src/libcollections/treemap.rs +++ b/src/libcollections/treemap.rs @@ -257,12 +257,12 @@ impl<K: Ord, V> Index<K, V> for TreeMap<K, V> { } } -/*impl<K: Ord, V> IndexMut<K, V> for TreeMap<K, V> { +impl<K: Ord, V> IndexMut<K, V> for TreeMap<K, V> { #[inline] fn index_mut<'a>(&'a mut self, i: &K) -> &'a mut V { self.find_mut(i).expect("no entry found for key") } -}*/ +} impl<K: Ord, V> TreeMap<K, V> { /// Creates an empty `TreeMap`. diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs index d02190e0824..8c18a6488ba 100644 --- a/src/libcollections/trie.rs +++ b/src/libcollections/trie.rs @@ -515,13 +515,12 @@ impl<T> Index<uint, T> for TrieMap<T> { } } -// FIXME(#12825) Indexing will always try IndexMut first and that causes issues. -/*impl<T> IndexMut<uint, T> for TrieMap<T> { +impl<T> IndexMut<uint, T> for TrieMap<T> { #[inline] fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut T { self.find_mut(i).expect("key not present") } -}*/ +} /// A set implemented as a radix trie. /// diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 759f9ec7d3f..b190093bafc 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -28,8 +28,7 @@ use core::raw::Slice as RawSlice; use core::uint; use {Mutable, MutableSeq}; -use slice::{MutableOrdSlice, MutableSliceAllocating, CloneableVector}; -use slice::{Items, MutItems}; +use slice::{CloneableVector}; /// An owned, growable vector. /// @@ -46,7 +45,7 @@ use slice::{Items, MutItems}; /// assert_eq!(vec.pop(), Some(2)); /// assert_eq!(vec.len(), 1); /// -/// *vec.get_mut(0) = 7i; +/// vec[0] = 7i; /// assert_eq!(vec[0], 7); /// /// vec.push_all([1, 2, 3]); @@ -414,11 +413,10 @@ impl<T> Index<uint,T> for Vec<T> { } } -#[cfg(not(stage0))] impl<T> IndexMut<uint,T> for Vec<T> { #[inline] fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T { - self.get_mut(*index) + &mut self.as_mut_slice()[*index] } } @@ -464,6 +462,16 @@ impl<T> ops::SliceMut<uint, [T]> for Vec<T> { } } +#[experimental = "waiting on Deref stability"] +impl<T> ops::Deref<[T]> for Vec<T> { + fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() } +} + +#[experimental = "waiting on DerefMut stability"] +impl<T> ops::DerefMut<[T]> for Vec<T> { + fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() } +} + #[experimental = "waiting on FromIterator stability"] impl<T> FromIterator<T> for Vec<T> { #[inline] @@ -712,14 +720,6 @@ impl<T> Vec<T> { } } - /// Deprecated, use `.extend(other.into_iter())` - #[inline] - #[deprecated = "use .extend(other.into_iter())"] - #[cfg(stage0)] - pub fn push_all_move(&mut self, other: Vec<T>) { - self.extend(other.into_iter()); - } - /// Returns a mutable slice of the elements of `self`. /// /// # Example @@ -735,7 +735,7 @@ impl<T> Vec<T> { pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] { unsafe { mem::transmute(RawSlice { - data: self.as_mut_ptr() as *const T, + data: self.ptr as *const T, len: self.len, }) } @@ -799,134 +799,17 @@ impl<T> Vec<T> { /// # Example /// /// ``` + /// # #![allow(deprecated)] /// let mut vec = vec![1i, 2, 3]; /// *vec.get_mut(1) = 4; /// assert_eq!(vec, vec![1i, 4, 3]); /// ``` #[inline] - #[unstable = "this is likely to be moved to actual indexing"] + #[deprecated = "use `foo[index] = bar` instead"] pub fn get_mut<'a>(&'a mut self, index: uint) -> &'a mut T { &mut self.as_mut_slice()[index] } - /// Returns an iterator over references to the elements of the vector in - /// order. - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3]; - /// for num in vec.iter() { - /// println!("{}", *num); - /// } - /// ``` - #[inline] - pub fn iter<'a>(&'a self) -> Items<'a,T> { - self.as_slice().iter() - } - - /// Returns an iterator over mutable references to the elements of the - /// vector in order. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2, 3]; - /// for num in vec.iter_mut() { - /// *num = 0; - /// } - /// assert_eq!(vec, vec![0i, 0, 0]); - /// ``` - #[inline] - pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a,T> { - self.as_mut_slice().iter_mut() - } - - /// Sorts the vector, in place, using `compare` to compare elements. - /// - /// This sort is `O(n log n)` worst-case and stable, but allocates - /// approximately `2 * n`, where `n` is the length of `self`. - /// - /// # Example - /// - /// ``` - /// let mut v = vec![5i, 4, 1, 3, 2]; - /// v.sort_by(|a, b| a.cmp(b)); - /// assert_eq!(v, vec![1i, 2, 3, 4, 5]); - /// - /// // reverse sorting - /// v.sort_by(|a, b| b.cmp(a)); - /// assert_eq!(v, vec![5i, 4, 3, 2, 1]); - /// ``` - #[inline] - pub fn sort_by(&mut self, compare: |&T, &T| -> Ordering) { - self.as_mut_slice().sort_by(compare) - } - - /// Returns a slice of self spanning the interval [`start`, `end`). - /// - /// # Failure - /// - /// Fails when the slice (or part of it) is outside the bounds of self, or when - /// `start` > `end`. - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3, 4]; - /// assert!(vec[0..2] == [1, 2]); - /// ``` - #[inline] - pub fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T] { - self[start..end] - } - - /// Returns a slice containing all but the first element of the vector. - /// - /// # Failure - /// - /// Fails when the vector is empty. - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3]; - /// assert!(vec.tail() == [2, 3]); - /// ``` - #[inline] - pub fn tail<'a>(&'a self) -> &'a [T] { - self[].tail() - } - - /// Returns a reference to the last element of a vector, or `None` if it is - /// empty. - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3]; - /// assert!(vec.last() == Some(&3)); - /// ``` - #[inline] - pub fn last<'a>(&'a self) -> Option<&'a T> { - self[].last() - } - - /// Returns a mutable reference to the last element of a vector, or `None` - /// if it is empty. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2, 3]; - /// *vec.last_mut().unwrap() = 4; - /// assert_eq!(vec, vec![1i, 2, 4]); - /// ``` - #[inline] - pub fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> { - self.as_mut_slice().last_mut() - } - /// Removes an element from anywhere in the vector and return it, replacing /// it with the last element. This does not preserve ordering, but is O(1). /// @@ -1035,215 +918,6 @@ impl<T> Vec<T> { } } - /// Returns a mutable slice of `self` between `start` and `end`. - /// - /// # Failure - /// - /// Fails when `start` or `end` point outside the bounds of `self`, or when - /// `start` > `end`. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2, 3, 4]; - /// assert!(vec[mut 0..2] == [1, 2]); - /// ``` - #[inline] - pub fn slice_mut<'a>(&'a mut self, start: uint, end: uint) - -> &'a mut [T] { - self[mut start..end] - } - - /// Returns a mutable slice of `self` from `start` to the end of the `Vec`. - /// - /// # Failure - /// - /// Fails when `start` points outside the bounds of self. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2, 3, 4]; - /// assert!(vec[mut 2..] == [3, 4]); - /// ``` - #[inline] - pub fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] { - self[mut start..] - } - - /// Returns a mutable slice of `self` from the start of the `Vec` to `end`. - /// - /// # Failure - /// - /// Fails when `end` points outside the bounds of self. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2, 3, 4]; - /// assert!(vec[mut ..2] == [1, 2]); - /// ``` - #[inline] - pub fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] { - self[mut ..end] - } - - /// Returns a pair of mutable slices that divides the `Vec` at an index. - /// - /// The first will contain all indices from `[0, mid)` (excluding - /// the index `mid` itself) and the second will contain all - /// indices from `[mid, len)` (excluding the index `len` itself). - /// - /// # Failure - /// - /// Fails if `mid > len`. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![1i, 2, 3, 4, 5, 6]; - /// - /// // scoped to restrict the lifetime of the borrows - /// { - /// let (left, right) = vec.split_at_mut(0); - /// assert!(left == &mut []); - /// assert!(right == &mut [1, 2, 3, 4, 5, 6]); - /// } - /// - /// { - /// let (left, right) = vec.split_at_mut(2); - /// assert!(left == &mut [1, 2]); - /// assert!(right == &mut [3, 4, 5, 6]); - /// } - /// - /// { - /// let (left, right) = vec.split_at_mut(6); - /// assert!(left == &mut [1, 2, 3, 4, 5, 6]); - /// assert!(right == &mut []); - /// } - /// ``` - #[inline] - pub fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) { - self[mut].split_at_mut(mid) - } - - /// Reverses the order of elements in a vector, in place. - /// - /// # Example - /// - /// ``` - /// let mut v = vec![1i, 2, 3]; - /// v.reverse(); - /// assert_eq!(v, vec![3i, 2, 1]); - /// ``` - #[inline] - pub fn reverse(&mut self) { - self[mut].reverse() - } - - /// Returns a slice of `self` from `start` to the end of the vec. - /// - /// # Failure - /// - /// Fails when `start` points outside the bounds of self. - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3]; - /// assert!(vec[1..] == [2, 3]); - /// ``` - #[inline] - pub fn slice_from<'a>(&'a self, start: uint) -> &'a [T] { - self[start..] - } - - /// Returns a slice of self from the start of the vec to `end`. - /// - /// # Failure - /// - /// Fails when `end` points outside the bounds of self. - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3, 4]; - /// assert!(vec[..2] == [1, 2]); - /// ``` - #[inline] - pub fn slice_to<'a>(&'a self, end: uint) -> &'a [T] { - self[..end] - } - - /// Returns a slice containing all but the last element of the vector. - /// - /// # Failure - /// - /// Fails if the vector is empty - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3]; - /// assert!(vec.init() == [1, 2]); - /// ``` - #[inline] - pub fn init<'a>(&'a self) -> &'a [T] { - self[0..self.len() - 1] - } - - - /// Returns an unsafe pointer to the vector's buffer. - /// - /// The caller must ensure that the vector outlives the pointer this - /// function returns, or else it will end up pointing to garbage. - /// - /// Modifying the vector may cause its buffer to be reallocated, which - /// would also make any pointers to it invalid. - /// - /// # Example - /// - /// ``` - /// let v = vec![1i, 2, 3]; - /// let p = v.as_ptr(); - /// unsafe { - /// // Examine each element manually - /// assert_eq!(*p, 1i); - /// assert_eq!(*p.offset(1), 2i); - /// assert_eq!(*p.offset(2), 3i); - /// } - /// ``` - #[inline] - pub fn as_ptr(&self) -> *const T { - self.ptr as *const T - } - - /// Returns a mutable unsafe pointer to the vector's buffer. - /// - /// The caller must ensure that the vector outlives the pointer this - /// function returns, or else it will end up pointing to garbage. - /// - /// Modifying the vector may cause its buffer to be reallocated, which - /// would also make any pointers to it invalid. - /// - /// # Example - /// - /// ``` - /// use std::ptr; - /// - /// let mut v = vec![1i, 2, 3]; - /// let p = v.as_mut_ptr(); - /// unsafe { - /// ptr::write(p, 9i); - /// ptr::write(p.offset(2), 5i); - /// } - /// assert_eq!(v, vec![9i, 2, 5]); - /// ``` - #[inline] - pub fn as_mut_ptr(&mut self) -> *mut T { - self.ptr - } - /// Retains only the elements specified by the predicate. /// /// In other words, remove all elements `e` such that `f(&e)` returns false. @@ -1297,24 +971,6 @@ impl<T> Vec<T> { } } -impl<T:Ord> Vec<T> { - /// Sorts the vector in place. - /// - /// This sort is `O(n log n)` worst-case and stable, but allocates - /// approximately `2 * n`, where `n` is the length of `self`. - /// - /// # Example - /// - /// ``` - /// let mut vec = vec![3i, 1, 2]; - /// vec.sort(); - /// assert_eq!(vec, vec![1, 2, 3]); - /// ``` - pub fn sort(&mut self) { - self.as_mut_slice().sort() - } -} - #[experimental = "waiting on Mutable stability"] impl<T> Mutable for Vec<T> { #[inline] @@ -1325,19 +981,6 @@ impl<T> Mutable for Vec<T> { } impl<T: PartialEq> Vec<T> { - /// Returns true if a vector contains an element equal to the given value. - /// - /// # Example - /// - /// ``` - /// let vec = vec![1i, 2, 3]; - /// assert!(vec.contains(&1)); - /// ``` - #[inline] - pub fn contains(&self, x: &T) -> bool { - self.as_slice().contains(x) - } - /// Removes consecutive repeated elements in the vector. /// /// If the vector is sorted, this removes all duplicates. @@ -1449,7 +1092,12 @@ impl<T> AsSlice<T> for Vec<T> { #[inline] #[stable] fn as_slice<'a>(&'a self) -> &'a [T] { - unsafe { mem::transmute(RawSlice { data: self.as_ptr(), len: self.len }) } + unsafe { + mem::transmute(RawSlice { + data: self.ptr as *const T, + len: self.len + }) + } } } @@ -1697,6 +1345,7 @@ pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> { pub mod raw { use super::Vec; use core::ptr; + use core::slice::MutableSlice; /// Constructs a vector from an unsafe pointer to a buffer. /// diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 79191c5a2b4..b8a91a912ba 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(missing_doc)] +#![allow(missing_docs)] use char; use collections::Collection; diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 093f5896aad..65107d6ab7d 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -10,7 +10,7 @@ //! Utilities for formatting and printing strings -#![allow(unused_variable)] +#![allow(unused_variables)] use any; use cell::{Cell, Ref, RefMut}; @@ -733,7 +733,7 @@ macro_rules! tuple ( () => (); ( $($name:ident,)+ ) => ( impl<$($name:Show),*> Show for ($($name,)*) { - #[allow(non_snake_case, dead_assignment)] + #[allow(non_snake_case, unused_assignments)] fn fmt(&self, f: &mut Formatter) -> Result { try!(write!(f, "(")); let ($(ref $name,)*) = *self; diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 22d8ba63b20..568528f6ae2 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -12,7 +12,7 @@ // FIXME: #6220 Implement floating point formatting -#![allow(unsigned_negate)] +#![allow(unsigned_negation)] use collections::Collection; use fmt; diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 68b3ca96de1..9d5c2113cb2 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -42,7 +42,7 @@ A quick refresher on memory ordering: */ #![experimental] -#![allow(missing_doc)] +#![allow(missing_docs)] pub type GlueFn = extern "Rust" fn(*const i8); @@ -57,107 +57,10 @@ pub struct TyDesc { // Called when a value of type `T` is no longer needed pub drop_glue: GlueFn, - // Called by reflection visitor to visit a value of type `T` - #[cfg(stage0)] - pub visit_glue: GlueFn, - // Name corresponding to the type pub name: &'static str, } -#[cfg(stage0)] -#[lang="opaque"] -pub enum Opaque { } - -#[cfg(stage0)] -pub type Disr = u64; - -#[cfg(stage0)] -#[lang="ty_visitor"] -pub trait TyVisitor { - fn visit_bot(&mut self) -> bool; - fn visit_nil(&mut self) -> bool; - fn visit_bool(&mut self) -> bool; - - fn visit_int(&mut self) -> bool; - fn visit_i8(&mut self) -> bool; - fn visit_i16(&mut self) -> bool; - fn visit_i32(&mut self) -> bool; - fn visit_i64(&mut self) -> bool; - - fn visit_uint(&mut self) -> bool; - fn visit_u8(&mut self) -> bool; - fn visit_u16(&mut self) -> bool; - fn visit_u32(&mut self) -> bool; - fn visit_u64(&mut self) -> bool; - - fn visit_f32(&mut self) -> bool; - fn visit_f64(&mut self) -> bool; - - fn visit_char(&mut self) -> bool; - - fn visit_estr_slice(&mut self) -> bool; - - fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; - fn visit_uniq(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; - fn visit_ptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; - fn visit_rptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; - - fn visit_evec_slice(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; - fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint, - inner: *const TyDesc) -> bool; - - fn visit_enter_rec(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - fn visit_rec_field(&mut self, i: uint, name: &str, - mtbl: uint, inner: *const TyDesc) -> bool; - fn visit_leave_rec(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - - fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, - sz: uint, align: uint) -> bool; - fn visit_class_field(&mut self, i: uint, name: &str, named: bool, - mtbl: uint, inner: *const TyDesc) -> bool; - fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, - sz: uint, align: uint) -> bool; - - fn visit_enter_tup(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - fn visit_tup_field(&mut self, i: uint, inner: *const TyDesc) -> bool; - fn visit_leave_tup(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - - fn visit_enter_enum(&mut self, n_variants: uint, - get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr, - sz: uint, align: uint) -> bool; - fn visit_enter_enum_variant(&mut self, variant: uint, - disr_val: Disr, - n_fields: uint, - name: &str) -> bool; - fn visit_enum_variant_field(&mut self, i: uint, offset: uint, - inner: *const TyDesc) -> bool; - fn visit_leave_enum_variant(&mut self, variant: uint, - disr_val: Disr, - n_fields: uint, - name: &str) -> bool; - fn visit_leave_enum(&mut self, n_variants: uint, - get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr, - sz: uint, align: uint) -> bool; - - fn visit_enter_fn(&mut self, purity: uint, proto: uint, - n_inputs: uint, retstyle: uint) -> bool; - fn visit_fn_input(&mut self, i: uint, mode: uint, - inner: *const TyDesc) -> bool; - fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, - converging: bool, inner: *const TyDesc) -> bool; - fn visit_leave_fn(&mut self, purity: uint, proto: uint, - n_inputs: uint, retstyle: uint) -> bool; - - fn visit_trait(&mut self, name: &str) -> bool; - fn visit_param(&mut self, i: uint) -> bool; - fn visit_self(&mut self) -> bool; -} - extern "rust-intrinsic" { // NB: These intrinsics take unsafe pointers because they mutate aliased diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 6370e55332e..a7be23e53e0 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -60,7 +60,7 @@ #![allow(unknown_features)] #![feature(globs, intrinsics, lang_items, macro_rules, phase)] #![feature(simd, unsafe_destructor, slicing_syntax)] -#![deny(missing_doc)] +#![deny(missing_docs)] mod macros; diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index bf362928f61..521085bca76 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -12,7 +12,7 @@ #![doc(primitive = "f32")] // FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353 -#![allow(type_overflow)] +#![allow(overflowing_literals)] use intrinsics; use mem; diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index 5ad2e2f9f8b..78065d7803e 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -12,7 +12,7 @@ #![doc(primitive = "f64")] // FIXME: MIN_VALUE and MAX_VALUE literals are parsed as -inf and inf #14353 -#![allow(type_overflow)] +#![allow(overflowing_literals)] use intrinsics; use mem; diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 525d588d70f..a177b89058c 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -12,7 +12,7 @@ //! Numeric traits and functions for generic mathematics -#![allow(missing_doc)] +#![allow(missing_docs)] use intrinsics; use {int, i8, i16, i32, i64}; @@ -1353,7 +1353,7 @@ checked_impl!(CheckedMul, checked_mul, i64, intrinsics::i64_mul_with_overflow) /// wrapping around on underflow and overflow. pub trait CheckedDiv: Div<Self, Self> { /// Divides two numbers, checking for underflow, overflow and division by zero. If any of that - /// happens, / `None` is returned. + /// happens, `None` is returned. /// /// # Example /// @@ -1502,7 +1502,7 @@ pub trait Float: Signed + Primitive { /// Take the square root of a number. /// - /// Returns NaN if `self` is not a non-negative number. + /// Returns NaN if `self` is a negative number. fn sqrt(self) -> Self; /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. fn rsqrt(self) -> Self; diff --git a/src/libcore/panicking.rs b/src/libcore/panicking.rs index 62c9d907cb2..39de04c27ce 100644 --- a/src/libcore/panicking.rs +++ b/src/libcore/panicking.rs @@ -28,7 +28,7 @@ //! one function. Currently, the actual symbol is declared in the standard //! library, but the location of this may change over time. -#![allow(dead_code, missing_doc)] +#![allow(dead_code, missing_docs)] use fmt; use intrinsics; @@ -63,7 +63,7 @@ fn panic_bounds_check(file_line: &(&'static str, uint), #[cfg(stage0)] #[cold] #[inline(never)] pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! { - #[allow(ctypes)] + #[allow(improper_ctypes)] extern { #[lang = "fail_fmt"] fn panic_impl(fmt: &fmt::Arguments, file: &'static str, @@ -104,7 +104,7 @@ fn panic_bounds_check(file_line: &(&'static str, uint), #[cfg(not(stage0))] #[cold] #[inline(never)] pub fn panic_fmt(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! { - #[allow(ctypes)] + #[allow(improper_ctypes)] extern { #[lang = "panic_fmt"] fn panic_impl(fmt: &fmt::Arguments, file: &'static str, diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 16342dcae77..d156f71462d 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(missing_doc)] +#![allow(missing_docs)] #![experimental] //! Contains struct definitions for the layout of compiler built-in types. diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs index 42418ccbc1a..2b6f97cf6a5 100644 --- a/src/libcore/simd.rs +++ b/src/libcore/simd.rs @@ -35,7 +35,7 @@ //! warning. #![allow(non_camel_case_types)] -#![allow(missing_doc)] +#![allow(missing_docs)] #[experimental] #[simd] diff --git a/src/libcore/str.rs b/src/libcore/str.rs index ff1db992844..433a3ce1109 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -768,7 +768,7 @@ Section: Comparing strings /// to compare &[u8] byte slices that are not necessarily valid UTF-8. #[inline] fn eq_slice_(a: &str, b: &str) -> bool { - #[allow(ctypes)] + #[allow(improper_ctypes)] extern { fn memcmp(s1: *const i8, s2: *const i8, n: uint) -> i32; } a.len() == b.len() && unsafe { memcmp(a.as_ptr() as *const i8, @@ -1118,7 +1118,7 @@ pub mod raw { Section: Trait implementations */ -#[allow(missing_doc)] +#[allow(missing_docs)] pub mod traits { use cmp::{Ord, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, Eq}; use collections::Collection; diff --git a/src/libcore/tuple/mod.rs b/src/libcore/tuple/mod.rs index ead35647180..56ea7a4e7a1 100644 --- a/src/libcore/tuple/mod.rs +++ b/src/libcore/tuple/mod.rs @@ -81,7 +81,7 @@ macro_rules! tuple_impls { } )+) => { $( - #[allow(missing_doc)] + #[allow(missing_docs)] #[stable] pub trait $Tuple<$($T),+> { $( @@ -97,21 +97,21 @@ macro_rules! tuple_impls { impl<$($T),+> $Tuple<$($T),+> for ($($T,)+) { $( #[inline] - #[allow(unused_variable)] + #[allow(unused_variables)] #[unstable = "may rename pending accessor naming conventions"] fn $valN(self) -> $T { let ($($x,)+) = self; $ret } #[inline] - #[allow(unused_variable)] + #[allow(unused_variables)] #[unstable = "may rename pending accessor naming conventions"] fn $refN<'a>(&'a self) -> &'a $T { let ($(ref $x,)+) = *self; $ret } #[inline] - #[allow(unused_variable)] + #[allow(unused_variables)] #[unstable = "may rename pending accessor naming conventions"] fn $mutN<'a>(&'a mut self) -> &'a mut $T { let ($(ref mut $x,)+) = *self; $ret diff --git a/src/libcoretest/fmt/num.rs b/src/libcoretest/fmt/num.rs index baef7e3a11e..868e14b928a 100644 --- a/src/libcoretest/fmt/num.rs +++ b/src/libcoretest/fmt/num.rs @@ -7,7 +7,7 @@ // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(unsigned_negate)] +#![allow(unsigned_negation)] use core::fmt::radix; diff --git a/src/libcoretest/str.rs b/src/libcoretest/str.rs index 51bd72ec014..d3f77c47c44 100644 --- a/src/libcoretest/str.rs +++ b/src/libcoretest/str.rs @@ -38,3 +38,72 @@ fn test_strslice_contains() { let x = "There are moments, Jeeves, when one asks oneself, 'Do trousers matter?'"; check_contains_all_substrings(x); } + +#[test] +fn test_rsplitn_char_iterator() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let mut split: Vec<&str> = data.rsplitn(3, ' ').collect(); + split.reverse(); + assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + + let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == ' ').collect(); + split.reverse(); + assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + + // Unicode + let mut split: Vec<&str> = data.rsplitn(3, 'ä').collect(); + split.reverse(); + assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); + + let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == 'ä').collect(); + split.reverse(); + assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); +} + +#[test] +fn test_split_char_iterator() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.split(' ').collect(); + assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + let mut rsplit: Vec<&str> = data.split(' ').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + let split: Vec<&str> = data.split(|c: char| c == ' ').collect(); + assert_eq!( split, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, vec!["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + // Unicode + let split: Vec<&str> = data.split('ä').collect(); + assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + + let mut rsplit: Vec<&str> = data.split('ä').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + + let split: Vec<&str> = data.split(|c: char| c == 'ä').collect(); + assert_eq!( split, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + + let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, vec!["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); +} + +#[test] +fn test_rev_split_char_iterator_no_trailing() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let mut split: Vec<&str> = data.split('\n').rev().collect(); + split.reverse(); + assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb", ""]); + + let mut split: Vec<&str> = data.split_terminator('\n').rev().collect(); + split.reverse(); + assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb"]); +} diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 24b78020974..906ca45fcc8 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -89,7 +89,7 @@ html_playground_url = "http://play.rust-lang.org/")] #![feature(globs, phase)] #![feature(import_shadowing)] -#![deny(missing_doc)] +#![deny(missing_docs)] #[cfg(test)] #[phase(plugin, link)] extern crate log; @@ -201,7 +201,7 @@ pub enum Fail_ { /// The type of failure that occurred. #[deriving(PartialEq, Eq)] -#[allow(missing_doc)] +#[allow(missing_docs)] pub enum FailType { ArgumentMissing_, UnrecognizedOption_, @@ -614,29 +614,29 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result { if name_pos == names.len() && !i_arg.is_none() { return Err(UnexpectedArgument(nm.to_string())); } - vals.get_mut(optid).push(Given); + vals[optid].push(Given); } Maybe => { if !i_arg.is_none() { - vals.get_mut(optid) + vals[optid] .push(Val((i_arg.clone()) .unwrap())); } else if name_pos < names.len() || i + 1 == l || is_arg(args[i + 1].as_slice()) { - vals.get_mut(optid).push(Given); + vals[optid].push(Given); } else { i += 1; - vals.get_mut(optid).push(Val(args[i].clone())); + vals[optid].push(Val(args[i].clone())); } } Yes => { if !i_arg.is_none() { - vals.get_mut(optid).push(Val(i_arg.clone().unwrap())); + vals[optid].push(Val(i_arg.clone().unwrap())); } else if i + 1 == l { return Err(ArgumentMissing(nm.to_string())); } else { i += 1; - vals.get_mut(optid).push(Val(args[i].clone())); + vals[optid].push(Val(args[i].clone())); } } } diff --git a/src/libgraphviz/maybe_owned_vec.rs b/src/libgraphviz/maybe_owned_vec.rs index c7659dc1b9f..a4d794d1f99 100644 --- a/src/libgraphviz/maybe_owned_vec.rs +++ b/src/libgraphviz/maybe_owned_vec.rs @@ -58,7 +58,7 @@ impl<'a,T> IntoMaybeOwnedVector<'a,T> for &'a [T] { impl<'a,T> MaybeOwnedVector<'a,T> { pub fn iter(&'a self) -> slice::Items<'a,T> { match self { - &Growable(ref v) => v.iter(), + &Growable(ref v) => v.as_slice().iter(), &Borrowed(ref v) => v.iter(), } } diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index d1a08660cb9..6756d4b21ff 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -75,8 +75,8 @@ #![allow(non_camel_case_types)] #![allow(non_snake_case)] -#![allow(non_uppercase_statics)] -#![allow(missing_doc)] +#![allow(non_upper_case_globals)] +#![allow(missing_docs)] #![allow(non_snake_case)] extern crate core; diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 832f61d8d66..b626b66427d 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -167,7 +167,7 @@ html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] #![feature(macro_rules)] -#![deny(missing_doc)] +#![deny(missing_docs)] extern crate regex; diff --git a/src/libnative/io/c_windows.rs b/src/libnative/io/c_windows.rs index eed3df28b8f..ee6aa26ede2 100644 --- a/src/libnative/io/c_windows.rs +++ b/src/libnative/io/c_windows.rs @@ -10,7 +10,7 @@ //! C definitions used by libnative that don't belong in liblibc -#![allow(type_overflow)] +#![allow(overflowing_literals)] use libc; diff --git a/src/libnative/io/timer_windows.rs b/src/libnative/io/timer_windows.rs index 421cc28e157..c17c541fc01 100644 --- a/src/libnative/io/timer_windows.rs +++ b/src/libnative/io/timer_windows.rs @@ -79,7 +79,7 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>, _: ()) { } } else { let remove = { - match chans.get_mut(idx as uint - 1) { + match &mut chans[idx as uint - 1] { &(ref mut c, oneshot) => { c.call(); oneshot } } }; diff --git a/src/libnative/lib.rs b/src/libnative/lib.rs index 4da088cccb3..c0ec4c16ab0 100644 --- a/src/libnative/lib.rs +++ b/src/libnative/lib.rs @@ -55,7 +55,7 @@ html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/nightly/")] -#![deny(unused_result, unused_must_use)] +#![deny(unused_results, unused_must_use)] #![allow(non_camel_case_types)] #![allow(unknown_features)] #![feature(default_type_params, lang_items, slicing_syntax)] diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs index 3d83012cecb..49d60a98b64 100644 --- a/src/librand/isaac.rs +++ b/src/librand/isaac.rs @@ -118,7 +118,7 @@ impl IsaacRng { /// Refills the output buffer (`self.rsl`) #[inline] - #[allow(unsigned_negate)] + #[allow(unsigned_negation)] fn isaac(&mut self) { self.c += 1; // abbreviations diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 3410a8745b1..95b6d9a17dd 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -26,7 +26,7 @@ html_playground_url = "http://play.rust-lang.org/")] #![allow(unknown_features)] #![feature(macro_rules, phase, slicing_syntax)] -#![allow(missing_doc)] +#![allow(missing_docs)] extern crate serialize; diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs index 53d2ea62a2a..2b82b620e39 100644 --- a/src/libregex/compile.rs +++ b/src/libregex/compile.rs @@ -157,7 +157,7 @@ impl<'r> Compiler<'r> { if cap >= len { self.names.grow(10 + cap - len, None) } - *self.names.get_mut(cap) = name; + self.names[cap] = name; self.push(Save(2 * cap)); self.compile(*x); @@ -243,7 +243,7 @@ impl<'r> Compiler<'r> { /// `panic!` is called. #[inline] fn set_split(&mut self, i: InstIdx, pc1: InstIdx, pc2: InstIdx) { - let split = self.insts.get_mut(i); + let split = &mut self.insts[i]; match *split { Split(_, _) => *split = Split(pc1, pc2), _ => panic!("BUG: Invalid split index."), @@ -263,7 +263,7 @@ impl<'r> Compiler<'r> { /// `panic!` is called. #[inline] fn set_jump(&mut self, i: InstIdx, pc: InstIdx) { - let jmp = self.insts.get_mut(i); + let jmp = &mut self.insts[i]; match *jmp { Jump(_) => *jmp = Jump(pc), _ => panic!("BUG: Invalid jump index."), diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index 691dd2a3a6c..f3633a006b1 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -370,7 +370,7 @@ #![allow(unknown_features)] #![feature(macro_rules, phase, slicing_syntax)] -#![deny(missing_doc)] +#![deny(missing_docs)] #[cfg(test)] extern crate "test" as stdtest; diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs index d71cc9cb511..3115161682f 100644 --- a/src/libregex/parse.rs +++ b/src/libregex/parse.rs @@ -978,7 +978,7 @@ fn combine_ranges(unordered: Vec<(char, char)>) -> Vec<(char, char)> { } match which { None => ordered.push((us, ue)), - Some(i) => *ordered.get_mut(i) = (us, ue), + Some(i) => ordered[i] = (us, ue), } } ordered.sort(); diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs index 0a4dca9125a..ce06828e764 100644 --- a/src/libregex/vm.rs +++ b/src/libregex/vm.rs @@ -461,13 +461,13 @@ impl Threads { } fn add(&mut self, pc: uint, groups: &[Option<uint>], empty: bool) { - let t = self.queue.get_mut(self.size); + let t = &mut self.queue[self.size]; t.pc = pc; match (empty, self.which) { (_, Exists) | (true, _) => {}, (false, Location) => { - *t.groups.get_mut(0) = groups[0]; - *t.groups.get_mut(1) = groups[1]; + t.groups[0] = groups[0]; + t.groups[1] = groups[1]; } (false, Submatches) => { for (slot, val) in t.groups.iter_mut().zip(groups.iter()) { @@ -475,7 +475,7 @@ impl Threads { } } } - *self.sparse.get_mut(pc) = self.size; + self.sparse[pc] = self.size; self.size += 1; } @@ -497,7 +497,7 @@ impl Threads { #[inline] fn groups<'r>(&'r mut self, i: uint) -> &'r mut [Option<uint>] { - self.queue.get_mut(i).groups.as_mut_slice() + self.queue[i].groups.as_mut_slice() } } diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs index 28b18ef0bf9..3cc6d361e3c 100644 --- a/src/libregex_macros/lib.rs +++ b/src/libregex_macros/lib.rs @@ -179,7 +179,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, } impl<'t> Nfa<'t> { - #[allow(unused_variable)] + #[allow(unused_variables)] fn run(&mut self, start: uint, end: uint) -> Vec<Option<uint>> { let mut matched = false; let prefix_bytes: &[u8] = $prefix_bytes; @@ -226,7 +226,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str, } // Sometimes `nlist` is never used (for empty regexes). - #[allow(unused_variable)] + #[allow(unused_variables)] #[inline] fn step(&self, groups: &mut Captures, nlist: &mut Threads, caps: &mut Captures, pc: uint) -> StepState { diff --git a/src/librustc/back/write.rs b/src/librustc/back/write.rs index 1a53db89196..031fc731f41 100644 --- a/src/librustc/back/write.rs +++ b/src/librustc/back/write.rs @@ -226,12 +226,10 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { } }; - unsafe { - sess.targ_cfg - .target_strs - .target_triple - .as_slice() - .with_c_str(|t| { + let triple = sess.targ_cfg.target_strs.target_triple.as_slice(); + + let tm = unsafe { + triple.with_c_str(|t| { sess.opts.cg.target_cpu.as_slice().with_c_str(|cpu| { target_feature(sess).with_c_str(|features| { llvm::LLVMRustCreateTargetMachine( @@ -249,7 +247,15 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef { }) }) }) - } + }; + + if tm.is_null() { + llvm_err(sess.diagnostic().handler(), + format!("Could not create LLVM TargetMachine for triple: {}", + triple).to_string()); + } else { + return tm; + }; } diff --git a/src/librustc/driver/config.rs b/src/librustc/driver/config.rs index 43687a31453..ace5ba26fdb 100644 --- a/src/librustc/driver/config.rs +++ b/src/librustc/driver/config.rs @@ -498,7 +498,7 @@ pub fn get_os(triple: &str) -> Option<abi::Os> { } None } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static os_names : &'static [(&'static str, abi::Os)] = &[ ("mingw32", abi::OsWindows), ("win32", abi::OsWindows), @@ -516,7 +516,7 @@ pub fn get_arch(triple: &str) -> Option<abi::Architecture> { } None } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static architecture_abis : &'static [(&'static str, abi::Architecture)] = &[ ("i386", abi::X86), ("i486", abi::X86), diff --git a/src/librustc/driver/mod.rs b/src/librustc/driver/mod.rs index fbdc0db1665..028d0ec607a 100644 --- a/src/librustc/driver/mod.rs +++ b/src/librustc/driver/mod.rs @@ -255,7 +255,8 @@ Available lint options: for (name, to) in lints.into_iter() { let name = name.chars().map(|x| x.to_lowercase()) .collect::<String>().replace("_", "-"); - let desc = to.into_iter().map(|x| x.as_str()).collect::<Vec<String>>().connect(", "); + let desc = to.into_iter().map(|x| x.as_str().replace("_", "-")) + .collect::<Vec<String>>().connect(", "); println!(" {} {}", padded(name.as_slice()), desc); } diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 35754fc584f..3e53620cbd4 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -1021,7 +1021,7 @@ declare_lint!(UNUSED_PARENS, Warn, pub struct UnusedParens; impl UnusedParens { - fn check_unnecessary_parens_core(&self, cx: &Context, value: &ast::Expr, msg: &str, + fn check_unused_parens_core(&self, cx: &Context, value: &ast::Expr, msg: &str, struct_lit_needs_parens: bool) { match value.node { ast::ExprParen(ref inner) => { @@ -1090,7 +1090,7 @@ impl LintPass for UnusedParens { ast::ExprAssignOp(_, _, ref value) => (value, "assigned value", false), _ => return }; - self.check_unnecessary_parens_core(cx, &**value, msg, struct_lit_needs_parens); + self.check_unused_parens_core(cx, &**value, msg, struct_lit_needs_parens); } fn check_stmt(&mut self, cx: &Context, s: &ast::Stmt) { @@ -1104,7 +1104,7 @@ impl LintPass for UnusedParens { }, _ => return }; - self.check_unnecessary_parens_core(cx, &**value, msg, false); + self.check_unused_parens_core(cx, &**value, msg, false); } } @@ -1364,7 +1364,7 @@ impl MissingDoc { *self.doc_hidden_stack.last().expect("empty doc_hidden_stack") } - fn check_missing_doc_attrs(&self, + fn check_missing_docs_attrs(&self, cx: &Context, id: Option<ast::NodeId>, attrs: &[ast::Attribute], @@ -1374,7 +1374,7 @@ impl MissingDoc { // documentation is probably not really relevant right now. if cx.sess().opts.test { return } - // `#[doc(hidden)]` disables missing_doc check. + // `#[doc(hidden)]` disables missing_docs check. if self.doc_hidden() { return } // Only check publicly-visible items, using the result from the privacy pass. @@ -1429,7 +1429,7 @@ impl LintPass for MissingDoc { } fn check_crate(&mut self, cx: &Context, krate: &ast::Crate) { - self.check_missing_doc_attrs(cx, None, krate.attrs.as_slice(), + self.check_missing_docs_attrs(cx, None, krate.attrs.as_slice(), krate.span, "crate"); } @@ -1442,7 +1442,7 @@ impl LintPass for MissingDoc { ast::ItemTrait(..) => "a trait", _ => return }; - self.check_missing_doc_attrs(cx, Some(it.id), it.attrs.as_slice(), + self.check_missing_docs_attrs(cx, Some(it.id), it.attrs.as_slice(), it.span, desc); } @@ -1456,7 +1456,7 @@ impl LintPass for MissingDoc { // Otherwise, doc according to privacy. This will also check // doc for default methods defined on traits. - self.check_missing_doc_attrs(cx, Some(m.id), m.attrs.as_slice(), + self.check_missing_docs_attrs(cx, Some(m.id), m.attrs.as_slice(), m.span, "a method"); } _ => {} @@ -1464,7 +1464,7 @@ impl LintPass for MissingDoc { } fn check_ty_method(&mut self, cx: &Context, tm: &ast::TypeMethod) { - self.check_missing_doc_attrs(cx, Some(tm.id), tm.attrs.as_slice(), + self.check_missing_docs_attrs(cx, Some(tm.id), tm.attrs.as_slice(), tm.span, "a type method"); } @@ -1473,7 +1473,7 @@ impl LintPass for MissingDoc { ast::NamedField(_, vis) if vis == ast::Public => { let cur_struct_def = *self.struct_def_stack.last() .expect("empty struct_def_stack"); - self.check_missing_doc_attrs(cx, Some(cur_struct_def), + self.check_missing_docs_attrs(cx, Some(cur_struct_def), sf.node.attrs.as_slice(), sf.span, "a struct field") } @@ -1482,7 +1482,7 @@ impl LintPass for MissingDoc { } fn check_variant(&mut self, cx: &Context, v: &ast::Variant, _: &ast::Generics) { - self.check_missing_doc_attrs(cx, Some(v.node.id), v.node.attrs.as_slice(), + self.check_missing_docs_attrs(cx, Some(v.node.id), v.node.attrs.as_slice(), v.span, "a variant"); } } diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 8e4095df45a..aa8e1ed2703 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -221,8 +221,8 @@ impl LintStore { add_lint_group!(sess, "unused", UNUSED_IMPORTS, UNUSED_VARIABLES, UNUSED_ASSIGNMENTS, DEAD_CODE, - UNUSED_MUT, UNREACHABLE_CODE, UNUSED_EXTERN_CRATES, UNUSED_MUST_USE, - UNUSED_UNSAFE, UNUSED_RESULTS, PATH_STATEMENTS) + UNUSED_MUT, UNREACHABLE_CODE, UNUSED_MUST_USE, + UNUSED_UNSAFE, PATH_STATEMENTS) // We have one lint pass defined in this module. self.register_pass(sess, false, box GatherNodeLevels as LintPassObject); @@ -254,21 +254,19 @@ impl LintStore { } - #[allow(unused_variable)] + #[allow(unused_variables)] fn find_lint(&self, lint_name: &str, sess: &Session, span: Option<Span>) -> Option<LintId> { match self.by_name.find_equiv(&lint_name) { Some(&Id(lint_id)) => Some(lint_id), Some(&Renamed(ref new_name, lint_id)) => { - // NOTE(stage0): add the following code after the next snapshot - - // let warning = format!("lint {} has been renamed to {}", - // lint_name, new_name); - // match span { - // Some(span) => sess.span_warn(span, warning.as_slice()), - // None => sess.warn(warning.as_slice()), - // }; + let warning = format!("lint {} has been renamed to {}", + lint_name, new_name); + match span { + Some(span) => sess.span_warn(span, warning.as_slice()), + None => sess.warn(warning.as_slice()), + }; Some(lint_id) } None => None diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 5afe5326171..0202aa18558 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -98,7 +98,7 @@ macro_rules! declare_lint ( #[macro_export] macro_rules! lint_array ( ($( $lint:expr ),*) => ( { - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] static array: LintArray = &[ $( &$lint ),* ]; array } diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs index 492feee6f84..bc58097b860 100644 --- a/src/librustc/metadata/common.rs +++ b/src/librustc/metadata/common.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_camel_case_types, non_uppercase_statics)] +#![allow(non_camel_case_types, non_upper_case_globals)] use std::mem; use back::svh::Svh; diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index e9e7d1de59d..e126449b248 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -1330,9 +1330,9 @@ pub fn get_missing_lang_items(cdata: Cmd) { let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_lang_items); let mut result = Vec::new(); - reader::tagged_docs(items, tag_lang_items_missing, |missing_doc| { + reader::tagged_docs(items, tag_lang_items_missing, |missing_docs| { let item: lang_items::LangItem = - FromPrimitive::from_u32(reader::doc_as_u32(missing_doc)).unwrap(); + FromPrimitive::from_u32(reader::doc_as_u32(missing_docs)).unwrap(); result.push(item); true }); diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 6fe14a2d12a..fd983075218 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -1619,7 +1619,7 @@ fn encode_index<T: Hash>(rbml_w: &mut Encoder, index: Vec<entry<T>>, let mut buckets: Vec<Vec<entry<T>>> = Vec::from_fn(256, |_| Vec::new()); for elt in index.into_iter() { let h = hash::hash(&elt.val) as uint; - buckets.get_mut(h % 256).push(elt); + buckets[h % 256].push(elt); } rbml_w.start_tag(tag_index); @@ -2028,7 +2028,7 @@ fn encode_dylib_dependency_formats(rbml_w: &mut Encoder, ecx: &EncodeContext) { } // NB: Increment this as you change the metadata encoding version. -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 1 ]; pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> Vec<u8> { diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index 5f3c46fcf4c..98376726913 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -83,7 +83,7 @@ impl Clone for MovePathIndex { } } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static InvalidMovePathIndex: MovePathIndex = MovePathIndex(uint::MAX); @@ -97,7 +97,7 @@ impl MoveIndex { } } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static InvalidMoveIndex: MoveIndex = MoveIndex(uint::MAX); @@ -214,13 +214,13 @@ impl MoveData { fn set_path_first_move(&self, index: MovePathIndex, first_move: MoveIndex) { - self.paths.borrow_mut().get_mut(index.get()).first_move = first_move + (*self.paths.borrow_mut())[index.get()].first_move = first_move } fn set_path_first_child(&self, index: MovePathIndex, first_child: MovePathIndex) { - self.paths.borrow_mut().get_mut(index.get()).first_child = first_child + (*self.paths.borrow_mut())[index.get()].first_child = first_child } fn move_next_move(&self, index: MoveIndex) -> MoveIndex { diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index 3d6b319ac0d..ad0040608ec 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(non_camel_case_types)] -#![allow(unsigned_negate)] +#![allow(unsigned_negation)] use metadata::csearch; use middle::astencode; diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 8e2d4d0dc5a..3baa8eb0cc0 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -161,7 +161,7 @@ fn calculate_type(sess: &session::Session, if src.dylib.is_none() && !formats.contains_key(&cnum) { assert!(src.rlib.is_some()); add_library(sess, cnum, cstore::RequireStatic, &mut formats); - *ret.get_mut(cnum as uint - 1) = Some(cstore::RequireStatic); + ret[cnum as uint - 1] = Some(cstore::RequireStatic); debug!("adding staticlib: {}", data.name); } }); diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index 4775f945f5c..18ecc9dd053 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -66,20 +66,20 @@ impl<E: Show> Show for Edge<E> { #[deriving(Clone, PartialEq, Show)] pub struct NodeIndex(pub uint); -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX); #[deriving(PartialEq, Show)] pub struct EdgeIndex(pub uint); -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX); // Use a private field here to guarantee no more instances are created: #[deriving(Show)] pub struct Direction { repr: uint } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const Outgoing: Direction = Direction { repr: 0 }; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const Incoming: Direction = Direction { repr: 1 }; impl NodeIndex { @@ -142,7 +142,7 @@ impl<N,E> Graph<N,E> { } pub fn mut_node_data<'a>(&'a mut self, idx: NodeIndex) -> &'a mut N { - &mut self.nodes.get_mut(idx.get()).data + &mut self.nodes[idx.get()].data } pub fn node_data<'a>(&'a self, idx: NodeIndex) -> &'a N { @@ -182,14 +182,14 @@ impl<N,E> Graph<N,E> { }); // adjust the firsts for each node target be the next object. - self.nodes.get_mut(source.get()).first_edge[Outgoing.repr] = idx; - self.nodes.get_mut(target.get()).first_edge[Incoming.repr] = idx; + self.nodes[source.get()].first_edge[Outgoing.repr] = idx; + self.nodes[target.get()].first_edge[Incoming.repr] = idx; return idx; } pub fn mut_edge_data<'a>(&'a mut self, idx: EdgeIndex) -> &'a mut E { - &mut self.edges.get_mut(idx.get()).data + &mut self.edges[idx.get()].data } pub fn edge_data<'a>(&'a self, idx: EdgeIndex) -> &'a E { diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index f9810120d21..80eba56ea6c 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -756,7 +756,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { } fn init_empty(&mut self, ln: LiveNode, succ_ln: LiveNode) { - *self.successors.get_mut(ln.get()) = succ_ln; + self.successors[ln.get()] = succ_ln; // It is not necessary to initialize the // values to empty because this is the value @@ -770,10 +770,10 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { fn init_from_succ(&mut self, ln: LiveNode, succ_ln: LiveNode) { // more efficient version of init_empty() / merge_from_succ() - *self.successors.get_mut(ln.get()) = succ_ln; + self.successors[ln.get()] = succ_ln; self.indices2(ln, succ_ln, |this, idx, succ_idx| { - *this.users.get_mut(idx) = this.users[succ_idx] + this.users[idx] = this.users[succ_idx] }); debug!("init_from_succ(ln={}, succ={})", self.ln_str(ln), self.ln_str(succ_ln)); @@ -789,11 +789,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { let mut changed = false; self.indices2(ln, succ_ln, |this, idx, succ_idx| { changed |= copy_if_invalid(this.users[succ_idx].reader, - &mut this.users.get_mut(idx).reader); + &mut this.users[idx].reader); changed |= copy_if_invalid(this.users[succ_idx].writer, - &mut this.users.get_mut(idx).writer); + &mut this.users[idx].writer); if this.users[succ_idx].used && !this.users[idx].used { - this.users.get_mut(idx).used = true; + this.users[idx].used = true; changed = true; } }); @@ -817,8 +817,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { // this) so we just clear out all the data. fn define(&mut self, writer: LiveNode, var: Variable) { let idx = self.idx(writer, var); - self.users.get_mut(idx).reader = invalid_node(); - self.users.get_mut(idx).writer = invalid_node(); + self.users[idx].reader = invalid_node(); + self.users[idx].writer = invalid_node(); debug!("{} defines {} (idx={}): {}", writer.to_string(), var.to_string(), idx, self.ln_str(writer)); @@ -830,7 +830,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> { ln.to_string(), acc, var.to_string(), self.ln_str(ln)); let idx = self.idx(ln, var); - let user = self.users.get_mut(idx); + let user = &mut self.users[idx]; if (acc & ACC_WRITE) != 0 { user.reader = invalid_node(); diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 7af4739d409..383a60e51da 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -2596,7 +2596,7 @@ impl<'a> Resolver<'a> { // We've successfully resolved the import. Write the results in. let mut import_resolutions = module_.import_resolutions.borrow_mut(); - let import_resolution = import_resolutions.get_mut(&target); + let import_resolution = &mut (*import_resolutions)[target]; match value_result { BoundResult(ref target_module, ref name_bindings) => { @@ -3158,7 +3158,7 @@ impl<'a> Resolver<'a> { (_, _) => { search_module = module_def.clone(); - // track extern crates for unused_extern_crate lint + // track extern crates for unused_extern_crates lint match module_def.def_id.get() { Some(did) => { self.used_crates.insert(did.krate); @@ -5697,7 +5697,7 @@ impl<'a> Resolver<'a> { let mut smallest = 0; for (i, other) in maybes.iter().enumerate() { - *values.get_mut(i) = name.lev_distance(other.get()); + values[i] = name.lev_distance(other.get()); if values[i] <= values[smallest] { smallest = i; diff --git a/src/librustc/middle/save/span_utils.rs b/src/librustc/middle/save/span_utils.rs index 511d8aa5bac..93ad29cff90 100644 --- a/src/librustc/middle/save/span_utils.rs +++ b/src/librustc/middle/save/span_utils.rs @@ -145,7 +145,7 @@ impl<'a> SpanUtils<'a> { last_span = None; let mut next = toks.next_token(); - if (next.tok == token::LParen || + if (next.tok == token::OpenDelim(token::Paren) || next.tok == token::Lt) && bracket_count == 0 && prev.tok.is_ident() { @@ -164,8 +164,8 @@ impl<'a> SpanUtils<'a> { } bracket_count += match prev.tok { - token::LParen | token::Lt => 1, - token::RParen | token::Gt => -1, + token::OpenDelim(token::Paren) | token::Lt => 1, + token::CloseDelim(token::Paren) | token::Gt => -1, token::BinOp(token::Shr) => -2, _ => 0 }; diff --git a/src/librustc/middle/traexpr b/src/librustc/middle/traexpr deleted file mode 100644 index e69de29bb2d..00000000000 --- a/src/librustc/middle/traexpr +++ /dev/null diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index f53b5331edd..70aef4504f0 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -403,7 +403,7 @@ fn expand_nested_bindings<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>, } let mut pats = br.pats.clone(); - *pats.get_mut(col) = pat; + pats[col] = pat; Match { pats: pats, data: &*br.data, diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs index 1f737cae86f..98d02dfb8d7 100644 --- a/src/librustc/middle/trans/adt.rs +++ b/src/librustc/middle/trans/adt.rs @@ -43,7 +43,7 @@ * taken to it, implementing them for Rust seems difficult. */ -#![allow(unsigned_negate)] +#![allow(unsigned_negation)] use std::collections::Map; use std::num::Int; @@ -393,12 +393,12 @@ fn mk_cenum(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> Repr { fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntType { debug!("range_to_inttype: {} {}", hint, bounds); // Lists of sizes to try. u64 is always allowed as a fallback. - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] static choose_shortest: &'static[IntType] = &[ attr::UnsignedInt(ast::TyU8), attr::SignedInt(ast::TyI8), attr::UnsignedInt(ast::TyU16), attr::SignedInt(ast::TyI16), attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)]; - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] static at_least_32: &'static[IntType] = &[ attr::UnsignedInt(ast::TyU32), attr::SignedInt(ast::TyI32)]; diff --git a/src/librustc/middle/trans/cabi_arm.rs b/src/librustc/middle/trans/cabi_arm.rs index d8cf8dbb795..2782970b975 100644 --- a/src/librustc/middle/trans/cabi_arm.rs +++ b/src/librustc/middle/trans/cabi_arm.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] use llvm; use llvm::{Integer, Pointer, Float, Double, Struct, Array}; diff --git a/src/librustc/middle/trans/cabi_mips.rs b/src/librustc/middle/trans/cabi_mips.rs index 9f51e153a0f..5fe10d2d8e7 100644 --- a/src/librustc/middle/trans/cabi_mips.rs +++ b/src/librustc/middle/trans/cabi_mips.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] use libc::c_uint; use std::cmp; diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs index 54fd20ff995..d9819ee7294 100644 --- a/src/librustc/middle/trans/cabi_x86_64.rs +++ b/src/librustc/middle/trans/cabi_x86_64.rs @@ -11,7 +11,7 @@ // The classification code for the x86_64 ABI is taken from the clay language // https://github.com/jckarter/clay/blob/master/compiler/src/externals.cpp -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] use llvm; use llvm::{Integer, Pointer, Float, Double}; diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs index e5825d7a38f..5a4979d9dcd 100644 --- a/src/librustc/middle/trans/cleanup.rs +++ b/src/librustc/middle/trans/cleanup.rs @@ -469,7 +469,7 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> { assert!(self.is_valid_custom_scope(custom_scope)); let mut scopes = self.scopes.borrow_mut(); - let scope = scopes.get_mut(custom_scope.index); + let scope = &mut (*scopes)[custom_scope.index]; scope.cleanups.push(cleanup); scope.clear_cached_exits(); } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 5e039a3c098..c688749a389 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -218,20 +218,20 @@ use syntax::parse::token::special_idents; static DW_LANG_RUST: c_uint = 0x9000; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static DW_TAG_auto_variable: c_uint = 0x100; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static DW_TAG_arg_variable: c_uint = 0x101; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static DW_ATE_boolean: c_uint = 0x02; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static DW_ATE_float: c_uint = 0x04; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static DW_ATE_signed: c_uint = 0x05; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static DW_ATE_unsigned: c_uint = 0x07; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static DW_ATE_unsigned_char: c_uint = 0x08; static UNKNOWN_LINE_NUMBER: c_uint = 0; diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 4d004c85f6e..3bfa6af4a9b 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -833,7 +833,7 @@ fn trans_def<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let _icx = push_ctxt("trans_def_lvalue"); match def { - def::DefFn(..) | def::DefStaticMethod(..) | + def::DefFn(..) | def::DefStaticMethod(..) | def::DefMethod(..) | def::DefStruct(_) | def::DefVariant(..) => { trans_def_fn_unadjusted(bcx, ref_expr, def) } @@ -1191,10 +1191,12 @@ fn trans_def_fn_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let llfn = match def { def::DefFn(did, _, _) | def::DefStruct(did) | def::DefVariant(_, did, _) | - def::DefStaticMethod(did, def::FromImpl(_), _) => { + def::DefStaticMethod(did, def::FromImpl(_), _) | + def::DefMethod(did, _, def::FromImpl(_)) => { callee::trans_fn_ref(bcx, did, ExprId(ref_expr.id)) } - def::DefStaticMethod(impl_did, def::FromTrait(trait_did), _) => { + def::DefStaticMethod(impl_did, def::FromTrait(trait_did), _) | + def::DefMethod(impl_did, _, def::FromTrait(trait_did)) => { meth::trans_static_method_callee(bcx, impl_did, trait_did, ref_expr.id) } @@ -1331,7 +1333,7 @@ fn trans_struct<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, field_ty.name == field.ident.node.name); match opt_pos { Some(i) => { - *need_base.get_mut(i) = false; + need_base[i] = false; (i, &*field.expr) } None => { diff --git a/src/librustc/middle/trans/intrinsic.rs b/src/librustc/middle/trans/intrinsic.rs index 2455970b6a6..906e9e8bfa0 100644 --- a/src/librustc/middle/trans/intrinsic.rs +++ b/src/librustc/middle/trans/intrinsic.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] use llvm; use llvm::{SequentiallyConsistent, Acquire, Release, AtomicXchg, ValueRef}; diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index 5c8287c0030..60c38af3e72 100644 --- a/src/librustc/middle/trans/tvec.rs +++ b/src/librustc/middle/trans/tvec.rs @@ -310,26 +310,23 @@ pub fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, return expr::trans_into(bcx, &**element, Ignore); } SaveIn(lldest) => { - let count = ty::eval_repeat_count(bcx.tcx(), &**count_expr); - if count == 0 { - return bcx; + match ty::eval_repeat_count(bcx.tcx(), &**count_expr) { + 0 => bcx, + 1 => expr::trans_into(bcx, &**element, SaveIn(lldest)), + count => { + let elem = unpack_datum!(bcx, expr::trans(bcx, &**element)); + assert!(!ty::type_moves_by_default(bcx.tcx(), elem.ty)); + + let bcx = iter_vec_loop(bcx, lldest, vt, + C_uint(bcx.ccx(), count), + |set_bcx, lleltptr, _| { + elem.shallow_copy(set_bcx, lleltptr) + }); + + elem.add_clean_if_rvalue(bcx, element.id); + bcx + } } - - // Some cleanup would be required in the case in which panic happens - // during a copy. But given that copy constructors are not overridable, - // this can only happen as a result of OOM. So we just skip out on the - // cleanup since things would *probably* be broken at that point anyways. - - let elem = unpack_datum!(bcx, expr::trans(bcx, &**element)); - assert!(!ty::type_moves_by_default(bcx.tcx(), elem.ty)); - - let bcx = iter_vec_loop(bcx, lldest, vt, - C_uint(bcx.ccx(), count), |set_bcx, lleltptr, _| { - elem.shallow_copy(set_bcx, lleltptr) - }); - - elem.add_clean_if_rvalue(bcx, element.id); - bcx } } } diff --git a/src/librustc/middle/trans/type_.rs b/src/librustc/middle/trans/type_.rs index f08fd20314a..851552592dd 100644 --- a/src/librustc/middle/trans/type_.rs +++ b/src/librustc/middle/trans/type_.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] use llvm; use llvm::{TypeRef, Bool, False, True, TypeKind, ValueRef}; @@ -284,7 +284,7 @@ impl Type { return Vec::new(); } let mut elts = Vec::from_elem(n_elts, 0 as TypeRef); - llvm::LLVMGetStructElementTypes(self.to_ref(), elts.get_mut(0)); + llvm::LLVMGetStructElementTypes(self.to_ref(), &mut elts[0]); mem::transmute(elts) } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index edb67f7fddf..6defc594fb8 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2215,7 +2215,7 @@ macro_rules! def_type_content_sets( mod $mname { use middle::ty::TypeContents; $( - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] pub const $name: TypeContents = TypeContents { bits: $bits }; )+ } @@ -3631,7 +3631,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind { def::DefFn(_, _, true) => RvalueDpsExpr, // Fn pointers are just scalar values. - def::DefFn(..) | def::DefStaticMethod(..) => RvalueDatumExpr, + def::DefFn(..) | def::DefStaticMethod(..) | def::DefMethod(..) => RvalueDatumExpr, // Note: there is actually a good case to be made that // DefArg's, particularly those of immediate type, ought to @@ -4670,7 +4670,7 @@ pub fn unboxed_closure_upvars(tcx: &ctxt, closure_id: ast::DefId, substs: &Subst } pub fn is_binopable(cx: &ctxt, ty: t, op: ast::BinOp) -> bool { - #![allow(non_uppercase_statics)] + #![allow(non_upper_case_globals)] static tycat_other: int = 0; static tycat_bool: int = 1; static tycat_char: int = 2; diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index da1e7e24571..66d4f73eacc 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -674,7 +674,7 @@ fn mk_pointer<'tcx, AC: AstConv<'tcx>, RS: RegionScope>( return constr(ty::mk_str(tcx)); } RPtr(r) => { - return ty::mk_str_slice(tcx, r, ast::MutImmutable); + return ty::mk_str_slice(tcx, r, a_seq_mutbl); } } } diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index cd3cc43b853..4334cf7db7a 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -648,7 +648,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> { ByValueExplicitSelfCategory => { let mut n = (*m).clone(); let self_ty = n.fty.sig.inputs[0]; - *n.fty.sig.inputs.get_mut(0) = ty::mk_uniq(tcx, self_ty); + n.fty.sig.inputs[0] = ty::mk_uniq(tcx, self_ty); m = Rc::new(n); } _ => { } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 94c4d7c25e0..13ffc1f4fcb 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -5456,7 +5456,7 @@ pub fn check_bounds_are_used(ccx: &CrateCtxt, match ty::get(t).sty { ty::ty_param(ParamTy {idx, ..}) => { debug!("Found use of ty param num {}", idx); - *tps_used.get_mut(idx) = true; + tps_used[idx] = true; } _ => () } diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index bcade1e74ca..d0338333bad 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -1757,7 +1757,7 @@ fn adjust_upvar_borrow_kind_for_mut(rcx: &Rcx, // is inferred to mutable if necessary let mut upvar_borrow_map = rcx.fcx.inh.upvar_borrow_map.borrow_mut(); - let ub = upvar_borrow_map.get_mut(upvar_id); + let ub = &mut (*upvar_borrow_map)[*upvar_id]; return adjust_upvar_borrow_kind(rcx, *upvar_id, ub, ty::MutBorrow); } @@ -1807,7 +1807,7 @@ fn adjust_upvar_borrow_kind_for_unique(rcx: &Rcx, cmt: mc::cmt) { // borrow_kind of the upvar to make sure it // is inferred to unique if necessary let mut ub = rcx.fcx.inh.upvar_borrow_map.borrow_mut(); - let ub = ub.get_mut(upvar_id); + let ub = &mut (*ub)[*upvar_id]; return adjust_upvar_borrow_kind(rcx, *upvar_id, ub, ty::UniqueImmBorrow); } diff --git a/src/librustc/middle/typeck/check/vtable.rs b/src/librustc/middle/typeck/check/vtable.rs index b7195734e8b..a17194f0085 100644 --- a/src/librustc/middle/typeck/check/vtable.rs +++ b/src/librustc/middle/typeck/check/vtable.rs @@ -402,15 +402,25 @@ pub fn maybe_report_ambiguity(fcx: &FnCtxt, obligation: &Obligation) { // has_errors() to be sure that compilation isn't happening // anyway. In that case, why inundate the user. if !fcx.tcx().sess.has_errors() { - fcx.tcx().sess.span_err( - obligation.cause.span, - format!( - "unable to infer enough type information to \ - locate the impl of the trait `{}` for \ - the type `{}`; type annotations required", - trait_ref.user_string(fcx.tcx()), - self_ty.user_string(fcx.tcx())).as_slice()); - note_obligation_cause(fcx, obligation); + if fcx.ccx.tcx.lang_items.sized_trait() + .map_or(false, |sized_id| sized_id == trait_ref.def_id) { + fcx.tcx().sess.span_err( + obligation.cause.span, + format!( + "unable to infer enough type information about `{}`; type annotations \ + required", + self_ty.user_string(fcx.tcx())).as_slice()); + } else { + fcx.tcx().sess.span_err( + obligation.cause.span, + format!( + "unable to infer enough type information to \ + locate the impl of the trait `{}` for \ + the type `{}`; type annotations required", + trait_ref.user_string(fcx.tcx()), + self_ty.user_string(fcx.tcx())).as_slice()); + note_obligation_cause(fcx, obligation); + } } } else if !fcx.tcx().sess.has_errors() { // Ambiguity. Coherence should have reported an error. diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index 56dec61d410..b53318861b8 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -1,4 +1,4 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -282,7 +282,9 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } _ => { span_err!(self.tcx().sess, reason.span(self.tcx()), E0100, - "cannot coerce non-statically resolved bare fn"); + "cannot coerce non-statically resolved bare fn to closure"); + span_help!(self.tcx().sess, reason.span(self.tcx()), + "consider embedding the function in a closure"); } } diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index 80213d43ec4..ff1ded726c5 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -261,7 +261,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { if snapshot.length == 0 { undo_log.truncate(0); } else { - *undo_log.get_mut(snapshot.length) = CommitedSnapshot; + (*undo_log)[snapshot.length] = CommitedSnapshot; } } diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index db26376fc69..73f595dbedc 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -46,7 +46,7 @@ // future). If you want to resolve everything but one type, you are // probably better off writing `resolve_all - resolve_ivar`. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] use middle::ty::{FloatVar, FloatVid, IntVar, IntVid, RegionVid, TyVar, TyVid}; use middle::ty::{IntType, UintType}; diff --git a/src/librustc/middle/typeck/infer/type_variable.rs b/src/librustc/middle/typeck/infer/type_variable.rs index 63094ceaabd..1383f7aa4dc 100644 --- a/src/librustc/middle/typeck/infer/type_variable.rs +++ b/src/librustc/middle/typeck/infer/type_variable.rs @@ -159,12 +159,12 @@ impl sv::SnapshotVecDelegate<TypeVariableData,UndoEntry> for Delegate { action: UndoEntry) { match action { SpecifyVar(vid, relations) => { - values.get_mut(vid.index).value = Bounded(relations); + values[vid.index].value = Bounded(relations); } Relate(a, b) => { - relations(values.get_mut(a.index)).pop(); - relations(values.get_mut(b.index)).pop(); + relations(&mut (*values)[a.index]).pop(); + relations(&mut (*values)[b.index]).pop(); } } } diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs index c8214a743de..5e62a8e9451 100644 --- a/src/librustc/middle/typeck/variance.rs +++ b/src/librustc/middle/typeck/variance.rs @@ -715,7 +715,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } _ => { - self.terms_cx.arena.alloc(|| TransformTerm(v1, v2)) + &*self.terms_cx.arena.alloc(|| TransformTerm(v1, v2)) } } } @@ -994,7 +994,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> { new_value, term.to_string()); - *self.solutions.get_mut(inferred) = new_value; + self.solutions[inferred] = new_value; changed = true; } } diff --git a/src/librustc/util/snapshot_vec.rs b/src/librustc/util/snapshot_vec.rs index 8885d86d4da..6d99fc7156c 100644 --- a/src/librustc/util/snapshot_vec.rs +++ b/src/librustc/util/snapshot_vec.rs @@ -105,7 +105,7 @@ impl<T,U,D:SnapshotVecDelegate<T,U>> SnapshotVec<T,U,D> { * action. */ - self.values.get_mut(index) + &mut self.values[index] } pub fn set(&mut self, index: uint, new_elem: T) { @@ -114,7 +114,7 @@ impl<T,U,D:SnapshotVecDelegate<T,U>> SnapshotVec<T,U,D> { * saved (and perhaps restored) if a snapshot is active. */ - let old_elem = mem::replace(self.values.get_mut(index), new_elem); + let old_elem = mem::replace(&mut self.values[index], new_elem); if self.in_snapshot() { self.undo_log.push(SetElem(index, old_elem)); } @@ -162,7 +162,7 @@ impl<T,U,D:SnapshotVecDelegate<T,U>> SnapshotVec<T,U,D> { } SetElem(i, v) => { - *self.values.get_mut(i) = v; + self.values[i] = v; } Other(u) => { @@ -189,7 +189,7 @@ impl<T,U,D:SnapshotVecDelegate<T,U>> SnapshotVec<T,U,D> { // The root snapshot. self.undo_log.truncate(0); } else { - *self.undo_log.get_mut(snapshot.length) = CommittedSnapshot; + self.undo_log[snapshot.length] = CommittedSnapshot; } } } diff --git a/src/librustc_back/abi.rs b/src/librustc_back/abi.rs index aa07b9a5034..19dd6b8459f 100644 --- a/src/librustc_back/abi.rs +++ b/src/librustc_back/abi.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] pub const box_field_refcnt: uint = 0u; pub const box_field_drop_glue: uint = 1u; diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index 03399e73908..06456a91e03 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(dead_code)] diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs index 0441e6b791f..4797ac7c66a 100644 --- a/src/librustdoc/html/highlight.rs +++ b/src/librustdoc/html/highlight.rs @@ -97,8 +97,8 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader, // miscellaneous, no highlighting token::Dot | token::DotDot | token::DotDotDot | token::Comma | token::Semi | - token::Colon | token::ModSep | token::LArrow | token::LParen | - token::RParen | token::LBracket | token::LBrace | token::RBrace | + token::Colon | token::ModSep | token::LArrow | token::OpenDelim(_) | + token::CloseDelim(token::Brace) | token::CloseDelim(token::Paren) | token::Question => "", token::Dollar => { if lexer.peek().tok.is_ident() { @@ -118,7 +118,7 @@ fn doit(sess: &parse::ParseSess, mut lexer: lexer::StringReader, try!(write!(out, r"<span class='attribute'>#")); continue } - token::RBracket => { + token::CloseDelim(token::Bracket) => { if is_attribute { is_attribute = false; try!(write!(out, "]</span>")); diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 642abf924ae..3e8ebc00579 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -212,7 +212,7 @@ pub fn maketest(s: &str, cratename: Option<&str>, lints: bool, dont_insert_main: if lints { prog.push_str(r" #![deny(warnings)] -#![allow(unused_variable, dead_assignment, unused_mut, unused_attribute, dead_code)] +#![allow(unused_variables, unused_assignments, unused_mut, unused_attributes, dead_code)] "); } diff --git a/src/librustrt/libunwind.rs b/src/librustrt/libunwind.rs index 6867cb2e76b..2932a3dd4a8 100644 --- a/src/librustrt/libunwind.rs +++ b/src/librustrt/libunwind.rs @@ -10,7 +10,7 @@ //! Unwind library interface -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] #![allow(dead_code)] // these are just bindings diff --git a/src/librustrt/local_data.rs b/src/librustrt/local_data.rs index 5d9e20b07de..14275d070f0 100644 --- a/src/librustrt/local_data.rs +++ b/src/librustrt/local_data.rs @@ -66,7 +66,7 @@ use task::{Task, LocalStorage}; */ pub type Key<T> = &'static KeyValue<T>; -#[allow(missing_doc)] +#[allow(missing_docs)] pub enum KeyValue<T> { KeyValueKey } // The task-local-map stores all TLD information for the currently running diff --git a/src/librustrt/unwind.rs b/src/librustrt/unwind.rs index 8279b7d9654..c5fc0084ed9 100644 --- a/src/librustrt/unwind.rs +++ b/src/librustrt/unwind.rs @@ -177,7 +177,7 @@ pub unsafe fn try(f: ||) -> ::core::result::Result<(), Box<Any + Send>> { // An uninlined, unmangled function upon which to slap yer breakpoints #[inline(never)] #[no_mangle] -fn rust_fail(cause: Box<Any + Send>) -> ! { +fn rust_panic(cause: Box<Any + Send>) -> ! { rtdebug!("begin_unwind()"); unsafe { @@ -588,7 +588,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> // (hopefully someone printed something about this). let mut task: Box<Task> = match Local::try_take() { Some(task) => task, - None => rust_fail(msg), + None => rust_panic(msg), }; if task.unwinder.unwinding { @@ -605,7 +605,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> // requires the task. We need a handle to its unwinder, however, so after // this we unsafely extract it and continue along. Local::put(task); - rust_fail(msg); + rust_panic(msg); } /// Register a callback to be invoked when a task unwinds. diff --git a/src/librustrt/util.rs b/src/librustrt/util.rs index a94da33e543..06d1efdcd70 100644 --- a/src/librustrt/util.rs +++ b/src/librustrt/util.rs @@ -28,9 +28,9 @@ pub const ENFORCE_SANITY: bool = true || !cfg!(rtopt) || cfg!(rtdebug) || pub struct Stdio(libc::c_int); -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const Stdout: Stdio = Stdio(libc::STDOUT_FILENO); -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const Stderr: Stdio = Stdio(libc::STDERR_FILENO); impl fmt::FormatWriter for Stdio { diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 99c60dde0ac..84b5cdd3cc8 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -12,7 +12,7 @@ // Copyright (c) 2011 Google Inc. #![forbid(non_camel_case_types)] -#![allow(missing_doc)] +#![allow(missing_docs)] /*! JSON parsing and serialization @@ -1231,7 +1231,7 @@ impl Stack { InternalIndex(i) => { i + 1 } _ => { panic!(); } }; - *self.stack.get_mut(len - 1) = InternalIndex(idx); + self.stack[len - 1] = InternalIndex(idx); } } diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 33c8e94e32b..31f37a8a1bb 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -331,8 +331,7 @@ impl IntoStr for Vec<Ascii> { #[inline] fn into_string(self) -> String { unsafe { - let s: &str = mem::transmute(self.as_slice()); - String::from_str(s) + string::raw::from_utf8(self.into_bytes()) } } } diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index fb5934c6af6..97a1f68606f 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -258,7 +258,7 @@ macro_rules! bitflags { } #[cfg(test)] -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] mod tests { use hash; use option::{Some, None}; diff --git a/src/libstd/collections/hashmap/map.rs b/src/libstd/collections/hashmap/map.rs index 6562a644988..cb47c28f8be 100644 --- a/src/libstd/collections/hashmap/map.rs +++ b/src/libstd/collections/hashmap/map.rs @@ -14,19 +14,14 @@ use clone::Clone; use cmp::{max, Eq, Equiv, PartialEq}; use collections::{Collection, Mutable, MutableSet, Map, MutableMap}; use default::Default; -use fmt::Show; -use fmt; +use fmt::{mod, Show}; use hash::{Hash, Hasher, RandomSipHasher}; -use iter::{Iterator, FromIterator, Extendable}; -use iter; -use mem::replace; -use mem; +use iter::{mod, Iterator, FromIterator, Extendable}; +use mem::{mod, replace}; use num; -use ops::Deref; +use ops::{Deref, Index, IndexMut}; use option::{Some, None, Option}; -use result::{Ok, Err}; -use ops::Index; -use core::result::Result; +use result::{Result, Ok, Err}; use super::table; use super::table::{ @@ -837,6 +832,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// # Example /// /// ``` + /// # #![allow(deprecated)] /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); @@ -852,11 +848,9 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> { /// *map.get_mut(&"a") = -2; /// assert_eq!(map["a"], -2); /// ``` + #[deprecated = "use indexing instead: `&mut map[key]`"] pub fn get_mut<'a>(&'a mut self, k: &K) -> &'a mut V { - match self.find_mut(k) { - Some(v) => v, - None => panic!("no entry found for key") - } + &mut self[*k] } /// Return true if the map contains a value for the specified key, @@ -1194,13 +1188,15 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Index<K, V> for HashMap<K, V, H> { } } -// FIXME(#12825) Indexing will always try IndexMut first and that causes issues. -/*impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> ops::IndexMut<K, V> for HashMap<K, V, H> { +impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> IndexMut<K, V> for HashMap<K, V, H> { #[inline] fn index_mut<'a>(&'a mut self, index: &K) -> &'a mut V { - self.get_mut(index) + match self.find_mut(index) { + Some(v) => v, + None => panic!("no entry found for key") + } } -}*/ +} /// HashMap iterator pub struct Entries<'a, K: 'a, V: 'a> { diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index c2f27caad1d..ec6eef07c95 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -17,7 +17,7 @@ A simple wrapper over the platform's dynamic library facilities */ #![experimental] -#![allow(missing_doc)] +#![allow(missing_docs)] use clone::Clone; use collections::MutableSeq; @@ -286,6 +286,7 @@ pub mod dl { use os; use ptr; use result::{Ok, Err, Result}; + use slice::ImmutableSlice; use str::StrSlice; use str; use string::String; diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs index 07f4ebda2d4..91f3f38f89d 100644 --- a/src/libstd/io/comm_adapters.rs +++ b/src/libstd/io/comm_adapters.rs @@ -15,7 +15,7 @@ use comm::{Sender, Receiver}; use io; use option::{None, Some}; use result::{Ok, Err}; -use slice::{bytes, CloneableVector}; +use slice::{bytes, CloneableVector, ImmutableSlice}; use super::{Buffer, Reader, Writer, IoResult}; use vec::Vec; diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index 078a9a014c9..06ed183e936 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -10,7 +10,7 @@ //! Utility mixins that apply to all Readers and Writers -#![allow(missing_doc)] +#![allow(missing_docs)] // FIXME: Not sure how this should be structured // FIXME: Iteration should probably be considered separately diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs index f749d6c823e..f193ce8cffa 100644 --- a/src/libstd/io/fs.rs +++ b/src/libstd/io/fs.rs @@ -963,7 +963,7 @@ mod test { macro_rules! error( ($e:expr, $s:expr) => ( match $e { - Ok(val) => panic!("Unexpected success. Should've been: {}", $s), + Ok(_) => panic!("Unexpected success. Should've been: {}", $s), Err(ref err) => assert!(err.to_string().as_slice().contains($s.as_slice()), format!("`{}` did not contain `{}`", err, $s)) } diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index d22650107a3..6d6c0c0dd75 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -1856,60 +1856,60 @@ bitflags! { const ALL_PERMISSIONS = USER_RWX.bits | GROUP_RWX.bits | OTHER_RWX.bits, // Deprecated names - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use USER_READ instead"] const UserRead = USER_READ.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use USER_WRITE instead"] const UserWrite = USER_WRITE.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use USER_EXECUTE instead"] const UserExecute = USER_EXECUTE.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use GROUP_READ instead"] const GroupRead = GROUP_READ.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use GROUP_WRITE instead"] const GroupWrite = GROUP_WRITE.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use GROUP_EXECUTE instead"] const GroupExecute = GROUP_EXECUTE.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use OTHER_READ instead"] const OtherRead = OTHER_READ.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use OTHER_WRITE instead"] const OtherWrite = OTHER_WRITE.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use OTHER_EXECUTE instead"] const OtherExecute = OTHER_EXECUTE.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use USER_RWX instead"] const UserRWX = USER_RWX.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use GROUP_RWX instead"] const GroupRWX = GROUP_RWX.bits, - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use OTHER_RWX instead"] const OtherRWX = OTHER_RWX.bits, #[doc = "Deprecated: use `USER_FILE` instead."] - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use USER_FILE instead"] const UserFile = USER_FILE.bits, #[doc = "Deprecated: use `USER_DIR` instead."] - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use USER_DIR instead"] const UserDir = USER_DIR.bits, #[doc = "Deprecated: use `USER_EXEC` instead."] - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use USER_EXEC instead"] const UserExec = USER_EXEC.bits, #[doc = "Deprecated: use `ALL_PERMISSIONS` instead"] - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] #[deprecated = "use ALL_PERMISSIONS instead"] const AllPermissions = ALL_PERMISSIONS.bits, } diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs index 9d85701eb29..3c72f58b10d 100644 --- a/src/libstd/io/net/addrinfo.rs +++ b/src/libstd/io/net/addrinfo.rs @@ -17,7 +17,7 @@ getaddrinfo() */ -#![allow(missing_doc)] +#![allow(missing_docs)] use iter::Iterator; use io::{IoResult, IoError}; @@ -91,7 +91,7 @@ pub fn get_host_addresses(host: &str) -> IoResult<Vec<IpAddr>> { /// /// FIXME: this is not public because the `Hint` structure is not ready for public /// consumption just yet. -#[allow(unused_variable)] +#[allow(unused_variables)] fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>) -> IoResult<Vec<Info>> { let hint = hint.map(|Hint { family, socktype, protocol, flags }| { @@ -125,6 +125,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>) // permission without help of apk #[cfg(all(test, not(target_os = "android")))] mod test { + use prelude::*; use super::*; use io::net::ip::*; diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs index 5140159e4ea..e93af744699 100644 --- a/src/libstd/io/net/ip.rs +++ b/src/libstd/io/net/ip.rs @@ -13,7 +13,7 @@ //! This module contains functions useful for parsing, formatting, and //! manipulating IP addresses. -#![allow(missing_doc)] +#![allow(missing_docs)] use collections::Collection; use fmt; diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs index 112094d1d39..8c7deadebea 100644 --- a/src/libstd/io/net/pipe.rs +++ b/src/libstd/io/net/pipe.rs @@ -22,7 +22,7 @@ instances as clients. */ -#![allow(missing_doc)] +#![allow(missing_docs)] use prelude::*; diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs index 9362a48a6f0..c77cffd561e 100644 --- a/src/libstd/io/pipe.rs +++ b/src/libstd/io/pipe.rs @@ -13,7 +13,7 @@ //! Currently these aren't particularly useful, there only exists bindings //! enough so that pipes can be created to child processes. -#![allow(missing_doc)] +#![allow(missing_docs)] use prelude::*; diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index 36d23590704..4e5f8822acb 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -11,7 +11,7 @@ //! Bindings for executing child processes #![allow(experimental)] -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] use prelude::*; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 5451d07ab46..67080f4551f 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -113,7 +113,7 @@ // Don't link to std. We are std. #![no_std] -#![deny(missing_doc)] +#![deny(missing_docs)] #![reexport_test_harness_main = "test_main"] diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 9e0530a76f2..0712719dd04 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -304,11 +304,11 @@ macro_rules! println( #[macro_export] macro_rules! local_data_key( ($name:ident: $ty:ty) => ( - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey; ); (pub $name:ident: $ty:ty) => ( - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey; ); ) diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 3fa181b8478..0b2f17b8f93 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -11,8 +11,8 @@ //! Operations and constants for 32-bits floats (`f32` type) #![experimental] -#![allow(missing_doc)] -#![allow(unsigned_negate)] +#![allow(missing_docs)] +#![allow(unsigned_negation)] #![doc(primitive = "f32")] use prelude::*; diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index b9d54ba182b..35555b14081 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -11,7 +11,7 @@ //! Operations and constants for 64-bits floats (`f64` type) #![experimental] -#![allow(missing_doc)] +#![allow(missing_docs)] #![doc(primitive = "f64")] use prelude::*; diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 564b6a25f7f..ffe162cbc64 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -14,7 +14,7 @@ //! u32, u64, uint, i8, i16, i32, i64, int, f32, f64}`. #![experimental] -#![allow(missing_doc)] +#![allow(missing_docs)] use option::Option; diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index 6e0d81a63c9..3b17f0bc79f 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -10,7 +10,7 @@ // // ignore-lexer-test FIXME #15679 -#![allow(missing_doc)] +#![allow(missing_docs)] use char; use clone::Clone; @@ -424,10 +424,10 @@ pub fn float_to_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Float+ // or set to 0 if max and carry the 1. let current_digit = ascii2value(buf[i as uint]); if current_digit < (radix - 1) { - *buf.get_mut(i as uint) = value2ascii(current_digit+1); + buf[i as uint] = value2ascii(current_digit+1); break; } else { - *buf.get_mut(i as uint) = value2ascii(0); + buf[i as uint] = value2ascii(0); i -= 1; } } diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index f9bc9eb539a..c69c3ffa41c 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -11,7 +11,7 @@ #![experimental] #![macro_escape] #![doc(hidden)] -#![allow(unsigned_negate)] +#![allow(unsigned_negation)] macro_rules! uint_module (($T:ty) => ( diff --git a/src/libstd/os.rs b/src/libstd/os.rs index c7994ae84e8..d4e6251cebe 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -28,7 +28,7 @@ #![experimental] -#![allow(missing_doc)] +#![allow(missing_docs)] #![allow(non_snake_case)] use clone::Clone; @@ -144,7 +144,7 @@ pub mod windows { use option::{None, Option}; use option; use os::TMPBUF_SZ; - use slice::MutableSlice; + use slice::{MutableSlice, ImmutableSlice}; use string::String; use str::StrSlice; use vec::Vec; diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs index f27a1c1feda..0d7a467b313 100644 --- a/src/libstd/path/posix.rs +++ b/src/libstd/path/posix.rs @@ -457,9 +457,9 @@ fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option<Vec<&'a [u8]>> { } } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static dot_static: &'static [u8] = b"."; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static dot_dot_static: &'static [u8] = b".."; #[cfg(test)] diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs index 1897c8638cc..1ddc027a07e 100644 --- a/src/libstd/path/windows.rs +++ b/src/libstd/path/windows.rs @@ -776,7 +776,7 @@ impl Path { let mut s = String::from_str(s.slice_to(len)); unsafe { let v = s.as_mut_vec(); - *v.get_mut(0) = (*v)[0] + v[0] = (*v)[0] .to_ascii() .to_uppercase() .to_byte(); @@ -784,7 +784,7 @@ impl Path { if is_abs { // normalize C:/ to C:\ unsafe { - *s.as_mut_vec().get_mut(2) = SEP_BYTE; + s.as_mut_vec()[2] = SEP_BYTE; } } Some(s) @@ -794,7 +794,7 @@ impl Path { let mut s = String::from_str(s.slice_to(len)); unsafe { let v = s.as_mut_vec(); - *v.get_mut(4) = (*v)[4].to_ascii().to_uppercase().to_byte(); + v[4] = (*v)[4].to_ascii().to_uppercase().to_byte(); } Some(s) } diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index db9f3114cda..48be404b0d0 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -76,7 +76,7 @@ #[doc(no_inline)] pub use num::{FloatMath, ToPrimitive, FromPrimitive}; #[doc(no_inline)] pub use boxed::Box; #[doc(no_inline)] pub use path::{GenericPath, Path, PosixPath, WindowsPath}; -#[doc(no_inline)] pub use ptr::RawPtr; +#[doc(no_inline)] pub use ptr::{RawPtr, RawMutPtr}; #[doc(no_inline)] pub use io::{Buffer, Writer, Reader, Seek}; #[doc(no_inline)] pub use str::{Str, StrVector, StrSlice}; #[doc(no_inline)] pub use str::{IntoMaybeOwned, StrAllocating, UnicodeStrSlice}; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index d1c655cb4d0..21e531d211a 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -411,7 +411,7 @@ pub fn sample<T, I: Iterator<T>, R: Rng>(rng: &mut R, for (i, elem) in iter.enumerate() { let k = rng.gen_range(0, i + 1 + amount); if k < amount { - *reservoir.get_mut(k) = elem; + reservoir[k] = elem; } } return reservoir; diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index 424fd039fd4..bf5bdc8a308 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -88,7 +88,7 @@ mod imp { #[repr(C)] struct SecRandom; - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] static kSecRandomDefault: *const SecRandom = 0 as *const SecRandom; #[link(name = "Security", kind = "framework")] diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index e36d4ce8d4b..b97e80d0dc1 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -52,7 +52,7 @@ Several modules in `core` are clients of `rt`: #![experimental] // FIXME: this should not be here. -#![allow(missing_doc)] +#![allow(missing_docs)] use failure; use rustrt; diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs index 36070509432..be0af3a3f1a 100644 --- a/src/libstd/sync/future.rs +++ b/src/libstd/sync/future.rs @@ -24,7 +24,7 @@ * ``` */ -#![allow(missing_doc)] +#![allow(missing_docs)] use core::prelude::*; use core::mem::replace; diff --git a/src/libsync/comm/sync.rs b/src/libsync/comm/sync.rs index bbb4813f5f9..42de6f66289 100644 --- a/src/libsync/comm/sync.rs +++ b/src/libsync/comm/sync.rs @@ -426,7 +426,7 @@ impl<T> Buffer<T> { fn enqueue(&mut self, t: T) { let pos = (self.start + self.size) % self.buf.len(); self.size += 1; - let prev = mem::replace(self.buf.get_mut(pos), Some(t)); + let prev = mem::replace(&mut self.buf[pos], Some(t)); assert!(prev.is_none()); } @@ -434,7 +434,7 @@ impl<T> Buffer<T> { let start = self.start; self.size -= 1; self.start = (self.start + 1) % self.buf.len(); - self.buf.get_mut(start).take().unwrap() + self.buf[start].take().unwrap() } fn size(&self) -> uint { self.size } diff --git a/src/libsync/lib.rs b/src/libsync/lib.rs index a33e8a57137..ffff32f04c4 100644 --- a/src/libsync/lib.rs +++ b/src/libsync/lib.rs @@ -29,7 +29,7 @@ #![feature(phase, globs, macro_rules, unsafe_destructor)] #![feature(import_shadowing)] -#![deny(missing_doc)] +#![deny(missing_docs)] #![no_std] #[phase(plugin, link)] extern crate core; diff --git a/src/libsync/mpmc_bounded_queue.rs b/src/libsync/mpmc_bounded_queue.rs index b3b504f49ca..f75511ecbc2 100644 --- a/src/libsync/mpmc_bounded_queue.rs +++ b/src/libsync/mpmc_bounded_queue.rs @@ -26,7 +26,7 @@ */ #![experimental] -#![allow(missing_doc, dead_code)] +#![allow(missing_docs, dead_code)] // http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs index 4fd62ac3a1d..1410091b924 100644 --- a/src/libsync/raw.rs +++ b/src/libsync/raw.rs @@ -308,7 +308,7 @@ impl<'a> Condvar<'a> { // To avoid :broadcast_heavy, we make a new waitqueue, // swap it out with the old one, and broadcast on the // old one outside of the little-lock. - queue = Some(mem::replace(state.blocked.get_mut(condvar_id), + queue = Some(mem::replace(&mut state.blocked[condvar_id], WaitQueue::new())); } else { out_of_bounds = Some(state.blocked.len()); diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index 03325ad4706..dc41f3d9279 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -47,9 +47,9 @@ pub enum Architecture { Mipsel } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] const IntelBits: u32 = (1 << (X86 as uint)) | (1 << (X86_64 as uint)); -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] const ArmBits: u32 = (1 << (Arm as uint)); pub struct AbiData { @@ -72,7 +72,7 @@ pub enum AbiArchitecture { Archs(u32) } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] static AbiDatas: &'static [AbiData] = &[ // Platform-specific ABIs AbiData {abi: Cdecl, name: "cdecl", abi_arch: Archs(IntelBits)}, diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 3bd25d245e1..a2c859cf9fd 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -595,17 +595,38 @@ pub enum CaptureClause { CaptureByRef, } -/// A token that delimits a sequence of token trees -#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Show)] -pub struct Delimiter { - pub span: Span, - pub token: ::parse::token::Token, -} +/// A delimited sequence of token trees +#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Show)] +pub struct Delimited { + /// The type of delimiter + pub delim: token::DelimToken, + /// The span covering the opening delimiter + pub open_span: Span, + /// The delimited sequence of token trees + pub tts: Vec<TokenTree>, + /// The span covering the closing delimiter + pub close_span: Span, +} + +impl Delimited { + /// Returns the opening delimiter as a token. + pub fn open_token(&self) -> token::Token { + token::OpenDelim(self.delim) + } + + /// Returns the closing delimiter as a token. + pub fn close_token(&self) -> token::Token { + token::CloseDelim(self.delim) + } + + /// Returns the opening delimiter as a token tree. + pub fn open_tt(&self) -> TokenTree { + TtToken(self.open_span, self.open_token()) + } -impl Delimiter { - /// Convert the delimiter to a `TtToken` - pub fn to_tt(&self) -> TokenTree { - TtToken(self.span, self.token.clone()) + /// Returns the closing delimiter as a token tree. + pub fn close_tt(&self) -> TokenTree { + TtToken(self.close_span, self.close_token()) } } @@ -635,15 +656,15 @@ pub enum KleeneOp { #[doc="For macro invocations; parsing is delegated to the macro"] pub enum TokenTree { /// A single token - TtToken(Span, ::parse::token::Token), + TtToken(Span, token::Token), /// A delimited sequence of token trees - TtDelimited(Span, Rc<(Delimiter, Vec<TokenTree>, Delimiter)>), + TtDelimited(Span, Rc<Delimited>), // These only make sense for right-hand-sides of MBE macros: /// A Kleene-style repetition sequence with an optional separator. // FIXME(eddyb) #6308 Use Rc<[TokenTree]> after DST. - TtSequence(Span, Rc<Vec<TokenTree>>, Option<::parse::token::Token>, KleeneOp), + TtSequence(Span, Rc<Vec<TokenTree>>, Option<token::Token>, KleeneOp), /// A syntactic variable that will be filled in by macro expansion. TtNonterminal(Span, Ident) } @@ -715,10 +736,10 @@ pub type Matcher = Spanned<Matcher_>; #[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Show)] pub enum Matcher_ { /// Match one token - MatchTok(::parse::token::Token), + MatchTok(token::Token), /// Match repetitions of a sequence: body, separator, Kleene operator, /// lo, hi position-in-match-array used: - MatchSeq(Vec<Matcher> , Option<::parse::token::Token>, KleeneOp, uint, uint), + MatchSeq(Vec<Matcher>, Option<token::Token>, KleeneOp, uint, uint), /// Parse a Rust NT: name to bind, name of NT, position in match array: MatchNonterminal(Ident, Ident, uint) } diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs index 915c2d1b318..fa36577ebdb 100644 --- a/src/libsyntax/ast_map/mod.rs +++ b/src/libsyntax/ast_map/mod.rs @@ -712,7 +712,7 @@ impl<'ast> NodeCollector<'ast> { if id as uint >= len { self.map.grow(id as uint - len + 1, NotPresent); } - *self.map.get_mut(id as uint) = entry; + self.map[id as uint] = entry; } fn insert(&mut self, id: NodeId, node: Node<'ast>) { diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 7e1716e6b18..8b0e1f32fd4 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -291,7 +291,7 @@ pub fn operator_prec(op: ast::BinOp) -> uint { /// Precedence of the `as` operator, which is a binary operator /// not appearing in the prior table. -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub static as_prec: uint = 12u; pub fn empty_generics() -> Generics { diff --git a/src/libsyntax/diagnostics/macros.rs b/src/libsyntax/diagnostics/macros.rs index c344168b62a..b4bf793d4e1 100644 --- a/src/libsyntax/diagnostics/macros.rs +++ b/src/libsyntax/diagnostics/macros.rs @@ -40,6 +40,13 @@ macro_rules! span_note( ) #[macro_export] +macro_rules! span_help( + ($session:expr, $span:expr, $($message:tt)*) => ({ + ($session).span_help($span, format!($($message)*).as_slice()) + }) +) + +#[macro_export] macro_rules! register_diagnostics( ($($code:tt),*) => ( $(register_diagnostic!($code))* diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 2b52b7feacc..d57d6e52d7f 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -84,9 +84,9 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) let span = p.last_span; - p.expect(&token::LParen); + p.expect(&token::OpenDelim(token::Paren)); let out = p.parse_expr(); - p.expect(&token::RParen); + p.expect(&token::CloseDelim(token::Paren)); // Expands a read+write operand into two operands. // @@ -129,9 +129,9 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) cx.span_err(p.last_span, "input operand constraint contains '+'"); } - p.expect(&token::LParen); + p.expect(&token::OpenDelim(token::Paren)); let input = p.parse_expr(); - p.expect(&token::RParen); + p.expect(&token::CloseDelim(token::Paren)); inputs.push((constraint, input)); } diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index a8326e79ef3..e641abbfeee 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -785,6 +785,6 @@ impl SyntaxEnv { pub fn info<'a>(&'a mut self) -> &'a mut BlockInfo { let last_chain_index = self.chain.len() - 1; - &mut self.chain.get_mut(last_chain_index).info + &mut self.chain[last_chain_index].info } } diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 1b12ae67ee5..fa9a844233a 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -247,7 +247,7 @@ impl<'a, 'b> Context<'a, 'b> { self.verify_same(self.args[arg].span, &ty, arg_type); } if self.arg_types[arg].is_none() { - *self.arg_types.get_mut(arg) = Some(ty); + self.arg_types[arg] = Some(ty); } } @@ -567,7 +567,7 @@ impl<'a, 'b> Context<'a, 'b> { let lname = self.ecx.ident_of(format!("__arg{}", *name).as_slice()); pats.push(self.ecx.pat_ident(e.span, lname)); - *names.get_mut(self.name_positions[*name]) = + names[self.name_positions[*name]] = Some(Context::format_arg(self.ecx, e.span, arg_ty, self.ecx.expr_ident(e.span, lname))); heads.push(self.ecx.expr_addr_of(e.span, e)); diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index a95a737720a..f751655c9ff 100644 --- a/src/libsyntax/ext/quote.rs +++ b/src/libsyntax/ext/quote.rs @@ -531,7 +531,16 @@ fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOpToken) -> P<ast::Expr> { mk_token_path(cx, sp, name) } -#[allow(non_uppercase_statics)] // NOTE(stage0): remove this attribute after the next snapshot +fn mk_delim(cx: &ExtCtxt, sp: Span, delim: token::DelimToken) -> P<ast::Expr> { + let name = match delim { + token::Paren => "Paren", + token::Bracket => "Bracket", + token::Brace => "Brace", + }; + mk_token_path(cx, sp, name) +} + +#[allow(non_upper_case_globals)] fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> { match *tok { token::BinOp(binop) => { @@ -542,6 +551,15 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> { vec!(mk_binop(cx, sp, binop))); } + token::OpenDelim(delim) => { + return cx.expr_call(sp, mk_token_path(cx, sp, "OpenDelim"), + vec![mk_delim(cx, sp, delim)]); + } + token::CloseDelim(delim) => { + return cx.expr_call(sp, mk_token_path(cx, sp, "CloseDelim"), + vec![mk_delim(cx, sp, delim)]); + } + token::LitByte(i) => { let e_byte = mk_name(cx, sp, i.ident()); @@ -625,12 +643,6 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> { token::RArrow => "RArrow", token::LArrow => "LArrow", token::FatArrow => "FatArrow", - token::LParen => "LParen", - token::RParen => "RParen", - token::LBracket => "LBracket", - token::RBracket => "RBracket", - token::LBrace => "LBrace", - token::RBrace => "RBrace", token::Pound => "Pound", token::Dollar => "Dollar", token::Underscore => "Underscore", @@ -640,7 +652,6 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> { mk_token_path(cx, sp, name) } - fn mk_tt(cx: &ExtCtxt, _: Span, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> { match *tt { ast::TtToken(sp, ref tok) => { @@ -656,10 +667,9 @@ fn mk_tt(cx: &ExtCtxt, _: Span, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> { vec!(cx.stmt_expr(e_push)) }, ast::TtDelimited(sp, ref delimed) => { - let (ref open, ref tts, ref close) = **delimed; - mk_tt(cx, sp, &open.to_tt()).into_iter() - .chain(tts.iter().flat_map(|tt| mk_tt(cx, sp, tt).into_iter())) - .chain(mk_tt(cx, sp, &close.to_tt()).into_iter()) + mk_tt(cx, sp, &delimed.open_tt()).into_iter() + .chain(delimed.tts.iter().flat_map(|tt| mk_tt(cx, sp, tt).into_iter())) + .chain(mk_tt(cx, sp, &delimed.close_tt()).into_iter()) .collect() }, ast::TtSequence(..) => panic!("TtSequence in quote!"), diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 9260a45adb9..b522d5881d7 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -288,8 +288,7 @@ pub fn parse(sess: &ParseSess, // Only touch the binders we have actually bound for idx in range(ei.match_lo, ei.match_hi) { let sub = (ei.matches[idx]).clone(); - new_pos.matches - .get_mut(idx) + new_pos.matches[idx] .push(Rc::new(MatchedSeq(sub, mk_sp(ei.sp_lo, sp.hi)))); } @@ -331,8 +330,7 @@ pub fn parse(sess: &ParseSess, new_ei.idx += 1u; //we specifically matched zero repeats. for idx in range(match_idx_lo, match_idx_hi) { - new_ei.matches - .get_mut(idx) + new_ei.matches[idx] .push(Rc::new(MatchedSeq(Vec::new(), sp))); } @@ -355,10 +353,8 @@ pub fn parse(sess: &ParseSess, // Built-in nonterminals never start with these tokens, // so we can eliminate them from consideration. match tok { - token::RParen | - token::RBrace | - token::RBracket => {}, - _ => bb_eis.push(ei) + token::CloseDelim(_) => {}, + _ => bb_eis.push(ei), } } MatchTok(ref t) => { @@ -376,7 +372,7 @@ pub fn parse(sess: &ParseSess, if token_name_eq(&tok, &token::Eof) { if eof_eis.len() == 1u { let mut v = Vec::new(); - for dv in eof_eis.get_mut(0).matches.iter_mut() { + for dv in eof_eis[0].matches.iter_mut() { v.push(dv.pop().unwrap()); } return Success(nameize(sess, ms, v.as_slice())); @@ -417,7 +413,7 @@ pub fn parse(sess: &ParseSess, match ei.elts[ei.idx].node { MatchNonterminal(_, name, idx) => { let name_string = token::get_ident(name); - ei.matches.get_mut(idx).push(Rc::new(MatchedNonterminal( + ei.matches[idx].push(Rc::new(MatchedNonterminal( parse_nt(&mut rust_parser, name_string.get())))); ei.idx += 1u; } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 85bd5cde304..e50d4457af2 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -172,10 +172,7 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt, MatchedNonterminal(NtTT(ref tt)) => { match **tt { // ignore delimiters - TtDelimited(_, ref delimed) => { - let (_, ref tts, _) = **delimed; - tts.clone() - }, + TtDelimited(_, ref delimed) => delimed.tts.clone(), _ => cx.span_fatal(sp, "macro rhs must be delimited"), } }, diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 2c7b583d460..249a985a648 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -129,8 +129,7 @@ impl Add<LockstepIterSize, LockstepIterSize> for LockstepIterSize { fn lockstep_iter_size(t: &TokenTree, r: &TtReader) -> LockstepIterSize { match *t { TtDelimited(_, ref delimed) => { - let (_, ref tts, _) = **delimed; - tts.iter().fold(LisUnconstrained, |size, tt| { + delimed.tts.iter().fold(LisUnconstrained, |size, tt| { size + lockstep_iter_size(tt, r) }) }, @@ -207,14 +206,13 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan { }; match t { TtDelimited(_, ref delimed) => { - let (ref open, ref tts, ref close) = **delimed; - let mut forest = Vec::with_capacity(1 + tts.len() + 1); - forest.push(open.to_tt()); - forest.extend(tts.iter().map(|x| (*x).clone())); - forest.push(close.to_tt()); + let mut tts = Vec::with_capacity(1 + delimed.tts.len() + 1); + tts.push(delimed.open_tt()); + tts.extend(delimed.tts.iter().map(|tt| tt.clone())); + tts.push(delimed.close_tt()); r.stack.push(TtFrame { - forest: Rc::new(forest), + forest: Rc::new(tts), idx: 0, dotdotdoted: false, sep: None diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 47ca66b0b49..9a55f07e98d 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -572,18 +572,14 @@ pub fn noop_fold_tt<T: Folder>(tt: &TokenTree, fld: &mut T) -> TokenTree { TtToken(span, ref tok) => TtToken(span, fld.fold_token(tok.clone())), TtDelimited(span, ref delimed) => { - let (ref open, ref tts, ref close) = **delimed; - TtDelimited(span, Rc::new(( - Delimiter { - span: open.span, - token: fld.fold_token(open.token.clone()) - }, - fld.fold_tts(tts.as_slice()), - Delimiter { - span: close.span, - token: fld.fold_token(close.token.clone()) - }, - ))) + TtDelimited(span, Rc::new( + Delimited { + delim: delimed.delim, + open_span: delimed.open_span, + tts: fld.fold_tts(delimed.tts.as_slice()), + close_span: delimed.close_span, + } + )) }, TtSequence(span, ref pattern, ref sep, is_optional) => TtSequence(span, diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index 458a5042a7e..aefac804e4d 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -81,10 +81,10 @@ impl<'a> ParserAttr for Parser<'a> { ast::AttrOuter }; - self.expect(&token::LBracket); + self.expect(&token::OpenDelim(token::Bracket)); let meta_item = self.parse_meta_item(); let hi = self.span.hi; - self.expect(&token::RBracket); + self.expect(&token::CloseDelim(token::Bracket)); (mk_sp(lo, hi), meta_item, style) } @@ -194,7 +194,7 @@ impl<'a> ParserAttr for Parser<'a> { let hi = self.span.hi; P(spanned(lo, hi, ast::MetaNameValue(name, lit))) } - token::LParen => { + token::OpenDelim(token::Paren) => { let inner_items = self.parse_meta_seq(); let hi = self.span.hi; P(spanned(lo, hi, ast::MetaList(name, inner_items))) @@ -208,15 +208,15 @@ impl<'a> ParserAttr for Parser<'a> { /// matches meta_seq = ( COMMASEP(meta_item) ) fn parse_meta_seq(&mut self) -> Vec<P<ast::MetaItem>> { - self.parse_seq(&token::LParen, - &token::RParen, + self.parse_seq(&token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_disallowed(token::Comma), |p| p.parse_meta_item()).node } fn parse_optional_meta(&mut self) -> Vec<P<ast::MetaItem>> { match self.token { - token::LParen => self.parse_meta_seq(), + token::OpenDelim(token::Paren) => self.parse_meta_seq(), _ => Vec::new() } } diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 3a6cf610b4f..293b91111b5 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -967,12 +967,12 @@ impl<'a> StringReader<'a> { token::Dot }; } - '(' => { self.bump(); return token::LParen; } - ')' => { self.bump(); return token::RParen; } - '{' => { self.bump(); return token::LBrace; } - '}' => { self.bump(); return token::RBrace; } - '[' => { self.bump(); return token::LBracket; } - ']' => { self.bump(); return token::RBracket; } + '(' => { self.bump(); return token::OpenDelim(token::Paren); } + ')' => { self.bump(); return token::CloseDelim(token::Paren); } + '{' => { self.bump(); return token::OpenDelim(token::Brace); } + '}' => { self.bump(); return token::CloseDelim(token::Brace); } + '[' => { self.bump(); return token::OpenDelim(token::Bracket); } + ']' => { self.bump(); return token::CloseDelim(token::Bracket); } '@' => { self.bump(); return token::At; } '#' => { self.bump(); return token::Pound; } '~' => { self.bump(); return token::Tilde; } diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index c731f3965a0..83499ec54c6 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -799,29 +799,23 @@ mod test { ast::TtDelimited(_, ref macro_delimed)] if name_macro_rules.as_str() == "macro_rules" && name_zip.as_str() == "zip" => { - let (ref macro_open, ref macro_tts, ref macro_close) = **macro_delimed; - match (macro_open, macro_tts.as_slice(), macro_close) { - (&ast::Delimiter { token: token::LParen, .. }, - [ast::TtDelimited(_, ref first_delimed), - ast::TtToken(_, token::FatArrow), - ast::TtDelimited(_, ref second_delimed)], - &ast::Delimiter { token: token::RParen, .. }) => { - let (ref first_open, ref first_tts, ref first_close) = **first_delimed; - match (first_open, first_tts.as_slice(), first_close) { - (&ast::Delimiter { token: token::LParen, .. }, - [ast::TtToken(_, token::Dollar), - ast::TtToken(_, token::Ident(name, token::Plain))], - &ast::Delimiter { token: token::RParen, .. }) - if name.as_str() == "a" => {}, + match macro_delimed.tts.as_slice() { + [ast::TtDelimited(_, ref first_delimed), + ast::TtToken(_, token::FatArrow), + ast::TtDelimited(_, ref second_delimed)] + if macro_delimed.delim == token::Paren => { + match first_delimed.tts.as_slice() { + [ast::TtToken(_, token::Dollar), + ast::TtToken(_, token::Ident(name, token::Plain))] + if first_delimed.delim == token::Paren + && name.as_str() == "a" => {}, _ => panic!("value 3: {}", **first_delimed), } - let (ref second_open, ref second_tts, ref second_close) = **second_delimed; - match (second_open, second_tts.as_slice(), second_close) { - (&ast::Delimiter { token: token::LParen, .. }, - [ast::TtToken(_, token::Dollar), - ast::TtToken(_, token::Ident(name, token::Plain))], - &ast::Delimiter { token: token::RParen, .. }) - if name.as_str() == "a" => {}, + match second_delimed.tts.as_slice() { + [ast::TtToken(_, token::Dollar), + ast::TtToken(_, token::Ident(name, token::Plain))] + if second_delimed.delim == token::Paren + && name.as_str() == "a" => {}, _ => panic!("value 4: {}", **second_delimed), } }, @@ -867,12 +861,10 @@ mod test { \"variant\":\"TtDelimited\",\ \"fields\":[\ null,\ - [\ - {\ - \"span\":null,\ - \"token\":\"LParen\"\ - },\ - [\ + {\ + \"delim\":\"Paren\",\ + \"open_span\":null,\ + \"tts\":[\ {\ \"variant\":\"TtToken\",\ \"fields\":[\ @@ -907,23 +899,18 @@ mod test { ]\ }\ ],\ - {\ - \"span\":null,\ - \"token\":\"RParen\"\ - }\ - ]\ + \"close_span\":null\ + }\ ]\ },\ {\ \"variant\":\"TtDelimited\",\ \"fields\":[\ null,\ - [\ - {\ - \"span\":null,\ - \"token\":\"LBrace\"\ - },\ - [\ + {\ + \"delim\":\"Brace\",\ + \"open_span\":null,\ + \"tts\":[\ {\ \"variant\":\"TtToken\",\ \"fields\":[\ @@ -945,11 +932,8 @@ mod test { ]\ }\ ],\ - {\ - \"span\":null,\ - \"token\":\"RBrace\"\ - }\ - ]\ + \"close_span\":null\ + }\ ]\ }\ ]".to_string() diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 8ef3a559bf4..aa3b9668d46 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -48,7 +48,7 @@ use ast::{StmtExpr, StmtSemi, StmtMac, StructDef, StructField}; use ast::{StructVariantKind, BiSub}; use ast::StrStyle; use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue}; -use ast::{Delimiter, TokenTree, TraitItem, TraitRef, TtDelimited, TtSequence, TtToken}; +use ast::{Delimited, TokenTree, TraitItem, TraitRef, TtDelimited, TtSequence, TtToken}; use ast::{TtNonterminal, TupleVariantKind, Ty, Ty_, TyBot}; use ast::{TypeField, TyFixedLengthVec, TyClosure, TyProc, TyBareFn}; use ast::{TyTypeof, TyInfer, TypeMethod}; @@ -474,15 +474,15 @@ impl<'a> Parser<'a> { /// recover (without consuming any expected input token). Returns /// true if and only if input was consumed for recovery. pub fn check_for_erroneous_unit_struct_expecting(&mut self, expected: &[token::Token]) -> bool { - if self.token == token::LBrace - && expected.iter().all(|t| *t != token::LBrace) - && self.look_ahead(1, |t| *t == token::RBrace) { + if self.token == token::OpenDelim(token::Brace) + && expected.iter().all(|t| *t != token::OpenDelim(token::Brace)) + && self.look_ahead(1, |t| *t == token::CloseDelim(token::Brace)) { // matched; signal non-fatal error and recover. let span = self.span; self.span_err(span, "unit-like struct construction is written with no trailing `{ }`"); - self.eat(&token::LBrace); - self.eat(&token::RBrace); + self.eat(&token::OpenDelim(token::Brace)); + self.eat(&token::CloseDelim(token::Brace)); true } else { false @@ -1265,8 +1265,8 @@ impl<'a> Parser<'a> { /// Parse the items in a trait declaration pub fn parse_trait_items(&mut self) -> Vec<TraitItem> { self.parse_unspanned_seq( - &token::LBrace, - &token::RBrace, + &token::OpenDelim(token::Brace), + &token::CloseDelim(token::Brace), seq_sep_none(), |p| { let attrs = p.parse_outer_attributes(); @@ -1319,7 +1319,7 @@ impl<'a> Parser<'a> { vis: vis, }) } - token::LBrace => { + token::OpenDelim(token::Brace) => { debug!("parse_trait_methods(): parsing provided method"); let (inner_attrs, body) = p.parse_inner_attrs_and_block(); @@ -1411,9 +1411,9 @@ impl<'a> Parser<'a> { let lo = self.span.lo; - let t = if self.token == token::LParen { + let t = if self.token == token::OpenDelim(token::Paren) { self.bump(); - if self.token == token::RParen { + if self.token == token::CloseDelim(token::Paren) { self.bump(); TyNil } else { @@ -1424,7 +1424,7 @@ impl<'a> Parser<'a> { let mut one_tuple = false; while self.token == token::Comma { self.bump(); - if self.token != token::RParen { + if self.token != token::CloseDelim(token::Paren) { ts.push(self.parse_ty(true)); } else { @@ -1433,11 +1433,11 @@ impl<'a> Parser<'a> { } if ts.len() == 1 && !one_tuple { - self.expect(&token::RParen); + self.expect(&token::CloseDelim(token::Paren)); TyParen(ts.into_iter().nth(0).unwrap()) } else { let t = TyTup(ts); - self.expect(&token::RParen); + self.expect(&token::CloseDelim(token::Paren)); t } } @@ -1446,7 +1446,7 @@ impl<'a> Parser<'a> { self.bump(); let last_span = self.last_span; match self.token { - token::LBracket => self.obsolete(last_span, ObsoleteOwnedVector), + token::OpenDelim(token::Bracket) => self.obsolete(last_span, ObsoleteOwnedVector), _ => self.obsolete(last_span, ObsoleteOwnedType) } TyUniq(self.parse_ty(false)) @@ -1454,9 +1454,9 @@ impl<'a> Parser<'a> { // STAR POINTER (bare pointer?) self.bump(); TyPtr(self.parse_ptr()) - } else if self.token == token::LBracket { + } else if self.token == token::OpenDelim(token::Bracket) { // VECTOR - self.expect(&token::LBracket); + self.expect(&token::OpenDelim(token::Bracket)); let t = self.parse_ty(true); // Parse the `, ..e` in `[ int, ..e ]` @@ -1465,7 +1465,7 @@ impl<'a> Parser<'a> { None => TyVec(t), Some(suffix) => TyFixedLengthVec(t, suffix) }; - self.expect(&token::RBracket); + self.expect(&token::CloseDelim(token::Bracket)); t } else if self.token == token::BinOp(token::And) || self.token == token::AndAnd { @@ -1490,9 +1490,9 @@ impl<'a> Parser<'a> { } else if self.eat_keyword(keywords::Typeof) { // TYPEOF // In order to not be ambiguous, the type must be surrounded by parens. - self.expect(&token::LParen); + self.expect(&token::OpenDelim(token::Paren)); let e = self.parse_expr(); - self.expect(&token::RParen); + self.expect(&token::CloseDelim(token::Paren)); TyTypeof(e) } else if self.eat_keyword(keywords::Proc) { self.parse_proc_type() @@ -1661,7 +1661,10 @@ impl<'a> Parser<'a> { LitBinary(parse::binary_lit(i.as_str())), token::LitBinaryRaw(i, _) => LitBinary(Rc::new(i.as_str().as_bytes().iter().map(|&x| x).collect())), - token::LParen => { self.expect(&token::RParen); LitNil }, + token::OpenDelim(token::Paren) => { + self.expect(&token::CloseDelim(token::Paren)); + LitNil + }, _ => { self.unexpected_last(tok); } } } @@ -2013,6 +2016,16 @@ impl<'a> Parser<'a> { }) } + fn expect_open_delim(&mut self) -> token::DelimToken { + match self.token { + token::OpenDelim(delim) => { + self.bump(); + delim + }, + _ => self.fatal("expected open delimiter"), + } + } + /// At the bottom (top?) of the precedence hierarchy, /// parse things like parenthesized exprs, /// macros, return, etc. @@ -2025,31 +2038,32 @@ impl<'a> Parser<'a> { let ex: Expr_; match self.token { - token::LParen => { + token::OpenDelim(token::Paren) => { self.bump(); // (e) is parenthesized e // (e,) is a tuple with only one field, e let mut trailing_comma = false; - if self.token == token::RParen { + if self.token == token::CloseDelim(token::Paren) { hi = self.span.hi; self.bump(); let lit = P(spanned(lo, hi, LitNil)); return self.mk_expr(lo, hi, ExprLit(lit)); } let mut es = vec!(self.parse_expr()); - self.commit_expr(&**es.last().unwrap(), &[], &[token::Comma, token::RParen]); + self.commit_expr(&**es.last().unwrap(), &[], + &[token::Comma, token::CloseDelim(token::Paren)]); while self.token == token::Comma { self.bump(); - if self.token != token::RParen { + if self.token != token::CloseDelim(token::Paren) { es.push(self.parse_expr()); self.commit_expr(&**es.last().unwrap(), &[], - &[token::Comma, token::RParen]); + &[token::Comma, token::CloseDelim(token::Paren)]); } else { trailing_comma = true; } } hi = self.span.hi; - self.commit_expr_expecting(&**es.last().unwrap(), token::RParen); + self.commit_expr_expecting(&**es.last().unwrap(), token::CloseDelim(token::Paren)); return if es.len() == 1 && !trailing_comma { self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap())) @@ -2057,7 +2071,7 @@ impl<'a> Parser<'a> { self.mk_expr(lo, hi, ExprTup(es)) } }, - token::LBrace => { + token::OpenDelim(token::Brace) => { self.bump(); let blk = self.parse_block_tail(lo, DefaultBlock); return self.mk_expr(blk.span.lo, blk.span.hi, @@ -2077,10 +2091,10 @@ impl<'a> Parser<'a> { ex = ExprPath(path); hi = self.last_span.hi; } - token::LBracket => { + token::OpenDelim(token::Bracket) => { self.bump(); - if self.token == token::RBracket { + if self.token == token::CloseDelim(token::Bracket) { // Empty vector. self.bump(); ex = ExprVec(Vec::new()); @@ -2093,13 +2107,13 @@ impl<'a> Parser<'a> { self.bump(); self.bump(); let count = self.parse_expr(); - self.expect(&token::RBracket); + self.expect(&token::CloseDelim(token::Bracket)); ex = ExprRepeat(first_expr, count); } else if self.token == token::Comma { // Vector with two or more elements. self.bump(); let remaining_exprs = self.parse_seq_to_end( - &token::RBracket, + &token::CloseDelim(token::Bracket), seq_sep_trailing_allowed(token::Comma), |p| p.parse_expr() ); @@ -2108,7 +2122,7 @@ impl<'a> Parser<'a> { ex = ExprVec(exprs); } else { // Vector with one element. - self.expect(&token::RBracket); + self.expect(&token::CloseDelim(token::Bracket)); ex = ExprVec(vec!(first_expr)); } } @@ -2209,14 +2223,9 @@ impl<'a> Parser<'a> { // MACRO INVOCATION expression self.bump(); - let ket = self.token.get_close_delimiter() - .unwrap_or_else(|| { - self.fatal("expected open delimiter") - }); - self.bump(); - + let delim = self.expect_open_delim(); let tts = self.parse_seq_to_end( - &ket, + &token::CloseDelim(delim), seq_sep_none(), |p| p.parse_token_tree()); let hi = self.span.hi; @@ -2227,7 +2236,7 @@ impl<'a> Parser<'a> { tts, EMPTY_CTXT)); } - if self.token == token::LBrace { + if self.token == token::OpenDelim(token::Brace) { // This is a struct literal, unless we're prohibited // from parsing struct literals here. if !self.restrictions.contains(RESTRICTION_NO_STRUCT_LITERAL) { @@ -2236,7 +2245,7 @@ impl<'a> Parser<'a> { let mut fields = Vec::new(); let mut base = None; - while self.token != token::RBrace { + while self.token != token::CloseDelim(token::Brace) { if self.eat(&token::DotDot) { base = Some(self.parse_expr()); break; @@ -2245,7 +2254,7 @@ impl<'a> Parser<'a> { fields.push(self.parse_field()); self.commit_expr(&*fields.last().unwrap().expr, &[token::Comma], - &[token::RBrace]); + &[token::CloseDelim(token::Brace)]); } if fields.len() == 0 && base.is_none() { @@ -2258,7 +2267,7 @@ impl<'a> Parser<'a> { } hi = self.span.hi; - self.expect(&token::RBrace); + self.expect(&token::CloseDelim(token::Brace)); ex = ExprStruct(pth, fields, base); return self.mk_expr(lo, hi, ex); } @@ -2281,7 +2290,7 @@ impl<'a> Parser<'a> { /// Parse a block or unsafe block pub fn parse_block_expr(&mut self, lo: BytePos, blk_mode: BlockCheckMode) -> P<Expr> { - self.expect(&token::LBrace); + self.expect(&token::OpenDelim(token::Brace)); let blk = self.parse_block_tail(lo, blk_mode); return self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk)); } @@ -2313,10 +2322,10 @@ impl<'a> Parser<'a> { // expr.f() method call match self.token { - token::LParen => { + token::OpenDelim(token::Paren) => { let mut es = self.parse_unspanned_seq( - &token::LParen, - &token::RParen, + &token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| p.parse_expr() ); @@ -2376,10 +2385,10 @@ impl<'a> Parser<'a> { if self.expr_is_complete(&*e) { break; } match self.token { // expr(...) - token::LParen => { + token::OpenDelim(token::Paren) => { let es = self.parse_unspanned_seq( - &token::LParen, - &token::RParen, + &token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| p.parse_expr() ); @@ -2393,7 +2402,7 @@ impl<'a> Parser<'a> { // Could be either an index expression or a slicing expression. // Any slicing non-terminal can have a mutable version with `mut` // after the opening square bracket. - token::LBracket => { + token::OpenDelim(token::Bracket) => { self.bump(); let mutbl = if self.eat_keyword(keywords::Mut) { MutMutable @@ -2402,7 +2411,7 @@ impl<'a> Parser<'a> { }; match self.token { // e[] - token::RBracket => { + token::CloseDelim(token::Bracket) => { self.bump(); hi = self.span.hi; let slice = self.mk_slice(e, None, None, mutbl); @@ -2413,7 +2422,7 @@ impl<'a> Parser<'a> { self.bump(); match self.token { // e[..] - token::RBracket => { + token::CloseDelim(token::Bracket) => { self.bump(); hi = self.span.hi; let slice = self.mk_slice(e, None, None, mutbl); @@ -2427,7 +2436,7 @@ impl<'a> Parser<'a> { _ => { hi = self.span.hi; let e2 = self.parse_expr(); - self.commit_expr_expecting(&*e2, token::RBracket); + self.commit_expr_expecting(&*e2, token::CloseDelim(token::Bracket)); let slice = self.mk_slice(e, None, Some(e2), mutbl); e = self.mk_expr(lo, hi, slice) } @@ -2442,14 +2451,15 @@ impl<'a> Parser<'a> { self.bump(); let e2 = match self.token { // e[e..] - token::RBracket => { + token::CloseDelim(token::Bracket) => { self.bump(); None } // e[e..e] _ => { let e2 = self.parse_expr(); - self.commit_expr_expecting(&*e2, token::RBracket); + self.commit_expr_expecting(&*e2, + token::CloseDelim(token::Bracket)); Some(e2) } }; @@ -2464,7 +2474,7 @@ impl<'a> Parser<'a> { "`mut` keyword is invalid in index expressions"); } hi = self.span.hi; - self.commit_expr_expecting(&*ix, token::RBracket); + self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket)); let index = self.mk_index(e, ix); e = self.mk_expr(lo, hi, index) } @@ -2525,7 +2535,7 @@ impl<'a> Parser<'a> { fn parse_non_delim_tt_tok(p: &mut Parser) -> TokenTree { maybe_whole!(deref p, NtTT); match p.token { - token::RParen | token::RBrace | token::RBracket => { + token::CloseDelim(_) => { // This is a conservative error: only report the last unclosed delimiter. The // previous unclosed delimiters could actually be closed! The parser just hasn't // gotten to them yet. @@ -2542,10 +2552,10 @@ impl<'a> Parser<'a> { p.bump(); let sp = p.span; - if p.token == token::LParen { + if p.token == token::OpenDelim(token::Paren) { let seq = p.parse_seq( - &token::LParen, - &token::RParen, + &token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_none(), |p| p.parse_token_tree() ); @@ -2564,8 +2574,8 @@ impl<'a> Parser<'a> { } } - match (&self.token, self.token.get_close_delimiter()) { - (&token::Eof, _) => { + match self.token { + token::Eof => { let open_braces = self.open_braces.clone(); for sp in open_braces.iter() { self.span_note(*sp, "Did you mean to close this delimiter?"); @@ -2573,36 +2583,39 @@ impl<'a> Parser<'a> { // There shouldn't really be a span, but it's easier for the test runner // if we give it one self.fatal("this file contains an un-closed delimiter "); - } - (_, Some(close_delim)) => { + }, + token::OpenDelim(delim) => { // The span for beginning of the delimited section let pre_span = self.span; // Parse the open delimiter. self.open_braces.push(self.span); - let open = Delimiter { - span: self.span, - token: self.bump_and_get(), - }; + let open_span = self.span; + self.bump(); // Parse the token trees within the delimeters let tts = self.parse_seq_to_before_end( - &close_delim, seq_sep_none(), |p| p.parse_token_tree() + &token::CloseDelim(delim), + seq_sep_none(), + |p| p.parse_token_tree() ); // Parse the close delimiter. - let close = Delimiter { - span: self.span, - token: self.bump_and_get(), - }; + let close_span = self.span; + self.bump(); self.open_braces.pop().unwrap(); // Expand to cover the entire delimited token tree let span = Span { hi: self.span.hi, ..pre_span }; - TtDelimited(span, Rc::new((open, tts, close))) - } - _ => parse_non_delim_tt_tok(self) + TtDelimited(span, Rc::new(Delimited { + delim: delim, + open_span: open_span, + tts: tts, + close_span: close_span, + })) + }, + _ => parse_non_delim_tt_tok(self), } } @@ -2621,13 +2634,8 @@ impl<'a> Parser<'a> { // the interpolation of Matcher's maybe_whole!(self, NtMatchers); let mut name_idx = 0u; - match self.token.get_close_delimiter() { - Some(other_delimiter) => { - self.bump(); - self.parse_matcher_subseq_upto(&mut name_idx, &other_delimiter) - } - None => self.fatal("expected open delimiter") - } + let delim = self.expect_open_delim(); + self.parse_matcher_subseq_upto(&mut name_idx, &token::CloseDelim(delim)) } /// This goofy function is necessary to correctly match parens in Matcher's. @@ -2641,8 +2649,8 @@ impl<'a> Parser<'a> { let mut lparens = 0u; while self.token != *ket || lparens > 0u { - if self.token == token::LParen { lparens += 1u; } - if self.token == token::RParen { lparens -= 1u; } + if self.token == token::OpenDelim(token::Paren) { lparens += 1u; } + if self.token == token::CloseDelim(token::Paren) { lparens -= 1u; } ret_val.push(self.parse_matcher(name_idx)); } @@ -2656,11 +2664,11 @@ impl<'a> Parser<'a> { let m = if self.token == token::Dollar { self.bump(); - if self.token == token::LParen { + if self.token == token::OpenDelim(token::Paren) { let name_idx_lo = *name_idx; self.bump(); let ms = self.parse_matcher_subseq_upto(name_idx, - &token::RParen); + &token::CloseDelim(token::Paren)); if ms.len() == 0u { self.fatal("repetition body must be nonempty"); } @@ -2717,7 +2725,9 @@ impl<'a> Parser<'a> { self.bump(); let last_span = self.last_span; match self.token { - token::LBracket => self.obsolete(last_span, ObsoleteOwnedVector), + token::OpenDelim(token::Bracket) => { + self.obsolete(last_span, ObsoleteOwnedVector) + }, _ => self.obsolete(last_span, ObsoleteOwnedExpr) } @@ -2730,14 +2740,28 @@ impl<'a> Parser<'a> { return self.parse_dot_or_call_expr(); } + let lo = self.span.lo; + self.bump(); // Check for a place: `box(PLACE) EXPR`. - if self.eat(&token::LParen) { + if self.eat(&token::OpenDelim(token::Paren)) { // Support `box() EXPR` as the default. - if !self.eat(&token::RParen) { + if !self.eat(&token::CloseDelim(token::Paren)) { let place = self.parse_expr(); - self.expect(&token::RParen); + self.expect(&token::CloseDelim(token::Paren)); + // Give a suggestion to use `box()` when a parenthesised expression is used + if !self.token.can_begin_expr() { + let span = self.span; + let this_token_to_string = self.this_token_to_string(); + self.span_err(span, + format!("expected expression, found `{}`", + this_token_to_string).as_slice()); + let box_span = mk_sp(lo, self.last_span.hi); + self.span_help(box_span, + "perhaps you meant `box() (foo)` instead?"); + self.abort_if_errors(); + } let subexpression = self.parse_prefix_expr(); hi = subexpression.span.hi; ex = ExprBox(place, subexpression); @@ -2966,9 +2990,9 @@ impl<'a> Parser<'a> { fn parse_match_expr(&mut self) -> P<Expr> { let lo = self.last_span.lo; let discriminant = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL); - self.commit_expr_expecting(&*discriminant, token::LBrace); + self.commit_expr_expecting(&*discriminant, token::OpenDelim(token::Brace)); let mut arms: Vec<Arm> = Vec::new(); - while self.token != token::RBrace { + while self.token != token::CloseDelim(token::Brace) { arms.push(self.parse_arm()); } let hi = self.span.hi; @@ -2988,10 +3012,10 @@ impl<'a> Parser<'a> { let require_comma = !classify::expr_is_simple_block(&*expr) - && self.token != token::RBrace; + && self.token != token::CloseDelim(token::Brace); if require_comma { - self.commit_expr(&*expr, &[token::Comma], &[token::RBrace]); + self.commit_expr(&*expr, &[token::Comma], &[token::CloseDelim(token::Brace)]); } else { self.eat(&token::Comma); } @@ -3047,7 +3071,7 @@ impl<'a> Parser<'a> { let mut first = true; let mut before_slice = true; - while self.token != token::RBracket { + while self.token != token::CloseDelim(token::Bracket) { if first { first = false; } else { @@ -3059,7 +3083,7 @@ impl<'a> Parser<'a> { self.bump(); if self.token == token::Comma || - self.token == token::RBracket { + self.token == token::CloseDelim(token::Bracket) { slice = Some(P(ast::Pat { id: ast::DUMMY_NODE_ID, node: PatWild(PatWildMulti), @@ -3095,13 +3119,13 @@ impl<'a> Parser<'a> { let mut fields = Vec::new(); let mut etc = false; let mut first = true; - while self.token != token::RBrace { + while self.token != token::CloseDelim(token::Brace) { if first { first = false; } else { self.expect(&token::Comma); // accept trailing commas - if self.token == token::RBrace { break } + if self.token == token::CloseDelim(token::Brace) { break } } let lo = self.span.lo; @@ -3109,7 +3133,7 @@ impl<'a> Parser<'a> { if self.token == token::DotDot { self.bump(); - if self.token != token::RBrace { + if self.token != token::CloseDelim(token::Brace) { let token_str = self.this_token_to_string(); self.fatal(format!("expected `{}`, found `{}`", "}", token_str).as_slice()) @@ -3205,10 +3229,10 @@ impl<'a> Parser<'a> { span: mk_sp(lo, hi) }) } - token::LParen => { + token::OpenDelim(token::Paren) => { // parse (pat,pat,pat,...) as tuple self.bump(); - if self.token == token::RParen { + if self.token == token::CloseDelim(token::Paren) { hi = self.span.hi; self.bump(); let lit = P(codemap::Spanned { @@ -3218,15 +3242,15 @@ impl<'a> Parser<'a> { pat = PatLit(expr); } else { let mut fields = vec!(self.parse_pat()); - if self.look_ahead(1, |t| *t != token::RParen) { + if self.look_ahead(1, |t| *t != token::CloseDelim(token::Paren)) { while self.token == token::Comma { self.bump(); - if self.token == token::RParen { break; } + if self.token == token::CloseDelim(token::Paren) { break; } fields.push(self.parse_pat()); } } if fields.len() == 1 { self.expect(&token::Comma); } - self.expect(&token::RParen); + self.expect(&token::CloseDelim(token::Paren)); pat = PatTup(fields); } hi = self.last_span.hi; @@ -3236,13 +3260,13 @@ impl<'a> Parser<'a> { span: mk_sp(lo, hi) }) } - token::LBracket => { + token::OpenDelim(token::Bracket) => { // parse [pat,pat,...] as vector pattern self.bump(); let (before, slice, after) = self.parse_pat_vec_elements(); - self.expect(&token::RBracket); + self.expect(&token::CloseDelim(token::Bracket)); pat = ast::PatVec(before, slice, after); hi = self.last_span.hi; return P(ast::Pat { @@ -3266,7 +3290,7 @@ impl<'a> Parser<'a> { let val = self.parse_literal_maybe_minus(); if (self.token == token::DotDotDot) && self.look_ahead(1, |t| { - *t != token::Comma && *t != token::RBracket + *t != token::Comma && *t != token::CloseDelim(token::Bracket) }) { self.bump(); let end = if self.token.is_ident() || self.token.is_path() { @@ -3303,15 +3327,14 @@ impl<'a> Parser<'a> { } else { let can_be_enum_or_struct = self.look_ahead(1, |t| { match *t { - token::LParen | token::LBracket | token::Lt | - token::LBrace | token::ModSep => true, + token::OpenDelim(_) | token::Lt | token::ModSep => true, _ => false, } }); if self.look_ahead(1, |t| *t == token::DotDotDot) && self.look_ahead(2, |t| { - *t != token::Comma && *t != token::RBracket + *t != token::Comma && *t != token::CloseDelim(token::Bracket) }) { let start = self.parse_expr_res(RESTRICTION_NO_BAR_OP); self.eat(&token::DotDotDot); @@ -3323,11 +3346,8 @@ impl<'a> Parser<'a> { let pth1 = codemap::Spanned{span:id_span, node: id}; if self.eat(&token::Not) { // macro invocation - let ket = self.token.get_close_delimiter() - .unwrap_or_else(|| self.fatal("expected open delimiter")); - self.bump(); - - let tts = self.parse_seq_to_end(&ket, + let delim = self.expect_open_delim(); + let tts = self.parse_seq_to_end(&token::CloseDelim(delim), seq_sep_none(), |p| p.parse_token_tree()); @@ -3348,7 +3368,7 @@ impl<'a> Parser<'a> { let enum_path = self.parse_path(LifetimeAndTypesWithColons) .path; match self.token { - token::LBrace => { + token::OpenDelim(token::Brace) => { self.bump(); let (fields, etc) = self.parse_pat_fields(); @@ -3358,7 +3378,7 @@ impl<'a> Parser<'a> { _ => { let mut args: Vec<P<Pat>> = Vec::new(); match self.token { - token::LParen => { + token::OpenDelim(token::Paren) => { let is_dotdot = self.look_ahead(1, |t| { match *t { token::DotDot => true, @@ -3369,12 +3389,12 @@ impl<'a> Parser<'a> { // This is a "top constructor only" pat self.bump(); self.bump(); - self.expect(&token::RParen); + self.expect(&token::CloseDelim(token::Paren)); pat = PatEnum(enum_path, None); } else { args = self.parse_enum_variant_seq( - &token::LParen, - &token::RParen, + &token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| p.parse_pat() ); @@ -3443,7 +3463,7 @@ impl<'a> Parser<'a> { // leads to a parse error. Note that if there is no explicit // binding mode then we do not end up here, because the lookahead // will direct us over to parse_enum_variant() - if self.token == token::LParen { + if self.token == token::OpenDelim(token::Paren) { let last_span = self.last_span; self.span_fatal( last_span, @@ -3543,18 +3563,17 @@ impl<'a> Parser<'a> { let pth = self.parse_path(NoTypesAllowed).path; self.bump(); - let id = if self.token.get_close_delimiter().is_some() { - token::special_idents::invalid // no special identifier - } else { - self.parse_ident() + let id = match self.token { + token::OpenDelim(_) => token::special_idents::invalid, // no special identifier + _ => self.parse_ident(), }; // check that we're pointing at delimiters (need to check // again after the `if`, because of `parse_ident` // consuming more tokens). - let (bra, ket) = match self.token.get_close_delimiter() { - Some(ket) => (self.token.clone(), ket), - None => { + let delim = match self.token { + token::OpenDelim(delim) => delim, + _ => { // we only expect an ident if we didn't parse one // above. let ident_str = if id.name == token::special_idents::invalid.name { @@ -3566,18 +3585,28 @@ impl<'a> Parser<'a> { self.fatal(format!("expected {}`(` or `{{`, found `{}`", ident_str, tok_str).as_slice()) - } + }, }; let tts = self.parse_unspanned_seq( - &bra, - &ket, + &token::OpenDelim(delim), + &token::CloseDelim(delim), seq_sep_none(), |p| p.parse_token_tree() ); let hi = self.span.hi; if id.name == token::special_idents::invalid.name { + if self.token == token::Dot { + let span = self.span; + let token_string = self.this_token_to_string(); + self.span_err(span, + format!("expected statement, found `{}`", + token_string).as_slice()); + let mac_span = mk_sp(lo, hi); + self.span_help(mac_span, "try parenthesizing this macro invocation"); + self.abort_if_errors(); + } P(spanned(lo, hi, StmtMac( spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT)), false))) } else { @@ -3632,7 +3661,7 @@ impl<'a> Parser<'a> { maybe_whole!(no_clone self, NtBlock); let lo = self.span.lo; - self.expect(&token::LBrace); + self.expect(&token::OpenDelim(token::Brace)); return self.parse_block_tail_(lo, DefaultBlock, Vec::new()); } @@ -3644,7 +3673,7 @@ impl<'a> Parser<'a> { maybe_whole!(pair_empty self, NtBlock); let lo = self.span.lo; - self.expect(&token::LBrace); + self.expect(&token::OpenDelim(token::Brace)); let (inner, next) = self.parse_inner_attrs_and_next(); (inner, self.parse_block_tail_(lo, DefaultBlock, next)) @@ -3681,7 +3710,7 @@ impl<'a> Parser<'a> { let mut attributes_box = attrs_remaining; - while self.token != token::RBrace { + while self.token != token::CloseDelim(token::Brace) { // parsing items even when they're not allowed lets us give // better error messages and recover more gracefully. attributes_box.push_all(self.parse_outer_attributes().as_slice()); @@ -3695,7 +3724,7 @@ impl<'a> Parser<'a> { } self.bump(); // empty } - token::RBrace => { + token::CloseDelim(token::Brace) => { // fall through and out. } _ => { @@ -3706,7 +3735,8 @@ impl<'a> Parser<'a> { // expression without semicolon if classify::expr_requires_semi_to_be_stmt(&*e) { // Just check for errors and recover; do not eat semicolon yet. - self.commit_stmt(&[], &[token::Semi, token::RBrace]); + self.commit_stmt(&[], &[token::Semi, + token::CloseDelim(token::Brace)]); } match self.token { @@ -3722,7 +3752,7 @@ impl<'a> Parser<'a> { span: span_with_semi, })); } - token::RBrace => { + token::CloseDelim(token::Brace) => { expr = Some(e); } _ => { @@ -3743,7 +3773,7 @@ impl<'a> Parser<'a> { })); self.bump(); } - token::RBrace => { + token::CloseDelim(token::Brace) => { // if a block ends in `m!(arg)` without // a `;`, it must be an expr expr = Some( @@ -3838,10 +3868,10 @@ impl<'a> Parser<'a> { token::ModSep | token::Ident(..) => { let path = self.parse_path(LifetimeAndTypesWithoutColons).path; - if self.token == token::LParen { + if self.token == token::OpenDelim(token::Paren) { self.bump(); let inputs = self.parse_seq_to_end( - &token::RParen, + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| p.parse_arg_general(false)); let (return_style, output) = self.parse_ret_ty(); @@ -4035,14 +4065,14 @@ impl<'a> Parser<'a> { let sp = self.span; let mut args: Vec<Option<Arg>> = self.parse_unspanned_seq( - &token::LParen, - &token::RParen, + &token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| { if p.token == token::DotDotDot { p.bump(); if allow_variadic { - if p.token != token::RParen { + if p.token != token::CloseDelim(token::Paren) { let span = p.span; p.span_fatal(span, "`...` must be last in argument list for variadic function"); @@ -4154,7 +4184,7 @@ impl<'a> Parser<'a> { } } - self.expect(&token::LParen); + self.expect(&token::OpenDelim(token::Paren)); // A bit of complexity and lookahead is needed here in order to be // backwards compatible. @@ -4249,14 +4279,14 @@ impl<'a> Parser<'a> { self.bump(); let sep = seq_sep_trailing_allowed(token::Comma); let mut fn_inputs = self.parse_seq_to_before_end( - &token::RParen, + &token::CloseDelim(token::Paren), sep, parse_arg_fn ); fn_inputs.insert(0, Arg::new_self(explicit_self_sp, mutbl_self, $self_id)); fn_inputs } - token::RParen => { + token::CloseDelim(token::Paren) => { vec!(Arg::new_self(explicit_self_sp, mutbl_self, $self_id)) } _ => { @@ -4271,7 +4301,7 @@ impl<'a> Parser<'a> { let fn_inputs = match explicit_self { SelfStatic => { let sep = seq_sep_trailing_allowed(token::Comma); - self.parse_seq_to_before_end(&token::RParen, sep, parse_arg_fn) + self.parse_seq_to_before_end(&token::CloseDelim(token::Paren), sep, parse_arg_fn) } SelfValue(id) => parse_remaining_arguments!(id), SelfRegion(_,_,id) => parse_remaining_arguments!(id), @@ -4279,7 +4309,7 @@ impl<'a> Parser<'a> { }; - self.expect(&token::RParen); + self.expect(&token::CloseDelim(token::Paren)); let hi = self.span.hi; @@ -4335,8 +4365,8 @@ impl<'a> Parser<'a> { /// Parses the `(arg, arg) -> return_type` header on a procedure. fn parse_proc_decl(&mut self) -> P<FnDecl> { let inputs = - self.parse_unspanned_seq(&token::LParen, - &token::RParen, + self.parse_unspanned_seq(&token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| p.parse_fn_block_arg()); @@ -4405,22 +4435,17 @@ impl<'a> Parser<'a> { let (method_, hi, new_attrs) = { if !self.token.is_any_keyword() && self.look_ahead(1, |t| *t == token::Not) - && (self.look_ahead(2, |t| *t == token::LParen) - || self.look_ahead(2, |t| *t == token::LBrace)) { + && (self.look_ahead(2, |t| *t == token::OpenDelim(token::Paren)) + || self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace))) { // method macro. let pth = self.parse_path(NoTypesAllowed).path; self.expect(&token::Not); // eat a matched-delimiter token tree: - let tts = match self.token.get_close_delimiter() { - Some(ket) => { - self.bump(); - self.parse_seq_to_end(&ket, - seq_sep_none(), - |p| p.parse_token_tree()) - } - None => self.fatal("expected open delimiter") - }; + let delim = self.expect_open_delim(); + let tts = self.parse_seq_to_end(&token::CloseDelim(delim), + seq_sep_none(), + |p| p.parse_token_tree()); let m_ = ast::MacInvocTT(pth, tts, EMPTY_CTXT); let m: ast::Mac = codemap::Spanned { node: m_, span: mk_sp(self.span.lo, @@ -4484,10 +4509,10 @@ impl<'a> Parser<'a> { fn parse_impl_items(&mut self) -> (Vec<ImplItem>, Vec<Attribute>) { let mut impl_items = Vec::new(); - self.expect(&token::LBrace); + self.expect(&token::OpenDelim(token::Brace)); let (inner_attrs, mut method_attrs) = self.parse_inner_attrs_and_next(); - while !self.eat(&token::RBrace) { + while !self.eat(&token::CloseDelim(token::Brace)) { method_attrs.extend(self.parse_outer_attributes().into_iter()); let vis = self.parse_visibility(); if self.eat_keyword(keywords::Type) { @@ -4513,7 +4538,7 @@ impl<'a> Parser<'a> { // Special case: if the next identifier that follows is '(', don't // allow this to be parsed as a trait. - let could_be_trait = self.token != token::LParen; + let could_be_trait = self.token != token::OpenDelim(token::Paren); // Parse the trait. let mut ty = self.parse_ty(true); @@ -4571,11 +4596,11 @@ impl<'a> Parser<'a> { let mut fields: Vec<StructField>; let is_tuple_like; - if self.eat(&token::LBrace) { + if self.eat(&token::OpenDelim(token::Brace)) { // It's a record-like struct. is_tuple_like = false; fields = Vec::new(); - while self.token != token::RBrace { + while self.token != token::CloseDelim(token::Brace) { fields.push(self.parse_struct_decl_field()); } if fields.len() == 0 { @@ -4584,12 +4609,12 @@ impl<'a> Parser<'a> { token::get_ident(class_name)).as_slice()); } self.bump(); - } else if self.token == token::LParen { + } else if self.token == token::OpenDelim(token::Paren) { // It's a tuple-like struct. is_tuple_like = true; fields = self.parse_unspanned_seq( - &token::LParen, - &token::RParen, + &token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| { let attrs = p.parse_outer_attributes(); @@ -4639,7 +4664,7 @@ impl<'a> Parser<'a> { token::Comma => { self.bump(); } - token::RBrace => {} + token::CloseDelim(token::Brace) => {} _ => { let span = self.span; let token_str = self.this_token_to_string(); @@ -4771,13 +4796,13 @@ impl<'a> Parser<'a> { (id, m, Some(attrs)) } else { self.push_mod_path(id, outer_attrs); - self.expect(&token::LBrace); + self.expect(&token::OpenDelim(token::Brace)); let mod_inner_lo = self.span.lo; let old_owns_directory = self.owns_directory; self.owns_directory = true; let (inner, next) = self.parse_inner_attrs_and_next(); - let m = self.parse_mod_items(token::RBrace, next, mod_inner_lo); - self.expect(&token::RBrace); + let m = self.parse_mod_items(token::CloseDelim(token::Brace), next, mod_inner_lo); + self.expect(&token::CloseDelim(token::Brace)); self.owns_directory = old_owns_directory; self.pop_mod_path(); (id, ItemMod(m), Some(inner)) @@ -4978,7 +5003,7 @@ impl<'a> Parser<'a> { self.span_err(last_span, Parser::expected_item_err(attrs_remaining.as_slice())); } - assert!(self.token == token::RBrace); + assert!(self.token == token::CloseDelim(token::Brace)); ast::ForeignMod { abi: abi, view_items: view_items, @@ -5065,13 +5090,13 @@ impl<'a> Parser<'a> { attrs: Vec<Attribute> ) -> ItemOrViewItem { - self.expect(&token::LBrace); + self.expect(&token::OpenDelim(token::Brace)); let abi = opt_abi.unwrap_or(abi::C); let (inner, next) = self.parse_inner_attrs_and_next(); let m = self.parse_foreign_mod_items(abi, next); - self.expect(&token::RBrace); + self.expect(&token::CloseDelim(token::Brace)); let last_span = self.last_span; let item = self.mk_item(lo, @@ -5098,7 +5123,7 @@ impl<'a> Parser<'a> { /// this should probably be renamed or refactored... fn parse_struct_def(&mut self) -> P<StructDef> { let mut fields: Vec<StructField> = Vec::new(); - while self.token != token::RBrace { + while self.token != token::CloseDelim(token::Brace) { fields.push(self.parse_struct_decl_field()); } self.bump(); @@ -5114,7 +5139,7 @@ impl<'a> Parser<'a> { let mut variants = Vec::new(); let mut all_nullary = true; let mut any_disr = None; - while self.token != token::RBrace { + while self.token != token::CloseDelim(token::Brace) { let variant_attrs = self.parse_outer_attributes(); let vlo = self.span.lo; @@ -5125,15 +5150,15 @@ impl<'a> Parser<'a> { let mut args = Vec::new(); let mut disr_expr = None; ident = self.parse_ident(); - if self.eat(&token::LBrace) { + if self.eat(&token::OpenDelim(token::Brace)) { // Parse a struct variant. all_nullary = false; kind = StructVariantKind(self.parse_struct_def()); - } else if self.token == token::LParen { + } else if self.token == token::OpenDelim(token::Paren) { all_nullary = false; let arg_tys = self.parse_enum_variant_seq( - &token::LParen, - &token::RParen, + &token::OpenDelim(token::Paren), + &token::CloseDelim(token::Paren), seq_sep_trailing_allowed(token::Comma), |p| p.parse_ty(true) ); @@ -5164,7 +5189,7 @@ impl<'a> Parser<'a> { if !self.eat(&token::Comma) { break; } } - self.expect(&token::RBrace); + self.expect(&token::CloseDelim(token::Brace)); match any_disr { Some(disr_span) if !all_nullary => self.span_err(disr_span, @@ -5180,7 +5205,7 @@ impl<'a> Parser<'a> { let id = self.parse_ident(); let mut generics = self.parse_generics(); self.parse_where_clause(&mut generics); - self.expect(&token::LBrace); + self.expect(&token::OpenDelim(token::Brace)); let enum_definition = self.parse_enum_def(&generics); (id, ItemEnum(enum_definition, generics), None) @@ -5188,7 +5213,7 @@ impl<'a> Parser<'a> { fn fn_expr_lookahead(tok: &token::Token) -> bool { match *tok { - token::LParen | token::At | token::Tilde | token::BinOp(_) => true, + token::OpenDelim(token::Paren) | token::At | token::Tilde | token::BinOp(_) => true, _ => false } } @@ -5291,7 +5316,7 @@ impl<'a> Parser<'a> { visibility, maybe_append(attrs, extra_attrs)); return IoviItem(item); - } else if self.token == token::LBrace { + } else if self.token == token::OpenDelim(token::Brace) { return self.parse_item_foreign_mod(lo, opt_abi, visibility, attrs); } @@ -5356,7 +5381,7 @@ impl<'a> Parser<'a> { return IoviItem(item); } if self.token.is_keyword(keywords::Unsafe) - && self.look_ahead(1u, |t| *t != token::LBrace) { + && self.look_ahead(1u, |t| *t != token::OpenDelim(token::Brace)) { // UNSAFE FUNCTION ITEM self.bump(); let abi = if self.eat_keyword(keywords::Extern) { @@ -5486,8 +5511,8 @@ impl<'a> Parser<'a> { if macros_allowed && !self.token.is_any_keyword() && self.look_ahead(1, |t| *t == token::Not) && (self.look_ahead(2, |t| t.is_plain_ident()) - || self.look_ahead(2, |t| *t == token::LParen) - || self.look_ahead(2, |t| *t == token::LBrace)) { + || self.look_ahead(2, |t| *t == token::OpenDelim(token::Paren)) + || self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace))) { // MACRO INVOCATION ITEM // item macro. @@ -5503,15 +5528,10 @@ impl<'a> Parser<'a> { token::special_idents::invalid // no special identifier }; // eat a matched-delimiter token tree: - let tts = match self.token.get_close_delimiter() { - Some(ket) => { - self.bump(); - self.parse_seq_to_end(&ket, - seq_sep_none(), - |p| p.parse_token_tree()) - } - None => self.fatal("expected open delimiter") - }; + let delim = self.expect_open_delim(); + let tts = self.parse_seq_to_end(&token::CloseDelim(delim), + seq_sep_none(), + |p| p.parse_token_tree()); // single-variant-enum... : let m = ast::MacInvocTT(pth, tts, EMPTY_CTXT); let m: ast::Mac = codemap::Spanned { node: m, @@ -5573,10 +5593,11 @@ impl<'a> Parser<'a> { fn parse_view_path(&mut self) -> P<ViewPath> { let lo = self.span.lo; - if self.token == token::LBrace { + if self.token == token::OpenDelim(token::Brace) { // use {foo,bar} let idents = self.parse_unspanned_seq( - &token::LBrace, &token::RBrace, + &token::OpenDelim(token::Brace), + &token::CloseDelim(token::Brace), seq_sep_trailing_allowed(token::Comma), |p| p.parse_path_list_item()); let path = ast::Path { @@ -5631,10 +5652,10 @@ impl<'a> Parser<'a> { } // foo::bar::{a,b,c} - token::LBrace => { + token::OpenDelim(token::Brace) => { let idents = self.parse_unspanned_seq( - &token::LBrace, - &token::RBrace, + &token::OpenDelim(token::Brace), + &token::CloseDelim(token::Brace), seq_sep_trailing_allowed(token::Comma), |p| p.parse_path_list_item() ); @@ -5793,7 +5814,7 @@ impl<'a> Parser<'a> { loop { match self.parse_foreign_item(attrs, macros_allowed) { IoviNone(returned_attrs) => { - if self.token == token::RBrace { + if self.token == token::CloseDelim(token::Brace) { attrs = returned_attrs; break } diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 9ed8e4bc3a7..d56aa8da72a 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -56,12 +56,6 @@ use std::rc::Rc; #[cfg(stage0)] pub use self::RArrow as RARROW; #[cfg(stage0)] pub use self::LArrow as LARROW; #[cfg(stage0)] pub use self::FatArrow as FAT_ARROW; -#[cfg(stage0)] pub use self::LParen as LPAREN; -#[cfg(stage0)] pub use self::RParen as RPAREN; -#[cfg(stage0)] pub use self::LBracket as LBRACKET; -#[cfg(stage0)] pub use self::RBracket as RBRACKET; -#[cfg(stage0)] pub use self::LBrace as LBRACE; -#[cfg(stage0)] pub use self::RBrace as RBRACE; #[cfg(stage0)] pub use self::Pound as POUND; #[cfg(stage0)] pub use self::Dollar as DOLLAR; #[cfg(stage0)] pub use self::Question as QUESTION; @@ -82,6 +76,12 @@ use std::rc::Rc; #[cfg(stage0)] pub use self::Comment as COMMENT; #[cfg(stage0)] pub use self::Shebang as SHEBANG; #[cfg(stage0)] pub use self::Eof as EOF; +#[cfg(stage0)] pub const LPAREN: Token = OpenDelim(Paren); +#[cfg(stage0)] pub const RPAREN: Token = CloseDelim(Paren); +#[cfg(stage0)] pub const LBRACKET: Token = OpenDelim(Bracket); +#[cfg(stage0)] pub const RBRACKET: Token = CloseDelim(Bracket); +#[cfg(stage0)] pub const LBRACE: Token = OpenDelim(Brace); +#[cfg(stage0)] pub const RBRACE: Token = CloseDelim(Brace); #[allow(non_camel_case_types)] #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)] @@ -98,11 +98,22 @@ pub enum BinOpToken { Shr, } +/// A delimeter token +#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)] +pub enum DelimToken { + /// A round parenthesis: `(` or `)` + Paren, + /// A square bracket: `[` or `]` + Bracket, + /// A curly brace: `{` or `}` + Brace, +} + #[cfg(stage0)] -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const ModName: bool = true; #[cfg(stage0)] -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const Plain: bool = false; #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)] @@ -143,15 +154,13 @@ pub enum Token { RArrow, LArrow, FatArrow, - LParen, - RParen, - LBracket, - RBracket, - LBrace, - RBrace, Pound, Dollar, Question, + /// An opening delimeter, eg. `{` + OpenDelim(DelimToken), + /// A closing delimeter, eg. `}` + CloseDelim(DelimToken), /* Literals */ LitByte(ast::Name), @@ -192,9 +201,7 @@ impl Token { /// Returns `true` if the token can appear at the start of an expression. pub fn can_begin_expr(&self) -> bool { match *self { - LParen => true, - LBrace => true, - LBracket => true, + OpenDelim(_) => true, Ident(_, _) => true, Underscore => true, Tilde => true, @@ -223,17 +230,6 @@ impl Token { } } - /// Returns the matching close delimiter if this is an open delimiter, - /// otherwise `None`. - pub fn get_close_delimiter(&self) -> Option<Token> { - match *self { - LParen => Some(RParen), - LBrace => Some(RBrace), - LBracket => Some(RBracket), - _ => None, - } - } - /// Returns `true` if the token is any literal pub fn is_lit(&self) -> bool { match *self { @@ -267,11 +263,11 @@ impl Token { /// Returns `true` if the token is a path that is not followed by a `::` /// token. - #[allow(non_uppercase_statics)] // NOTE(stage0): remove this attribute after the next snapshot + #[allow(non_upper_case_globals)] pub fn is_plain_ident(&self) -> bool { match *self { Ident(_, Plain) => true, - _ => false, + _ => false, } } @@ -315,7 +311,7 @@ impl Token { } /// Returns `true` if the token is a given keyword, `kw`. - #[allow(non_uppercase_statics)] // NOTE(stage0): remove this attribute after the next snapshot + #[allow(non_upper_case_globals)] pub fn is_keyword(&self, kw: keywords::Keyword) -> bool { match *self { Ident(sid, Plain) => kw.to_name() == sid.name, @@ -325,7 +321,7 @@ impl Token { /// Returns `true` if the token is either a special identifier, or a strict /// or reserved keyword. - #[allow(non_uppercase_statics)] // NOTE(stage0): remove this attribute after the next snapshot + #[allow(non_upper_case_globals)] pub fn is_any_keyword(&self) -> bool { match *self { Ident(sid, Plain) => { @@ -342,7 +338,7 @@ impl Token { } /// Returns `true` if the token may not appear as an identifier. - #[allow(non_uppercase_statics)] // NOTE(stage0): remove this attribute after the next snapshot + #[allow(non_upper_case_globals)] pub fn is_strict_keyword(&self) -> bool { match *self { Ident(sid, Plain) => { @@ -368,7 +364,7 @@ impl Token { /// Returns `true` if the token is a keyword that has been reserved for /// possible future use. - #[allow(non_uppercase_statics)] // NOTE(stage0): remove this attribute after the next snapshot + #[allow(non_upper_case_globals)] pub fn is_reserved_keyword(&self) -> bool { match *self { Ident(sid, Plain) => { @@ -396,20 +392,20 @@ impl Token { #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)] /// For interpolation during macro expansion. pub enum Nonterminal { - NtItem( P<ast::Item>), + NtItem(P<ast::Item>), NtBlock(P<ast::Block>), - NtStmt( P<ast::Stmt>), - NtPat( P<ast::Pat>), - NtExpr( P<ast::Expr>), - NtTy( P<ast::Ty>), + NtStmt(P<ast::Stmt>), + NtPat(P<ast::Pat>), + NtExpr(P<ast::Expr>), + NtTy(P<ast::Ty>), #[cfg(stage0)] NtIdent(Box<ast::Ident>, bool), #[cfg(not(stage0))] NtIdent(Box<ast::Ident>, IdentStyle), /// Stuff inside brackets for attributes - NtMeta( P<ast::MetaItem>), + NtMeta(P<ast::MetaItem>), NtPath(Box<ast::Path>), - NtTT( P<ast::TokenTree>), // needs P'ed to break a circularity + NtTT(P<ast::TokenTree>), // needs P'ed to break a circularity NtMatchers(Vec<ast::Matcher>) } @@ -469,7 +465,7 @@ macro_rules! declare_special_idents_and_keywords {( pub mod special_idents { use ast; $( - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] pub const $si_static: ast::Ident = ast::Ident { name: ast::Name($si_name), ctxt: 0, @@ -480,7 +476,7 @@ macro_rules! declare_special_idents_and_keywords {( pub mod special_names { use ast; $( - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] pub const $si_static: ast::Name = ast::Name($si_name); )* } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 57c72ca77c6..5523f85aceb 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -303,7 +303,7 @@ impl Printer { } // be very careful with this! pub fn replace_last_token(&mut self, t: Token) { - *self.token.get_mut(self.right) = t; + self.token[self.right] = t; } pub fn pretty_print(&mut self, t: Token) -> io::IoResult<()> { debug!("pp ~[{},{}]", self.left, self.right); @@ -327,8 +327,8 @@ impl Printer { } else { self.advance_right(); } debug!("pp Begin({})/buffer ~[{},{}]", b.offset, self.left, self.right); - *self.token.get_mut(self.right) = t; - *self.size.get_mut(self.right) = -self.right_total; + self.token[self.right] = t; + self.size[self.right] = -self.right_total; let right = self.right; self.scan_push(right); Ok(()) @@ -340,8 +340,8 @@ impl Printer { } else { debug!("pp End/buffer ~[{},{}]", self.left, self.right); self.advance_right(); - *self.token.get_mut(self.right) = t; - *self.size.get_mut(self.right) = -1; + self.token[self.right] = t; + self.size[self.right] = -1; let right = self.right; self.scan_push(right); Ok(()) @@ -359,8 +359,8 @@ impl Printer { self.check_stack(0); let right = self.right; self.scan_push(right); - *self.token.get_mut(self.right) = t; - *self.size.get_mut(self.right) = -self.right_total; + self.token[self.right] = t; + self.size[self.right] = -self.right_total; self.right_total += b.blank_space; Ok(()) } @@ -373,8 +373,8 @@ impl Printer { debug!("pp String('{}')/buffer ~[{},{}]", *s, self.left, self.right); self.advance_right(); - *self.token.get_mut(self.right) = t.clone(); - *self.size.get_mut(self.right) = len; + self.token[self.right] = t.clone(); + self.size[self.right] = len; self.right_total += len; self.check_stream() } @@ -391,7 +391,7 @@ impl Printer { if self.left == self.scan_stack[self.bottom] { debug!("setting {} to infinity and popping", self.left); let scanned = self.scan_pop_bottom(); - *self.size.get_mut(scanned) = SIZE_INFINITY; + self.size[scanned] = SIZE_INFINITY; } } let left = self.token[self.left].clone(); @@ -412,7 +412,7 @@ impl Printer { self.top %= self.buf_len; assert!((self.top != self.bottom)); } - *self.scan_stack.get_mut(self.top) = x; + self.scan_stack[self.top] = x; } pub fn scan_pop(&mut self) -> uint { assert!((!self.scan_stack_empty)); @@ -474,20 +474,19 @@ impl Printer { Begin(_) => { if k > 0 { let popped = self.scan_pop(); - *self.size.get_mut(popped) = self.size[x] + - self.right_total; + self.size[popped] = self.size[x] + self.right_total; self.check_stack(k - 1); } } End => { // paper says + not =, but that makes no sense. let popped = self.scan_pop(); - *self.size.get_mut(popped) = 1; + self.size[popped] = 1; self.check_stack(k + 1); } _ => { let popped = self.scan_pop(); - *self.size.get_mut(popped) = self.size[x] + self.right_total; + self.size[popped] = self.size[x] + self.right_total; if k > 0 { self.check_stack(k); } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index d347d0199a7..386fd8ae5a6 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -90,10 +90,10 @@ pub fn rust_printer_annotated<'a>(writer: Box<io::Writer+'static>, } } -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const indent_unit: uint = 4u; -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const default_columns: uint = 78u; /// Requires you to pass an input filename and reader so that @@ -225,12 +225,12 @@ pub fn token_to_string(tok: &Token) -> String { token::RArrow => "->".into_string(), token::LArrow => "<-".into_string(), token::FatArrow => "=>".into_string(), - token::LParen => "(".into_string(), - token::RParen => ")".into_string(), - token::LBracket => "[".into_string(), - token::RBracket => "]".into_string(), - token::LBrace => "{".into_string(), - token::RBrace => "}".into_string(), + token::OpenDelim(token::Paren) => "(".into_string(), + token::CloseDelim(token::Paren) => ")".into_string(), + token::OpenDelim(token::Bracket) => "[".into_string(), + token::CloseDelim(token::Bracket) => "]".into_string(), + token::OpenDelim(token::Brace) => "{".into_string(), + token::CloseDelim(token::Brace) => "}".into_string(), token::Pound => "#".into_string(), token::Dollar => "$".into_string(), token::Question => "?".into_string(), @@ -1121,12 +1121,11 @@ impl<'a> State<'a> { pub fn print_tt(&mut self, tt: &ast::TokenTree) -> IoResult<()> { match *tt { ast::TtDelimited(_, ref delimed) => { - let (ref open, ref tts, ref close) = **delimed; - try!(word(&mut self.s, token_to_string(&open.token).as_slice())); + try!(word(&mut self.s, token_to_string(&delimed.open_token()).as_slice())); try!(space(&mut self.s)); - try!(self.print_tts(tts.as_slice())); + try!(self.print_tts(delimed.tts.as_slice())); try!(space(&mut self.s)); - word(&mut self.s, token_to_string(&close.token).as_slice()) + word(&mut self.s, token_to_string(&delimed.close_token()).as_slice()) }, ast::TtToken(_, ref tk) => { try!(word(&mut self.s, token_to_string(tk).as_slice())); diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index 2e93f6badf2..02a2613d481 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -52,7 +52,7 @@ #![allow(unknown_features)] #![feature(macro_rules, phase, slicing_syntax)] -#![deny(missing_doc)] +#![deny(missing_docs)] #[phase(plugin, link)] extern crate log; diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs index a3482dc85c6..5a0f10ce520 100644 --- a/src/libterm/terminfo/parm.rs +++ b/src/libterm/terminfo/parm.rs @@ -38,7 +38,7 @@ enum FormatState { } /// Types of parameters a capability can use -#[allow(missing_doc)] +#[allow(missing_docs)] #[deriving(Clone)] pub enum Param { Words(String), diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs index 6b921144144..9eb7216fba0 100644 --- a/src/libterm/terminfo/parser/compiled.rs +++ b/src/libterm/terminfo/parser/compiled.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] //! ncurses-compatible compiled terminfo format parsing (term(5)) diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 72c61f3afc7..2cc694176de 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(missing_doc)] +#![allow(missing_docs)] use std::collections::hashmap; use std::collections::hashmap::{Occupied, Vacant}; @@ -128,7 +128,7 @@ pub trait Stats <T: FloatMath + FromPrimitive>{ /// Extracted collection of all the summary statistics of a sample set. #[deriving(Clone, PartialEq)] -#[allow(missing_doc)] +#[allow(missing_docs)] pub struct Summary<T> { pub sum: T, pub min: T, @@ -185,7 +185,7 @@ impl<'a, T: FloatMath + FromPrimitive> Stats<T> for &'a [T] { let hi = x + y; let lo = y - (hi - x); if !lo.is_zero() { - *partials.get_mut(j) = lo; + partials[j] = lo; j += 1; } x = hi; @@ -193,7 +193,7 @@ impl<'a, T: FloatMath + FromPrimitive> Stats<T> for &'a [T] { if j >= partials.len() { partials.push(x); } else { - *partials.get_mut(j) = x; + partials[j] = x; partials.truncate(j+1); } } diff --git a/src/libunicode/tables.rs b/src/libunicode/tables.rs index 3f15abcad6d..5fe91a87056 100644 --- a/src/libunicode/tables.rs +++ b/src/libunicode/tables.rs @@ -10,7 +10,7 @@ // NOTE: The following code was generated by "src/etc/unicode.py", do not edit directly -#![allow(missing_doc, non_uppercase_statics, non_snake_case)] +#![allow(missing_docs, non_upper_case_globals, non_snake_case)] /// The version of [Unicode](http://www.unicode.org/) /// that the `UnicodeChar` and `UnicodeStrSlice` traits are based on. diff --git a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs index 1d14da73b7e..8f83c9ec94f 100644 --- a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs +++ b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused-static.rs @@ -15,9 +15,9 @@ extern crate regex; #[phase(plugin)] extern crate regex_macros; -#[deny(unused_variable)] +#[deny(unused_variables)] #[deny(dead_code)] -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] // Tests to make sure that extraneous dead code warnings aren't emitted from // the code generated by regex!. diff --git a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs index c17f3c6da50..b4dda05f42d 100644 --- a/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs +++ b/src/test/compile-fail-fulldeps/syntax-extension-regex-unused.rs @@ -15,7 +15,7 @@ extern crate regex; #[phase(plugin)] extern crate regex_macros; -#[deny(unused_variable)] +#[deny(unused_variables)] #[deny(dead_code)] // Tests to make sure that extraneous dead code warnings aren't emitted from diff --git a/src/test/compile-fail/asm-misplaced-option.rs b/src/test/compile-fail/asm-misplaced-option.rs index 74bfc6e6ffc..b29899e1940 100644 --- a/src/test/compile-fail/asm-misplaced-option.rs +++ b/src/test/compile-fail/asm-misplaced-option.rs @@ -12,7 +12,7 @@ #![feature(asm)] -#![allow(dead_code, non_uppercase_statics)] +#![allow(dead_code, non_upper_case_globals)] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] diff --git a/src/test/compile-fail/borrowck-lend-flow-match.rs b/src/test/compile-fail/borrowck-lend-flow-match.rs index 049bec3d37b..0b40a78425f 100644 --- a/src/test/compile-fail/borrowck-lend-flow-match.rs +++ b/src/test/compile-fail/borrowck-lend-flow-match.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(unused_variable)] -#![allow(dead_assignment)] +#![allow(unused_variables)] +#![allow(unused_assignments)] fn separate_arms() { // Here both arms perform assignments, but only is illegal. diff --git a/src/test/compile-fail/coerce-bare-fn-to-closure-and-proc.rs b/src/test/compile-fail/coerce-bare-fn-to-closure-and-proc.rs index c165802d61f..9f258aee746 100644 --- a/src/test/compile-fail/coerce-bare-fn-to-closure-and-proc.rs +++ b/src/test/compile-fail/coerce-bare-fn-to-closure-and-proc.rs @@ -13,7 +13,9 @@ fn foo() {} fn main() { let f = foo; let f_closure: || = f; - //~^ ERROR: cannot coerce non-statically resolved bare fn + //~^ ERROR: cannot coerce non-statically resolved bare fn to closure + //~^^ HELP: consider embedding the function in a closure let f_proc: proc() = f; - //~^ ERROR: cannot coerce non-statically resolved bare fn + //~^ ERROR: cannot coerce non-statically resolved bare fn to closure + //~^^ HELP: consider embedding the function in a closure } diff --git a/src/test/compile-fail/issue-10656.rs b/src/test/compile-fail/issue-10656.rs index 5a4ed1d3df8..0b335a526a4 100644 --- a/src/test/compile-fail/issue-10656.rs +++ b/src/test/compile-fail/issue-10656.rs @@ -10,5 +10,5 @@ // error-pattern: missing documentation for crate -#![deny(missing_doc)] +#![deny(missing_docs)] #![crate_type="lib"] diff --git a/src/test/compile-fail/issue-14309.rs b/src/test/compile-fail/issue-14309.rs index d4a40ade72c..9225889ef63 100644 --- a/src/test/compile-fail/issue-14309.rs +++ b/src/test/compile-fail/issue-14309.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(ctypes)] +#![deny(improper_ctypes)] #![allow(dead_code)] struct A { diff --git a/src/test/compile-fail/issue-16562.rs b/src/test/compile-fail/issue-16562.rs index 1e69fb7bfc9..2207e10add4 100644 --- a/src/test/compile-fail/issue-16562.rs +++ b/src/test/compile-fail/issue-16562.rs @@ -16,8 +16,7 @@ struct Col<D, C> { } impl<T, M: MatrixShape> Collection for Col<M, uint> { -//~^ ERROR unable to infer enough type information to locate the impl of the trait -//~^^ NOTE the trait `core::kinds::Sized` must be implemented because it is required by +//~^ ERROR unable to infer enough type information fn len(&self) -> uint { unimplemented!() } diff --git a/src/test/compile-fail/issue-17551.rs b/src/test/compile-fail/issue-17551.rs index 197319b6d43..e7f61a4f3ff 100644 --- a/src/test/compile-fail/issue-17551.rs +++ b/src/test/compile-fail/issue-17551.rs @@ -13,6 +13,6 @@ struct B<T>; fn main() { - let foo = B; //~ ERROR unable to infer enough type information to locate the impl of the trait + let foo = B; //~ ERROR unable to infer enough type information let closure = |:| foo; } diff --git a/src/test/compile-fail/issue-17999.rs b/src/test/compile-fail/issue-17999.rs index 4d4b40ed12d..e3ad2dd1b06 100644 --- a/src/test/compile-fail/issue-17999.rs +++ b/src/test/compile-fail/issue-17999.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(unused_variable)] +#![deny(unused_variables)] fn main() { for _ in range(1i, 101) { diff --git a/src/test/compile-fail/issue-18159.rs b/src/test/compile-fail/issue-18159.rs new file mode 100644 index 00000000000..e46bcf46cc3 --- /dev/null +++ b/src/test/compile-fail/issue-18159.rs @@ -0,0 +1,13 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + let x; //~ ERROR unable to infer enough type information +} diff --git a/src/test/compile-fail/issue-2150.rs b/src/test/compile-fail/issue-2150.rs index 468fed1eff5..455cde63f27 100644 --- a/src/test/compile-fail/issue-2150.rs +++ b/src/test/compile-fail/issue-2150.rs @@ -9,7 +9,7 @@ // except according to those terms. #![deny(unreachable_code)] -#![allow(unused_variable)] +#![allow(unused_variables)] #![allow(dead_code)] fn fail_len(v: Vec<int> ) -> uint { diff --git a/src/test/compile-fail/lint-ctypes-enum.rs b/src/test/compile-fail/lint-ctypes-enum.rs index d45a3b027a7..dea933085de 100644 --- a/src/test/compile-fail/lint-ctypes-enum.rs +++ b/src/test/compile-fail/lint-ctypes-enum.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(ctypes)] +#![deny(improper_ctypes)] #![allow(dead_code)] enum Z { } diff --git a/src/test/compile-fail/lint-ctypes.rs b/src/test/compile-fail/lint-ctypes.rs index 9e609814c8b..1755a9a2481 100644 --- a/src/test/compile-fail/lint-ctypes.rs +++ b/src/test/compile-fail/lint-ctypes.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(ctypes)] +#![deny(improper_ctypes)] extern crate libc; diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs index 96d40c52657..1283c61e41a 100644 --- a/src/test/compile-fail/lint-dead-code-1.rs +++ b/src/test/compile-fail/lint-dead-code-1.rs @@ -9,9 +9,9 @@ // except according to those terms. #![no_std] -#![allow(unused_variable)] +#![allow(unused_variables)] #![allow(non_camel_case_types)] -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] #![deny(dead_code)] #![crate_type="lib"] diff --git a/src/test/compile-fail/lint-dead-code-2.rs b/src/test/compile-fail/lint-dead-code-2.rs index eb284c4d054..c7199eec8a3 100644 --- a/src/test/compile-fail/lint-dead-code-2.rs +++ b/src/test/compile-fail/lint-dead-code-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(unused_variable)] +#![allow(unused_variables)] #![deny(dead_code)] struct Foo; diff --git a/src/test/compile-fail/lint-dead-code-3.rs b/src/test/compile-fail/lint-dead-code-3.rs index f73c19b5fc9..4ef76030bcc 100644 --- a/src/test/compile-fail/lint-dead-code-3.rs +++ b/src/test/compile-fail/lint-dead-code-3.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(unused_variable)] +#![allow(unused_variables)] #![allow(non_camel_case_types)] #![deny(dead_code)] diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs index ac8b9c3821e..a698bf61f58 100644 --- a/src/test/compile-fail/lint-dead-code-4.rs +++ b/src/test/compile-fail/lint-dead-code-4.rs @@ -9,7 +9,7 @@ // except according to those terms. #![feature(struct_variant)] -#![allow(unused_variable)] +#![allow(unused_variables)] #![allow(non_camel_case_types)] #![deny(dead_code)] diff --git a/src/test/compile-fail/lint-dead-code-5.rs b/src/test/compile-fail/lint-dead-code-5.rs index 62afa089bbe..1f0d91dcb3c 100644 --- a/src/test/compile-fail/lint-dead-code-5.rs +++ b/src/test/compile-fail/lint-dead-code-5.rs @@ -9,7 +9,7 @@ // except according to those terms. #![feature(struct_variant)] -#![allow(unused_variable)] +#![allow(unused_variables)] #![deny(dead_code)] enum Enum1 { diff --git a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs index bbd88f1f0aa..efb28449564 100644 --- a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs +++ b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs @@ -9,7 +9,7 @@ // except according to those terms. #![deny(unused_imports)] -#![allow(non_uppercase_statics)] +#![allow(non_upper_case_globals)] // The aim of this test is to ensure that deny/allow/warn directives // are applied to individual "use" statements instead of silently diff --git a/src/test/compile-fail/lint-misplaced-attr.rs b/src/test/compile-fail/lint-misplaced-attr.rs index dea712e976b..18ea5a383f6 100644 --- a/src/test/compile-fail/lint-misplaced-attr.rs +++ b/src/test/compile-fail/lint-misplaced-attr.rs @@ -11,7 +11,7 @@ // When denying at the crate level, be sure to not get random warnings from the // injected intrinsics by the compiler. -#![deny(unused_attribute)] +#![deny(unused_attributes)] mod a { #![crate_type = "bin"] //~ ERROR unused attribute diff --git a/src/test/compile-fail/lint-missing-doc.rs b/src/test/compile-fail/lint-missing-doc.rs index a63a3a61f68..f0b6abe28d3 100644 --- a/src/test/compile-fail/lint-missing-doc.rs +++ b/src/test/compile-fail/lint-missing-doc.rs @@ -12,7 +12,7 @@ // injected intrinsics by the compiler. #![feature(struct_variant)] #![feature(globs)] -#![deny(missing_doc)] +#![deny(missing_docs)] #![allow(dead_code)] //! Some garbage docs for the crate here @@ -28,7 +28,7 @@ pub struct PubFoo { //~ ERROR: missing documentation b: int, } -#[allow(missing_doc)] +#[allow(missing_docs)] pub struct PubFoo2 { pub a: int, pub c: int, @@ -41,7 +41,7 @@ pub mod pub_module_no_dox {} //~ ERROR: missing documentation pub fn foo() {} pub fn foo2() {} //~ ERROR: missing documentation fn foo3() {} -#[allow(missing_doc)] pub fn foo4() {} +#[allow(missing_docs)] pub fn foo4() {} /// dox pub trait A { @@ -50,7 +50,7 @@ pub trait A { /// dox fn foo_with_impl() {} } -#[allow(missing_doc)] +#[allow(missing_docs)] trait B { fn foo(); fn foo_with_impl() {} @@ -59,7 +59,7 @@ pub trait C { //~ ERROR: missing documentation fn foo(); //~ ERROR: missing documentation fn foo_with_impl() {} //~ ERROR: missing documentation } -#[allow(missing_doc)] pub trait D {} +#[allow(missing_docs)] pub trait D {} impl Foo { pub fn foo() {} @@ -71,10 +71,10 @@ impl PubFoo { /// dox pub fn foo1() {} fn foo2() {} - #[allow(missing_doc)] pub fn foo3() {} + #[allow(missing_docs)] pub fn foo3() {} } -#[allow(missing_doc)] +#[allow(missing_docs)] trait F { fn a(); fn b(&self); @@ -86,7 +86,7 @@ impl F for Foo { fn b(&self) {} } -// It sure is nice if doc(hidden) implies allow(missing_doc), and that it +// It sure is nice if doc(hidden) implies allow(missing_docs), and that it // applies recursively #[doc(hidden)] mod a { @@ -121,7 +121,7 @@ pub enum PubBaz2 { }, } -#[allow(missing_doc)] +#[allow(missing_docs)] pub enum PubBaz3 { PubBaz3A { pub a: int, diff --git a/src/test/compile-fail/lint-non-uppercase-statics.rs b/src/test/compile-fail/lint-non-uppercase-statics.rs index 2d9f2d8fc1c..7ff5cafd097 100644 --- a/src/test/compile-fail/lint-non-uppercase-statics.rs +++ b/src/test/compile-fail/lint-non-uppercase-statics.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![forbid(non_uppercase_statics)] +#![forbid(non_upper_case_globals)] #![allow(dead_code)] static foo: int = 1; //~ ERROR static constant `foo` should have an uppercase name such as `FOO` diff --git a/src/test/compile-fail/lint-obsolete-attr.rs b/src/test/compile-fail/lint-obsolete-attr.rs index 6b46a0c19bd..e4fd042d098 100644 --- a/src/test/compile-fail/lint-obsolete-attr.rs +++ b/src/test/compile-fail/lint-obsolete-attr.rs @@ -11,7 +11,7 @@ // When denying at the crate level, be sure to not get random warnings from the // injected intrinsics by the compiler. -#![deny(unused_attribute)] +#![deny(unused_attributes)] #![allow(dead_code)] #[abi="stdcall"] extern {} //~ ERROR unused attribute diff --git a/src/test/compile-fail/lint-owned-heap-memory.rs b/src/test/compile-fail/lint-owned-heap-memory.rs index 8f20999a56c..5ee16f0aa26 100644 --- a/src/test/compile-fail/lint-owned-heap-memory.rs +++ b/src/test/compile-fail/lint-owned-heap-memory.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(dead_code)] -#![forbid(owned_heap_memory)] +#![forbid(box_pointers)] struct Foo { diff --git a/src/test/compile-fail/lint-qualification.rs b/src/test/compile-fail/lint-qualification.rs index 7006a283750..18a5a8ecc5d 100644 --- a/src/test/compile-fail/lint-qualification.rs +++ b/src/test/compile-fail/lint-qualification.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(unnecessary_qualification)] +#![deny(unused_qualifications)] mod foo { pub fn bar() {} diff --git a/src/test/compile-fail/lint-renaming.rs b/src/test/compile-fail/lint-renaming.rs new file mode 100644 index 00000000000..7ffec37772f --- /dev/null +++ b/src/test/compile-fail/lint-renaming.rs @@ -0,0 +1,16 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Check that lint deprecation works + +#[deny(unused_variable)] //~ warning: lint unused_variable has been renamed to unused_variables +pub fn main() { + let x = 0u8; //~ error: unused variable: +} diff --git a/src/test/compile-fail/lint-type-overflow.rs b/src/test/compile-fail/lint-type-overflow.rs index 81b186a2998..47dc93dae13 100644 --- a/src/test/compile-fail/lint-type-overflow.rs +++ b/src/test/compile-fail/lint-type-overflow.rs @@ -9,13 +9,13 @@ // except according to those terms. // -#![deny(type_overflow)] +#![deny(overflowing_literals)] fn test(x: i8) { println!("x {}", x); } -#[allow(unused_variable)] +#[allow(unused_variables)] fn main() { let x1: u8 = 255; // should be OK let x1: u8 = 256; //~ error: literal out of range for its type diff --git a/src/test/compile-fail/lint-unknown-attr.rs b/src/test/compile-fail/lint-unknown-attr.rs index 020ed80c0fb..e4cb92477c2 100644 --- a/src/test/compile-fail/lint-unknown-attr.rs +++ b/src/test/compile-fail/lint-unknown-attr.rs @@ -11,7 +11,7 @@ // When denying at the crate level, be sure to not get random warnings from the // injected intrinsics by the compiler. -#![deny(unused_attribute)] +#![deny(unused_attributes)] #![mutable_doc] //~ ERROR unused attribute diff --git a/src/test/compile-fail/lint-unnecessary-casts.rs b/src/test/compile-fail/lint-unnecessary-casts.rs index 644c5d9fb3d..b3cf8257b8f 100644 --- a/src/test/compile-fail/lint-unnecessary-casts.rs +++ b/src/test/compile-fail/lint-unnecessary-casts.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![forbid(unnecessary_typecast)] +#![forbid(unused_typecasts)] fn foo_i32(_: i32) {} diff --git a/src/test/compile-fail/lint-unnecessary-import-braces.rs b/src/test/compile-fail/lint-unnecessary-import-braces.rs index c44918d9879..1c0401ec56b 100644 --- a/src/test/compile-fail/lint-unnecessary-import-braces.rs +++ b/src/test/compile-fail/lint-unnecessary-import-braces.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(unnecessary_import_braces)] +#![deny(unused_import_braces)] #![allow(dead_code)] #![allow(unused_imports)] diff --git a/src/test/compile-fail/lint-unnecessary-parens.rs b/src/test/compile-fail/lint-unnecessary-parens.rs index 6c766dec9a3..826a4ea5a80 100644 --- a/src/test/compile-fail/lint-unnecessary-parens.rs +++ b/src/test/compile-fail/lint-unnecessary-parens.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(unnecessary_parens)] +#![deny(unused_parens)] #![feature(if_let,while_let)] #[deriving(Eq, PartialEq)] diff --git a/src/test/compile-fail/lint-unsafe-block.rs b/src/test/compile-fail/lint-unsafe-block.rs index a4c50781a77..8899d06804f 100644 --- a/src/test/compile-fail/lint-unsafe-block.rs +++ b/src/test/compile-fail/lint-unsafe-block.rs @@ -10,12 +10,12 @@ #![allow(unused_unsafe)] #![allow(dead_code)] -#![deny(unsafe_block)] +#![deny(unsafe_blocks)] #![feature(macro_rules)] unsafe fn allowed() {} -#[allow(unsafe_block)] fn also_allowed() { unsafe {} } +#[allow(unsafe_blocks)] fn also_allowed() { unsafe {} } macro_rules! unsafe_in_macro { () => { diff --git a/src/test/compile-fail/lint-unused-extern-crate.rs b/src/test/compile-fail/lint-unused-extern-crate.rs index a4dfdbdaeae..a63e8e913f4 100644 --- a/src/test/compile-fail/lint-unused-extern-crate.rs +++ b/src/test/compile-fail/lint-unused-extern-crate.rs @@ -9,8 +9,8 @@ // except according to those terms. #![feature(globs)] -#![deny(unused_extern_crate)] -#![allow(unused_variable)] +#![deny(unused_extern_crates)] +#![allow(unused_variables)] extern crate libc; //~ ERROR: unused extern crate diff --git a/src/test/compile-fail/lint-unused-mut-self.rs b/src/test/compile-fail/lint-unused-mut-self.rs index fc19a1ba06f..370f664e430 100644 --- a/src/test/compile-fail/lint-unused-mut-self.rs +++ b/src/test/compile-fail/lint-unused-mut-self.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(dead_assignment)] -#![allow(unused_variable)] +#![allow(unused_assignments)] +#![allow(unused_variables)] #![allow(dead_code)] #![deny(unused_mut)] diff --git a/src/test/compile-fail/lint-unused-mut-variables.rs b/src/test/compile-fail/lint-unused-mut-variables.rs index c5281bf6781..29b4686198b 100644 --- a/src/test/compile-fail/lint-unused-mut-variables.rs +++ b/src/test/compile-fail/lint-unused-mut-variables.rs @@ -10,8 +10,8 @@ // Exercise the unused_mut attribute in some positive and negative cases -#![allow(dead_assignment)] -#![allow(unused_variable)] +#![allow(unused_assignments)] +#![allow(unused_variables)] #![allow(dead_code)] #![deny(unused_mut)] diff --git a/src/test/compile-fail/liveness-dead.rs b/src/test/compile-fail/liveness-dead.rs index cba0a1da7e6..18baf7a9c3f 100644 --- a/src/test/compile-fail/liveness-dead.rs +++ b/src/test/compile-fail/liveness-dead.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(dead_code)] -#![deny(dead_assignment)] +#![deny(unused_assignments)] fn f1(x: &mut int) { *x = 1; // no error diff --git a/src/test/compile-fail/liveness-unused.rs b/src/test/compile-fail/liveness-unused.rs index 41a30e23b22..a747615199e 100644 --- a/src/test/compile-fail/liveness-unused.rs +++ b/src/test/compile-fail/liveness-unused.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(unused_variable)] -#![deny(dead_assignment)] +#![deny(unused_variables)] +#![deny(unused_assignments)] #![allow(dead_code, non_camel_case_types)] fn f1(x: int) { @@ -20,7 +20,7 @@ fn f1b(x: &mut int) { //~^ ERROR unused variable: `x` } -#[allow(unused_variable)] +#[allow(unused_variables)] fn f1c(x: int) {} fn f1d() { @@ -48,14 +48,14 @@ fn f3b() { } } -#[allow(unused_variable)] +#[allow(unused_variables)] fn f3c() { let mut z = 3i; loop { z += 4i; } } -#[allow(unused_variable)] -#[allow(dead_assignment)] +#[allow(unused_variables)] +#[allow(unused_assignments)] fn f3d() { let mut x = 3i; x += 4i; diff --git a/src/test/compile-fail/macro-invocation-dot-help.rs b/src/test/compile-fail/macro-invocation-dot-help.rs new file mode 100644 index 00000000000..bd45b76dd5a --- /dev/null +++ b/src/test/compile-fail/macro-invocation-dot-help.rs @@ -0,0 +1,14 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + foo!() //~ HELP try parenthesizing this macro invocation + .bar //~ ERROR expected statement +} diff --git a/src/test/compile-fail/match-static-const-lc.rs b/src/test/compile-fail/match-static-const-lc.rs index af7938948a7..15a832aad89 100644 --- a/src/test/compile-fail/match-static-const-lc.rs +++ b/src/test/compile-fail/match-static-const-lc.rs @@ -11,9 +11,9 @@ // Issue #7526: lowercase static constants in patterns look like bindings #![allow(dead_code)] -#![deny(non_uppercase_statics)] +#![deny(non_upper_case_globals)] -#[allow(non_uppercase_statics)] +#[allow(non_upper_case_globals)] pub const a : int = 97; fn f() { @@ -26,7 +26,7 @@ fn f() { } mod m { - #[allow(non_uppercase_statics)] + #[allow(non_upper_case_globals)] pub const aha : int = 7; } diff --git a/src/test/compile-fail/parenthesized-box-expr-message.rs b/src/test/compile-fail/parenthesized-box-expr-message.rs new file mode 100644 index 00000000000..05bbaec37af --- /dev/null +++ b/src/test/compile-fail/parenthesized-box-expr-message.rs @@ -0,0 +1,14 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + box(1 + 1) //~ HELP perhaps you meant `box() (foo)` instead? + ; //~ ERROR expected expression, found `;` +} diff --git a/src/test/compile-fail/regions-fn-subtyping-return-static.rs b/src/test/compile-fail/regions-fn-subtyping-return-static.rs index 72004f8714c..4c90b1f0eea 100644 --- a/src/test/compile-fail/regions-fn-subtyping-return-static.rs +++ b/src/test/compile-fail/regions-fn-subtyping-return-static.rs @@ -17,7 +17,7 @@ // lifetimes are sublifetimes of 'static. #![allow(dead_code)] -#![allow(unused_variable)] +#![allow(unused_variables)] struct S; diff --git a/src/test/compile-fail/removed-syntax-record.rs b/src/test/compile-fail/removed-syntax-record.rs index b3fa04d8025..b31e2538ab9 100644 --- a/src/test/compile-fail/removed-syntax-record.rs +++ b/src/test/compile-fail/removed-syntax-record.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -type t = { f: () }; //~ ERROR expected type, found token LBrace +type t = { f: () }; //~ ERROR expected type, found token OpenDelim(Brace) diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs index 62fabc0b33f..ba39f3e0d17 100644 --- a/src/test/compile-fail/unique-vec-res.rs +++ b/src/test/compile-fail/unique-vec-res.rs @@ -29,14 +29,16 @@ impl<'a> Drop for r<'a> { fn f<T>(_i: Vec<T> , _j: Vec<T> ) { } +fn clone<T: Clone>(t: &T) -> T { t.clone() } + fn main() { let i1 = &Cell::new(0); let i2 = &Cell::new(1); let r1 = vec!(box r { i: i1 }); let r2 = vec!(box r { i: i2 }); - f(r1.clone(), r2.clone()); - //~^ ERROR does not implement any method in scope named `clone` - //~^^ ERROR does not implement any method in scope named `clone` + f(clone(&r1), clone(&r2)); + //~^ ERROR the trait `core::clone::Clone` is not implemented for the type + //~^^ ERROR the trait `core::clone::Clone` is not implemented for the type println!("{}", (r2, i1.get())); println!("{}", (r1, i2.get())); } diff --git a/src/test/compile-fail/unreachable-code.rs b/src/test/compile-fail/unreachable-code.rs index fb9a6b52018..87342352e9a 100644 --- a/src/test/compile-fail/unreachable-code.rs +++ b/src/test/compile-fail/unreachable-code.rs @@ -9,7 +9,7 @@ // except according to those terms. #![deny(unreachable_code)] -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { loop{} diff --git a/src/test/compile-fail/unused-attr.rs b/src/test/compile-fail/unused-attr.rs index 0a5a9db8fa8..e797c7eec5f 100644 --- a/src/test/compile-fail/unused-attr.rs +++ b/src/test/compile-fail/unused-attr.rs @@ -7,7 +7,7 @@ // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(unused_attribute)] +#![deny(unused_attributes)] #![allow(dead_code, unused_imports)] #![foo] //~ ERROR unused attribute diff --git a/src/test/compile-fail/unused-result.rs b/src/test/compile-fail/unused-result.rs index 124bd9c4d5b..1263d7c5710 100644 --- a/src/test/compile-fail/unused-result.rs +++ b/src/test/compile-fail/unused-result.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(unused_result, unused_must_use)] +#![deny(unused_results, unused_must_use)] #![allow(dead_code)] #[must_use] @@ -23,14 +23,14 @@ fn bar() -> int { return foo::<int>(); } fn baz() -> MustUse { return foo::<MustUse>(); } fn qux() -> MustUseMsg { return foo::<MustUseMsg>(); } -#[allow(unused_result)] +#[allow(unused_results)] fn test() { foo::<int>(); foo::<MustUse>(); //~ ERROR: unused result which must be used foo::<MustUseMsg>(); //~ ERROR: unused result which must be used: some message } -#[allow(unused_result, unused_must_use)] +#[allow(unused_results, unused_must_use)] fn test2() { foo::<int>(); foo::<MustUse>(); diff --git a/src/test/compile-fail/warn-foreign-int-types.rs b/src/test/compile-fail/warn-foreign-int-types.rs index cfa6623176c..5f7a2f69c4f 100644 --- a/src/test/compile-fail/warn-foreign-int-types.rs +++ b/src/test/compile-fail/warn-foreign-int-types.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![forbid(ctypes)] +#![forbid(improper_ctypes)] #![allow(dead_code)] mod xx { diff --git a/src/test/debuginfo/basic-types-globals-metadata.rs b/src/test/debuginfo/basic-types-globals-metadata.rs index 66631f7efba..b2f82493fa7 100644 --- a/src/test/debuginfo/basic-types-globals-metadata.rs +++ b/src/test/debuginfo/basic-types-globals-metadata.rs @@ -46,7 +46,7 @@ // gdb-check:type = f64 // gdb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] #![allow(dead_code)] diff --git a/src/test/debuginfo/basic-types-globals.rs b/src/test/debuginfo/basic-types-globals.rs index 9755c8711ae..d08feadefda 100644 --- a/src/test/debuginfo/basic-types-globals.rs +++ b/src/test/debuginfo/basic-types-globals.rs @@ -52,7 +52,7 @@ // gdb-check:$14 = 3.5 // gdb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] static B: bool = false; static I: int = -1; diff --git a/src/test/debuginfo/basic-types-metadata.rs b/src/test/debuginfo/basic-types-metadata.rs index dae1aca4ed3..e46177c8844 100644 --- a/src/test/debuginfo/basic-types-metadata.rs +++ b/src/test/debuginfo/basic-types-metadata.rs @@ -49,7 +49,7 @@ // gdb-check:[...]![...]_yyy([...])([...]); // gdb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { let unit: () = (); diff --git a/src/test/debuginfo/basic-types-mut-globals.rs b/src/test/debuginfo/basic-types-mut-globals.rs index 9fb3644d75d..241bfcd7510 100644 --- a/src/test/debuginfo/basic-types-mut-globals.rs +++ b/src/test/debuginfo/basic-types-mut-globals.rs @@ -87,7 +87,7 @@ // gdb-command:detach // gdb-command:quit -#![allow(unused_variable)] +#![allow(unused_variables)] static mut B: bool = false; static mut I: int = -1; diff --git a/src/test/debuginfo/basic-types.rs b/src/test/debuginfo/basic-types.rs index b9e9b03c41b..525d71b560f 100644 --- a/src/test/debuginfo/basic-types.rs +++ b/src/test/debuginfo/basic-types.rs @@ -89,7 +89,7 @@ // lldb-command:print f64 // lldb-check:[...]$12 = 3.5 -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { let b: bool = false; diff --git a/src/test/debuginfo/borrowed-basic.rs b/src/test/debuginfo/borrowed-basic.rs index aad9e40e040..eac3652f163 100644 --- a/src/test/debuginfo/borrowed-basic.rs +++ b/src/test/debuginfo/borrowed-basic.rs @@ -110,7 +110,7 @@ // lldb-command:print *f64_ref // lldb-check:[...]$12 = 3.5 -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { let bool_val: bool = true; diff --git a/src/test/debuginfo/borrowed-c-style-enum.rs b/src/test/debuginfo/borrowed-c-style-enum.rs index e7a90780f57..b2431d7221f 100644 --- a/src/test/debuginfo/borrowed-c-style-enum.rs +++ b/src/test/debuginfo/borrowed-c-style-enum.rs @@ -42,7 +42,7 @@ // lldb-command:print *the_c_ref // lldb-check:[...]$2 = TheC -#![allow(unused_variable)] +#![allow(unused_variables)] enum ABC { TheA, TheB, TheC } diff --git a/src/test/debuginfo/borrowed-enum.rs b/src/test/debuginfo/borrowed-enum.rs index fa3fff9fdbc..8b72f2538c5 100644 --- a/src/test/debuginfo/borrowed-enum.rs +++ b/src/test/debuginfo/borrowed-enum.rs @@ -41,7 +41,7 @@ // lldb-command:print *univariant_ref // lldb-check:[...]$2 = TheOnlyCase(4820353753753434) -#![allow(unused_variable)] +#![allow(unused_variables)] #![feature(struct_variant)] // The first element is to ensure proper alignment, irrespective of the machines word size. Since diff --git a/src/test/debuginfo/borrowed-struct.rs b/src/test/debuginfo/borrowed-struct.rs index a784fef2cb9..a9c5a59488f 100644 --- a/src/test/debuginfo/borrowed-struct.rs +++ b/src/test/debuginfo/borrowed-struct.rs @@ -65,7 +65,7 @@ // lldb-command:print *unique_val_interior_ref_2 // lldb-check:[...]$6 = 26.5 -#![allow(unused_variable)] +#![allow(unused_variables)] struct SomeStruct { x: int, diff --git a/src/test/debuginfo/borrowed-tuple.rs b/src/test/debuginfo/borrowed-tuple.rs index a41a24b53b5..f5afa008d2e 100644 --- a/src/test/debuginfo/borrowed-tuple.rs +++ b/src/test/debuginfo/borrowed-tuple.rs @@ -43,7 +43,7 @@ // lldb-check:[...]$2 = (-17, -22) -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { let stack_val: (i16, f32) = (-14, -19f32); diff --git a/src/test/debuginfo/borrowed-unique-basic.rs b/src/test/debuginfo/borrowed-unique-basic.rs index 9fcb49927f6..2592b166256 100644 --- a/src/test/debuginfo/borrowed-unique-basic.rs +++ b/src/test/debuginfo/borrowed-unique-basic.rs @@ -112,7 +112,7 @@ // lldb-command:print *f64_ref // lldb-check:[...]$12 = 3.5 -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { diff --git a/src/test/debuginfo/box.rs b/src/test/debuginfo/box.rs index 6acd94743c2..8075d9ab69d 100644 --- a/src/test/debuginfo/box.rs +++ b/src/test/debuginfo/box.rs @@ -33,7 +33,7 @@ // lldb-command:print *b // lldb-check:[...]$1 = (2, 3.5) -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { let a = box 1i; diff --git a/src/test/debuginfo/boxed-struct.rs b/src/test/debuginfo/boxed-struct.rs index 348e03c04a6..87eea49dd0c 100644 --- a/src/test/debuginfo/boxed-struct.rs +++ b/src/test/debuginfo/boxed-struct.rs @@ -36,7 +36,7 @@ // lldb-command:print *unique_dtor // lldb-check:[...]$1 = StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 } -#![allow(unused_variable)] +#![allow(unused_variables)] struct StructWithSomePadding { x: i16, diff --git a/src/test/debuginfo/c-style-enum-in-composite.rs b/src/test/debuginfo/c-style-enum-in-composite.rs index cea1840e3a3..ec385840d1d 100644 --- a/src/test/debuginfo/c-style-enum-in-composite.rs +++ b/src/test/debuginfo/c-style-enum-in-composite.rs @@ -66,7 +66,7 @@ // lldb-command:print struct_with_drop // lldb-check:[...]$6 = (StructWithDrop { a: OneHundred, b: Vienna }, 9) -#![allow(unused_variable)] +#![allow(unused_variables)] enum AnEnum { OneHundred = 100, diff --git a/src/test/debuginfo/c-style-enum.rs b/src/test/debuginfo/c-style-enum.rs index 5f4521b6504..9f80f6475e2 100644 --- a/src/test/debuginfo/c-style-enum.rs +++ b/src/test/debuginfo/c-style-enum.rs @@ -101,7 +101,7 @@ // lldb-command:print single_variant // lldb-check:[...]$6 = TheOnlyVariant -#![allow(unused_variable)] +#![allow(unused_variables)] #![allow(dead_code)] enum AutoDiscriminant { diff --git a/src/test/debuginfo/destructured-fn-argument.rs b/src/test/debuginfo/destructured-fn-argument.rs index 81ff0bb6d4f..993a1a55012 100644 --- a/src/test/debuginfo/destructured-fn-argument.rs +++ b/src/test/debuginfo/destructured-fn-argument.rs @@ -333,7 +333,7 @@ // lldb-check:[...]$48 = 62 // lldb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] struct Struct { diff --git a/src/test/debuginfo/destructured-local.rs b/src/test/debuginfo/destructured-local.rs index 0bce797a36f..a16298349ed 100644 --- a/src/test/debuginfo/destructured-local.rs +++ b/src/test/debuginfo/destructured-local.rs @@ -245,7 +245,7 @@ // lldb-check:[...]$42 = 56 -#![allow(unused_variable)] +#![allow(unused_variables)] struct Struct { a: i64, diff --git a/src/test/debuginfo/evec-in-struct.rs b/src/test/debuginfo/evec-in-struct.rs index 48d4dd26b00..66407d68aa6 100644 --- a/src/test/debuginfo/evec-in-struct.rs +++ b/src/test/debuginfo/evec-in-struct.rs @@ -53,7 +53,7 @@ // lldb-command:print struct_padded_at_end // lldb-check:[...]$4 = StructPaddedAtEnd { x: [22, 23], y: [24, 25] } -#![allow(unused_variable)] +#![allow(unused_variables)] struct NoPadding1 { x: [u32, ..3], diff --git a/src/test/debuginfo/function-arg-initialization.rs b/src/test/debuginfo/function-arg-initialization.rs index 602cca979f2..ea9802afe94 100644 --- a/src/test/debuginfo/function-arg-initialization.rs +++ b/src/test/debuginfo/function-arg-initialization.rs @@ -236,7 +236,7 @@ -#![allow(unused_variable)] +#![allow(unused_variables)] diff --git a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs index 1814eca0f7d..359d14d2a50 100644 --- a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs +++ b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs @@ -245,7 +245,7 @@ // lldb-check:[...]$31 = 45 // lldb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] #[no_stack_check] fn immediate_args(a: int, b: bool, c: f64) { diff --git a/src/test/debuginfo/function-prologue-stepping-regular.rs b/src/test/debuginfo/function-prologue-stepping-regular.rs index 060ba4a4932..dbeb87fd44a 100644 --- a/src/test/debuginfo/function-prologue-stepping-regular.rs +++ b/src/test/debuginfo/function-prologue-stepping-regular.rs @@ -125,7 +125,7 @@ // lldb-check:[...]$31 = 45 // lldb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] fn immediate_args(a: int, b: bool, c: f64) { () diff --git a/src/test/debuginfo/include_string.rs b/src/test/debuginfo/include_string.rs index 179bbf7dfe4..378b27b3597 100644 --- a/src/test/debuginfo/include_string.rs +++ b/src/test/debuginfo/include_string.rs @@ -37,7 +37,7 @@ // lldb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] // This test case makes sure that debug info does not ICE when include_str is // used multiple times (see issue #11322). diff --git a/src/test/debuginfo/lexical-scopes-in-block-expression.rs b/src/test/debuginfo/lexical-scopes-in-block-expression.rs index 99032ca078c..191b1d2a09c 100644 --- a/src/test/debuginfo/lexical-scopes-in-block-expression.rs +++ b/src/test/debuginfo/lexical-scopes-in-block-expression.rs @@ -373,8 +373,8 @@ // lldb-check:[...]$47 = 10 // lldb-command:continue -#![allow(unused_variable)] -#![allow(dead_assignment)] +#![allow(unused_variables)] +#![allow(unused_assignments)] static mut MUT_INT: int = 0; diff --git a/src/test/debuginfo/limited-debuginfo.rs b/src/test/debuginfo/limited-debuginfo.rs index 6c71971a0f8..292e42ba30b 100644 --- a/src/test/debuginfo/limited-debuginfo.rs +++ b/src/test/debuginfo/limited-debuginfo.rs @@ -31,7 +31,7 @@ // gdb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] struct Struct { a: i64, diff --git a/src/test/debuginfo/multiple-functions-equal-var-names.rs b/src/test/debuginfo/multiple-functions-equal-var-names.rs index 3490b12d15a..6bb2313100f 100644 --- a/src/test/debuginfo/multiple-functions-equal-var-names.rs +++ b/src/test/debuginfo/multiple-functions-equal-var-names.rs @@ -48,7 +48,7 @@ // lldb-command:print abc // lldb-check:[...]$2 = 30303 -#![allow(unused_variable)] +#![allow(unused_variables)] fn function_one() { let abc = 10101i; diff --git a/src/test/debuginfo/multiple-functions.rs b/src/test/debuginfo/multiple-functions.rs index 06a2d2e5d11..58fe9d250c9 100644 --- a/src/test/debuginfo/multiple-functions.rs +++ b/src/test/debuginfo/multiple-functions.rs @@ -48,7 +48,7 @@ // lldb-command:print c // lldb-check:[...]$2 = 30303 -#![allow(unused_variable)] +#![allow(unused_variables)] fn function_one() { let a = 10101i; diff --git a/src/test/debuginfo/nil-enum.rs b/src/test/debuginfo/nil-enum.rs index 511786999ab..a0c72615753 100644 --- a/src/test/debuginfo/nil-enum.rs +++ b/src/test/debuginfo/nil-enum.rs @@ -24,7 +24,7 @@ // gdb-command:print second // gdb-check:$2 = {<No data fields>} -#![allow(unused_variable)] +#![allow(unused_variables)] enum ANilEnum {} enum AnotherNilEnum {} diff --git a/src/test/debuginfo/no-debug-attribute.rs b/src/test/debuginfo/no-debug-attribute.rs index e61ded4ee26..a739c9ee5fa 100644 --- a/src/test/debuginfo/no-debug-attribute.rs +++ b/src/test/debuginfo/no-debug-attribute.rs @@ -25,7 +25,7 @@ // gdb-check:abc = 10 // gdb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] fn function_with_debuginfo() { let abc = 10u; diff --git a/src/test/debuginfo/packed-struct-with-destructor.rs b/src/test/debuginfo/packed-struct-with-destructor.rs index 9af6130e5a9..438a771b7be 100644 --- a/src/test/debuginfo/packed-struct-with-destructor.rs +++ b/src/test/debuginfo/packed-struct-with-destructor.rs @@ -76,7 +76,7 @@ // lldb-check:[...]$7 = DeeplyNested { a: PackedInPacked { a: 1, b: Packed { x: 2, y: 3, z: 4 }, c: 5, d: Packed { x: 6, y: 7, z: 8 } }, b: UnpackedInPackedWithDrop { a: 9, b: Unpacked { x: 10, y: 11, z: 12 }, c: Unpacked { x: 13, y: 14, z: 15 }, d: 16 }, c: PackedInUnpacked { a: 17, b: Packed { x: 18, y: 19, z: 20 }, c: 21, d: Packed { x: 22, y: 23, z: 24 } }, d: PackedInUnpackedWithDrop { a: 25, b: Packed { x: 26, y: 27, z: 28 }, c: 29, d: Packed { x: 30, y: 31, z: 32 } }, e: UnpackedInPacked { a: 33, b: Unpacked { x: 34, y: 35, z: 36 }, c: Unpacked { x: 37, y: 38, z: 39 }, d: 40 }, f: PackedInPackedWithDrop { a: 41, b: Packed { x: 42, y: 43, z: 44 }, c: 45, d: Packed { x: 46, y: 47, z: 48 } } } -#![allow(unused_variable)] +#![allow(unused_variables)] #[repr(packed)] struct Packed { diff --git a/src/test/debuginfo/packed-struct.rs b/src/test/debuginfo/packed-struct.rs index 3e29efd7f8d..906a1f4685b 100644 --- a/src/test/debuginfo/packed-struct.rs +++ b/src/test/debuginfo/packed-struct.rs @@ -62,7 +62,7 @@ // lldb-command:print sizeof(packedInPacked) // lldb-check:[...]$5 = 40 -#![allow(unused_variable)] +#![allow(unused_variables)] #[repr(packed)] struct Packed { diff --git a/src/test/debuginfo/recursive-enum.rs b/src/test/debuginfo/recursive-enum.rs index 4eb251c6084..6d26e2eff7a 100644 --- a/src/test/debuginfo/recursive-enum.rs +++ b/src/test/debuginfo/recursive-enum.rs @@ -18,7 +18,7 @@ // Test whether compiling a recursive enum definition crashes debug info generation. The test case // is taken from issue #11083. -#![allow(unused_variable)] +#![allow(unused_variables)] pub struct Window<'a> { callbacks: WindowCallbacks<'a> diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs index 40c056f5cd2..1e64dc3a031 100644 --- a/src/test/debuginfo/recursive-struct.rs +++ b/src/test/debuginfo/recursive-struct.rs @@ -72,7 +72,7 @@ // gdb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] #![feature(struct_variant)] enum Opt<T> { diff --git a/src/test/debuginfo/simd.rs b/src/test/debuginfo/simd.rs index e355327a5ef..d8854eb9084 100644 --- a/src/test/debuginfo/simd.rs +++ b/src/test/debuginfo/simd.rs @@ -44,7 +44,7 @@ // gdb-command:continue #![allow(experimental)] -#![allow(unused_variable)] +#![allow(unused_variables)] use std::simd::{i8x16, i16x8,i32x4,i64x2,u8x16,u16x8,u32x4,u64x2,f32x4,f64x2}; diff --git a/src/test/debuginfo/simple-struct.rs b/src/test/debuginfo/simple-struct.rs index 66e03f81aa6..83f77b08b68 100644 --- a/src/test/debuginfo/simple-struct.rs +++ b/src/test/debuginfo/simple-struct.rs @@ -99,7 +99,7 @@ // lldb-command:print padding_at_end // lldb-check:[...]$5 = PaddingAtEnd { x: -10014, y: 10015 } -#![allow(unused_variable)]; +#![allow(unused_variables)]; #![allow(dead_code)]; struct NoPadding16 { diff --git a/src/test/debuginfo/simple-tuple.rs b/src/test/debuginfo/simple-tuple.rs index b0cdf5991e8..26239f7f62b 100644 --- a/src/test/debuginfo/simple-tuple.rs +++ b/src/test/debuginfo/simple-tuple.rs @@ -95,7 +95,7 @@ // lldb-command:print paddingAtEnd // lldb-check:[...]$6 = (15, 16) -#![allow(unused_variable)] +#![allow(unused_variables)] #![allow(dead_code)] static mut NO_PADDING_8: (i8, u8) = (-50, 50); diff --git a/src/test/debuginfo/struct-in-enum.rs b/src/test/debuginfo/struct-in-enum.rs index 52b44457dc0..5e2ae478d7d 100644 --- a/src/test/debuginfo/struct-in-enum.rs +++ b/src/test/debuginfo/struct-in-enum.rs @@ -43,7 +43,7 @@ // lldb-command:print univariant // lldb-check:[...]$2 = TheOnlyCase(Struct { x: 123, y: 456, z: 789 }) -#![allow(unused_variable)] +#![allow(unused_variables)] struct Struct { x: u32, diff --git a/src/test/debuginfo/struct-in-struct.rs b/src/test/debuginfo/struct-in-struct.rs index eafeaeb5297..1e0b84f1ef1 100644 --- a/src/test/debuginfo/struct-in-struct.rs +++ b/src/test/debuginfo/struct-in-struct.rs @@ -59,7 +59,7 @@ // lldb-command:print tree // lldb-check:[...]$7 = Tree { x: Simple { x: 25 }, y: InternalPaddingParent { x: InternalPadding { x: 26, y: 27 }, y: InternalPadding { x: 28, y: 29 }, z: InternalPadding { x: 30, y: 31 } }, z: BagInBag { x: Bag { x: Simple { x: 32 } } } } -#![allow(unused_variable)] +#![allow(unused_variables)] struct Simple { x: i32 diff --git a/src/test/debuginfo/struct-style-enum.rs b/src/test/debuginfo/struct-style-enum.rs index 924b3743989..d23c65e71a0 100644 --- a/src/test/debuginfo/struct-style-enum.rs +++ b/src/test/debuginfo/struct-style-enum.rs @@ -50,7 +50,7 @@ // lldb-command:print univariant // lldb-check:[...]$3 = TheOnlyCase { a: -1 } -#![allow(unused_variable)] +#![allow(unused_variables)] #![feature(struct_variant)] // The first element is to ensure proper alignment, irrespective of the machines word size. Since diff --git a/src/test/debuginfo/struct-with-destructor.rs b/src/test/debuginfo/struct-with-destructor.rs index 32ff9f3f148..c2372da35aa 100644 --- a/src/test/debuginfo/struct-with-destructor.rs +++ b/src/test/debuginfo/struct-with-destructor.rs @@ -46,7 +46,7 @@ // lldb-command:print nested // lldb-check:[...]$3 = NestedOuter { a: NestedInner { a: WithDestructor { x: 7890, y: 9870 } } } -#![allow(unused_variable)] +#![allow(unused_variables)] struct NoDestructor { x: i32, diff --git a/src/test/debuginfo/trait-pointers.rs b/src/test/debuginfo/trait-pointers.rs index ca407aef1a4..de74a4d8f91 100644 --- a/src/test/debuginfo/trait-pointers.rs +++ b/src/test/debuginfo/trait-pointers.rs @@ -15,7 +15,7 @@ // compile-flags:-g // gdb-command:run -#![allow(unused_variable)] +#![allow(unused_variables)] trait Trait { diff --git a/src/test/debuginfo/tuple-in-struct.rs b/src/test/debuginfo/tuple-in-struct.rs index 9ac66f8300f..5a47b164648 100644 --- a/src/test/debuginfo/tuple-in-struct.rs +++ b/src/test/debuginfo/tuple-in-struct.rs @@ -42,7 +42,7 @@ // gdb-command:print mixed_padding // gdb-check:$10 = {x = {{40, 41, 42}, {43, 44}}, y = {45, 46, 47, 48}} -#![allow(unused_variable)] +#![allow(unused_variables)] struct NoPadding1 { x: (i32, i32), diff --git a/src/test/debuginfo/tuple-in-tuple.rs b/src/test/debuginfo/tuple-in-tuple.rs index 70344bd3d5e..b7f4b0efe0c 100644 --- a/src/test/debuginfo/tuple-in-tuple.rs +++ b/src/test/debuginfo/tuple-in-tuple.rs @@ -59,7 +59,7 @@ // lldb-command:print padding_at_end2 // lldb-check:[...]$6 = ((21, 22), 23) -#![allow(unused_variable)] +#![allow(unused_variables)] fn main() { let no_padding1: ((u32, u32), u32, u32) = ((0, 1), 2, 3); diff --git a/src/test/debuginfo/tuple-style-enum.rs b/src/test/debuginfo/tuple-style-enum.rs index 1527c6a8e31..1c933637e3e 100644 --- a/src/test/debuginfo/tuple-style-enum.rs +++ b/src/test/debuginfo/tuple-style-enum.rs @@ -50,7 +50,7 @@ // lldb-command:print univariant // lldb-check:[...]$3 = TheOnlyCase(-1) -#![allow(unused_variable)] +#![allow(unused_variables)] // The first element is to ensure proper alignment, irrespective of the machines word size. Since // the size of the discriminant value is machine dependent, this has be taken into account when diff --git a/src/test/debuginfo/unique-enum.rs b/src/test/debuginfo/unique-enum.rs index 12a63614ba4..33382542ef2 100644 --- a/src/test/debuginfo/unique-enum.rs +++ b/src/test/debuginfo/unique-enum.rs @@ -43,7 +43,7 @@ // lldb-command:print *univariant // lldb-check:[...]$2 = TheOnlyCase(123234) -#![allow(unused_variable)] +#![allow(unused_variables)] #![feature(struct_variant)] // The first element is to ensure proper alignment, irrespective of the machines word size. Since diff --git a/src/test/debuginfo/var-captured-in-nested-closure.rs b/src/test/debuginfo/var-captured-in-nested-closure.rs index c200b310a36..8f128c428e7 100644 --- a/src/test/debuginfo/var-captured-in-nested-closure.rs +++ b/src/test/debuginfo/var-captured-in-nested-closure.rs @@ -81,7 +81,7 @@ // lldb-check:[...]$11 = 8 // lldb-command:continue -#![allow(unused_variable)] +#![allow(unused_variables)] struct Struct { a: int, diff --git a/src/test/debuginfo/var-captured-in-sendable-closure.rs b/src/test/debuginfo/var-captured-in-sendable-closure.rs index 9b8718d085a..da2726782e9 100644 --- a/src/test/debuginfo/var-captured-in-sendable-closure.rs +++ b/src/test/debuginfo/var-captured-in-sendable-closure.rs @@ -38,7 +38,7 @@ // lldb-command:print *owned // lldb-check:[...]$2 = 5 -#![allow(unused_variable)] +#![allow(unused_variables)] struct Struct { a: int, diff --git a/src/test/debuginfo/var-captured-in-stack-closure.rs b/src/test/debuginfo/var-captured-in-stack-closure.rs index dc586c266b6..5d484bbacc8 100644 --- a/src/test/debuginfo/var-captured-in-stack-closure.rs +++ b/src/test/debuginfo/var-captured-in-stack-closure.rs @@ -46,7 +46,7 @@ // lldb-command:print *owned // lldb-check:[...]$4 = 6 -#![allow(unused_variable)] +#![allow(unused_variables)] struct Struct { a: int, diff --git a/src/test/debuginfo/vec-slices.rs b/src/test/debuginfo/vec-slices.rs index 688d2a595dc..6d56ed32c31 100644 --- a/src/test/debuginfo/vec-slices.rs +++ b/src/test/debuginfo/vec-slices.rs @@ -80,7 +80,7 @@ // lldb-command:print padded_struct // lldb-check:[...]$5 = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }] -#![allow(unused_variable)] +#![allow(unused_variables)] #![feature(slicing_syntax)] struct AStruct { diff --git a/src/test/debuginfo/vec.rs b/src/test/debuginfo/vec.rs index f3761e4b54a..872d66fdc88 100644 --- a/src/test/debuginfo/vec.rs +++ b/src/test/debuginfo/vec.rs @@ -32,7 +32,7 @@ // lldb-command:print a // lldb-check:[...]$0 = [1, 2, 3] -#![allow(unused_variable)] +#![allow(unused_variables)] static mut VECT: [i32, ..3] = [1, 2, 3]; diff --git a/src/test/run-fail/explicit-fail-msg.rs b/src/test/run-fail/explicit-fail-msg.rs index f6d27cf9959..ae6e72bdd4f 100644 --- a/src/test/run-fail/explicit-fail-msg.rs +++ b/src/test/run-fail/explicit-fail-msg.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(dead_assignment)] -#![allow(unused_variable)] +#![allow(unused_assignments)] +#![allow(unused_variables)] // error-pattern:wooooo fn main() { diff --git a/src/test/run-fail/issue-3029.rs b/src/test/run-fail/issue-3029.rs index 686277c8c09..0846ba2e71a 100644 --- a/src/test/run-fail/issue-3029.rs +++ b/src/test/run-fail/issue-3029.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(unnecessary_allocation)] +#![allow(unused_allocation)] #![allow(unreachable_code)] -#![allow(unused_variable)] +#![allow(unused_variables)] // error-pattern:so long diff --git a/src/test/run-fail/issue-948.rs b/src/test/run-fail/issue-948.rs index 878a293c373..e51e8d93eb0 100644 --- a/src/test/run-fail/issue-948.rs +++ b/src/test/run-fail/issue-948.rs @@ -10,7 +10,7 @@ // error-pattern:beep boop -#![allow(unused_variable)] +#![allow(unused_variables)] struct Point { x: int, y: int } diff --git a/src/test/run-fail/match-bot-fail.rs b/src/test/run-fail/match-bot-fail.rs index 1b7cace14b0..2b1672ad4e5 100644 --- a/src/test/run-fail/match-bot-fail.rs +++ b/src/test/run-fail/match-bot-fail.rs @@ -11,7 +11,7 @@ // error-pattern:explicit panic #![allow(unreachable_code)] -#![allow(unused_variable)] +#![allow(unused_variables)] fn foo(s: String) { } diff --git a/src/test/run-fail/rhs-type.rs b/src/test/run-fail/rhs-type.rs index ec19e08c74f..ff4040ded5f 100644 --- a/src/test/run-fail/rhs-type.rs +++ b/src/test/run-fail/rhs-type.rs @@ -13,7 +13,7 @@ // error-pattern:bye #![allow(unreachable_code)] -#![allow(unused_variable)] +#![allow(unused_variables)] struct T { t: String } diff --git a/src/test/run-pass/issue-17361.rs b/src/test/run-pass/issue-17361.rs new file mode 100644 index 00000000000..fa38dcc1986 --- /dev/null +++ b/src/test/run-pass/issue-17361.rs @@ -0,0 +1,16 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test that astconv doesn't forget about mutability of &mut str + +fn main() { + fn foo<Sized? T>(_: &mut T) {} + let _f: fn(&mut str) = foo; +} diff --git a/src/test/run-pass/issue-18412.rs b/src/test/run-pass/issue-18412.rs new file mode 100644 index 00000000000..c03301f17f3 --- /dev/null +++ b/src/test/run-pass/issue-18412.rs @@ -0,0 +1,36 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(tuple_indexing)] + +// Test that non-static methods can be assigned to local variables as +// function pointers. + +trait Foo { + fn foo(&self) -> uint; +} + +struct A(uint); + +impl A { + fn bar(&self) -> uint { self.0 } +} + +impl Foo for A { + fn foo(&self) -> uint { self.bar() } +} + +fn main() { + let f = A::bar; + let g = Foo::foo; + let a = A(42); + + assert_eq!(f(&a), g(&a)); +} diff --git a/src/test/run-pass/issue-18425.rs b/src/test/run-pass/issue-18425.rs new file mode 100644 index 00000000000..6bb244bf88f --- /dev/null +++ b/src/test/run-pass/issue-18425.rs @@ -0,0 +1,16 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Check that trans doesn't ICE when translating an array repeat +// expression with a count of 1 and a non-Copy element type. + +fn main() { + let _ = [box 1u, ..1]; +} |