diff options
176 files changed, 2438 insertions, 1849 deletions
diff --git a/src/doc/reference.md b/src/doc/reference.md index 357ff813fef..31524579df7 100644 --- a/src/doc/reference.md +++ b/src/doc/reference.md @@ -2165,7 +2165,7 @@ fn needs_foo_or_bar() { // This function is only included when compiling for a unixish OS with a 32-bit // architecture -#[cfg(all(unix, target_word_size = "32"))] +#[cfg(all(unix, target_pointer_width = "32"))] fn on_32bit_unix() { // ... } @@ -2193,9 +2193,9 @@ The following configurations must be defined by the implementation: * `target_os = "..."`. Operating system of the target, examples include `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"`, `"bitrig"` or `"openbsd"`. -* `target_word_size = "..."`. Target word size in bits. This is set to `"32"` - for targets with 32-bit pointers, and likewise set to `"64"` for 64-bit - pointers. +* `target_pointer_width = "..."`. Target pointer width in bits. This is set + to `"32"` for targets with 32-bit pointers, and likewise set to `"64"` for + 64-bit pointers. * `unix`. See `target_family`. * `windows`. See `target_family`. diff --git a/src/doc/rust.css b/src/doc/rust.css index c2a25cd7a58..cd158283180 100644 --- a/src/doc/rust.css +++ b/src/doc/rust.css @@ -56,6 +56,7 @@ /* General structure */ body { + background-color: white; margin: 0 auto; padding: 0 15px; font-family: "Source Serif Pro", Georgia, Times, "Times New Roman", serif; diff --git a/src/doc/trpl/error-handling.md b/src/doc/trpl/error-handling.md index 68b36e7a4b7..cf60bd88c54 100644 --- a/src/doc/trpl/error-handling.md +++ b/src/doc/trpl/error-handling.md @@ -223,6 +223,78 @@ let input = io::stdin().read_line() .ok() .expect("Failed to read line"); ``` + `ok()` converts the `IoResult` into an `Option`, and `expect()` does the same thing as `unwrap()`, but takes a message. This message is passed along to the underlying `panic!`, providing a better error message if the code errors. + +# Using `try!` + +When writing code that calls many functions that return the `Result` type, the +error handling can be tedious. The `try!` macro hides some of the boilerplate +of propagating errors up the call stack. + +It replaces this: + +```rust +use std::fs::File; +use std::io; +use std::io::prelude::*; + +struct Info { + name: String, + age: i32, + rating: i32, +} + +fn write_info(info: &Info) -> io::Result<()> { + let mut file = File::open("my_best_friends.txt").unwrap(); + + if let Err(e) = writeln!(&mut file, "name: {}", info.name) { + return Err(e) + } + if let Err(e) = writeln!(&mut file, "age: {}", info.age) { + return Err(e) + } + if let Err(e) = writeln!(&mut file, "rating: {}", info.rating) { + return Err(e) + } + + return Ok(()); +} +``` + +With this: + +```rust +use std::fs::File; +use std::io; +use std::io::prelude::*; + +struct Info { + name: String, + age: i32, + rating: i32, +} + +fn write_info(info: &Info) -> io::Result<()> { + let mut file = try!(File::open("my_best_friends.txt")); + + try!(writeln!(&mut file, "name: {}", info.name)); + try!(writeln!(&mut file, "age: {}", info.age)); + try!(writeln!(&mut file, "rating: {}", info.rating)); + + return Ok(()); +} +``` + +Wrapping an expression in `try!` will result in the unwrapped success (`Ok`) +value, unless the result is `Err`, in which case `Err` is returned early from +the enclosing function. + +It's worth noting that you can only use `try!` from a function that returns a +`Result`, which means that you cannot use `try!` inside of `main()`, because +`main()` doesn't return anything. + +`try!` makes use of [`FromError`](../std/error/#the-fromerror-trait) to determine +what to return in the error case. diff --git a/src/doc/trpl/macros.md b/src/doc/trpl/macros.md index ce6fa3ce949..49da298bb3f 100644 --- a/src/doc/trpl/macros.md +++ b/src/doc/trpl/macros.md @@ -73,7 +73,7 @@ macro_rules! vec { }; } # fn main() { -# assert_eq!(&[1,2,3], &vec![1,2,3]); +# assert_eq!([1,2,3], vec![1,2,3]); # } ``` diff --git a/src/doc/trpl/pointers.md b/src/doc/trpl/pointers.md index 332f299a67f..0f46b4da0d6 100644 --- a/src/doc/trpl/pointers.md +++ b/src/doc/trpl/pointers.md @@ -361,16 +361,16 @@ duration a *lifetime*. Let's try a more complex example: ```{rust} fn main() { - let x = &mut 5; + let mut x = 5; - if *x < 10 { + if x < 10 { let y = &x; println!("Oh no: {}", y); return; } - *x -= 1; + x -= 1; println!("Oh no: {}", x); } @@ -382,17 +382,18 @@ mutated, and therefore, lets us pass. This wouldn't work: ```{rust,ignore} fn main() { - let x = &mut 5; + let mut x = 5; - if *x < 10 { + if x < 10 { let y = &x; - *x -= 1; + + x -= 1; println!("Oh no: {}", y); return; } - *x -= 1; + x -= 1; println!("Oh no: {}", x); } @@ -401,12 +402,12 @@ fn main() { It gives this error: ```text -test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed -test.rs:5 *x -= 1; - ^~ -test.rs:4:16: 4:18 note: borrow of `*x` occurs here -test.rs:4 let y = &x; - ^~ +test.rs:7:9: 7:15 error: cannot assign to `x` because it is borrowed +test.rs:7 x -= 1; + ^~~~~~ +test.rs:5:18: 5:19 note: borrow of `x` occurs here +test.rs:5 let y = &x; + ^ ``` As you might guess, this kind of analysis is complex for a human, and therefore diff --git a/src/doc/trpl/static-and-dynamic-dispatch.md b/src/doc/trpl/static-and-dynamic-dispatch.md index 1baf41329f5..fc1ab9bf9e8 100644 --- a/src/doc/trpl/static-and-dynamic-dispatch.md +++ b/src/doc/trpl/static-and-dynamic-dispatch.md @@ -93,8 +93,8 @@ dynamic dispatch is sometimes more efficient. However, the common case is that it is more efficient to use static dispatch, and one can always have a thin statically-dispatched wrapper function that does -a dynamic, but not vice versa, meaning static calls are more flexible. The -standard library tries to be statically dispatched where possible for this +a dynamic dispatch, but not vice versa, meaning static calls are more flexible. +The standard library tries to be statically dispatched where possible for this reason. ## Dynamic dispatch diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 9f549fd7237..36c76dbad14 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -480,7 +480,7 @@ impl<T: Ord> BinaryHeap<T> { /// heap.push(3); /// /// let vec = heap.into_sorted_vec(); - /// assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7]); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]); /// ``` pub fn into_sorted_vec(mut self) -> Vec<T> { let mut end = self.len(); diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index f28f9976f0c..61bb204a443 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -640,13 +640,13 @@ impl BitVec { /// let mut bv = BitVec::from_elem(3, true); /// bv.set(1, false); /// - /// assert_eq!(bv.to_bytes(), vec!(0b10100000)); + /// assert_eq!(bv.to_bytes(), [0b10100000]); /// /// let mut bv = BitVec::from_elem(9, false); /// bv.set(2, true); /// bv.set(8, true); /// - /// assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000)); + /// assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]); /// ``` pub fn to_bytes(&self) -> Vec<u8> { fn bit(bit_vec: &BitVec, byte: usize, bit: usize) -> u8 { @@ -806,7 +806,7 @@ impl BitVec { /// let mut bv = BitVec::from_bytes(&[0b01001011]); /// bv.grow(2, true); /// assert_eq!(bv.len(), 10); - /// assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000)); + /// assert_eq!(bv.to_bytes(), [0b01001011, 0b11000000]); /// ``` pub fn grow(&mut self, n: usize, value: bool) { // Note: we just bulk set all the bits in the last word in this fn in multiple places @@ -2285,12 +2285,12 @@ mod tests { fn test_to_bytes() { let mut bv = BitVec::from_elem(3, true); bv.set(1, false); - assert_eq!(bv.to_bytes(), vec!(0b10100000)); + assert_eq!(bv.to_bytes(), [0b10100000]); let mut bv = BitVec::from_elem(9, false); bv.set(2, true); bv.set(8, true); - assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000)); + assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]); } #[test] @@ -2675,7 +2675,7 @@ mod bit_set_test { let bit_vec: BitSet = usizes.into_iter().collect(); let idxs: Vec<_> = bit_vec.iter().collect(); - assert_eq!(idxs, vec![0, 2, 3]); + assert_eq!(idxs, [0, 2, 3]); let long: BitSet = (0..10000).filter(|&n| n % 2 == 0).collect(); let real: Vec<_> = range_step(0, 10000, 2).collect(); diff --git a/src/libcollections/borrow.rs b/src/libcollections/borrow.rs index e92f38741c9..f3c44a84ee5 100644 --- a/src/libcollections/borrow.rs +++ b/src/libcollections/borrow.rs @@ -132,7 +132,7 @@ impl<T> ToOwned for T where T: Clone { /// ```rust /// use std::borrow::Cow; /// -/// fn abs_all(input: &mut Cow<[int]>) { +/// fn abs_all(input: &mut Cow<[i32]>) { /// for i in 0..input.len() { /// let v = input[i]; /// if v < 0 { diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 1b456eec830..532aee1c3fd 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -347,7 +347,7 @@ impl<K: Ord, V> BTreeMap<K, V> { let result = stack.with(move |pusher, node| { // Same basic logic as found in `find`, but with PartialSearchStack mediating the // actual nodes for us - return match Node::search(node, &key) { + match Node::search(node, &key) { Found(mut handle) => { // Perfect match, swap the values and return the old one mem::swap(handle.val_mut(), &mut value); @@ -372,7 +372,7 @@ impl<K: Ord, V> BTreeMap<K, V> { } }); match result { - Finished(ret) => { return ret; }, + Finished(ret) => return ret, Continue((new_stack, renewed_key, renewed_val)) => { stack = new_stack; key = renewed_key; @@ -439,7 +439,7 @@ impl<K: Ord, V> BTreeMap<K, V> { let mut stack = stack::PartialSearchStack::new(self); loop { let result = stack.with(move |pusher, node| { - return match Node::search(node, key) { + match Node::search(node, key) { Found(handle) => { // Perfect match. Terminate the stack here, and remove the entry Finished(Some(pusher.seal(handle).remove())) @@ -1281,7 +1281,7 @@ impl<K, V> BTreeMap<K, V> { /// a.insert(2, "b"); /// /// let keys: Vec<usize> = a.keys().cloned().collect(); - /// assert_eq!(keys, vec![1,2,]); + /// assert_eq!(keys, [1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn keys<'a>(&'a self) -> Keys<'a, K, V> { @@ -1303,7 +1303,7 @@ impl<K, V> BTreeMap<K, V> { /// a.insert(2, "b"); /// /// let values: Vec<&str> = a.values().cloned().collect(); - /// assert_eq!(values, vec!["a","b"]); + /// assert_eq!(values, ["a", "b"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn values<'a>(&'a self) -> Values<'a, K, V> { @@ -1560,7 +1560,7 @@ impl<K: Ord, V> BTreeMap<K, V> { let mut stack = stack::PartialSearchStack::new(self); loop { let result = stack.with(move |pusher, node| { - return match Node::search(node, &key) { + match Node::search(node, &key) { Found(handle) => { // Perfect match Finished(Occupied(OccupiedEntry { diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 929b2f58043..8a668a23dbb 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -121,7 +121,7 @@ impl<T> BTreeSet<T> { /// } /// /// let v: Vec<usize> = set.iter().cloned().collect(); - /// assert_eq!(v, vec![1,2,3,4]); + /// assert_eq!(v, [1, 2, 3, 4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> Iter<T> { @@ -138,7 +138,7 @@ impl<T> BTreeSet<T> { /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect(); /// /// let v: Vec<usize> = set.into_iter().collect(); - /// assert_eq!(v, vec![1,2,3,4]); + /// assert_eq!(v, [1, 2, 3, 4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn into_iter(self) -> IntoIter<T> { @@ -197,7 +197,7 @@ impl<T: Ord> BTreeSet<T> { /// b.insert(3); /// /// let diff: Vec<usize> = a.difference(&b).cloned().collect(); - /// assert_eq!(diff, vec![1]); + /// assert_eq!(diff, [1]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> { @@ -220,7 +220,7 @@ impl<T: Ord> BTreeSet<T> { /// b.insert(3); /// /// let sym_diff: Vec<usize> = a.symmetric_difference(&b).cloned().collect(); - /// assert_eq!(sym_diff, vec![1,3]); + /// assert_eq!(sym_diff, [1, 3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>) @@ -244,7 +244,7 @@ impl<T: Ord> BTreeSet<T> { /// b.insert(3); /// /// let intersection: Vec<usize> = a.intersection(&b).cloned().collect(); - /// assert_eq!(intersection, vec![2]); + /// assert_eq!(intersection, [2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) @@ -266,7 +266,7 @@ impl<T: Ord> BTreeSet<T> { /// b.insert(2); /// /// let union: Vec<usize> = a.union(&b).cloned().collect(); - /// assert_eq!(union, vec![1,2]); + /// assert_eq!(union, [1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> { @@ -534,7 +534,7 @@ impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> { /// /// let result = &a - &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![1, 2]); + /// assert_eq!(result_vec, [1, 2]); /// ``` fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T> { self.difference(rhs).cloned().collect() @@ -557,7 +557,7 @@ impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> { /// /// let result = &a ^ &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![1, 4]); + /// assert_eq!(result_vec, [1, 4]); /// ``` fn bitxor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> { self.symmetric_difference(rhs).cloned().collect() @@ -580,7 +580,7 @@ impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> { /// /// let result = &a & &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![2, 3]); + /// assert_eq!(result_vec, [2, 3]); /// ``` fn bitand(self, rhs: &BTreeSet<T>) -> BTreeSet<T> { self.intersection(rhs).cloned().collect() @@ -603,7 +603,7 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> { /// /// let result = &a | &b; /// let result_vec: Vec<_> = result.into_iter().collect(); - /// assert_eq!(result_vec, vec![1, 2, 3, 4, 5]); + /// assert_eq!(result_vec, [1, 2, 3, 4, 5]); /// ``` fn bitor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> { self.union(rhs).cloned().collect() diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 0c957426060..12c5d7a9cc6 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -428,19 +428,19 @@ mod test { e1.insert(A); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A], elems); + assert_eq!([A], elems); e1.insert(C); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A,C], elems); + assert_eq!([A,C], elems); e1.insert(C); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A,C], elems); + assert_eq!([A,C], elems); e1.insert(B); let elems: ::vec::Vec<_> = e1.iter().collect(); - assert_eq!(vec![A,B,C], elems); + assert_eq!([A,B,C], elems); } /////////////////////////////////////////////////////////////////////////// @@ -458,35 +458,35 @@ mod test { let e_union = e1 | e2; let elems: ::vec::Vec<_> = e_union.iter().collect(); - assert_eq!(vec![A,B,C], elems); + assert_eq!([A,B,C], elems); let e_intersection = e1 & e2; let elems: ::vec::Vec<_> = e_intersection.iter().collect(); - assert_eq!(vec![C], elems); + assert_eq!([C], elems); // Another way to express intersection let e_intersection = e1 - (e1 - e2); let elems: ::vec::Vec<_> = e_intersection.iter().collect(); - assert_eq!(vec![C], elems); + assert_eq!([C], elems); let e_subtract = e1 - e2; let elems: ::vec::Vec<_> = e_subtract.iter().collect(); - assert_eq!(vec![A], elems); + assert_eq!([A], elems); // Bitwise XOR of two sets, aka symmetric difference let e_symmetric_diff = e1 ^ e2; let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect(); - assert_eq!(vec![A,B], elems); + assert_eq!([A,B], elems); // Another way to express symmetric difference let e_symmetric_diff = (e1 - e2) | (e2 - e1); let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect(); - assert_eq!(vec![A,B], elems); + assert_eq!([A,B], elems); // Yet another way to express symmetric difference let e_symmetric_diff = (e1 | e2) - (e1 & e2); let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect(); - assert_eq!(vec![A,B], elems); + assert_eq!([A,B], elems); } #[test] diff --git a/src/libcollections/fmt.rs b/src/libcollections/fmt.rs index 1b5018f4ad7..98673af3c68 100644 --- a/src/libcollections/fmt.rs +++ b/src/libcollections/fmt.rs @@ -404,7 +404,7 @@ #![stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{Formatter, Result, Write, rt}; -pub use core::fmt::{Show, String, Octal, Binary}; +pub use core::fmt::{Octal, Binary}; pub use core::fmt::{Display, Debug}; pub use core::fmt::{LowerHex, UpperHex, Pointer}; pub use core::fmt::{LowerExp, UpperExp}; diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs index 3c61fc3da90..aa9bd5b0fed 100644 --- a/src/libcollections/linked_list.rs +++ b/src/libcollections/linked_list.rs @@ -777,7 +777,7 @@ impl<'a, A> IterMut<'a, A> { /// } /// { /// let vec: Vec<_> = list.into_iter().collect(); - /// assert_eq!(vec, vec![1, 2, 3, 4]); + /// assert_eq!(vec, [1, 2, 3, 4]); /// } /// ``` #[inline] @@ -1273,7 +1273,7 @@ mod tests { } check_links(&m); assert_eq!(m.len(), 3 + len * 2); - assert_eq!(m.into_iter().collect::<Vec<_>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]); + assert_eq!(m.into_iter().collect::<Vec<_>>(), [-2,0,1,2,3,4,5,6,7,8,9,0,1]); } #[test] diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs index ebcfb8d1cf8..e9764547628 100644 --- a/src/libcollections/macros.rs +++ b/src/libcollections/macros.rs @@ -26,7 +26,7 @@ /// /// ``` /// let v = vec![1; 3]; -/// assert_eq!(v, vec![1, 1, 1]); +/// assert_eq!(v, [1, 1, 1]); /// ``` /// /// Note that unlike array expressions this syntax supports all elements diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 776b8b3af14..6850e8c0f8e 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -1779,10 +1779,10 @@ mod tests { let mut v = vec![1, 2, 3, 4, 5]; let mut e = v.swap_remove(0); assert_eq!(e, 1); - assert_eq!(v, vec![5, 2, 3, 4]); + assert_eq!(v, [5, 2, 3, 4]); e = v.swap_remove(3); assert_eq!(e, 4); - assert_eq!(v, vec![5, 2, 3]); + assert_eq!(v, [5, 2, 3]); } #[test] @@ -1890,7 +1890,7 @@ mod tests { fn test_retain() { let mut v = vec![1, 2, 3, 4, 5]; v.retain(is_odd); - assert_eq!(v, vec![1, 3, 5]); + assert_eq!(v, [1, 3, 5]); } #[test] @@ -2159,45 +2159,45 @@ mod tests { let v: [Vec<i32>; 0] = []; let c = v.concat(); assert_eq!(c, []); - let d = [vec![1], vec![2,3]].concat(); - assert_eq!(d, vec![1, 2, 3]); + let d = [vec![1], vec![2, 3]].concat(); + assert_eq!(d, [1, 2, 3]); let v: &[&[_]] = &[&[1], &[2, 3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 3]); let v: &[&[_]] = &[&[1], &[2], &[3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]); } #[test] fn test_connect() { let v: [Vec<i32>; 0] = []; - assert_eq!(v.connect(&0), vec![]); - assert_eq!([vec![1], vec![2, 3]].connect(&0), vec![1, 0, 2, 3]); - assert_eq!([vec![1], vec![2], vec![3]].connect(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), []); + assert_eq!([vec![1i], vec![2, 3]].connect(&0), [1, 0, 2, 3]); + assert_eq!([vec![1i], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]); let v: [&[_]; 2] = [&[1], &[2, 3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 3]); let v: [&[_]; 3] = [&[1], &[2], &[3]]; - assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), [1, 0, 2, 0, 3]); } #[test] fn test_insert() { let mut a = vec![1, 2, 4]; a.insert(2, 3); - assert_eq!(a, vec![1, 2, 3, 4]); + assert_eq!(a, [1, 2, 3, 4]); let mut a = vec![1, 2, 3]; a.insert(0, 0); - assert_eq!(a, vec![0, 1, 2, 3]); + assert_eq!(a, [0, 1, 2, 3]); let mut a = vec![1, 2, 3]; a.insert(3, 4); - assert_eq!(a, vec![1, 2, 3, 4]); + assert_eq!(a, [1, 2, 3, 4]); let mut a = vec![]; a.insert(0, 1); - assert_eq!(a, vec![1]); + assert_eq!(a, [1]); } #[test] @@ -2212,16 +2212,16 @@ mod tests { let mut a = vec![1, 2, 3, 4]; assert_eq!(a.remove(2), 3); - assert_eq!(a, vec![1, 2, 4]); + assert_eq!(a, [1, 2, 4]); assert_eq!(a.remove(2), 4); - assert_eq!(a, vec![1, 2]); + assert_eq!(a, [1, 2]); assert_eq!(a.remove(0), 1); - assert_eq!(a, vec![2]); + assert_eq!(a, [2]); assert_eq!(a.remove(0), 2); - assert_eq!(a, vec![]); + assert_eq!(a, []); } #[test] diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index f3b2e973897..c58cca828d8 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -552,7 +552,7 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// ``` /// let v: Vec<char> = "abc åäö".chars().collect(); /// - /// assert_eq!(v, vec!['a', 'b', 'c', ' ', 'Ã¥', 'ä', 'ö']); + /// assert_eq!(v, ['a', 'b', 'c', ' ', 'Ã¥', 'ä', 'ö']); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn chars(&self) -> Chars { @@ -600,20 +600,20 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// /// ``` /// let v: Vec<&str> = "Mary had a little lamb".split(' ').collect(); - /// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]); + /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); /// /// let v: Vec<&str> = "".split('X').collect(); - /// assert_eq!(v, vec![""]); + /// assert_eq!(v, [""]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi".split(|c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["abc", "def", "ghi"]); + /// assert_eq!(v, ["abc", "def", "ghi"]); /// /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect(); - /// assert_eq!(v, vec!["lion", "", "tiger", "leopard"]); + /// assert_eq!(v, ["lion", "", "tiger", "leopard"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> { @@ -632,23 +632,23 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// /// ``` /// let v: Vec<&str> = "Mary had a little lambda".splitn(2, ' ').collect(); - /// assert_eq!(v, vec!["Mary", "had", "a little lambda"]); + /// assert_eq!(v, ["Mary", "had", "a little lambda"]); /// /// let v: Vec<&str> = "lionXXtigerXleopard".splitn(2, 'X').collect(); - /// assert_eq!(v, vec!["lion", "", "tigerXleopard"]); + /// assert_eq!(v, ["lion", "", "tigerXleopard"]); /// /// let v: Vec<&str> = "abcXdef".splitn(0, 'X').collect(); - /// assert_eq!(v, vec!["abcXdef"]); + /// assert_eq!(v, ["abcXdef"]); /// /// let v: Vec<&str> = "".splitn(1, 'X').collect(); - /// assert_eq!(v, vec![""]); + /// assert_eq!(v, [""]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi".splitn(1, |c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["abc", "def2ghi"]); + /// assert_eq!(v, ["abc", "def2ghi"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn splitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> SplitN<'a, P> { @@ -669,17 +669,17 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// /// ``` /// let v: Vec<&str> = "A.B.".split_terminator('.').collect(); - /// assert_eq!(v, vec!["A", "B"]); + /// assert_eq!(v, ["A", "B"]); /// /// let v: Vec<&str> = "A..B..".split_terminator('.').collect(); - /// assert_eq!(v, vec!["A", "", "B", ""]); + /// assert_eq!(v, ["A", "", "B", ""]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi3".split_terminator(|c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["abc", "def", "ghi"]); + /// assert_eq!(v, ["abc", "def", "ghi"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> { @@ -699,17 +699,17 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// /// ``` /// let v: Vec<&str> = "Mary had a little lamb".rsplitn(2, ' ').collect(); - /// assert_eq!(v, vec!["lamb", "little", "Mary had a"]); + /// assert_eq!(v, ["lamb", "little", "Mary had a"]); /// /// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(2, 'X').collect(); - /// assert_eq!(v, vec!["leopard", "tiger", "lionX"]); + /// assert_eq!(v, ["leopard", "tiger", "lionX"]); /// ``` /// /// More complex patterns with a lambda: /// /// ``` /// let v: Vec<&str> = "abc1def2ghi".rsplitn(1, |c: char| c.is_numeric()).collect(); - /// assert_eq!(v, vec!["ghi", "abc1def"]); + /// assert_eq!(v, ["ghi", "abc1def"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn rsplitn<'a, P: Pattern<'a>>(&'a self, count: usize, pat: P) -> RSplitN<'a, P> { @@ -727,13 +727,13 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// /// ``` /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect(); - /// assert_eq!(v, vec![(0,3), (6,9), (12,15)]); + /// assert_eq!(v, [(0,3), (6,9), (12,15)]); /// /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect(); - /// assert_eq!(v, vec![(1,4), (4,7)]); + /// assert_eq!(v, [(1,4), (4,7)]); /// /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect(); - /// assert_eq!(v, vec![(0, 3)]); // only the first `aba` + /// assert_eq!(v, [(0, 3)]); // only the first `aba` /// ``` #[unstable(feature = "collections", reason = "might have its iterator type changed")] @@ -749,10 +749,10 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// /// ``` /// let v: Vec<&str> = "abcXXXabcYYYabc".split_str("abc").collect(); - /// assert_eq!(v, vec!["", "XXX", "YYY", ""]); + /// assert_eq!(v, ["", "XXX", "YYY", ""]); /// /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect(); - /// assert_eq!(v, vec!["1", "", "2"]); + /// assert_eq!(v, ["1", "", "2"]); /// ``` #[unstable(feature = "collections")] #[deprecated(since = "1.0.0", reason = "use `split()` with a `&str`")] @@ -770,7 +770,7 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// let four_lines = "foo\nbar\n\nbaz"; /// let v: Vec<&str> = four_lines.lines().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` /// /// Leaving off the trailing character: @@ -779,7 +779,7 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// let four_lines = "foo\nbar\n\nbaz\n"; /// let v: Vec<&str> = four_lines.lines().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn lines(&self) -> Lines { @@ -796,7 +796,7 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// let four_lines = "foo\r\nbar\n\r\nbaz"; /// let v: Vec<&str> = four_lines.lines_any().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` /// /// Leaving off the trailing character: @@ -805,7 +805,7 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// let four_lines = "foo\r\nbar\n\r\nbaz\n"; /// let v: Vec<&str> = four_lines.lines_any().collect(); /// - /// assert_eq!(v, vec!["foo", "bar", "", "baz"]); + /// assert_eq!(v, ["foo", "bar", "", "baz"]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn lines_any(&self) -> LinesAny { @@ -1441,7 +1441,7 @@ pub trait StrExt: Index<RangeFull, Output = str> { /// let some_words = " Mary had\ta little \n\t lamb"; /// let v: Vec<&str> = some_words.words().collect(); /// - /// assert_eq!(v, vec!["Mary", "had", "a", "little", "lamb"]); + /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]); /// ``` #[unstable(feature = "str_words", reason = "the precise algorithm to use is unclear")] @@ -2400,17 +2400,17 @@ mod tests { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: Vec<&str> = data.splitn(3, ' ').collect(); - assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect(); - assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); // Unicode let split: Vec<&str> = data.splitn(3, 'ä').collect(); - assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect(); - assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); + assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); } #[test] @@ -2418,17 +2418,17 @@ mod tests { let data = "\nMäry häd ä little lämb\nLittle lämb\n"; let split: Vec<&str> = data.split('\n').collect(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb", ""]); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]); let split: Vec<&str> = data.split_terminator('\n').collect(); - assert_eq!(split, vec!["", "Märy häd ä little lämb", "Little lämb"]); + assert_eq!(split, ["", "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(); - assert_eq!(words, vec!["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"]) + assert_eq!(words, ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"]) } #[test] @@ -2513,11 +2513,11 @@ mod tests { fn test_lines() { let data = "\nMäry häd ä little lämb\n\nLittle lämb\n"; let lines: Vec<&str> = data.lines().collect(); - assert_eq!(lines, vec!["", "Märy häd ä little lämb", "", "Little lämb"]); + assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]); let data = "\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n let lines: Vec<&str> = data.lines().collect(); - assert_eq!(lines, vec!["", "Märy häd ä little lämb", "", "Little lämb"]); + assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]); } #[test] diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 6c2624cd204..e9070cff207 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -120,7 +120,7 @@ impl String { /// let invalid_vec = vec![240, 144, 128]; /// let s = String::from_utf8(invalid_vec).err().unwrap(); /// assert_eq!(s.utf8_error(), Utf8Error::TooShort); - /// assert_eq!(s.into_bytes(), vec![240, 144, 128]); + /// assert_eq!(s.into_bytes(), [240, 144, 128]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -340,7 +340,7 @@ impl String { /// ``` /// let s = String::from_str("hello"); /// let bytes = s.into_bytes(); - /// assert_eq!(bytes, vec![104, 101, 108, 108, 111]); + /// assert_eq!(bytes, [104, 101, 108, 108, 111]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -619,7 +619,7 @@ impl String { /// let mut s = String::from_str("hello"); /// unsafe { /// let vec = s.as_mut_vec(); - /// assert!(vec == &mut vec![104, 101, 108, 108, 111]); + /// assert!(vec == &[104, 101, 108, 108, 111]); /// vec.reverse(); /// } /// assert_eq!(s.as_slice(), "olleh"); diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 3f5f9288916..c446618649d 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -93,7 +93,7 @@ use borrow::{Cow, IntoCow}; /// for x in vec.iter() { /// println!("{}", x); /// } -/// assert_eq!(vec, vec![7, 1, 2, 3]); +/// assert_eq!(vec, [7, 1, 2, 3]); /// ``` /// /// The `vec!` macro is provided to make initialization more convenient: @@ -101,7 +101,7 @@ use borrow::{Cow, IntoCow}; /// ``` /// let mut vec = vec![1, 2, 3]; /// vec.push(4); -/// assert_eq!(vec, vec![1, 2, 3, 4]); +/// assert_eq!(vec, [1, 2, 3, 4]); /// ``` /// /// Use a `Vec<T>` as an efficient stack: @@ -242,7 +242,7 @@ impl<T> Vec<T> { /// /// // Put everything back together into a Vec /// let rebuilt = Vec::from_raw_parts(p, len, cap); - /// assert_eq!(rebuilt, vec![4, 5, 6]); + /// assert_eq!(rebuilt, [4, 5, 6]); /// } /// } /// ``` @@ -404,7 +404,7 @@ impl<T> Vec<T> { /// ``` /// let mut vec = vec![1, 2, 3, 4]; /// vec.truncate(2); - /// assert_eq!(vec, vec![1, 2]); + /// assert_eq!(vec, [1, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn truncate(&mut self, len: usize) { @@ -505,10 +505,10 @@ impl<T> Vec<T> { /// let mut v = vec!["foo", "bar", "baz", "qux"]; /// /// assert_eq!(v.swap_remove(1), "bar"); - /// assert_eq!(v, vec!["foo", "qux", "baz"]); + /// assert_eq!(v, ["foo", "qux", "baz"]); /// /// assert_eq!(v.swap_remove(0), "foo"); - /// assert_eq!(v, vec!["baz", "qux"]); + /// assert_eq!(v, ["baz", "qux"]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -531,9 +531,9 @@ impl<T> Vec<T> { /// ``` /// let mut vec = vec![1, 2, 3]; /// vec.insert(1, 4); - /// assert_eq!(vec, vec![1, 4, 2, 3]); + /// assert_eq!(vec, [1, 4, 2, 3]); /// vec.insert(4, 5); - /// assert_eq!(vec, vec![1, 4, 2, 3, 5]); + /// assert_eq!(vec, [1, 4, 2, 3, 5]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn insert(&mut self, index: usize, element: T) { @@ -569,7 +569,7 @@ impl<T> Vec<T> { /// ``` /// let mut v = vec![1, 2, 3]; /// assert_eq!(v.remove(1), 2); - /// assert_eq!(v, vec![1, 3]); + /// assert_eq!(v, [1, 3]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn remove(&mut self, index: usize) -> T { @@ -603,7 +603,7 @@ impl<T> Vec<T> { /// ``` /// let mut vec = vec![1, 2, 3, 4]; /// vec.retain(|&x| x%2 == 0); - /// assert_eq!(vec, vec![2, 4]); + /// assert_eq!(vec, [2, 4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn retain<F>(&mut self, mut f: F) where F: FnMut(&T) -> bool { @@ -636,7 +636,7 @@ impl<T> Vec<T> { /// ```rust /// let mut vec = vec!(1, 2); /// vec.push(3); - /// assert_eq!(vec, vec!(1, 2, 3)); + /// assert_eq!(vec, [1, 2, 3]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -674,7 +674,7 @@ impl<T> Vec<T> { /// ```rust /// let mut vec = vec![1, 2, 3]; /// assert_eq!(vec.pop(), Some(3)); - /// assert_eq!(vec, vec![1, 2]); + /// assert_eq!(vec, [1, 2]); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -701,8 +701,8 @@ impl<T> Vec<T> { /// let mut vec = vec![1, 2, 3]; /// let mut vec2 = vec![4, 5, 6]; /// vec.append(&mut vec2); - /// assert_eq!(vec, vec![1, 2, 3, 4, 5, 6]); - /// assert_eq!(vec2, vec![]); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]); + /// assert_eq!(vec2, []); /// ``` #[inline] #[unstable(feature = "collections", @@ -1019,8 +1019,8 @@ impl<T> Vec<T> { /// ``` /// let mut vec = vec![1,2,3]; /// let vec2 = vec.split_off(1); - /// assert_eq!(vec, vec![1]); - /// assert_eq!(vec2, vec![2, 3]); + /// assert_eq!(vec, [1]); + /// assert_eq!(vec2, [2, 3]); /// ``` #[inline] #[unstable(feature = "collections", @@ -1057,11 +1057,11 @@ impl<T: Clone> Vec<T> { /// ``` /// let mut vec = vec!["hello"]; /// vec.resize(3, "world"); - /// assert_eq!(vec, vec!["hello", "world", "world"]); + /// assert_eq!(vec, ["hello", "world", "world"]); /// /// let mut vec = vec![1, 2, 3, 4]; /// vec.resize(2, 0); - /// assert_eq!(vec, vec![1, 2]); + /// assert_eq!(vec, [1, 2]); /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification; waiting for dust to settle")] @@ -1085,7 +1085,7 @@ impl<T: Clone> Vec<T> { /// ``` /// let mut vec = vec![1]; /// vec.push_all(&[2, 3, 4]); - /// assert_eq!(vec, vec![1, 2, 3, 4]); + /// assert_eq!(vec, [1, 2, 3, 4]); /// ``` #[inline] #[unstable(feature = "collections", @@ -1121,7 +1121,7 @@ impl<T: PartialEq> Vec<T> { /// /// vec.dedup(); /// - /// assert_eq!(vec, vec![1, 2, 3, 2]); + /// assert_eq!(vec, [1, 2, 3, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn dedup(&mut self) { @@ -2105,7 +2105,7 @@ mod tests { } } - assert!(values == vec![2, 3, 5, 6, 7]); + assert_eq!(values, [2, 3, 5, 6, 7]); } #[test] @@ -2147,7 +2147,7 @@ mod tests { fn test_retain() { let mut vec = vec![1, 2, 3, 4]; vec.retain(|&x| x % 2 == 0); - assert!(vec == vec![2, 4]); + assert_eq!(vec, [2, 4]); } #[test] @@ -2207,13 +2207,13 @@ mod tests { let a = [1, 2, 3]; let ptr = a.as_ptr(); let b = Vec::from_raw_buf(ptr, 3); - assert_eq!(b, vec![1, 2, 3]); + assert_eq!(b, [1, 2, 3]); // Test on-heap copy-from-buf. let c = vec![1, 2, 3, 4, 5]; let ptr = c.as_ptr(); let d = Vec::from_raw_buf(ptr, 5); - assert_eq!(d, vec![1, 2, 3, 4, 5]); + assert_eq!(d, [1, 2, 3, 4, 5]); } } @@ -2375,7 +2375,7 @@ mod tests { for i in vec { vec2.push(i); } - assert!(vec2 == vec![1, 2, 3]); + assert_eq!(vec2, [1, 2, 3]); } #[test] @@ -2385,7 +2385,7 @@ mod tests { for i in vec.into_iter().rev() { vec2.push(i); } - assert!(vec2 == vec![3, 2, 1]); + assert_eq!(vec2, [3, 2, 1]); } #[test] @@ -2395,7 +2395,7 @@ mod tests { for i in vec { vec2.push(i); } - assert!(vec2 == vec![(), (), ()]); + assert_eq!(vec2, [(), (), ()]); } #[test] @@ -2443,16 +2443,16 @@ mod tests { let mut vec = vec![1, 2, 3]; let mut vec2 = vec![4, 5, 6]; vec.append(&mut vec2); - assert_eq!(vec, vec![1, 2, 3, 4, 5, 6]); - assert_eq!(vec2, vec![]); + assert_eq!(vec, [1, 2, 3, 4, 5, 6]); + assert_eq!(vec2, []); } #[test] fn test_split_off() { let mut vec = vec![1, 2, 3, 4, 5, 6]; let vec2 = vec.split_off(4); - assert_eq!(vec, vec![1, 2, 3, 4]); - assert_eq!(vec2, vec![5, 6]); + assert_eq!(vec, [1, 2, 3, 4]); + assert_eq!(vec2, [5, 6]); } #[bench] diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index f65e644fa52..02927719d41 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -2105,7 +2105,7 @@ mod tests { let mut d: VecDeque<_> = (0..5).collect(); d.pop_front(); d.swap(0, 3); - assert_eq!(d.iter().cloned().collect::<Vec<_>>(), vec!(4, 2, 3, 1)); + assert_eq!(d.iter().cloned().collect::<Vec<_>>(), [4, 2, 3, 1]); } #[test] @@ -2868,17 +2868,17 @@ mod tests { // normal append a.append(&mut b); - assert_eq!(a.iter().cloned().collect(), vec![1, 2, 3, 4, 5, 6]); - assert_eq!(b.iter().cloned().collect(), vec![]); + assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]); + assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []); // append nothing to something a.append(&mut b); - assert_eq!(a.iter().cloned().collect(), vec![1, 2, 3, 4, 5, 6]); - assert_eq!(b.iter().cloned().collect(), vec![]); + assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]); + assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []); // append something to nothing b.append(&mut a); - assert_eq!(b.iter().cloned().collect(), vec![1, 2, 3, 4, 5, 6]); - assert_eq!(a.iter().cloned().collect(), vec![]); + assert_eq!(b.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]); + assert_eq!(a.iter().cloned().collect::<Vec<_>>(), []); } } diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index d92249379fa..1c497c86dfd 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -308,7 +308,7 @@ impl<V> VecMap<V> { /// /// let vec: Vec<(usize, &str)> = map.into_iter().collect(); /// - /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); + /// assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn into_iter(self) -> IntoIter<V> { @@ -425,7 +425,7 @@ impl<V> VecMap<V> { /// /// let vec: Vec<(usize, &str)> = map.drain().collect(); /// - /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); + /// assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]); /// ``` #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] @@ -1226,7 +1226,7 @@ mod test_map { let vec: Vec<_> = map.drain().collect(); - assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); + assert_eq!(vec, [(1, "a"), (2, "b"), (3, "c")]); assert_eq!(map.len(), 0); } diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index 7f7264a0468..f92e631c1f2 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -40,10 +40,10 @@ pub enum ExponentFormat { pub enum SignificantDigits { /// At most the given number of digits will be printed, truncating any /// trailing zeroes. - DigMax(uint), + DigMax(usize), /// Precisely the given number of digits will be printed. - DigExact(uint) + DigExact(usize) } /// How to emit the sign of a number. @@ -240,27 +240,27 @@ pub fn float_to_str_bytes_common<T: Float, U, F>( // If reached left end of number, have to // insert additional digit: if i < 0 - || buf[i as uint] == b'-' - || buf[i as uint] == b'+' { - for j in (i as uint + 1..end).rev() { + || buf[i as usize] == b'-' + || buf[i as usize] == b'+' { + for j in (i as usize + 1..end).rev() { buf[j + 1] = buf[j]; } - buf[(i + 1) as uint] = value2ascii(1); + buf[(i + 1) as usize] = value2ascii(1); end += 1; break; } // Skip the '.' - if buf[i as uint] == b'.' { i -= 1; continue; } + if buf[i as usize] == b'.' { i -= 1; continue; } // Either increment the digit, // or set to 0 if max and carry the 1. - let current_digit = ascii2value(buf[i as uint]); + let current_digit = ascii2value(buf[i as usize]); if current_digit < (radix - 1) { - buf[i as uint] = value2ascii(current_digit+1); + buf[i as usize] = value2ascii(current_digit+1); break; } else { - buf[i as uint] = value2ascii(0); + buf[i as usize] = value2ascii(0); i -= 1; } } @@ -311,7 +311,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>( struct Filler<'a> { buf: &'a mut [u8], - end: &'a mut uint, + end: &'a mut usize, } impl<'a> fmt::Write for Filler<'a> { diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index a2c1bbc0331..0bf44dd77aa 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -110,11 +110,14 @@ pub trait Write { /// traits. #[stable(feature = "rust1", since = "1.0.0")] pub struct Formatter<'a> { - flags: uint, + #[cfg(not(stage0))] + flags: u32, + #[cfg(stage0)] + flags: usize, fill: char, align: rt::v1::Alignment, - width: Option<uint>, - precision: Option<uint>, + width: Option<usize>, + precision: Option<usize>, buf: &'a mut (Write+'a), curarg: slice::Iter<'a, ArgumentV1<'a>>, @@ -140,7 +143,7 @@ pub struct ArgumentV1<'a> { impl<'a> ArgumentV1<'a> { #[inline(never)] - fn show_uint(x: &uint, f: &mut Formatter) -> Result { + fn show_usize(x: &usize, f: &mut Formatter) -> Result { Display::fmt(x, f) } @@ -156,15 +159,22 @@ impl<'a> ArgumentV1<'a> { } } + #[cfg(stage0)] #[doc(hidden)] #[stable(feature = "rust1", since = "1.0.0")] pub fn from_uint(x: &uint) -> ArgumentV1 { - ArgumentV1::new(x, ArgumentV1::show_uint) + ArgumentV1::new(x, ArgumentV1::show_usize) + } + #[cfg(not(stage0))] + #[doc(hidden)] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_usize(x: &usize) -> ArgumentV1 { + ArgumentV1::new(x, ArgumentV1::show_usize) } - fn as_uint(&self) -> Option<uint> { - if self.formatter as uint == ArgumentV1::show_uint as uint { - Some(unsafe { *(self.value as *const _ as *const uint) }) + fn as_usize(&self) -> Option<usize> { + if self.formatter as usize == ArgumentV1::show_usize as usize { + Some(unsafe { *(self.value as *const _ as *const usize) }) } else { None } @@ -194,7 +204,7 @@ impl<'a> Arguments<'a> { /// The `pieces` array must be at least as long as `fmt` to construct /// a valid Arguments structure. Also, any `Count` within `fmt` that is /// `CountIsParam` or `CountIsNextParam` has to point to an argument - /// created with `argumentuint`. However, failing to do so doesn't cause + /// created with `argumentusize`. However, failing to do so doesn't cause /// unsafety, but will ignore invalid . #[doc(hidden)] #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -248,16 +258,6 @@ impl<'a> Display for Arguments<'a> { /// Format trait for the `:?` format. Useful for debugging, all types /// should implement this. -#[deprecated(since = "1.0.0", reason = "renamed to Debug")] -#[unstable(feature = "old_fmt")] -pub trait Show { - /// Formats the value using the given formatter. - #[stable(feature = "rust1", since = "1.0.0")] - fn fmt(&self, &mut Formatter) -> Result; -} - -/// Format trait for the `:?` format. Useful for debugging, all types -/// should implement this. #[stable(feature = "rust1", since = "1.0.0")] #[rustc_on_unimplemented = "`{Self}` cannot be formatted using `:?`; if it is \ defined in your crate, add `#[derive(Debug)]` or \ @@ -269,22 +269,6 @@ pub trait Debug { fn fmt(&self, &mut Formatter) -> Result; } -#[allow(deprecated)] -impl<T: Show + ?Sized> Debug for T { - #[allow(deprecated)] - fn fmt(&self, f: &mut Formatter) -> Result { Show::fmt(self, f) } -} - -/// When a value can be semantically expressed as a String, this trait may be -/// used. It corresponds to the default format, `{}`. -#[deprecated(since = "1.0.0", reason = "renamed to Display")] -#[unstable(feature = "old_fmt")] -pub trait String { - /// Formats the value using the given formatter. - #[stable(feature = "rust1", since = "1.0.0")] - fn fmt(&self, &mut Formatter) -> Result; -} - /// When a value can be semantically expressed as a String, this trait may be /// used. It corresponds to the default format, `{}`. #[rustc_on_unimplemented = "`{Self}` cannot be formatted with the default \ @@ -297,12 +281,6 @@ pub trait Display { fn fmt(&self, &mut Formatter) -> Result; } -#[allow(deprecated)] -impl<T: String + ?Sized> Display for T { - #[allow(deprecated)] - fn fmt(&self, f: &mut Formatter) -> Result { String::fmt(self, f) } -} - /// Format trait for the `o` character #[stable(feature = "rust1", since = "1.0.0")] pub trait Octal { @@ -434,15 +412,15 @@ impl<'a> Formatter<'a> { (value.formatter)(value.value, self) } - fn getcount(&mut self, cnt: &rt::v1::Count) -> Option<uint> { + fn getcount(&mut self, cnt: &rt::v1::Count) -> Option<usize> { match *cnt { rt::v1::Count::Is(n) => Some(n), rt::v1::Count::Implied => None, rt::v1::Count::Param(i) => { - self.args[i].as_uint() + self.args[i].as_usize() } rt::v1::Count::NextParam => { - self.curarg.next().and_then(|arg| arg.as_uint()) + self.curarg.next().and_then(|arg| arg.as_usize()) } } } @@ -476,12 +454,12 @@ impl<'a> Formatter<'a> { let mut sign = None; if !is_positive { sign = Some('-'); width += 1; - } else if self.flags & (1 << (FlagV1::SignPlus as uint)) != 0 { + } else if self.flags & (1 << (FlagV1::SignPlus as u32)) != 0 { sign = Some('+'); width += 1; } let mut prefixed = false; - if self.flags & (1 << (FlagV1::Alternate as uint)) != 0 { + if self.flags & (1 << (FlagV1::Alternate as u32)) != 0 { prefixed = true; width += prefix.char_len(); } @@ -511,7 +489,7 @@ impl<'a> Formatter<'a> { } // The sign and prefix goes before the padding if the fill character // is zero - Some(min) if self.flags & (1 << (FlagV1::SignAwareZeroPad as uint)) != 0 => { + Some(min) if self.flags & (1 << (FlagV1::SignAwareZeroPad as u32)) != 0 => { self.fill = '0'; try!(write_prefix(self)); self.with_padding(min - width, Alignment::Right, |f| { @@ -581,7 +559,7 @@ impl<'a> Formatter<'a> { /// Runs a callback, emitting the correct padding either before or /// afterwards depending on whether right or left alignment is requested. - fn with_padding<F>(&mut self, padding: uint, default: Alignment, + fn with_padding<F>(&mut self, padding: usize, default: Alignment, f: F) -> Result where F: FnOnce(&mut Formatter) -> Result, { @@ -627,6 +605,11 @@ impl<'a> Formatter<'a> { write(self.buf, fmt) } + #[cfg(not(stage0))] + /// Flags for formatting (packed version of rt::Flag) + #[stable(feature = "rust1", since = "1.0.0")] + pub fn flags(&self) -> u32 { self.flags } + #[cfg(stage0)] /// Flags for formatting (packed version of rt::Flag) #[stable(feature = "rust1", since = "1.0.0")] pub fn flags(&self) -> usize { self.flags } @@ -641,11 +624,11 @@ impl<'a> Formatter<'a> { /// Optionally specified integer width that the output should be #[unstable(feature = "core", reason = "method was just created")] - pub fn width(&self) -> Option<uint> { self.width } + pub fn width(&self) -> Option<usize> { self.width } /// Optionally specified precision for numeric types #[unstable(feature = "core", reason = "method was just created")] - pub fn precision(&self) -> Option<uint> { self.precision } + pub fn precision(&self) -> Option<usize> { self.precision } } #[stable(feature = "rust1", since = "1.0.0")] @@ -731,9 +714,9 @@ impl Display for char { #[stable(feature = "rust1", since = "1.0.0")] impl<T> Pointer for *const T { fn fmt(&self, f: &mut Formatter) -> Result { - f.flags |= 1 << (FlagV1::Alternate as uint); - let ret = LowerHex::fmt(&(*self as uint), f); - f.flags &= !(1 << (FlagV1::Alternate as uint)); + f.flags |= 1 << (FlagV1::Alternate as u32); + let ret = LowerHex::fmt(&(*self as u32), f); + f.flags &= !(1 << (FlagV1::Alternate as u32)); ret } } @@ -889,7 +872,7 @@ impl<'a> Debug for &'a (any::Any+'a) { #[stable(feature = "rust1", since = "1.0.0")] impl<T: Debug> Debug for [T] { fn fmt(&self, f: &mut Formatter) -> Result { - if f.flags & (1 << (FlagV1::Alternate as uint)) == 0 { + if f.flags & (1 << (FlagV1::Alternate as u32)) == 0 { try!(write!(f, "[")); } let mut is_first = true; @@ -901,7 +884,7 @@ impl<T: Debug> Debug for [T] { } try!(write!(f, "{:?}", *x)) } - if f.flags & (1 << (FlagV1::Alternate as uint)) == 0 { + if f.flags & (1 << (FlagV1::Alternate as u32)) == 0 { try!(write!(f, "]")); } Ok(()) diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 1222126b5e0..0175e21c8da 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -214,7 +214,7 @@ macro_rules! integer { show! { $Uint with $SU } } } -integer! { int, uint, "i", "u" } +integer! { isize, usize, "i", "u" } integer! { i8, u8 } integer! { i16, u16 } integer! { i32, u32 } diff --git a/src/libcore/fmt/rt/v1.rs b/src/libcore/fmt/rt/v1.rs index 0c9bb6316e0..c35611acb81 100644 --- a/src/libcore/fmt/rt/v1.rs +++ b/src/libcore/fmt/rt/v1.rs @@ -32,8 +32,12 @@ pub struct FormatSpec { pub fill: char, #[stable(feature = "rust1", since = "1.0.0")] pub align: Alignment, + #[cfg(stage0)] #[stable(feature = "rust1", since = "1.0.0")] - pub flags: uint, + pub flags: usize, + #[cfg(not(stage0))] + #[stable(feature = "rust1", since = "1.0.0")] + pub flags: u32, #[stable(feature = "rust1", since = "1.0.0")] pub precision: Count, #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index ed48903a7c2..edc4b7e10ee 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -20,7 +20,7 @@ //! //! #[derive(Hash)] //! struct Person { -//! id: uint, +//! id: u32, //! name: String, //! phone: u64, //! } @@ -38,7 +38,7 @@ //! use std::hash::{hash, Hash, Hasher, SipHasher}; //! //! struct Person { -//! id: uint, +//! id: u32, //! name: String, //! phone: u64, //! } diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs index 6f24fc70673..39bcbacdff1 100644 --- a/src/libcore/hash/sip.rs +++ b/src/libcore/hash/sip.rs @@ -34,13 +34,13 @@ use super::Hasher; pub struct SipHasher { k0: u64, k1: u64, - length: uint, // how many bytes we've processed + length: usize, // how many bytes we've processed v0: u64, // hash state v1: u64, v2: u64, v3: u64, tail: u64, // unprocessed bytes le - ntail: uint, // how many bytes in tail are valid + ntail: usize, // how many bytes in tail are valid } // sadly, these macro definitions can't appear later, diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 2d50bbb6413..6d8e04d97dd 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -86,6 +86,7 @@ use usize; #[rustc_on_unimplemented = "`{Self}` is not an iterator; maybe try calling `.iter()` or a similar \ method"] pub trait Iterator { + /// The type of the elements being iterated #[stable(feature = "rust1", since = "1.0.0")] type Item; @@ -122,9 +123,11 @@ pub trait FromIterator<A> { /// Conversion into an `Iterator` #[stable(feature = "rust1", since = "1.0.0")] pub trait IntoIterator { + /// The type of the elements being iterated #[stable(feature = "rust1", since = "1.0.0")] type Item; + /// A container for iterating over elements of type Item #[stable(feature = "rust1", since = "1.0.0")] type IntoIter: Iterator<Item=Self::Item>; @@ -579,8 +582,8 @@ pub trait IteratorExt: Iterator + Sized { /// ``` /// let vec = vec![1, 2, 3, 4]; /// let (even, odd): (Vec<_>, Vec<_>) = vec.into_iter().partition(|&n| n % 2 == 0); - /// assert_eq!(even, vec![2, 4]); - /// assert_eq!(odd, vec![1, 3]); + /// assert_eq!(even, [2, 4]); + /// assert_eq!(odd, [1, 3]); /// ``` #[unstable(feature = "core", reason = "recently added as part of collections reform")] diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 7612469c808..b1039f79f23 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -1672,6 +1672,7 @@ macro_rules! from_str_radix_int_impl { let is_signed_ty = (0 as $T) > Int::min_value(); match src.slice_shift_char() { + Some(('-', "")) => Err(PIE { kind: Empty }), Some(('-', src)) if is_signed_ty => { // The number is negative let mut result = 0; diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index fbd7f840da6..c382ac46d5d 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -184,6 +184,7 @@ macro_rules! forward_ref_binop { #[lang="add"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Add<RHS=Self> { + /// The resulting type after applying the `+` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -237,6 +238,7 @@ add_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 } #[lang="sub"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Sub<RHS=Self> { + /// The resulting type after applying the `-` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -290,6 +292,7 @@ sub_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 } #[lang="mul"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Mul<RHS=Self> { + /// The resulting type after applying the `*` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -343,6 +346,7 @@ mul_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 } #[lang="div"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Div<RHS=Self> { + /// The resulting type after applying the `/` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -396,6 +400,7 @@ div_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 } #[lang="rem"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Rem<RHS=Self> { + /// The resulting type after applying the `%` operator #[stable(feature = "rust1", since = "1.0.0")] type Output = Self; @@ -468,6 +473,7 @@ rem_float_impl! { f64, fmod } #[lang="neg"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Neg { + /// The resulting type after applying the `-` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -544,6 +550,7 @@ neg_uint_impl! { u64, i64 } #[lang="not"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Not { + /// The resulting type after applying the `!` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -597,6 +604,7 @@ not_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 } #[lang="bitand"] #[stable(feature = "rust1", since = "1.0.0")] pub trait BitAnd<RHS=Self> { + /// The resulting type after applying the `&` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -650,6 +658,7 @@ bitand_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 } #[lang="bitor"] #[stable(feature = "rust1", since = "1.0.0")] pub trait BitOr<RHS=Self> { + /// The resulting type after applying the `|` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -703,6 +712,7 @@ bitor_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 } #[lang="bitxor"] #[stable(feature = "rust1", since = "1.0.0")] pub trait BitXor<RHS=Self> { + /// The resulting type after applying the `^` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -756,6 +766,7 @@ bitxor_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 } #[lang="shl"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Shl<RHS> { + /// The resulting type after applying the `<<` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -827,6 +838,7 @@ shl_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize } #[lang="shr"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Shr<RHS> { + /// The resulting type after applying the `>>` operator #[stable(feature = "rust1", since = "1.0.0")] type Output; @@ -900,6 +912,7 @@ shr_impl_all! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize } #[rustc_on_unimplemented = "the type `{Self}` cannot be indexed by `{Idx}`"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Index<Idx: ?Sized> { + /// The returned type after indexing type Output: ?Sized; /// The method for the indexing (`Foo[Bar]`) operation @@ -1047,6 +1060,7 @@ impl<Idx: fmt::Debug> fmt::Debug for RangeTo<Idx> { #[lang="deref"] #[stable(feature = "rust1", since = "1.0.0")] pub trait Deref { + /// The resulting type after dereferencing #[stable(feature = "rust1", since = "1.0.0")] type Target: ?Sized; @@ -1122,6 +1136,7 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_paren_sugar] pub trait Fn<Args> { + /// The returned type after the call operator is used. type Output; /// This is called when the call operator is used. @@ -1133,6 +1148,7 @@ pub trait Fn<Args> { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_paren_sugar] pub trait FnMut<Args> { + /// The returned type after the call operator is used. type Output; /// This is called when the call operator is used. @@ -1144,6 +1160,7 @@ pub trait FnMut<Args> { #[stable(feature = "rust1", since = "1.0.0")] #[rustc_paren_sugar] pub trait FnOnce<Args> { + /// The returned type after the call operator is used. type Output; /// This is called when the call operator is used. diff --git a/src/libcore/option.rs b/src/libcore/option.rs index abfef72a5db..1ecbd8fae8c 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -556,7 +556,7 @@ impl<T> Option<T> { /// ``` /// let x = Some("string"); /// let v: Vec<&str> = x.into_iter().collect(); - /// assert_eq!(v, vec!["string"]); + /// assert_eq!(v, ["string"]); /// /// let x = None; /// let v: Vec<&str> = x.into_iter().collect(); diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 16b84dcf18e..b44cc899787 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -249,6 +249,7 @@ pub unsafe fn write<T>(dst: *mut T, src: T) { /// Methods on raw pointers #[stable(feature = "rust1", since = "1.0.0")] pub trait PtrExt: Sized { + /// The type which is being pointed at type Target; /// Returns true if the pointer is null. @@ -284,6 +285,7 @@ pub trait PtrExt: Sized { /// Methods on mutable raw pointers #[stable(feature = "rust1", since = "1.0.0")] pub trait MutPtrExt { + /// The type which is being pointed at type Target; /// Returns `None` if the pointer is null, or else returns a mutable diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 23e936a75d7..bca73782491 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -548,11 +548,11 @@ impl<T, E> Result<T, E> { /// ``` /// let x: Result<u32, &str> = Ok(5); /// let v: Vec<u32> = x.into_iter().collect(); - /// assert_eq!(v, vec![5]); + /// assert_eq!(v, [5]); /// /// let x: Result<u32, &str> = Err("nothing!"); /// let v: Vec<u32> = x.into_iter().collect(); - /// assert_eq!(v, vec![]); + /// assert_eq!(v, []); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index 6cbc7bf1bbc..8a27400389f 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -74,7 +74,7 @@ fn test_multi_iter() { fn test_counter_from_iter() { let it = count(0, 5).take(10); let xs: Vec<int> = FromIterator::from_iter(it); - assert!(xs == vec![0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); + assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); } #[test] @@ -104,7 +104,7 @@ fn test_iterator_chain() { fn test_filter_map() { let it = count(0, 1).take(10) .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None }); - assert!(it.collect::<Vec<uint>>() == vec![0*0, 2*2, 4*4, 6*6, 8*8]); + assert_eq!(it.collect::<Vec<uint>>(), [0*0, 2*2, 4*4, 6*6, 8*8]); } #[test] @@ -730,12 +730,12 @@ fn test_random_access_cycle() { #[test] fn test_double_ended_range() { - assert!((11..14).rev().collect::<Vec<_>>() == vec![13, 12, 11]); + assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]); for _ in (10..0).rev() { panic!("unreachable"); } - assert!((11..14).rev().collect::<Vec<_>>() == vec![13, 12, 11]); + assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]); for _ in (10..0).rev() { panic!("unreachable"); } @@ -743,10 +743,9 @@ fn test_double_ended_range() { #[test] fn test_range() { - assert!((0..5).collect::<Vec<_>>() == vec![0, 1, 2, 3, 4]); - assert!((-10..-1).collect::<Vec<_>>() == - vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]); - assert!((0..5).rev().collect::<Vec<_>>() == vec![4, 3, 2, 1, 0]); + assert_eq!((0..5).collect::<Vec<_>>(), [0, 1, 2, 3, 4]); + assert_eq!((-10..-1).collect::<Vec<_>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]); + assert_eq!((0..5).rev().collect::<Vec<_>>(), [4, 3, 2, 1, 0]); assert_eq!((200..-5).count(), 0); assert_eq!((200..-5).rev().count(), 0); assert_eq!((200..200).count(), 0); @@ -767,38 +766,28 @@ fn test_range_inclusive() { vec![5, 4, 3, 2, 1, 0]); assert_eq!(range_inclusive(200, -5).count(), 0); assert_eq!(range_inclusive(200, -5).rev().count(), 0); - assert!(range_inclusive(200, 200).collect::<Vec<int>>() == vec![200]); - assert!(range_inclusive(200, 200).rev().collect::<Vec<int>>() == vec![200]); + assert_eq!(range_inclusive(200, 200).collect::<Vec<int>>(), [200]); + assert_eq!(range_inclusive(200, 200).rev().collect::<Vec<int>>(), [200]); } #[test] fn test_range_step() { - assert!(range_step(0, 20, 5).collect::<Vec<int>>() == - vec![0, 5, 10, 15]); - assert!(range_step(20, 0, -5).collect::<Vec<int>>() == - vec![20, 15, 10, 5]); - assert!(range_step(20, 0, -6).collect::<Vec<int>>() == - vec![20, 14, 8, 2]); - assert!(range_step(200u8, 255, 50).collect::<Vec<u8>>() == - vec![200u8, 250]); - assert!(range_step(200, -5, 1).collect::<Vec<int>>() == vec![]); - assert!(range_step(200, 200, 1).collect::<Vec<int>>() == vec![]); + assert_eq!(range_step(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15]); + assert_eq!(range_step(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5]); + assert_eq!(range_step(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]); + assert_eq!(range_step(200u8, 255, 50).collect::<Vec<u8>>(), [200u8, 250]); + assert_eq!(range_step(200i, -5, 1).collect::<Vec<int>>(), []); + assert_eq!(range_step(200i, 200, 1).collect::<Vec<int>>(), []); } #[test] fn test_range_step_inclusive() { - assert!(range_step_inclusive(0, 20, 5).collect::<Vec<int>>() == - vec![0, 5, 10, 15, 20]); - assert!(range_step_inclusive(20, 0, -5).collect::<Vec<int>>() == - vec![20, 15, 10, 5, 0]); - assert!(range_step_inclusive(20, 0, -6).collect::<Vec<int>>() == - vec![20, 14, 8, 2]); - assert!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() == - vec![200u8, 250]); - assert!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>() == - vec![]); - assert!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>() == - vec![200]); + assert_eq!(range_step_inclusive(0, 20, 5).collect::<Vec<int>>(), [0, 5, 10, 15, 20]); + assert_eq!(range_step_inclusive(20, 0, -5).collect::<Vec<int>>(), [20, 15, 10, 5, 0]); + assert_eq!(range_step_inclusive(20, 0, -6).collect::<Vec<int>>(), [20, 14, 8, 2]); + assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>(), [200u8, 250]); + assert_eq!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>(), []); + assert_eq!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>(), [200]); } #[test] diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs index 5aeb330b78b..73000670c61 100644 --- a/src/libcoretest/mem.rs +++ b/src/libcoretest/mem.rs @@ -103,7 +103,7 @@ fn test_transmute() { } unsafe { - assert!(vec![76u8] == transmute::<_, Vec<u8>>("L".to_string())); + assert_eq!([76u8], transmute::<_, Vec<u8>>("L".to_string())); } } diff --git a/src/libcoretest/nonzero.rs b/src/libcoretest/nonzero.rs index be4c83d23e8..f60570eaaf4 100644 --- a/src/libcoretest/nonzero.rs +++ b/src/libcoretest/nonzero.rs @@ -54,7 +54,7 @@ fn test_match_option_empty_vec() { fn test_match_option_vec() { let a = Some(vec![1, 2, 3, 4]); match a { - Some(v) => assert_eq!(v, vec![1, 2, 3, 4]), + Some(v) => assert_eq!(v, [1, 2, 3, 4]), None => panic!("unexpected None while matching on Some(vec![1, 2, 3, 4])") } } diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs index 2c6efc0040f..03f6e51a349 100644 --- a/src/libcoretest/num/mod.rs +++ b/src/libcoretest/num/mod.rs @@ -122,4 +122,9 @@ mod test { assert_eq!("-9223372036854775808".parse::<i64>().ok(), Some(i64_val)); assert_eq!("-9223372036854775809".parse::<i64>().ok(), None); } + + #[test] + fn test_int_from_minus_sign() { + assert_eq!("-".parse::<i32>().ok(), None); + } } diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs index 57456bfb1a7..c8a54ef59ab 100644 --- a/src/libcoretest/ptr.rs +++ b/src/libcoretest/ptr.rs @@ -156,7 +156,7 @@ fn test_ptr_subtraction() { m_ptr = m_ptr.offset(-1); } - assert!(xs_mut == vec![0,2,4,6,8,10,12,14,16,18]); + assert_eq!(xs_mut, [0,2,4,6,8,10,12,14,16,18]); } } diff --git a/src/libcoretest/str.rs b/src/libcoretest/str.rs index beb746d25b6..019f935911f 100644 --- a/src/libcoretest/str.rs +++ b/src/libcoretest/str.rs @@ -22,7 +22,7 @@ fn test_pattern_deref_forward() { fn test_empty_match_indices() { let data = "aää¸!"; let vec: Vec<_> = data.match_indices("").collect(); - assert_eq!(vec, vec![(0, 0), (1, 1), (3, 3), (6, 6), (7, 7)]); + assert_eq!(vec, [(0, 0), (1, 1), (3, 3), (6, 6), (7, 7)]); } #[test] @@ -69,20 +69,20 @@ fn test_rsplitn_char_iterator() { 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"]); + assert_eq!(split, ["\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"]); + assert_eq!(split, ["\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"]); + assert_eq!(split, ["\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"]); + assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); } #[test] @@ -90,33 +90,33 @@ 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"]); + assert_eq!( split, ["\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"]); + assert_eq!(rsplit, ["\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"]); + assert_eq!( split, ["\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"]); + assert_eq!(rsplit, ["\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"]); + assert_eq!( split, ["\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"]); + assert_eq!(rsplit, ["\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"]); + assert_eq!( split, ["\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"]); + assert_eq!(rsplit, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); } #[test] @@ -125,18 +125,18 @@ fn test_rev_split_char_iterator_no_trailing() { 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", ""]); + assert_eq!(split, ["", "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"]); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]); } #[test] fn test_utf16_code_units() { use unicode::str::Utf16Encoder; assert_eq!(Utf16Encoder::new(vec!['é', '\u{1F4A9}'].into_iter()).collect::<Vec<u16>>(), - vec![0xE9, 0xD83D, 0xDCA9]) + [0xE9, 0xD83D, 0xDCA9]) } #[test] diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index be77622ac1d..4e25e51e9a4 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -24,7 +24,6 @@ html_root_url = "http://doc.rust-lang.org/nightly/", html_playground_url = "http://play.rust-lang.org/")] -#![feature(int_uint)] #![feature(staged_api)] #![feature(unicode)] @@ -65,7 +64,7 @@ pub struct FormatSpec<'a> { /// Optionally specified alignment pub align: Alignment, /// Packed version of various flags provided - pub flags: uint, + pub flags: u32, /// The integer precision to use pub precision: Count<'a>, /// The string width requested for the resulting format @@ -82,7 +81,7 @@ pub enum Position<'a> { /// The argument will be in the next position. This is the default. ArgumentNext, /// The argument is located at a specific index. - ArgumentIs(uint), + ArgumentIs(usize), /// The argument has a name. ArgumentNamed(&'a str), } @@ -121,11 +120,11 @@ pub enum Flag { #[derive(Copy, PartialEq)] pub enum Count<'a> { /// The count is specified explicitly. - CountIs(uint), + CountIs(usize), /// The count is specified by the argument with the given name. CountIsName(&'a str), /// The count is specified by the argument at the given index. - CountIsParam(uint), + CountIsParam(usize), /// The count is specified by the next parameter. CountIsNextParam, /// The count is implied and cannot be explicitly specified. @@ -237,7 +236,7 @@ impl<'a> Parser<'a> { /// Parses all of a string which is to be considered a "raw literal" in a /// format string. This is everything outside of the braces. - fn string(&mut self, start: uint) -> &'a str { + fn string(&mut self, start: usize) -> &'a str { loop { // we may not consume the character, so clone the iterator match self.cur.clone().next() { @@ -314,13 +313,13 @@ impl<'a> Parser<'a> { } // Sign flags if self.consume('+') { - spec.flags |= 1 << (FlagSignPlus as uint); + spec.flags |= 1 << (FlagSignPlus as u32); } else if self.consume('-') { - spec.flags |= 1 << (FlagSignMinus as uint); + spec.flags |= 1 << (FlagSignMinus as u32); } // Alternate marker if self.consume('#') { - spec.flags |= 1 << (FlagAlternate as uint); + spec.flags |= 1 << (FlagAlternate as u32); } // Width and precision let mut havewidth = false; @@ -333,7 +332,7 @@ impl<'a> Parser<'a> { spec.width = CountIsParam(0); havewidth = true; } else { - spec.flags |= 1 << (FlagSignAwareZeroPad as uint); + spec.flags |= 1 << (FlagSignAwareZeroPad as u32); } } if !havewidth { @@ -413,7 +412,7 @@ impl<'a> Parser<'a> { /// Optionally parses an integer at the current position. This doesn't deal /// with overflow at all, it's just accumulating digits. - fn integer(&mut self) -> Option<uint> { + fn integer(&mut self) -> Option<usize> { let mut cur = 0; let mut found = false; loop { @@ -617,7 +616,7 @@ mod tests { format: FormatSpec { fill: None, align: AlignUnknown, - flags: (1 << FlagSignMinus as uint), + flags: (1 << FlagSignMinus as u32), precision: CountImplied, width: CountImplied, ty: "", @@ -628,7 +627,7 @@ mod tests { format: FormatSpec { fill: None, align: AlignUnknown, - flags: (1 << FlagSignPlus as uint) | (1 << FlagAlternate as uint), + flags: (1 << FlagSignPlus as u32) | (1 << FlagAlternate as u32), precision: CountImplied, width: CountImplied, ty: "", diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index bf0cc9b4ad5..8d8f6a406f5 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -76,6 +76,7 @@ //! one from Berkeley after the lawsuits died down and the CSRG dissolved. #![allow(bad_style, raw_pointer_derive)] +#![cfg_attr(target_os = "nacl", allow(unused_imports))] #[cfg(feature = "cargo-build")] extern crate "std" as core; #[cfg(not(feature = "cargo-build"))] extern crate core; @@ -86,78 +87,33 @@ // you can write more-platform-agnostic code if you stick to just these // symbols. -pub use types::common::c95::{FILE, c_void, fpos_t}; -pub use types::common::c99::{int8_t, int16_t, int32_t, int64_t}; -pub use types::common::c99::{uint8_t, uint16_t, uint32_t, uint64_t}; -pub use types::common::posix88::{DIR, dirent_t}; -pub use types::os::common::posix01::{timeval}; -pub use types::os::common::bsd44::{addrinfo, in_addr, in6_addr, sockaddr_storage}; -pub use types::os::common::bsd44::{ip_mreq, ip6_mreq, sockaddr, sockaddr_un}; -pub use types::os::common::bsd44::{sa_family_t, sockaddr_in, sockaddr_in6, socklen_t}; -pub use types::os::arch::c95::{c_char, c_double, c_float, c_int, c_uint}; -pub use types::os::arch::c95::{c_long, c_short, c_uchar, c_ulong, wchar_t}; -pub use types::os::arch::c95::{c_ushort, clock_t, ptrdiff_t, c_schar}; -pub use types::os::arch::c95::{size_t, time_t, suseconds_t}; -pub use types::os::arch::c99::{c_longlong, c_ulonglong}; -pub use types::os::arch::c99::{intptr_t, uintptr_t}; -pub use types::os::arch::c99::{intmax_t, uintmax_t}; -pub use types::os::arch::posix88::{dev_t, ino_t, mode_t}; -pub use types::os::arch::posix88::{off_t, pid_t, ssize_t}; - -pub use consts::os::c95::{_IOFBF, _IOLBF, _IONBF, BUFSIZ, EOF}; -pub use consts::os::c95::{EXIT_FAILURE, EXIT_SUCCESS}; -pub use consts::os::c95::{FILENAME_MAX, FOPEN_MAX, L_tmpnam}; -pub use consts::os::c95::{RAND_MAX, SEEK_CUR, SEEK_END}; -pub use consts::os::c95::{SEEK_SET, TMP_MAX}; -pub use consts::os::posix88::{F_OK, O_APPEND, O_CREAT, O_EXCL}; -pub use consts::os::posix88::{O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY}; -pub use consts::os::posix88::{R_OK, S_IEXEC, S_IFBLK, S_IFCHR}; -pub use consts::os::posix88::{S_IFDIR, S_IFIFO, S_IFMT, S_IFREG, S_IFLNK}; -pub use consts::os::posix88::{S_IREAD, S_IRUSR, S_IRWXU, S_IWUSR}; -pub use consts::os::posix88::{STDERR_FILENO, STDIN_FILENO, S_IXUSR}; -pub use consts::os::posix88::{STDOUT_FILENO, W_OK, X_OK}; -pub use consts::os::bsd44::{AF_INET, AF_INET6, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW}; -pub use consts::os::bsd44::{IPPROTO_IP, IPPROTO_IPV6, IPPROTO_TCP, TCP_NODELAY}; -pub use consts::os::bsd44::{SOL_SOCKET, SO_KEEPALIVE, SO_ERROR}; -pub use consts::os::bsd44::{SO_REUSEADDR, SO_BROADCAST, SHUT_WR, IP_MULTICAST_LOOP}; -pub use consts::os::bsd44::{IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP}; -pub use consts::os::bsd44::{IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP}; -pub use consts::os::bsd44::{IP_MULTICAST_TTL, IP_TTL, IP_HDRINCL, SHUT_RD}; -pub use consts::os::extra::{IPPROTO_RAW}; - -pub use funcs::c95::ctype::{isalnum, isalpha, iscntrl, isdigit}; -pub use funcs::c95::ctype::{islower, isprint, ispunct, isspace}; -pub use funcs::c95::ctype::{isupper, isxdigit, tolower, toupper}; - -pub use funcs::c95::stdio::{fclose, feof, ferror, fflush, fgetc}; -pub use funcs::c95::stdio::{fgetpos, fgets, fopen, fputc, fputs}; -pub use funcs::c95::stdio::{fread, freopen, fseek, fsetpos, ftell}; -pub use funcs::c95::stdio::{fwrite, perror, puts, remove, rename, rewind}; -pub use funcs::c95::stdio::{setbuf, setvbuf, tmpfile, ungetc}; - -pub use funcs::c95::stdlib::{abs, atof, atoi, calloc, exit, _exit, atexit}; -pub use funcs::c95::stdlib::{free, getenv, labs, malloc, rand}; -pub use funcs::c95::stdlib::{realloc, srand, strtod, strtol}; -pub use funcs::c95::stdlib::{strtoul, system}; - -pub use funcs::c95::string::{memchr, memcmp}; -pub use funcs::c95::string::{strcat, strchr, strcmp}; -pub use funcs::c95::string::{strcoll, strcpy, strcspn, strerror}; -pub use funcs::c95::string::{strlen, strncat, strncmp, strncpy}; -pub use funcs::c95::string::{strpbrk, strrchr, strspn, strstr}; -pub use funcs::c95::string::{strtok, strxfrm}; - -pub use funcs::posix88::fcntl::{open, creat}; -pub use funcs::posix88::stat_::{chmod, fstat, mkdir, stat}; -pub use funcs::posix88::stdio::{fdopen, fileno, pclose, popen}; -pub use funcs::posix88::unistd::{access, chdir, close, dup, dup2}; -pub use funcs::posix88::unistd::{execv, execve, execvp, getcwd}; -pub use funcs::posix88::unistd::{getpid, isatty, lseek, pipe, read}; -pub use funcs::posix88::unistd::{rmdir, unlink, write}; - -pub use funcs::bsd43::{socket, setsockopt, bind, send, recv, recvfrom}; -pub use funcs::bsd43::{listen, sendto, accept, connect, getpeername, getsockname}; -pub use funcs::bsd43::{shutdown}; +pub use types::common::c95::*; +pub use types::common::c99::*; +pub use types::common::posix88::*; +pub use types::os::common::posix01::*; +pub use types::os::common::bsd44::*; +pub use types::os::arch::c95::*; +pub use types::os::arch::c99::*; +pub use types::os::arch::posix88::*; +pub use types::os::arch::posix01::*; +pub use types::os::arch::extra::*; + +pub use consts::os::c95::*; +pub use consts::os::posix88::*; +pub use consts::os::posix01::*; +pub use consts::os::bsd44::*; +pub use consts::os::extra::*; + +pub use funcs::c95::ctype::*; +pub use funcs::c95::stdio::*; +pub use funcs::c95::stdlib::*; +pub use funcs::c95::string::*; +pub use funcs::posix88::fcntl::*; +pub use funcs::posix88::stat_::*; +pub use funcs::posix88::stdio::*; +pub use funcs::posix88::unistd::*; + +pub use funcs::bsd43::*; // But we also reexport most everything // if you're interested in writing platform-specific code. @@ -169,149 +125,43 @@ pub use funcs::bsd43::{shutdown}; // // So the following exports don't follow any particular plan. -#[cfg(unix)] pub use consts::os::sysconf::{_SC_PAGESIZE}; -#[cfg(unix)] pub use consts::os::posix88::{PROT_READ, PROT_WRITE, PROT_EXEC}; -#[cfg(unix)] pub use consts::os::posix88::{MAP_FIXED, MAP_FILE, MAP_ANON, MAP_PRIVATE, MAP_FAILED}; -#[cfg(unix)] pub use consts::os::posix88::{EACCES, EBADF, EINVAL, ENODEV, ENOMEM}; -#[cfg(unix)] pub use consts::os::posix88::{ECONNREFUSED, ECONNRESET, EPERM, EPIPE}; -#[cfg(unix)] pub use consts::os::posix88::{ENOTCONN, ECONNABORTED, EADDRNOTAVAIL, EINTR}; -#[cfg(unix)] pub use consts::os::posix88::{EADDRINUSE, ENOENT, EISDIR, EAGAIN, EWOULDBLOCK}; -#[cfg(unix)] pub use consts::os::posix88::{ECANCELED, SIGINT, EINPROGRESS}; -#[cfg(unix)] pub use consts::os::posix88::{ENOSYS, ENOTTY, ETIMEDOUT, EMFILE}; -#[cfg(unix)] pub use consts::os::posix88::{SIGTERM, SIGKILL, SIGPIPE, PROT_NONE}; -#[cfg(unix)] pub use consts::os::posix01::{SIG_IGN, F_GETFL, F_SETFL}; -#[cfg(unix)] pub use consts::os::bsd44::{AF_UNIX}; -#[cfg(unix)] pub use consts::os::extra::{O_NONBLOCK}; - -#[cfg(unix)] pub use types::os::common::posix01::{pthread_t, timespec, timezone}; - -#[cfg(unix)] pub use types::os::arch::posix88::{uid_t, gid_t}; -#[cfg(unix)] pub use types::os::arch::posix01::{pthread_attr_t}; -#[cfg(unix)] pub use types::os::arch::posix01::{stat, utimbuf}; -#[cfg(unix)] pub use types::os::common::bsd44::{ifaddrs}; -#[cfg(unix)] pub use funcs::posix88::unistd::{sysconf, setgid, setsid, setuid, pread, pwrite}; -#[cfg(unix)] pub use funcs::posix88::unistd::{getgid, getuid, getsid}; -#[cfg(unix)] pub use funcs::posix88::unistd::{_PC_NAME_MAX, utime, nanosleep, pathconf, link}; -#[cfg(unix)] pub use funcs::posix88::unistd::{chown}; -#[cfg(unix)] pub use funcs::posix88::mman::{mmap, munmap, mprotect}; -#[cfg(unix)] pub use funcs::posix88::dirent::{opendir, readdir_r, closedir}; -#[cfg(unix)] pub use funcs::posix88::fcntl::{fcntl}; -#[cfg(unix)] pub use funcs::posix88::net::{if_nametoindex}; -#[cfg(unix)] pub use funcs::posix01::stat_::{lstat}; -#[cfg(unix)] pub use funcs::posix01::unistd::{fsync, ftruncate}; -#[cfg(unix)] pub use funcs::posix01::unistd::{readlink, symlink}; -#[cfg(unix)] pub use funcs::bsd43::{getifaddrs, freeifaddrs}; - -#[cfg(windows)] pub use consts::os::c95::{WSAECONNREFUSED, WSAECONNRESET, WSAEACCES}; -#[cfg(windows)] pub use consts::os::c95::{WSAEWOULDBLOCK, WSAENOTCONN, WSAECONNABORTED}; -#[cfg(windows)] pub use consts::os::c95::{WSAEADDRNOTAVAIL, WSAEADDRINUSE, WSAEINTR}; -#[cfg(windows)] pub use consts::os::c95::{WSAEINPROGRESS, WSAEINVAL, WSAEMFILE}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_INSUFFICIENT_BUFFER}; -#[cfg(windows)] pub use consts::os::extra::{O_BINARY, O_NOINHERIT, PAGE_NOACCESS}; -#[cfg(windows)] pub use consts::os::extra::{PAGE_READONLY, PAGE_READWRITE, PAGE_EXECUTE}; -#[cfg(windows)] pub use consts::os::extra::{PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE}; -#[cfg(windows)] pub use consts::os::extra::{MEM_COMMIT, MEM_RESERVE, MEM_RELEASE}; -#[cfg(windows)] pub use consts::os::extra::{FILE_MAP_READ, FILE_MAP_WRITE, FILE_MAP_EXECUTE}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_ALREADY_EXISTS, ERROR_NO_DATA}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_FILE_NOT_FOUND, ERROR_INVALID_NAME}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_BROKEN_PIPE, ERROR_INVALID_FUNCTION}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_CALL_NOT_IMPLEMENTED}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_NOTHING_TO_TERMINATE}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_INVALID_HANDLE}; -#[cfg(windows)] pub use consts::os::extra::{TRUE, FALSE, INFINITE}; -#[cfg(windows)] pub use consts::os::extra::{PROCESS_TERMINATE, PROCESS_QUERY_INFORMATION}; -#[cfg(windows)] pub use consts::os::extra::{STILL_ACTIVE, DETACHED_PROCESS}; -#[cfg(windows)] pub use consts::os::extra::{CREATE_NEW_PROCESS_GROUP, CREATE_UNICODE_ENVIRONMENT}; -#[cfg(windows)] pub use consts::os::extra::{FILE_BEGIN, FILE_END, FILE_CURRENT}; -#[cfg(windows)] pub use consts::os::extra::{FILE_GENERIC_READ, FILE_GENERIC_WRITE}; -#[cfg(windows)] pub use consts::os::extra::{FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_SHARE_DELETE}; -#[cfg(windows)] pub use consts::os::extra::{TRUNCATE_EXISTING, CREATE_ALWAYS, OPEN_EXISTING}; -#[cfg(windows)] pub use consts::os::extra::{CREATE_NEW, FILE_APPEND_DATA, FILE_WRITE_DATA}; -#[cfg(windows)] pub use consts::os::extra::{OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL}; -#[cfg(windows)] pub use consts::os::extra::{FILE_FLAG_BACKUP_SEMANTICS, INVALID_HANDLE_VALUE}; -#[cfg(windows)] pub use consts::os::extra::{MOVEFILE_REPLACE_EXISTING}; -#[cfg(windows)] pub use consts::os::extra::{GENERIC_READ, GENERIC_WRITE}; -#[cfg(windows)] pub use consts::os::extra::{VOLUME_NAME_DOS}; -#[cfg(windows)] pub use consts::os::extra::{PIPE_ACCESS_DUPLEX, FILE_FLAG_FIRST_PIPE_INSTANCE}; -#[cfg(windows)] pub use consts::os::extra::{FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE}; -#[cfg(windows)] pub use consts::os::extra::{PIPE_READMODE_BYTE, PIPE_WAIT}; -#[cfg(windows)] pub use consts::os::extra::{PIPE_UNLIMITED_INSTANCES, ERROR_ACCESS_DENIED}; -#[cfg(windows)] pub use consts::os::extra::{FILE_WRITE_ATTRIBUTES, FILE_READ_ATTRIBUTES}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_PIPE_BUSY, ERROR_IO_PENDING}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_PIPE_CONNECTED, WAIT_OBJECT_0}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_NOT_FOUND}; -#[cfg(windows)] pub use consts::os::extra::{ERROR_OPERATION_ABORTED}; -#[cfg(windows)] pub use consts::os::extra::{FIONBIO}; -#[cfg(windows)] pub use types::os::common::bsd44::{SOCKET}; -#[cfg(windows)] pub use types::os::common::posix01::{stat, utimbuf}; -#[cfg(windows)] pub use types::os::arch::extra::{HANDLE, BOOL, LPSECURITY_ATTRIBUTES}; -#[cfg(windows)] pub use types::os::arch::extra::{LPCSTR, WORD, DWORD, BYTE, FILETIME}; -#[cfg(windows)] pub use types::os::arch::extra::{LARGE_INTEGER, LPVOID, LONG}; -#[cfg(windows)] pub use types::os::arch::extra::{time64_t, OVERLAPPED, LPCWSTR}; -#[cfg(windows)] pub use types::os::arch::extra::{LPOVERLAPPED, SIZE_T, LPDWORD}; -#[cfg(windows)] pub use types::os::arch::extra::{SECURITY_ATTRIBUTES, WIN32_FIND_DATAW}; -#[cfg(windows)] pub use funcs::c95::string::{wcslen}; -#[cfg(windows)] pub use funcs::posix88::stat_::{wstat, wutime, wchmod, wrmdir}; -#[cfg(windows)] pub use funcs::bsd43::{closesocket}; -#[cfg(windows)] pub use funcs::extra::kernel32::{GetCurrentDirectoryW, GetLastError}; -#[cfg(windows)] pub use funcs::extra::kernel32::{GetEnvironmentVariableW, SetEnvironmentVariableW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{GetModuleFileNameW, SetCurrentDirectoryW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{GetSystemInfo, VirtualAlloc, VirtualFree}; -#[cfg(windows)] pub use funcs::extra::kernel32::{CreateFileMappingW, MapViewOfFile}; -#[cfg(windows)] pub use funcs::extra::kernel32::{UnmapViewOfFile, CloseHandle}; -#[cfg(windows)] pub use funcs::extra::kernel32::{WaitForSingleObject, GetSystemTimeAsFileTime}; -#[cfg(windows)] pub use funcs::extra::kernel32::{QueryPerformanceCounter}; -#[cfg(windows)] pub use funcs::extra::kernel32::{QueryPerformanceFrequency}; -#[cfg(windows)] pub use funcs::extra::kernel32::{GetExitCodeProcess, TerminateProcess}; -#[cfg(windows)] pub use funcs::extra::kernel32::{ReadFile, WriteFile, SetFilePointerEx}; -#[cfg(windows)] pub use funcs::extra::kernel32::{SetEndOfFile, CreateFileW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{CreateDirectoryW, FindFirstFileW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{FindNextFileW, FindClose, DeleteFileW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{CreateHardLinkW, CreateEventW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{FlushFileBuffers, CreateNamedPipeW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{SetNamedPipeHandleState, WaitNamedPipeW}; -#[cfg(windows)] pub use funcs::extra::kernel32::{GetOverlappedResult, ConnectNamedPipe}; -#[cfg(windows)] pub use funcs::extra::kernel32::{DisconnectNamedPipe, OpenProcess}; -#[cfg(windows)] pub use funcs::extra::kernel32::{MoveFileExW, VirtualProtect}; -#[cfg(windows)] pub use funcs::extra::kernel32::{RemoveDirectoryW}; -#[cfg(windows)] pub use funcs::extra::msvcrt::{get_osfhandle, open_osfhandle}; -#[cfg(windows)] pub use funcs::extra::winsock::{ioctlsocket}; - -#[cfg(any(target_os = "linux", - target_os = "android", - target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "openbsd"))] -pub use consts::os::posix01::{CLOCK_REALTIME, CLOCK_MONOTONIC}; - -#[cfg(any(target_os = "linux", target_os = "android"))] -pub use funcs::posix01::unistd::{fdatasync}; -#[cfg(any(target_os = "linux", target_os = "android"))] -pub use types::os::arch::extra::{sockaddr_ll}; -#[cfg(any(target_os = "linux", target_os = "android"))] -pub use consts::os::extra::{AF_PACKET}; - -#[cfg(all(unix, not(any(target_os = "freebsd", target_os = "bitrig", target_os = "openbsd"))))] -pub use consts::os::extra::{MAP_STACK}; - -#[cfg(any(target_os = "freebsd", target_os = "dragonfly"))] -pub use consts::os::bsd44::{TCP_KEEPIDLE}; - -#[cfg(any(target_os = "macos", target_os = "ios"))] -pub use consts::os::bsd44::{TCP_KEEPALIVE}; -#[cfg(any(target_os = "macos", target_os = "ios"))] -pub use consts::os::extra::{F_FULLFSYNC}; - -#[cfg(any(target_os = "macos", target_os = "ios"))] -pub use types::os::arch::extra::{mach_timebase_info}; - - -#[cfg(not(windows))] +#[cfg(unix)] pub use consts::os::sysconf::*; + +#[cfg(unix)] pub use funcs::posix88::mman::*; +#[cfg(unix)] pub use funcs::posix88::dirent::*; +#[cfg(unix)] pub use funcs::posix88::net::*; +#[cfg(unix)] pub use funcs::posix01::stat_::*; +#[cfg(unix)] pub use funcs::posix01::unistd::*; + + +#[cfg(windows)] pub use funcs::extra::kernel32::*; +#[cfg(windows)] pub use funcs::extra::winsock::*; +#[cfg(windows)] pub use funcs::extra::msvcrt::*; + +// On NaCl, these libraries are static. Thus it would be a Bad Idea to link them +// in when creating a test crate. +#[cfg(not(any(windows, all(target_os = "nacl", test))))] #[link(name = "c")] #[link(name = "m")] extern {} +// libnacl provides functions that require a trip through the IRT to work. +// ie: _exit, mmap, nanosleep, etc. Anything that would otherwise require a trip +// to the kernel. +#[cfg(all(target_os = "nacl", not(feature = "cargo-build"), not(test)))] +#[link(name = "nacl", kind = "static")] +extern {} + +// pnaclmm provides a number of functions that the toolchain's Clang emits calls +// to when codegening atomic ops. All the functions within wrap various atomic +// operations. +// Yes, it could be linked by rustc explicitly, however by linking it here +// instead we save a bit of time where bins are involved (by not running the +// optimizations on the whole pnaclmm foreach binary built). +#[cfg(all(target_os = "nacl", not(feature = "cargo-build"), not(test)))] +#[link(name = "pnaclmm", kind = "static")] +extern {} + pub mod types { // Types tend to vary *per architecture* so we pull their definitions out @@ -362,7 +212,7 @@ pub mod types { // Standard types that are scalar but vary by OS and arch. - #[cfg(any(target_os = "linux", target_os = "android"))] + #[cfg(any(target_os = "linux", target_os = "android", target_os = "nacl"))] pub mod os { pub mod common { pub mod posix01 { @@ -370,7 +220,10 @@ pub mod types { use types::os::arch::c95::{c_char, c_ulong, size_t, time_t, suseconds_t, c_long}; + #[cfg(not(target_os = "nacl"))] pub type pthread_t = c_ulong; + #[cfg(target_os = "nacl")] + pub type pthread_t = *mut c_void; #[repr(C)] #[derive(Copy)] pub struct glob_t { @@ -467,10 +320,10 @@ pub mod types { #[cfg(target_os = "linux")] pub ai_canonname: *mut c_char, - #[cfg(target_os = "android")] + #[cfg(any(target_os = "android", target_os = "nacl"))] pub ai_canonname: *mut c_char, - #[cfg(target_os = "android")] + #[cfg(any(target_os = "android", target_os = "nacl"))] pub ai_addr: *mut sockaddr, pub ai_next: *mut addrinfo, @@ -499,7 +352,8 @@ pub mod types { target_arch = "arm", target_arch = "mips", target_arch = "mipsel", - target_arch = "powerpc"))] + target_arch = "powerpc", + target_arch = "le32"))] pub mod arch { pub mod c95 { pub type c_char = i8; @@ -531,7 +385,8 @@ pub mod types { #[cfg(any(target_arch = "x86", target_arch = "mips", target_arch = "mipsel", - target_arch = "powerpc"))] + target_arch = "powerpc", + target_arch = "le32"))] pub mod posix88 { pub type off_t = i32; pub type dev_t = u64; @@ -556,6 +411,7 @@ pub mod types { pub type ssize_t = i32; } #[cfg(any(target_arch = "x86", + target_arch = "le32", target_arch = "powerpc"))] pub mod posix01 { use types::os::arch::c95::{c_short, c_long, time_t}; @@ -2480,7 +2336,7 @@ pub mod consts { pub const SHUT_RDWR: c_int = 2; } pub mod extra { - use SOCKET; + use types::os::common::bsd44::SOCKET; use types::os::arch::c95::{c_int, c_long}; use types::os::arch::extra::{WORD, DWORD, BOOL, HANDLE}; @@ -2715,7 +2571,7 @@ pub mod consts { } - #[cfg(any(target_os = "linux", target_os = "android"))] + #[cfg(any(target_os = "linux", target_os = "android", target_os = "nacl"))] pub mod os { pub mod c95 { use types::os::arch::c95::{c_int, c_uint}; @@ -2742,6 +2598,7 @@ pub mod consts { target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64", + target_arch = "le32", target_arch = "powerpc"))] pub mod posix88 { use types::os::arch::c95::c_int; @@ -3165,6 +3022,7 @@ pub mod consts { pub const EDQUOT: c_int = 1133; } + #[cfg(not(target_os = "nacl"))] pub mod posix01 { use types::os::arch::c95::{c_int, size_t}; @@ -3175,7 +3033,6 @@ pub mod consts { pub const F_SETFL : c_int = 4; pub const SIGTRAP : c_int = 5; - pub const SIGPIPE: c_int = 13; pub const SIG_IGN: size_t = 1; pub const GLOB_ERR : c_int = 1 << 0; @@ -3247,12 +3104,81 @@ pub mod consts { pub const CLOCK_REALTIME: c_int = 0; pub const CLOCK_MONOTONIC: c_int = 1; } + #[cfg(target_os = "nacl")] + pub mod posix01 { + use types::os::arch::c95::{c_int, size_t}; + + pub const F_DUPFD : c_int = 0; + pub const F_GETFD : c_int = 1; + pub const F_SETFD : c_int = 2; + pub const F_GETFL : c_int = 3; + pub const F_SETFL : c_int = 4; + + pub const SIGTRAP : c_int = 5; + pub const SIG_IGN: size_t = 1; + + pub const GLOB_ERR : c_int = 1 << 0; + pub const GLOB_MARK : c_int = 1 << 1; + pub const GLOB_NOSORT : c_int = 1 << 2; + pub const GLOB_DOOFFS : c_int = 1 << 3; + pub const GLOB_NOCHECK : c_int = 1 << 4; + pub const GLOB_APPEND : c_int = 1 << 5; + pub const GLOB_NOESCAPE : c_int = 1 << 6; + + pub const GLOB_NOSPACE : c_int = 1; + pub const GLOB_ABORTED : c_int = 2; + pub const GLOB_NOMATCH : c_int = 3; + + pub const POSIX_MADV_NORMAL : c_int = 0; + pub const POSIX_MADV_RANDOM : c_int = 1; + pub const POSIX_MADV_SEQUENTIAL : c_int = 2; + pub const POSIX_MADV_WILLNEED : c_int = 3; + pub const POSIX_MADV_DONTNEED : c_int = 4; + + pub const _SC_MQ_PRIO_MAX : c_int = 28; + pub const _SC_IOV_MAX : c_int = 60; + pub const _SC_GETGR_R_SIZE_MAX : c_int = 69; + pub const _SC_GETPW_R_SIZE_MAX : c_int = 70; + pub const _SC_LOGIN_NAME_MAX : c_int = 71; + pub const _SC_TTY_NAME_MAX : c_int = 72; + pub const _SC_THREADS : c_int = 67; + pub const _SC_THREAD_SAFE_FUNCTIONS : c_int = 68; + pub const _SC_THREAD_DESTRUCTOR_ITERATIONS : c_int = 73; + pub const _SC_THREAD_KEYS_MAX : c_int = 74; + pub const _SC_THREAD_STACK_MIN : c_int = 75; + pub const _SC_THREAD_THREADS_MAX : c_int = 76; + pub const _SC_THREAD_ATTR_STACKADDR : c_int = 77; + pub const _SC_THREAD_ATTR_STACKSIZE : c_int = 78; + pub const _SC_THREAD_PRIORITY_SCHEDULING : c_int = 79; + pub const _SC_THREAD_PRIO_INHERIT : c_int = 80; + pub const _SC_THREAD_PRIO_PROTECT : c_int = 81; + pub const _SC_THREAD_PROCESS_SHARED : c_int = 82; + pub const _SC_ATEXIT_MAX : c_int = 87; + pub const _SC_XOPEN_VERSION : c_int = 89; + pub const _SC_XOPEN_XCU_VERSION : c_int = 90; + pub const _SC_XOPEN_UNIX : c_int = 91; + pub const _SC_XOPEN_CRYPT : c_int = 92; + pub const _SC_XOPEN_ENH_I18N : c_int = 93; + pub const _SC_XOPEN_SHM : c_int = 94; + pub const _SC_XOPEN_LEGACY : c_int = 129; + pub const _SC_XOPEN_REALTIME : c_int = 130; + pub const _SC_XOPEN_REALTIME_THREADS : c_int = 131; + + pub const PTHREAD_CREATE_JOINABLE: c_int = 1; + pub const PTHREAD_CREATE_DETACHED: c_int = 0; + + pub const PTHREAD_STACK_MIN: size_t = 1024; + + pub const CLOCK_REALTIME: c_int = 0; + pub const CLOCK_MONOTONIC: c_int = 1; + } pub mod posix08 { } #[cfg(any(target_arch = "arm", target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64", + target_arch = "le32", target_arch = "powerpc"))] pub mod bsd44 { use types::os::arch::c95::c_int; @@ -3350,6 +3276,7 @@ pub mod consts { target_arch = "x86_64", target_arch = "arm", target_arch = "aarch64", + target_arch = "le32", target_arch = "powerpc"))] pub mod extra { use types::os::arch::c95::c_int; @@ -3465,6 +3392,14 @@ pub mod consts { pub const _SC_XBS5_ILP32_OFFBIG : c_int = 126; pub const _SC_XBS5_LPBIG_OFFBIG : c_int = 128; } + #[cfg(target_os = "nacl")] + pub mod sysconf { + use types::os::arch::c95::c_int; + + pub static _SC_SENDMSG_MAX_SIZE : c_int = 0; + pub static _SC_NPROCESSORS_ONLN : c_int = 1; + pub static _SC_PAGESIZE : c_int = 2; + } #[cfg(target_os = "android")] pub mod sysconf { use types::os::arch::c95::c_int; @@ -3706,7 +3641,6 @@ pub mod consts { pub const F_SETFL : c_int = 4; pub const SIGTRAP : c_int = 5; - pub const SIGPIPE: c_int = 13; pub const SIG_IGN: size_t = 1; pub const GLOB_APPEND : c_int = 0x0001; @@ -4113,7 +4047,6 @@ pub mod consts { pub const F_DUPFD_CLOEXEC : c_int = 10; pub const SIGTRAP : c_int = 5; - pub const SIGPIPE: c_int = 13; pub const SIG_IGN: size_t = 1; pub const GLOB_APPEND : c_int = 0x0001; @@ -4504,7 +4437,6 @@ pub mod consts { pub const F_SETFL : c_int = 4; pub const SIGTRAP : c_int = 5; - pub const SIGPIPE: c_int = 13; pub const SIG_IGN: size_t = 1; pub const GLOB_APPEND : c_int = 0x0001; @@ -5009,7 +4941,8 @@ pub mod funcs { target_os = "freebsd", target_os = "dragonfly", target_os = "bitrig", - target_os = "openbsd"))] + target_os = "openbsd", + target_os = "nacl"))] pub mod posix88 { pub mod stat_ { use types::os::arch::c95::{c_char, c_int}; @@ -5026,7 +4959,8 @@ pub mod funcs { target_os = "bitrig", target_os = "openbsd", target_os = "android", - target_os = "ios"))] + target_os = "ios", + target_os = "nacl"))] pub fn fstat(fildes: c_int, buf: *mut stat) -> c_int; #[cfg(target_os = "macos")] @@ -5034,6 +4968,7 @@ pub mod funcs { pub fn fstat(fildes: c_int, buf: *mut stat) -> c_int; pub fn mkdir(path: *const c_char, mode: mode_t) -> c_int; + #[cfg(not(target_os = "nacl"))] pub fn mkfifo(path: *const c_char, mode: mode_t) -> c_int; #[cfg(any(target_os = "linux", @@ -5042,7 +4977,8 @@ pub mod funcs { target_os = "bitrig", target_os = "openbsd", target_os = "android", - target_os = "ios"))] + target_os = "ios", + target_os = "nacl"))] pub fn stat(path: *const c_char, buf: *mut stat) -> c_int; #[cfg(target_os = "macos")] @@ -5114,6 +5050,7 @@ pub mod funcs { pub const _PC_NAME_MAX: c_int = 4; + #[cfg(not(target_os = "nacl"))] extern { pub fn access(path: *const c_char, amode: c_int) -> c_int; pub fn alarm(seconds: c_uint) -> c_uint; @@ -5135,7 +5072,7 @@ pub mod funcs { pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char; pub fn getegid() -> gid_t; pub fn geteuid() -> uid_t; - pub fn getgid() -> gid_t ; + pub fn getgid() -> gid_t; pub fn getgroups(ngroups_max: c_int, groups: *mut gid_t) -> c_int; pub fn getlogin() -> *mut c_char; @@ -5176,6 +5113,57 @@ pub mod funcs { offset: off_t) -> ssize_t; pub fn utime(file: *const c_char, buf: *const utimbuf) -> c_int; } + #[cfg(target_os = "nacl")] + extern { + pub fn access(path: *const c_char, amode: c_int) -> c_int; + pub fn chdir(dir: *const c_char) -> c_int; + pub fn chown(path: *const c_char, uid: uid_t, + gid: gid_t) -> c_int; + pub fn close(fd: c_int) -> c_int; + pub fn dup(fd: c_int) -> c_int; + pub fn dup2(src: c_int, dst: c_int) -> c_int; + pub fn execv(prog: *const c_char, + argv: *mut *const c_char) -> c_int; + pub fn execve(prog: *const c_char, argv: *mut *const c_char, + envp: *mut *const c_char) + -> c_int; + pub fn execvp(c: *const c_char, + argv: *mut *const c_char) -> c_int; + pub fn fork() -> pid_t; + pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char; + pub fn getegid() -> gid_t; + pub fn geteuid() -> uid_t; + pub fn getgid() -> gid_t; + pub fn getlogin() -> *mut c_char; + pub fn getopt(argc: c_int, argv: *mut *const c_char, + optstr: *const c_char) -> c_int; + pub fn getuid() -> uid_t; + pub fn getsid(pid: pid_t) -> pid_t; + pub fn isatty(fd: c_int) -> c_int; + pub fn link(src: *const c_char, dst: *const c_char) -> c_int; + pub fn lseek(fd: c_int, offset: off_t, whence: c_int) + -> off_t; + pub fn pipe(fds: *mut c_int) -> c_int; + pub fn read(fd: c_int, buf: *mut c_void, count: size_t) + -> ssize_t; + pub fn rmdir(path: *const c_char) -> c_int; + pub fn setgid(gid: gid_t) -> c_int; + pub fn setuid(uid: uid_t) -> c_int; + pub fn sleep(secs: c_uint) -> c_uint; + pub fn usleep(secs: c_uint) -> c_int; + pub fn nanosleep(rqtp: *const timespec, + rmtp: *mut timespec) -> c_int; + pub fn sysconf(name: c_int) -> c_long; + pub fn ttyname(fd: c_int) -> *mut c_char; + pub fn unlink(c: *const c_char) -> c_int; + pub fn write(fd: c_int, buf: *const c_void, count: size_t) + -> ssize_t; + pub fn pread(fd: c_int, buf: *mut c_void, count: size_t, + offset: off_t) -> ssize_t; + pub fn pwrite(fd: c_int, buf: *const c_void, count: size_t, + offset: off_t) -> ssize_t; + pub fn utime(file: *const c_char, buf: *const utimbuf) -> c_int; + } } pub mod signal { @@ -5192,12 +5180,24 @@ pub mod funcs { use types::os::arch::c95::{size_t, c_int, c_char}; use types::os::arch::posix88::{mode_t, off_t}; + #[cfg(not(target_os = "nacl"))] extern { pub fn mlock(addr: *const c_void, len: size_t) -> c_int; pub fn munlock(addr: *const c_void, len: size_t) -> c_int; pub fn mlockall(flags: c_int) -> c_int; pub fn munlockall() -> c_int; + pub fn mprotect(addr: *mut c_void, len: size_t, prot: c_int) + -> c_int; + + pub fn msync(addr: *mut c_void, len: size_t, flags: c_int) + -> c_int; + pub fn shm_open(name: *const c_char, oflag: c_int, mode: mode_t) + -> c_int; + pub fn shm_unlink(name: *const c_char) -> c_int; + } + + extern { pub fn mmap(addr: *mut c_void, len: size_t, prot: c_int, @@ -5207,14 +5207,6 @@ pub mod funcs { -> *mut c_void; pub fn munmap(addr: *mut c_void, len: size_t) -> c_int; - pub fn mprotect(addr: *mut c_void, len: size_t, prot: c_int) - -> c_int; - - pub fn msync(addr: *mut c_void, len: size_t, flags: c_int) - -> c_int; - pub fn shm_open(name: *const c_char, oflag: c_int, mode: mode_t) - -> c_int; - pub fn shm_unlink(name: *const c_char) -> c_int; } } @@ -5235,7 +5227,8 @@ pub mod funcs { target_os = "freebsd", target_os = "dragonfly", target_os = "bitrig", - target_os = "openbsd"))] + target_os = "openbsd", + target_os = "nacl"))] pub mod posix01 { pub mod stat_ { use types::os::arch::c95::{c_char, c_int}; @@ -5248,7 +5241,8 @@ pub mod funcs { target_os = "bitrig", target_os = "openbsd", target_os = "android", - target_os = "ios"))] + target_os = "ios", + target_os = "nacl"))] pub fn lstat(path: *const c_char, buf: *mut stat) -> c_int; #[cfg(target_os = "macos")] @@ -5320,6 +5314,7 @@ pub mod funcs { use types::common::c95::{c_void}; use types::os::arch::c95::{c_int, size_t}; + #[cfg(not(target_os = "nacl"))] extern { pub fn posix_madvise(addr: *mut c_void, len: size_t, @@ -5356,7 +5351,8 @@ pub mod funcs { target_os = "freebsd", target_os = "dragonfly", target_os = "bitrig", - target_os = "openbsd"))] + target_os = "openbsd", + target_os = "nacl"))] pub mod posix08 { pub mod unistd { } @@ -5494,6 +5490,13 @@ pub mod funcs { } } + #[cfg(target_os = "nacl")] + pub mod bsd44 { + use types::os::arch::c95::c_int; + extern { + pub fn getdtablesize() -> c_int; + } + } #[cfg(target_os = "windows")] pub mod bsd44 { @@ -5516,7 +5519,7 @@ pub mod funcs { pub mod extra { } - #[cfg(any(target_os = "linux", target_os = "android"))] + #[cfg(any(target_os = "linux", target_os = "android", target_os = "nacl"))] pub mod extra { } diff --git a/src/librbml/io.rs b/src/librbml/io.rs index 230fda11ab5..c52465a8899 100644 --- a/src/librbml/io.rs +++ b/src/librbml/io.rs @@ -45,7 +45,7 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> /// let mut w = SeekableMemWriter::new(); /// w.write(&[0, 1, 2]); /// -/// assert_eq!(w.unwrap(), vec!(0, 1, 2)); +/// assert_eq!(w.unwrap(), [0, 1, 2]); /// ``` pub struct SeekableMemWriter { buf: Vec<u8>, diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 3c06bae177c..9b5e94e87a1 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -1292,46 +1292,36 @@ impl LintPass for UnsafeCode { } fn check_item(&mut self, cx: &Context, it: &ast::Item) { - use syntax::ast::Unsafety::Unsafe; - - fn check_method(cx: &Context, meth: &P<ast::Method>) { - if let ast::Method_::MethDecl(_, _, _, _, Unsafe, _, _, _) = meth.node { - cx.span_lint(UNSAFE_CODE, meth.span, "implementation of an `unsafe` method"); - } - } - match it.node { - ast::ItemFn(_, Unsafe, _, _, _) => - cx.span_lint(UNSAFE_CODE, it.span, "declaration of an `unsafe` function"), + ast::ItemTrait(ast::Unsafety::Unsafe, _, _, _) => + cx.span_lint(UNSAFE_CODE, it.span, "declaration of an `unsafe` trait"), - ast::ItemTrait(trait_safety, _, _, ref items) => { - if trait_safety == Unsafe { - cx.span_lint(UNSAFE_CODE, it.span, "declaration of an `unsafe` trait"); - } + ast::ItemImpl(ast::Unsafety::Unsafe, _, _, _, _, _) => + cx.span_lint(UNSAFE_CODE, it.span, "implementation of an `unsafe` trait"), - for it in items { - match *it { - ast::RequiredMethod(ast::TypeMethod { unsafety: Unsafe, span, ..}) => - cx.span_lint(UNSAFE_CODE, span, "declaration of an `unsafe` method"), - ast::ProvidedMethod(ref meth) => check_method(cx, meth), - _ => (), - } - } - }, + _ => return, + } + } - ast::ItemImpl(impl_safety, _, _, _, _, ref impls) => { - if impl_safety == Unsafe { - cx.span_lint(UNSAFE_CODE, it.span, "implementation of an `unsafe` trait"); - } + fn check_fn(&mut self, cx: &Context, fk: visit::FnKind, _: &ast::FnDecl, + _: &ast::Block, span: Span, _: ast::NodeId) { + match fk { + visit::FkItemFn(_, _, ast::Unsafety::Unsafe, _) => + cx.span_lint(UNSAFE_CODE, span, "declaration of an `unsafe` function"), - for item in impls { - if let ast::ImplItem::MethodImplItem(ref meth) = *item { - check_method(cx, meth); - } + visit::FkMethod(_, _, m) => { + if let ast::Method_::MethDecl(_, _, _, _, ast::Unsafety::Unsafe, _, _, _) = m.node { + cx.span_lint(UNSAFE_CODE, m.span, "implementation of an `unsafe` method") } }, - _ => return, + _ => (), + } + } + + fn check_ty_method(&mut self, cx: &Context, ty_method: &ast::TypeMethod) { + if let ast::TypeMethod { unsafety: ast::Unsafety::Unsafe, span, ..} = *ty_method { + cx.span_lint(UNSAFE_CODE, span, "declaration of an `unsafe` method") } } } @@ -1577,6 +1567,14 @@ impl LintPass for MissingDoc { tm.span, "a type method"); } + fn check_trait_method(&mut self, cx: &Context, it: &ast::TraitItem) { + if let ast::TraitItem::TypeTraitItem(ref ty) = *it { + let assoc_ty = &ty.ty_param; + self.check_missing_docs_attrs(cx, Some(assoc_ty.id), &ty.attrs, + assoc_ty.span, "an associated type"); + } + } + fn check_struct_field(&mut self, cx: &Context, sf: &ast::StructField) { if let ast::NamedField(_, vis) = sf.node.kind { if vis == ast::Public || self.in_variant { @@ -1848,7 +1846,7 @@ impl LintPass for UnconditionalRecursion { continue } visited.insert(cfg_id); - let node_id = cfg.graph.node_data(idx).id; + let node_id = cfg.graph.node_data(idx).id(); // is this a recursive call? if node_id != ast::DUMMY_NODE_ID && checker(cx.tcx, impl_node_id, id, name, node_id) { diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index fbc3e76cf93..07082d81876 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -736,12 +736,10 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result<MetadataBlo } }; return match ArchiveMetadata::new(archive).map(|ar| MetadataArchive(ar)) { - None => { - return Err((format!("failed to read rlib metadata: '{}'", - filename.display()))) - } - Some(blob) => return Ok(blob) - } + None => Err(format!("failed to read rlib metadata: '{}'", + filename.display())), + Some(blob) => Ok(blob) + }; } unsafe { let buf = CString::new(filename.as_vec()).unwrap(); @@ -791,7 +789,7 @@ fn get_metadata_section_imp(is_osx: bool, filename: &Path) -> Result<MetadataBlo } llvm::LLVMMoveToNextSection(si.llsi); } - return Err(format!("metadata not found: '{}'", filename.display())); + Err(format!("metadata not found: '{}'", filename.display())) } } diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index e1e9d49dd05..11609ebe675 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -153,9 +153,6 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t ty::ty_err => { mywrite!(w, "e"); } - ty::ty_open(_) => { - cx.diag.handler().bug("unexpected type in enc_sty (ty_open)"); - } } let end = w.tell().unwrap(); diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs index d95dfb6feae..52eedc460eb 100644 --- a/src/librustc/middle/cfg/construct.rs +++ b/src/librustc/middle/cfg/construct.rs @@ -11,16 +11,15 @@ use middle::cfg::*; use middle::def; use middle::graph; +use middle::pat_util; use middle::region::CodeExtent; use middle::ty; use syntax::ast; use syntax::ast_util; use syntax::ptr::P; -use util::nodemap::NodeMap; struct CFGBuilder<'a, 'tcx: 'a> { tcx: &'a ty::ctxt<'tcx>, - exit_map: NodeMap<CFGIndex>, graph: CFGGraph, fn_exit: CFGIndex, loop_scopes: Vec<LoopScope>, @@ -36,17 +35,16 @@ struct LoopScope { pub fn construct(tcx: &ty::ctxt, blk: &ast::Block) -> CFG { let mut graph = graph::Graph::new(); - let entry = add_initial_dummy_node(&mut graph); + let entry = graph.add_node(CFGNodeData::Entry); // `fn_exit` is target of return exprs, which lies somewhere // outside input `blk`. (Distinguishing `fn_exit` and `block_exit` // also resolves chicken-and-egg problem that arises if you try to // have return exprs jump to `block_exit` during construction.) - let fn_exit = add_initial_dummy_node(&mut graph); + let fn_exit = graph.add_node(CFGNodeData::Exit); let block_exit; let mut cfg_builder = CFGBuilder { - exit_map: NodeMap(), graph: graph, fn_exit: fn_exit, tcx: tcx, @@ -54,17 +52,12 @@ pub fn construct(tcx: &ty::ctxt, }; block_exit = cfg_builder.block(blk, entry); cfg_builder.add_contained_edge(block_exit, fn_exit); - let CFGBuilder {exit_map, graph, ..} = cfg_builder; - CFG {exit_map: exit_map, - graph: graph, + let CFGBuilder {graph, ..} = cfg_builder; + CFG {graph: graph, entry: entry, exit: fn_exit} } -fn add_initial_dummy_node(g: &mut CFGGraph) -> CFGIndex { - g.add_node(CFGNodeData { id: ast::DUMMY_NODE_ID }) -} - impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { fn block(&mut self, blk: &ast::Block, pred: CFGIndex) -> CFGIndex { let mut stmts_exit = pred; @@ -74,19 +67,19 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let expr_exit = self.opt_expr(&blk.expr, stmts_exit); - self.add_node(blk.id, &[expr_exit]) + self.add_ast_node(blk.id, &[expr_exit]) } fn stmt(&mut self, stmt: &ast::Stmt, pred: CFGIndex) -> CFGIndex { match stmt.node { ast::StmtDecl(ref decl, id) => { let exit = self.decl(&**decl, pred); - self.add_node(id, &[exit]) + self.add_ast_node(id, &[exit]) } ast::StmtExpr(ref expr, id) | ast::StmtSemi(ref expr, id) => { let exit = self.expr(&**expr, pred); - self.add_node(id, &[exit]) + self.add_ast_node(id, &[exit]) } ast::StmtMac(..) => { @@ -115,33 +108,33 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { ast::PatLit(..) | ast::PatRange(..) | ast::PatWild(_) => { - self.add_node(pat.id, &[pred]) + self.add_ast_node(pat.id, &[pred]) } ast::PatBox(ref subpat) | ast::PatRegion(ref subpat, _) | ast::PatIdent(_, _, Some(ref subpat)) => { let subpat_exit = self.pat(&**subpat, pred); - self.add_node(pat.id, &[subpat_exit]) + self.add_ast_node(pat.id, &[subpat_exit]) } ast::PatEnum(_, Some(ref subpats)) | ast::PatTup(ref subpats) => { let pats_exit = self.pats_all(subpats.iter(), pred); - self.add_node(pat.id, &[pats_exit]) + self.add_ast_node(pat.id, &[pats_exit]) } ast::PatStruct(_, ref subpats, _) => { let pats_exit = self.pats_all(subpats.iter().map(|f| &f.node.pat), pred); - self.add_node(pat.id, &[pats_exit]) + self.add_ast_node(pat.id, &[pats_exit]) } ast::PatVec(ref pre, ref vec, ref post) => { let pre_exit = self.pats_all(pre.iter(), pred); let vec_exit = self.pats_all(vec.iter(), pre_exit); let post_exit = self.pats_all(post.iter(), vec_exit); - self.add_node(pat.id, &[post_exit]) + self.add_ast_node(pat.id, &[post_exit]) } ast::PatMac(_) => { @@ -157,28 +150,11 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { pats.fold(pred, |pred, pat| self.pat(&**pat, pred)) } - fn pats_any(&mut self, - pats: &[P<ast::Pat>], - pred: CFGIndex) -> CFGIndex { - //! Handles case where just one of the patterns must match. - - if pats.len() == 1 { - self.pat(&*pats[0], pred) - } else { - let collect = self.add_dummy_node(&[]); - for pat in pats { - let pat_exit = self.pat(&**pat, pred); - self.add_contained_edge(pat_exit, collect); - } - collect - } - } - fn expr(&mut self, expr: &ast::Expr, pred: CFGIndex) -> CFGIndex { match expr.node { ast::ExprBlock(ref blk) => { let blk_exit = self.block(&**blk, pred); - self.add_node(expr.id, &[blk_exit]) + self.add_ast_node(expr.id, &[blk_exit]) } ast::ExprIf(ref cond, ref then, None) => { @@ -198,7 +174,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // let cond_exit = self.expr(&**cond, pred); // 1 let then_exit = self.block(&**then, cond_exit); // 2 - self.add_node(expr.id, &[cond_exit, then_exit]) // 3,4 + self.add_ast_node(expr.id, &[cond_exit, then_exit]) // 3,4 } ast::ExprIf(ref cond, ref then, Some(ref otherwise)) => { @@ -219,7 +195,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let cond_exit = self.expr(&**cond, pred); // 1 let then_exit = self.block(&**then, cond_exit); // 2 let else_exit = self.expr(&**otherwise, cond_exit); // 3 - self.add_node(expr.id, &[then_exit, else_exit]) // 4, 5 + self.add_ast_node(expr.id, &[then_exit, else_exit]) // 4, 5 } ast::ExprIfLet(..) => { @@ -247,7 +223,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // Is the condition considered part of the loop? let loopback = self.add_dummy_node(&[pred]); // 1 let cond_exit = self.expr(&**cond, loopback); // 2 - let expr_exit = self.add_node(expr.id, &[cond_exit]); // 3 + let expr_exit = self.add_ast_node(expr.id, &[cond_exit]); // 3 self.loop_scopes.push(LoopScope { loop_id: expr.id, continue_index: loopback, @@ -283,7 +259,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // may cause additional edges. let loopback = self.add_dummy_node(&[pred]); // 1 - let expr_exit = self.add_node(expr.id, &[]); // 2 + let expr_exit = self.add_ast_node(expr.id, &[]); // 2 self.loop_scopes.push(LoopScope { loop_id: expr.id, continue_index: loopback, @@ -296,45 +272,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } ast::ExprMatch(ref discr, ref arms, _) => { - // - // [pred] - // | - // v 1 - // [discr] - // | - // v 2 - // [cond1] - // / \ - // | \ - // v 3 \ - // [pat1] \ - // | | - // v 4 | - // [guard1] | - // | | - // | | - // v 5 v - // [body1] [cond2] - // | / \ - // | ... ... - // | | | - // v 6 v v - // [.....expr.....] - // - let discr_exit = self.expr(&**discr, pred); // 1 - - let expr_exit = self.add_node(expr.id, &[]); - let mut cond_exit = discr_exit; - for arm in arms { - cond_exit = self.add_dummy_node(&[cond_exit]); // 2 - let pats_exit = self.pats_any(&arm.pats, - cond_exit); // 3 - let guard_exit = self.opt_expr(&arm.guard, - pats_exit); // 4 - let body_exit = self.expr(&*arm.body, guard_exit); // 5 - self.add_contained_edge(body_exit, expr_exit); // 6 - } - expr_exit + self.match_(expr.id, &discr, &arms, pred) } ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op.node) => { @@ -354,30 +292,30 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // let l_exit = self.expr(&**l, pred); // 1 let r_exit = self.expr(&**r, l_exit); // 2 - self.add_node(expr.id, &[l_exit, r_exit]) // 3,4 + self.add_ast_node(expr.id, &[l_exit, r_exit]) // 3,4 } ast::ExprRet(ref v) => { let v_exit = self.opt_expr(v, pred); - let b = self.add_node(expr.id, &[v_exit]); + let b = self.add_ast_node(expr.id, &[v_exit]); self.add_returning_edge(expr, b); - self.add_node(ast::DUMMY_NODE_ID, &[]) + self.add_unreachable_node() } ast::ExprBreak(label) => { let loop_scope = self.find_scope(expr, label); - let b = self.add_node(expr.id, &[pred]); + let b = self.add_ast_node(expr.id, &[pred]); self.add_exiting_edge(expr, b, loop_scope, loop_scope.break_index); - self.add_node(ast::DUMMY_NODE_ID, &[]) + self.add_unreachable_node() } ast::ExprAgain(label) => { let loop_scope = self.find_scope(expr, label); - let a = self.add_node(expr.id, &[pred]); + let a = self.add_ast_node(expr.id, &[pred]); self.add_exiting_edge(expr, a, loop_scope, loop_scope.continue_index); - self.add_node(ast::DUMMY_NODE_ID, &[]) + self.add_unreachable_node() } ast::ExprVec(ref elems) => { @@ -454,7 +392,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let &(_, ref expr, _) = a; &**expr }), post_inputs); - self.add_node(expr.id, &[post_outputs]) + self.add_ast_node(expr.id, &[post_outputs]) } ast::ExprMac(..) | @@ -481,7 +419,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let func_or_rcvr_exit = self.expr(func_or_rcvr, pred); let ret = self.straightline(call_expr, func_or_rcvr_exit, args); if return_ty.diverges() { - self.add_node(ast::DUMMY_NODE_ID, &[]) + self.add_unreachable_node() } else { ret } @@ -508,20 +446,126 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { //! Handles case of an expression that evaluates `subexprs` in order let subexprs_exit = self.exprs(subexprs, pred); - self.add_node(expr.id, &[subexprs_exit]) + self.add_ast_node(expr.id, &[subexprs_exit]) + } + + fn match_(&mut self, id: ast::NodeId, discr: &ast::Expr, + arms: &[ast::Arm], pred: CFGIndex) -> CFGIndex { + // The CFG for match expression is quite complex, so no ASCII + // art for it (yet). + // + // The CFG generated below matches roughly what trans puts + // out. Each pattern and guard is visited in parallel, with + // arms containing multiple patterns generating multiple nodes + // for the same guard expression. The guard expressions chain + // into each other from top to bottom, with a specific + // exception to allow some additional valid programs + // (explained below). Trans differs slightly in that the + // pattern matching may continue after a guard but the visible + // behaviour should be the same. + // + // What is going on is explained in further comments. + + // Visit the discriminant expression + let discr_exit = self.expr(discr, pred); + + // Add a node for the exit of the match expression as a whole. + let expr_exit = self.add_ast_node(id, &[]); + + // Keep track of the previous guard expressions + let mut prev_guards = Vec::new(); + // Track if the previous pattern contained bindings or wildcards + let mut prev_has_bindings = false; + + for arm in arms { + // Add an exit node for when we've visited all the + // patterns and the guard (if there is one) in the arm. + let arm_exit = self.add_dummy_node(&[]); + + for pat in &arm.pats { + // Visit the pattern, coming from the discriminant exit + let mut pat_exit = self.pat(&**pat, discr_exit); + + // If there is a guard expression, handle it here + if let Some(ref guard) = arm.guard { + // Add a dummy node for the previous guard + // expression to target + let guard_start = self.add_dummy_node(&[pat_exit]); + // Visit the guard expression + let guard_exit = self.expr(&**guard, guard_start); + + let this_has_bindings = pat_util::pat_contains_bindings_or_wild( + &self.tcx.def_map, &**pat); + + // If both this pattern and the previous pattern + // were free of bindings, they must consist only + // of "constant" patterns. Note we cannot match an + // all-constant pattern, fail the guard, and then + // match *another* all-constant pattern. This is + // because if the previous pattern matches, then + // we *cannot* match this one, unless all the + // constants are the same (which is rejected by + // `check_match`). + // + // We can use this to be smarter about the flow + // along guards. If the previous pattern matched, + // then we know we will not visit the guard in + // this one (whether or not the guard succeeded), + // if the previous pattern failed, then we know + // the guard for that pattern will not have been + // visited. Thus, it is not possible to visit both + // the previous guard and the current one when + // both patterns consist only of constant + // sub-patterns. + // + // However, if the above does not hold, then all + // previous guards need to be wired to visit the + // current guard pattern. + if prev_has_bindings || this_has_bindings { + while let Some(prev) = prev_guards.pop() { + self.add_contained_edge(prev, guard_start); + } + } + + prev_has_bindings = this_has_bindings; + + // Push the guard onto the list of previous guards + prev_guards.push(guard_exit); + + // Update the exit node for the pattern + pat_exit = guard_exit; + } + + // Add an edge from the exit of this pattern to the + // exit of the arm + self.add_contained_edge(pat_exit, arm_exit); + } + + // Visit the body of this arm + let body_exit = self.expr(&arm.body, arm_exit); + + // Link the body to the exit of the expression + self.add_contained_edge(body_exit, expr_exit); + } + + expr_exit } fn add_dummy_node(&mut self, preds: &[CFGIndex]) -> CFGIndex { - self.add_node(ast::DUMMY_NODE_ID, preds) + self.add_node(CFGNodeData::Dummy, preds) } - fn add_node(&mut self, id: ast::NodeId, preds: &[CFGIndex]) -> CFGIndex { - assert!(!self.exit_map.contains_key(&id)); - let node = self.graph.add_node(CFGNodeData {id: id}); - if id != ast::DUMMY_NODE_ID { - assert!(!self.exit_map.contains_key(&id)); - self.exit_map.insert(id, node); - } + fn add_ast_node(&mut self, id: ast::NodeId, preds: &[CFGIndex]) -> CFGIndex { + assert!(id != ast::DUMMY_NODE_ID); + self.add_node(CFGNodeData::AST(id), preds) + } + + fn add_unreachable_node(&mut self) -> CFGIndex { + self.add_node(CFGNodeData::Unreachable, &[]) + } + + fn add_node(&mut self, data: CFGNodeData, preds: &[CFGIndex]) -> CFGIndex { + let node = self.graph.add_node(data); for &pred in preds { self.add_contained_edge(pred, node); } diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs index 14c6ff01e0e..0c5eca3c129 100644 --- a/src/librustc/middle/cfg/graphviz.rs +++ b/src/librustc/middle/cfg/graphviz.rs @@ -65,10 +65,10 @@ impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> { dot::LabelText::LabelStr("entry".into_cow()) } else if i == self.cfg.exit { dot::LabelText::LabelStr("exit".into_cow()) - } else if n.data.id == ast::DUMMY_NODE_ID { + } else if n.data.id() == ast::DUMMY_NODE_ID { dot::LabelText::LabelStr("(dummy_node)".into_cow()) } else { - let s = self.ast_map.node_to_string(n.data.id); + let s = self.ast_map.node_to_string(n.data.id()); // left-aligns the lines let s = replace_newline_with_backslash_l(s); dot::LabelText::EscStr(s.into_cow()) diff --git a/src/librustc/middle/cfg/mod.rs b/src/librustc/middle/cfg/mod.rs index 0ca146a295e..e8a99f59b1e 100644 --- a/src/librustc/middle/cfg/mod.rs +++ b/src/librustc/middle/cfg/mod.rs @@ -14,21 +14,33 @@ use middle::graph; use middle::ty; use syntax::ast; -use util::nodemap::NodeMap; mod construct; pub mod graphviz; pub struct CFG { - pub exit_map: NodeMap<CFGIndex>, pub graph: CFGGraph, pub entry: CFGIndex, pub exit: CFGIndex, } -#[derive(Copy)] -pub struct CFGNodeData { - pub id: ast::NodeId +#[derive(Copy, PartialEq)] +pub enum CFGNodeData { + AST(ast::NodeId), + Entry, + Exit, + Dummy, + Unreachable, +} + +impl CFGNodeData { + pub fn id(&self) -> ast::NodeId { + if let CFGNodeData::AST(id) = *self { + id + } else { + ast::DUMMY_NODE_ID + } + } } pub struct CFGEdgeData { @@ -50,6 +62,6 @@ impl CFG { } pub fn node_is_reachable(&self, id: ast::NodeId) -> bool { - self.graph.depth_traverse(self.entry).any(|node| node.id == id) + self.graph.depth_traverse(self.entry).any(|node| node.id() == id) } } diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index cf33cd71365..1718df70255 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -53,7 +53,7 @@ pub struct DataFlowContext<'a, 'tcx: 'a, O> { // mapping from node to cfg node index // FIXME (#6298): Shouldn't this go with CFG? - nodeid_to_index: NodeMap<CFGIndex>, + nodeid_to_index: NodeMap<Vec<CFGIndex>>, // Bit sets per cfg node. The following three fields (`gens`, `kills`, // and `on_entry`) all have the same structure. For each id in @@ -88,11 +88,9 @@ struct PropagationContext<'a, 'b: 'a, 'tcx: 'b, O: 'a> { changed: bool } -fn to_cfgidx_or_die(id: ast::NodeId, index: &NodeMap<CFGIndex>) -> CFGIndex { - let opt_cfgindex = index.get(&id).cloned(); - opt_cfgindex.unwrap_or_else(|| { - panic!("nodeid_to_index does not have entry for NodeId {}", id); - }) +fn get_cfg_indices<'a>(id: ast::NodeId, index: &'a NodeMap<Vec<CFGIndex>>) -> &'a [CFGIndex] { + let opt_indices = index.get(&id); + opt_indices.map(|v| &v[..]).unwrap_or(&[]) } impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { @@ -114,9 +112,13 @@ impl<'a, 'tcx, O:DataFlowOperator> pprust::PpAnn for DataFlowContext<'a, 'tcx, O pprust::NodePat(pat) => pat.id }; - if self.has_bitset_for_nodeid(id) { - assert!(self.bits_per_id > 0); - let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index); + if !self.has_bitset_for_nodeid(id) { + return Ok(()); + } + + assert!(self.bits_per_id > 0); + let indices = get_cfg_indices(id, &self.nodeid_to_index); + for &cfgidx in indices { let (start, end) = self.compute_id_range(cfgidx); let on_entry = &self.on_entry[start.. end]; let entry_str = bits_to_string(on_entry); @@ -144,7 +146,7 @@ impl<'a, 'tcx, O:DataFlowOperator> pprust::PpAnn for DataFlowContext<'a, 'tcx, O } fn build_nodeid_to_index(decl: Option<&ast::FnDecl>, - cfg: &cfg::CFG) -> NodeMap<CFGIndex> { + cfg: &cfg::CFG) -> NodeMap<Vec<CFGIndex>> { let mut index = NodeMap(); // FIXME (#6298): Would it be better to fold formals from decl @@ -157,28 +159,38 @@ fn build_nodeid_to_index(decl: Option<&ast::FnDecl>, } cfg.graph.each_node(|node_idx, node| { - if node.data.id != ast::DUMMY_NODE_ID { - index.insert(node.data.id, node_idx); + if let cfg::CFGNodeData::AST(id) = node.data { + match index.entry(id).get() { + Ok(v) => v.push(node_idx), + Err(e) => { + e.insert(vec![node_idx]); + } + } } true }); return index; - fn add_entries_from_fn_decl(index: &mut NodeMap<CFGIndex>, + fn add_entries_from_fn_decl(index: &mut NodeMap<Vec<CFGIndex>>, decl: &ast::FnDecl, entry: CFGIndex) { //! add mappings from the ast nodes for the formal bindings to //! the entry-node in the graph. struct Formals<'a> { entry: CFGIndex, - index: &'a mut NodeMap<CFGIndex>, + index: &'a mut NodeMap<Vec<CFGIndex>>, } let mut formals = Formals { entry: entry, index: index }; visit::walk_fn_decl(&mut formals, decl); impl<'a, 'v> visit::Visitor<'v> for Formals<'a> { fn visit_pat(&mut self, p: &ast::Pat) { - self.index.insert(p.id, self.entry); + match self.index.entry(p.id).get() { + Ok(v) => v.push(self.entry), + Err(e) => { + e.insert(vec![self.entry]); + } + } visit::walk_pat(self, p) } } @@ -230,10 +242,12 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { assert!(self.nodeid_to_index.contains_key(&id)); assert!(self.bits_per_id > 0); - let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index); - let (start, end) = self.compute_id_range(cfgidx); - let gens = &mut self.gens[start.. end]; - set_bit(gens, bit); + let indices = get_cfg_indices(id, &self.nodeid_to_index); + for &cfgidx in indices { + let (start, end) = self.compute_id_range(cfgidx); + let gens = &mut self.gens[start.. end]; + set_bit(gens, bit); + } } pub fn add_kill(&mut self, id: ast::NodeId, bit: uint) { @@ -243,10 +257,12 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { assert!(self.nodeid_to_index.contains_key(&id)); assert!(self.bits_per_id > 0); - let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index); - let (start, end) = self.compute_id_range(cfgidx); - let kills = &mut self.kills[start.. end]; - set_bit(kills, bit); + let indices = get_cfg_indices(id, &self.nodeid_to_index); + for &cfgidx in indices { + let (start, end) = self.compute_id_range(cfgidx); + let kills = &mut self.kills[start.. end]; + set_bit(kills, bit); + } } fn apply_gen_kill(&self, cfgidx: CFGIndex, bits: &mut [uint]) { @@ -279,7 +295,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { } - pub fn each_bit_on_entry<F>(&self, id: ast::NodeId, f: F) -> bool where + pub fn each_bit_on_entry<F>(&self, id: ast::NodeId, mut f: F) -> bool where F: FnMut(uint) -> bool, { //! Iterates through each bit that is set on entry to `id`. @@ -287,8 +303,13 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { if !self.has_bitset_for_nodeid(id) { return true; } - let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index); - self.each_bit_for_node(Entry, cfgidx, f) + let indices = get_cfg_indices(id, &self.nodeid_to_index); + for &cfgidx in indices { + if !self.each_bit_for_node(Entry, cfgidx, |i| f(i)) { + return false; + } + } + return true; } pub fn each_bit_for_node<F>(&self, e: EntryOrExit, cfgidx: CFGIndex, f: F) -> bool where @@ -320,7 +341,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { self.each_bit(slice, f) } - pub fn each_gen_bit<F>(&self, id: ast::NodeId, f: F) -> bool where + pub fn each_gen_bit<F>(&self, id: ast::NodeId, mut f: F) -> bool where F: FnMut(uint) -> bool, { //! Iterates through each bit in the gen set for `id`. @@ -334,12 +355,17 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { return true; } - let cfgidx = to_cfgidx_or_die(id, &self.nodeid_to_index); - let (start, end) = self.compute_id_range(cfgidx); - let gens = &self.gens[start.. end]; - debug!("{} each_gen_bit(id={}, gens={})", - self.analysis_name, id, bits_to_string(gens)); - self.each_bit(gens, f) + let indices = get_cfg_indices(id, &self.nodeid_to_index); + for &cfgidx in indices { + let (start, end) = self.compute_id_range(cfgidx); + let gens = &self.gens[start.. end]; + debug!("{} each_gen_bit(id={}, gens={})", + self.analysis_name, id, bits_to_string(gens)); + if !self.each_bit(gens, |i| f(i)) { + return false; + } + } + return true; } fn each_bit<F>(&self, words: &[uint], mut f: F) -> bool where @@ -400,13 +426,15 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { let mut changed = false; for &node_id in &edge.data.exiting_scopes { - let opt_cfg_idx = self.nodeid_to_index.get(&node_id).cloned(); + let opt_cfg_idx = self.nodeid_to_index.get(&node_id); match opt_cfg_idx { - Some(cfg_idx) => { - let (start, end) = self.compute_id_range(cfg_idx); - let kills = &self.kills[start.. end]; - if bitwise(&mut orig_kills, kills, &Union) { - changed = true; + Some(indices) => { + for &cfg_idx in indices { + let (start, end) = self.compute_id_range(cfg_idx); + let kills = &self.kills[start.. end]; + if bitwise(&mut orig_kills, kills, &Union) { + changed = true; + } } } None => { @@ -482,7 +510,7 @@ impl<'a, 'b, 'tcx, O:DataFlowOperator> PropagationContext<'a, 'b, 'tcx, O> { cfg.graph.each_node(|node_index, node| { debug!("DataFlowContext::walk_cfg idx={:?} id={} begin in_out={}", - node_index, node.data.id, bits_to_string(in_out)); + node_index, node.data.id(), bits_to_string(in_out)); let (start, end) = self.dfcx.compute_id_range(node_index); diff --git a/src/librustc/middle/fast_reject.rs b/src/librustc/middle/fast_reject.rs index b33e5a802f1..7584a2e44cc 100644 --- a/src/librustc/middle/fast_reject.rs +++ b/src/librustc/middle/fast_reject.rs @@ -93,7 +93,7 @@ pub fn simplify_type(tcx: &ty::ctxt, None } } - ty::ty_open(_) | ty::ty_infer(_) | ty::ty_err => None, + ty::ty_infer(_) | ty::ty_err => None, } } diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs index 99cb2a0978e..38dd9a4d6ec 100644 --- a/src/librustc/middle/infer/combine.rs +++ b/src/librustc/middle/infer/combine.rs @@ -228,11 +228,11 @@ pub trait Combine<'tcx> : Sized { variadic: a.variadic}); - fn argvecs<'tcx, C: Combine<'tcx>>(combiner: &C, - a_args: &[Ty<'tcx>], - b_args: &[Ty<'tcx>]) - -> cres<'tcx, Vec<Ty<'tcx>>> - { + fn argvecs<'tcx, C>(combiner: &C, + a_args: &[Ty<'tcx>], + b_args: &[Ty<'tcx>]) + -> cres<'tcx, Vec<Ty<'tcx>>> + where C: Combine<'tcx> { if a_args.len() == b_args.len() { a_args.iter().zip(b_args.iter()) .map(|(a, b)| combiner.args(*a, *b)).collect() @@ -351,51 +351,51 @@ pub trait Combineable<'tcx> : Repr<'tcx> + TypeFoldable<'tcx> { impl<'tcx,T> Combineable<'tcx> for Rc<T> where T : Combineable<'tcx> { - fn combine<C:Combine<'tcx>>(combiner: &C, - a: &Rc<T>, - b: &Rc<T>) - -> cres<'tcx, Rc<T>> - { + fn combine<C>(combiner: &C, + a: &Rc<T>, + b: &Rc<T>) + -> cres<'tcx, Rc<T>> + where C: Combine<'tcx> { Ok(Rc::new(try!(Combineable::combine(combiner, &**a, &**b)))) } } impl<'tcx> Combineable<'tcx> for ty::TraitRef<'tcx> { - fn combine<C:Combine<'tcx>>(combiner: &C, - a: &ty::TraitRef<'tcx>, - b: &ty::TraitRef<'tcx>) - -> cres<'tcx, ty::TraitRef<'tcx>> - { + fn combine<C>(combiner: &C, + a: &ty::TraitRef<'tcx>, + b: &ty::TraitRef<'tcx>) + -> cres<'tcx, ty::TraitRef<'tcx>> + where C: Combine<'tcx> { combiner.trait_refs(a, b) } } impl<'tcx> Combineable<'tcx> for Ty<'tcx> { - fn combine<C:Combine<'tcx>>(combiner: &C, - a: &Ty<'tcx>, - b: &Ty<'tcx>) - -> cres<'tcx, Ty<'tcx>> - { + fn combine<C>(combiner: &C, + a: &Ty<'tcx>, + b: &Ty<'tcx>) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { combiner.tys(*a, *b) } } impl<'tcx> Combineable<'tcx> for ty::ProjectionPredicate<'tcx> { - fn combine<C:Combine<'tcx>>(combiner: &C, - a: &ty::ProjectionPredicate<'tcx>, - b: &ty::ProjectionPredicate<'tcx>) - -> cres<'tcx, ty::ProjectionPredicate<'tcx>> - { + fn combine<C>(combiner: &C, + a: &ty::ProjectionPredicate<'tcx>, + b: &ty::ProjectionPredicate<'tcx>) + -> cres<'tcx, ty::ProjectionPredicate<'tcx>> + where C: Combine<'tcx> { combiner.projection_predicates(a, b) } } impl<'tcx> Combineable<'tcx> for ty::FnSig<'tcx> { - fn combine<C:Combine<'tcx>>(combiner: &C, - a: &ty::FnSig<'tcx>, - b: &ty::FnSig<'tcx>) - -> cres<'tcx, ty::FnSig<'tcx>> - { + fn combine<C>(combiner: &C, + a: &ty::FnSig<'tcx>, + b: &ty::FnSig<'tcx>) + -> cres<'tcx, ty::FnSig<'tcx>> + where C: Combine<'tcx> { combiner.fn_sigs(a, b) } } @@ -407,8 +407,11 @@ pub struct CombineFields<'a, 'tcx: 'a> { pub trace: TypeTrace<'tcx>, } -pub fn expected_found<'tcx, C: Combine<'tcx>, T>( - this: &C, a: T, b: T) -> ty::expected_found<T> { +pub fn expected_found<'tcx, C, T>(this: &C, + a: T, + b: T) + -> ty::expected_found<T> + where C: Combine<'tcx> { if this.a_is_expected() { ty::expected_found {expected: a, found: b} } else { @@ -416,29 +419,26 @@ pub fn expected_found<'tcx, C: Combine<'tcx>, T>( } } -pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, - a: Ty<'tcx>, - b: Ty<'tcx>) - -> cres<'tcx, Ty<'tcx>> -{ +pub fn super_tys<'tcx, C>(this: &C, + a: Ty<'tcx>, + b: Ty<'tcx>) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { let tcx = this.infcx().tcx; let a_sty = &a.sty; let b_sty = &b.sty; debug!("super_tys: a_sty={:?} b_sty={:?}", a_sty, b_sty); return match (a_sty, b_sty) { - // The "subtype" ought to be handling cases involving var: - (&ty::ty_infer(TyVar(_)), _) | - (_, &ty::ty_infer(TyVar(_))) => { - tcx.sess.bug( - &format!("{}: bot and var types should have been handled ({},{})", - this.tag(), - a.repr(this.infcx().tcx), - b.repr(this.infcx().tcx))); - } - - (&ty::ty_err, _) | (_, &ty::ty_err) => { - Ok(tcx.types.err) - } + // The "subtype" ought to be handling cases involving var: + (&ty::ty_infer(TyVar(_)), _) + | (_, &ty::ty_infer(TyVar(_))) => + tcx.sess.bug( + &format!("{}: bot and var types should have been handled ({},{})", + this.tag(), + a.repr(this.infcx().tcx), + b.repr(this.infcx().tcx))), + + (&ty::ty_err, _) | (_, &ty::ty_err) => Ok(tcx.types.err), // Relate integral variables to other types (&ty::ty_infer(IntVar(a_id)), &ty::ty_infer(IntVar(b_id))) => { @@ -475,68 +475,62 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, unify_float_variable(this, !this.a_is_expected(), v_id, v) } - (&ty::ty_char, _) | - (&ty::ty_bool, _) | - (&ty::ty_int(_), _) | - (&ty::ty_uint(_), _) | - (&ty::ty_float(_), _) => { - if a == b { - Ok(a) - } else { - Err(ty::terr_sorts(expected_found(this, a, b))) - } - } - - (&ty::ty_param(ref a_p), &ty::ty_param(ref b_p)) if - a_p.idx == b_p.idx && a_p.space == b_p.space => { - Ok(a) - } - - (&ty::ty_enum(a_id, a_substs), - &ty::ty_enum(b_id, b_substs)) - if a_id == b_id => { - let substs = try!(this.substs(a_id, - a_substs, - b_substs)); - Ok(ty::mk_enum(tcx, a_id, tcx.mk_substs(substs))) - } - - (&ty::ty_trait(ref a_), - &ty::ty_trait(ref b_)) => { - debug!("Trying to match traits {:?} and {:?}", a, b); - let principal = try!(this.binders(&a_.principal, &b_.principal)); - let bounds = try!(this.existential_bounds(&a_.bounds, &b_.bounds)); - Ok(ty::mk_trait(tcx, principal, bounds)) - } - - (&ty::ty_struct(a_id, a_substs), &ty::ty_struct(b_id, b_substs)) - if a_id == b_id => { + (&ty::ty_char, _) + | (&ty::ty_bool, _) + | (&ty::ty_int(_), _) + | (&ty::ty_uint(_), _) + | (&ty::ty_float(_), _) => { + if a == b { + Ok(a) + } else { + Err(ty::terr_sorts(expected_found(this, a, b))) + } + } + + (&ty::ty_param(ref a_p), &ty::ty_param(ref b_p)) if + a_p.idx == b_p.idx && a_p.space == b_p.space => Ok(a), + + (&ty::ty_enum(a_id, a_substs), &ty::ty_enum(b_id, b_substs)) + if a_id == b_id => { + let substs = try!(this.substs(a_id, a_substs, b_substs)); + Ok(ty::mk_enum(tcx, a_id, tcx.mk_substs(substs))) + } + + (&ty::ty_trait(ref a_), &ty::ty_trait(ref b_)) => { + debug!("Trying to match traits {:?} and {:?}", a, b); + let principal = try!(this.binders(&a_.principal, &b_.principal)); + let bounds = try!(this.existential_bounds(&a_.bounds, &b_.bounds)); + Ok(ty::mk_trait(tcx, principal, bounds)) + } + + (&ty::ty_struct(a_id, a_substs), &ty::ty_struct(b_id, b_substs)) + if a_id == b_id => { let substs = try!(this.substs(a_id, a_substs, b_substs)); Ok(ty::mk_struct(tcx, a_id, tcx.mk_substs(substs))) - } - - (&ty::ty_closure(a_id, a_region, a_substs), - &ty::ty_closure(b_id, b_region, b_substs)) - if a_id == b_id => { - // All ty_closure types with the same id represent - // the (anonymous) type of the same closure expression. So - // all of their regions should be equated. - let region = try!(this.equate().regions(*a_region, *b_region)); - let substs = try!(this.substs_variances(None, a_substs, b_substs)); - Ok(ty::mk_closure(tcx, a_id, tcx.mk_region(region), tcx.mk_substs(substs))) - } - - (&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => { - let typ = try!(this.tys(a_inner, b_inner)); - Ok(ty::mk_uniq(tcx, typ)) - } - - (&ty::ty_ptr(ref a_mt), &ty::ty_ptr(ref b_mt)) => { - let mt = try!(this.mts(a_mt, b_mt)); - Ok(ty::mk_ptr(tcx, mt)) - } - - (&ty::ty_rptr(a_r, ref a_mt), &ty::ty_rptr(b_r, ref b_mt)) => { + } + + (&ty::ty_closure(a_id, a_region, a_substs), + &ty::ty_closure(b_id, b_region, b_substs)) + if a_id == b_id => { + // All ty_closure types with the same id represent + // the (anonymous) type of the same closure expression. So + // all of their regions should be equated. + let region = try!(this.equate().regions(*a_region, *b_region)); + let substs = try!(this.substs_variances(None, a_substs, b_substs)); + Ok(ty::mk_closure(tcx, a_id, tcx.mk_region(region), tcx.mk_substs(substs))) + } + + (&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => { + let typ = try!(this.tys(a_inner, b_inner)); + Ok(ty::mk_uniq(tcx, typ)) + } + + (&ty::ty_ptr(ref a_mt), &ty::ty_ptr(ref b_mt)) => { + let mt = try!(this.mts(a_mt, b_mt)); + Ok(ty::mk_ptr(tcx, mt)) + } + + (&ty::ty_rptr(a_r, ref a_mt), &ty::ty_rptr(b_r, ref b_mt)) => { let r = try!(this.regions_with_variance(ty::Contravariant, *a_r, *b_r)); // FIXME(14985) If we have mutable references to trait objects, we @@ -551,45 +545,43 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, _ => try!(this.mts(a_mt, b_mt)) }; Ok(ty::mk_rptr(tcx, tcx.mk_region(r), mt)) - } + } - (&ty::ty_vec(a_t, Some(sz_a)), &ty::ty_vec(b_t, Some(sz_b))) => { - this.tys(a_t, b_t).and_then(|t| { - if sz_a == sz_b { - Ok(ty::mk_vec(tcx, t, Some(sz_a))) - } else { - Err(ty::terr_fixed_array_size(expected_found(this, sz_a, sz_b))) - } - }) - } + (&ty::ty_vec(a_t, Some(sz_a)), &ty::ty_vec(b_t, Some(sz_b))) => { + this.tys(a_t, b_t).and_then(|t| { + if sz_a == sz_b { + Ok(ty::mk_vec(tcx, t, Some(sz_a))) + } else { + Err(ty::terr_fixed_array_size(expected_found(this, sz_a, sz_b))) + } + }) + } - (&ty::ty_vec(a_t, sz_a), &ty::ty_vec(b_t, sz_b)) => { - this.tys(a_t, b_t).and_then(|t| { - if sz_a == sz_b { - Ok(ty::mk_vec(tcx, t, sz_a)) + (&ty::ty_vec(a_t, sz_a), &ty::ty_vec(b_t, sz_b)) => { + this.tys(a_t, b_t).and_then(|t| { + if sz_a == sz_b { + Ok(ty::mk_vec(tcx, t, sz_a)) + } else { + Err(ty::terr_sorts(expected_found(this, a, b))) + } + }) + } + + (&ty::ty_str, &ty::ty_str) => Ok(ty::mk_str(tcx)), + + (&ty::ty_tup(ref as_), &ty::ty_tup(ref bs)) => { + if as_.len() == bs.len() { + as_.iter().zip(bs.iter()) + .map(|(a, b)| this.tys(*a, *b)) + .collect::<Result<_, _>>() + .map(|ts| ty::mk_tup(tcx, ts)) + } else if as_.len() != 0 && bs.len() != 0 { + Err(ty::terr_tuple_size( + expected_found(this, as_.len(), bs.len()))) } else { Err(ty::terr_sorts(expected_found(this, a, b))) } - }) - } - - (&ty::ty_str, &ty::ty_str) => { - Ok(ty::mk_str(tcx)) - } - - (&ty::ty_tup(ref as_), &ty::ty_tup(ref bs)) => { - if as_.len() == bs.len() { - as_.iter().zip(bs.iter()) - .map(|(a, b)| this.tys(*a, *b)) - .collect::<Result<_, _>>() - .map(|ts| ty::mk_tup(tcx, ts)) - } else if as_.len() != 0 && bs.len() != 0 { - Err(ty::terr_tuple_size( - expected_found(this, as_.len(), bs.len()))) - } else { - Err(ty::terr_sorts(expected_found(this, a, b))) } - } (&ty::ty_bare_fn(a_opt_def_id, a_fty), &ty::ty_bare_fn(b_opt_def_id, b_fty)) if a_opt_def_id == b_opt_def_id => @@ -598,33 +590,33 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, Ok(ty::mk_bare_fn(tcx, a_opt_def_id, tcx.mk_bare_fn(fty))) } - (&ty::ty_projection(ref a_data), &ty::ty_projection(ref b_data)) => { - let projection_ty = try!(this.projection_tys(a_data, b_data)); - Ok(ty::mk_projection(tcx, projection_ty.trait_ref, projection_ty.item_name)) - } + (&ty::ty_projection(ref a_data), &ty::ty_projection(ref b_data)) => { + let projection_ty = try!(this.projection_tys(a_data, b_data)); + Ok(ty::mk_projection(tcx, projection_ty.trait_ref, projection_ty.item_name)) + } - _ => Err(ty::terr_sorts(expected_found(this, a, b))) + _ => Err(ty::terr_sorts(expected_found(this, a, b))), }; - fn unify_integral_variable<'tcx, C: Combine<'tcx>>( - this: &C, - vid_is_expected: bool, - vid: ty::IntVid, - val: ty::IntVarValue) -> cres<'tcx, Ty<'tcx>> - { + fn unify_integral_variable<'tcx, C>(this: &C, + vid_is_expected: bool, + vid: ty::IntVid, + val: ty::IntVarValue) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { try!(this.infcx().simple_var_t(vid_is_expected, vid, val)); match val { IntType(v) => Ok(ty::mk_mach_int(this.tcx(), v)), - UintType(v) => Ok(ty::mk_mach_uint(this.tcx(), v)) + UintType(v) => Ok(ty::mk_mach_uint(this.tcx(), v)), } } - fn unify_float_variable<'tcx, C: Combine<'tcx>>( - this: &C, - vid_is_expected: bool, - vid: ty::FloatVid, - val: ast::FloatTy) -> cres<'tcx, Ty<'tcx>> - { + fn unify_float_variable<'tcx, C>(this: &C, + vid_is_expected: bool, + vid: ty::FloatVid, + val: ast::FloatTy) + -> cres<'tcx, Ty<'tcx>> + where C: Combine<'tcx> { try!(this.infcx().simple_var_t(vid_is_expected, vid, val)); Ok(ty::mk_mach_float(this.tcx(), val)) } @@ -696,12 +688,8 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { None => { // ...not yet instantiated: // Generalize type if necessary. let generalized_ty = try!(match dir { - EqTo => { - self.generalize(a_ty, b_vid, false) - } - BiTo | SupertypeOf | SubtypeOf => { - self.generalize(a_ty, b_vid, true) - } + EqTo => self.generalize(a_ty, b_vid, false), + BiTo | SupertypeOf | SubtypeOf => self.generalize(a_ty, b_vid, true), }); debug!("instantiate(a_ty={}, dir={:?}, \ b_vid={}, generalized_ty={})", @@ -723,22 +711,14 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { // to associate causes/spans with each of the relations in // the stack to get this right. match dir { - BiTo => { - try!(self.bivariate().tys(a_ty, b_ty)); - } + BiTo => try!(self.bivariate().tys(a_ty, b_ty)), - EqTo => { - try!(self.equate().tys(a_ty, b_ty)); - } + EqTo => try!(self.equate().tys(a_ty, b_ty)), - SubtypeOf => { - try!(self.sub().tys(a_ty, b_ty)); - } + SubtypeOf => try!(self.sub().tys(a_ty, b_ty)), - SupertypeOf => { - try!(self.sub().tys_with_variance(ty::Contravariant, a_ty, b_ty)); - } - } + SupertypeOf => try!(self.sub().tys_with_variance(ty::Contravariant, a_ty, b_ty)), + }; } Ok(()) @@ -754,11 +734,13 @@ impl<'f, 'tcx> CombineFields<'f, 'tcx> { make_region_vars: bool) -> cres<'tcx, Ty<'tcx>> { - let mut generalize = Generalizer { infcx: self.infcx, - span: self.trace.origin.span(), - for_vid: for_vid, - make_region_vars: make_region_vars, - cycle_detected: false }; + let mut generalize = Generalizer { + infcx: self.infcx, + span: self.trace.origin.span(), + for_vid: for_vid, + make_region_vars: make_region_vars, + cycle_detected: false + }; let u = ty.fold_with(&mut generalize); if generalize.cycle_detected { Err(ty::terr_cyclic_ty) diff --git a/src/librustc/middle/infer/freshen.rs b/src/librustc/middle/infer/freshen.rs index 1b7e6c33c05..e41b949d5df 100644 --- a/src/librustc/middle/infer/freshen.rs +++ b/src/librustc/middle/infer/freshen.rs @@ -135,7 +135,6 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> { t } - ty::ty_open(..) | ty::ty_bool | ty::ty_char | ty::ty_int(..) | diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs index 7800d99f8ed..759d7357df1 100644 --- a/src/librustc/middle/infer/region_inference/mod.rs +++ b/src/librustc/middle/infer/region_inference/mod.rs @@ -1133,18 +1133,12 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { true // changed } - ErrorValue => { - false // no change - } + ErrorValue => false, // no change Value(a_region) => { match a_data.classification { - Expanding => { - check_node(self, a_vid, a_data, a_region, b_region) - } - Contracting => { - adjust_node(self, a_vid, a_data, a_region, b_region) - } + Expanding => check_node(self, a_vid, a_data, a_region, b_region), + Contracting => adjust_node(self, a_vid, a_data, a_region, b_region), } } }; @@ -1154,7 +1148,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a_data: &mut VarData, a_region: Region, b_region: Region) - -> bool { + -> bool { if !this.is_subregion_of(a_region, b_region) { debug!("Setting {:?} to ErrorValue: {} not subregion of {}", a_vid, @@ -1170,7 +1164,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> { a_data: &mut VarData, a_region: Region, b_region: Region) - -> bool { + -> bool { match this.glb_concrete_regions(a_region, b_region) { Ok(glb) => { if glb == a_region { diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 01dc55c3eee..a7df2f4a5da 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -119,6 +119,21 @@ pub fn pat_contains_bindings(dm: &DefMap, pat: &ast::Pat) -> bool { contains_bindings } +/// Checks if the pattern contains any patterns that bind something to +/// an ident or wildcard, e.g. `foo`, or `Foo(_)`, `foo @ Bar(..)`, +pub fn pat_contains_bindings_or_wild(dm: &DefMap, pat: &ast::Pat) -> bool { + let mut contains_bindings = false; + walk_pat(pat, |p| { + if pat_is_binding_or_wild(dm, p) { + contains_bindings = true; + false // there's at least one binding/wildcard, can short circuit now. + } else { + true + } + }); + contains_bindings +} + pub fn simple_identifier<'a>(pat: &'a ast::Pat) -> Option<&'a ast::Ident> { match pat.node { ast::PatIdent(ast::BindByValue(_), ref path1, None) => { diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index 9ef4a436b8d..4d45bb841f4 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -194,7 +194,6 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { ty::ty_closure(..) | ty::ty_infer(..) | - ty::ty_open(..) | ty::ty_err => { tcx.sess.bug( &format!("ty_is_local invoked on unexpected type: {}", diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs index f10f7eb3951..64835a666fa 100644 --- a/src/librustc/middle/traits/object_safety.rs +++ b/src/librustc/middle/traits/object_safety.rs @@ -42,9 +42,6 @@ pub enum ObjectSafetyViolation<'tcx> { /// Reasons a method might not be object-safe. #[derive(Copy,Clone,Debug)] pub enum MethodViolationCode { - /// e.g., `fn(self)` - ByValueSelf, - /// e.g., `fn foo()` StaticMethod, @@ -158,18 +155,24 @@ fn trait_has_sized_self<'tcx>(tcx: &ty::ctxt<'tcx>, trait_def_id: ast::DefId) -> bool { + let trait_def = ty::lookup_trait_def(tcx, trait_def_id); + let trait_predicates = ty::lookup_predicates(tcx, trait_def_id); + generics_require_sized_self(tcx, &trait_def.generics, &trait_predicates) +} + +fn generics_require_sized_self<'tcx>(tcx: &ty::ctxt<'tcx>, + generics: &ty::Generics<'tcx>, + predicates: &ty::GenericPredicates<'tcx>) + -> bool +{ let sized_def_id = match tcx.lang_items.sized_trait() { Some(def_id) => def_id, None => { return false; /* No Sized trait, can't require it! */ } }; // Search for a predicate like `Self : Sized` amongst the trait bounds. - let trait_def = ty::lookup_trait_def(tcx, trait_def_id); - let free_substs = ty::construct_free_substs(tcx, &trait_def.generics, ast::DUMMY_NODE_ID); - - let trait_predicates = ty::lookup_predicates(tcx, trait_def_id); - let predicates = trait_predicates.instantiate(tcx, &free_substs).predicates.into_vec(); - + let free_substs = ty::construct_free_substs(tcx, generics, ast::DUMMY_NODE_ID); + let predicates = predicates.instantiate(tcx, &free_substs).predicates.into_vec(); elaborate_predicates(tcx, predicates) .any(|predicate| { match predicate { @@ -192,17 +195,21 @@ fn object_safety_violations_for_method<'tcx>(tcx: &ty::ctxt<'tcx>, method: &ty::Method<'tcx>) -> Option<MethodViolationCode> { - // The method's first parameter must be something that derefs to - // `&self`. For now, we only accept `&self` and `Box<Self>`. - match method.explicit_self { - ty::ByValueExplicitSelfCategory => { - return Some(MethodViolationCode::ByValueSelf); - } + // Any method that has a `Self : Sized` requisite is otherwise + // exempt from the regulations. + if generics_require_sized_self(tcx, &method.generics, &method.predicates) { + return None; + } + // The method's first parameter must be something that derefs (or + // autorefs) to `&self`. For now, we only accept `self`, `&self` + // and `Box<Self>`. + match method.explicit_self { ty::StaticExplicitSelfCategory => { return Some(MethodViolationCode::StaticMethod); } + ty::ByValueExplicitSelfCategory | ty::ByReferenceExplicitSelfCategory(..) | ty::ByBoxExplicitSelfCategory => { } diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index daf7e50e1bc..9ec89f55b8f 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -1409,27 +1409,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty()); return match self_ty.sty { - ty::ty_infer(ty::IntVar(_)) | - ty::ty_infer(ty::FloatVar(_)) | - ty::ty_uint(_) | - ty::ty_int(_) | - ty::ty_bool | - ty::ty_float(_) | - ty::ty_bare_fn(..) | - ty::ty_char => { + ty::ty_infer(ty::IntVar(_)) + | ty::ty_infer(ty::FloatVar(_)) + | ty::ty_uint(_) + | ty::ty_int(_) + | ty::ty_bool + | ty::ty_float(_) + | ty::ty_bare_fn(..) + | ty::ty_char => { // safe for everything Ok(If(Vec::new())) } ty::ty_uniq(_) => { // Box<T> match bound { - ty::BoundCopy => { - Err(Unimplemented) - } + ty::BoundCopy => Err(Unimplemented), - ty::BoundSized => { - Ok(If(Vec::new())) - } + ty::BoundSized => Ok(If(Vec::new())), ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); @@ -1439,9 +1435,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::ty_ptr(..) => { // *const T, *mut T match bound { - ty::BoundCopy | ty::BoundSized => { - Ok(If(Vec::new())) - } + ty::BoundCopy | ty::BoundSized => Ok(If(Vec::new())), ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); @@ -1451,9 +1445,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::ty_trait(ref data) => { match bound { - ty::BoundSized => { - Err(Unimplemented) - } + ty::BoundSized => Err(Unimplemented), ty::BoundCopy => { if data.bounds.builtin_bounds.contains(&bound) { Ok(If(Vec::new())) @@ -1485,20 +1477,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { ty::BoundCopy => { match mutbl { // &mut T is affine and hence never `Copy` - ast::MutMutable => { - Err(Unimplemented) - } + ast::MutMutable => Err(Unimplemented), // &T is always copyable - ast::MutImmutable => { - Ok(If(Vec::new())) - } + ast::MutImmutable => Ok(If(Vec::new())), } } - ty::BoundSized => { - Ok(If(Vec::new())) - } + ty::BoundSized => Ok(If(Vec::new())), ty::BoundSync | ty::BoundSend => { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); @@ -1511,14 +1497,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { match bound { ty::BoundCopy => { match *len { - Some(_) => { - // [T, ..n] is copy iff T is copy - Ok(If(vec![element_ty])) - } - None => { - // [T] is unsized and hence affine - Err(Unimplemented) - } + // [T, ..n] is copy iff T is copy + Some(_) => Ok(If(vec![element_ty])), + + // [T] is unsized and hence affine + None => Err(Unimplemented), } } @@ -1543,16 +1526,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); } - ty::BoundCopy | ty::BoundSized => { - Err(Unimplemented) - } + ty::BoundCopy | ty::BoundSized => Err(Unimplemented), } } - ty::ty_tup(ref tys) => { - // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet - Ok(If(tys.clone())) - } + // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet + ty::ty_tup(ref tys) => Ok(If(tys.clone())), ty::ty_closure(def_id, _, substs) => { // FIXME -- This case is tricky. In the case of by-ref @@ -1581,9 +1560,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } match self.closure_typer.closure_upvars(def_id, substs) { - Some(upvars) => { - Ok(If(upvars.iter().map(|c| c.ty).collect())) - } + Some(upvars) => Ok(If(upvars.iter().map(|c| c.ty).collect())), None => { debug!("assemble_builtin_bound_candidates: no upvar types available yet"); Ok(AmbiguousBuiltin) @@ -1609,8 +1586,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { nominal(bound, types) } - ty::ty_projection(_) | - ty::ty_param(_) => { + ty::ty_projection(_) | ty::ty_param(_) => { // Note: A type parameter is only considered to meet a // particular bound if there is a where clause telling // us that it does, and that case is handled by @@ -1626,31 +1602,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { Ok(AmbiguousBuiltin) } - ty::ty_open(ty) => { - // these only crop up in trans, and represent an - // "opened" unsized/existential type (one that has - // been dereferenced) - match bound { - ty::BoundCopy => { - Ok(If(vec!(ty))) - } - - ty::BoundSized => { - Err(Unimplemented) - } - - ty::BoundSync | - ty::BoundSend => { - self.tcx().sess.bug("Send/Sync shouldn't occur in builtin_bounds()"); - } - } - } - ty::ty_err => { - Ok(If(Vec::new())) - } + ty::ty_err => Ok(If(Vec::new())), - ty::ty_infer(ty::FreshTy(_)) | - ty::ty_infer(ty::FreshIntTy(_)) => { + ty::ty_infer(ty::FreshTy(_)) + | ty::ty_infer(ty::FreshIntTy(_)) => { self.tcx().sess.bug( &format!( "asked to assemble builtin bounds of unexpected type: {}", @@ -1660,7 +1615,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { fn nominal<'cx, 'tcx>(bound: ty::BuiltinBound, types: Vec<Ty<'tcx>>) - -> Result<BuiltinBoundConditions<'tcx>,SelectionError<'tcx>> + -> Result<BuiltinBoundConditions<'tcx>, SelectionError<'tcx>> { // First check for markers and other nonsense. match bound { @@ -1711,15 +1666,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { self.tcx().sess.bug( &format!( "asked to assemble constituent types of unexpected type: {}", - t.repr(self.tcx()))[]); + t.repr(self.tcx()))); } ty::ty_uniq(referent_ty) => { // Box<T> Some(vec![referent_ty]) } - ty::ty_open(element_ty) => {Some(vec![element_ty])}, - ty::ty_ptr(ty::mt { ty: element_ty, ..}) | ty::ty_rptr(_, ty::mt { ty: element_ty, ..}) => { Some(vec![element_ty]) @@ -1930,7 +1883,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }).collect::<Result<_, _>>(); let obligations = match obligations { Ok(o) => o, - Err(ErrorReported) => Vec::new() + Err(ErrorReported) => Vec::new(), }; let obligations = VecPerParamSpace::new(obligations, Vec::new(), Vec::new()); @@ -1958,14 +1911,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let self_ty = self.infcx.shallow_resolve(obligation.predicate.0.self_ty()); match self.constituent_types_for_ty(self_ty) { - Some(types) => { - Ok(self.vtable_default_impl(obligation, impl_def_id, types)) - } + Some(types) => Ok(self.vtable_default_impl(obligation, impl_def_id, types)), None => { self.tcx().sess.bug( &format!( "asked to confirm default implementation for ambiguous type: {}", - self_ty.repr(self.tcx()))[]); + self_ty.repr(self.tcx()))); } } } @@ -2244,9 +2195,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { { match self.match_impl(impl_def_id, obligation, snapshot, skol_map, skol_obligation_trait_ref) { - Ok(substs) => { - substs - } + Ok(substs) => substs, Err(()) => { self.tcx().sess.bug( &format!("Impl {} was matchable against {} but now is not", @@ -2294,30 +2243,26 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { skol_obligation_trait_ref.repr(self.tcx())); let origin = infer::RelateOutputImplTypes(obligation.cause.span); - match self.infcx.sub_trait_refs(false, - origin, - impl_trait_ref.value.clone(), - skol_obligation_trait_ref) { - Ok(()) => { } - Err(e) => { - debug!("match_impl: failed sub_trait_refs due to `{}`", - ty::type_err_to_str(self.tcx(), &e)); - return Err(()); - } + if let Err(e) = self.infcx.sub_trait_refs(false, + origin, + impl_trait_ref.value.clone(), + skol_obligation_trait_ref) { + debug!("match_impl: failed sub_trait_refs due to `{}`", + ty::type_err_to_str(self.tcx(), &e)); + return Err(()); } - match self.infcx.leak_check(skol_map, snapshot) { - Ok(()) => { } - Err(e) => { - debug!("match_impl: failed leak check due to `{}`", - ty::type_err_to_str(self.tcx(), &e)); - return Err(()); - } + if let Err(e) = self.infcx.leak_check(skol_map, snapshot) { + debug!("match_impl: failed leak check due to `{}`", + ty::type_err_to_str(self.tcx(), &e)); + return Err(()); } debug!("match_impl: success impl_substs={}", impl_substs.repr(self.tcx())); - Ok(Normalized { value: impl_substs, - obligations: impl_trait_ref.obligations }) + Ok(Normalized { + value: impl_substs, + obligations: impl_trait_ref.obligations + }) } fn fast_reject_trait_refs(&mut self, @@ -2353,9 +2298,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { where_clause_trait_ref: ty::PolyTraitRef<'tcx>) -> Result<Vec<PredicateObligation<'tcx>>,()> { - let () = - try!(self.match_poly_trait_ref(obligation, where_clause_trait_ref)); - + try!(self.match_poly_trait_ref(obligation, where_clause_trait_ref)); Ok(Vec::new()) } @@ -2472,7 +2415,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { match self.tcx().trait_impls.borrow().get(&trait_def_id) { None => Vec::new(), - Some(impls) => impls.borrow().clone() + Some(impls) => impls.borrow().clone(), } } @@ -2570,9 +2513,7 @@ impl<'tcx> Repr<'tcx> for SelectionCandidate<'tcx> { DefaultImplCandidate(t) => format!("DefaultImplCandidate({:?})", t), ProjectionCandidate => format!("ProjectionCandidate"), FnPointerCandidate => format!("FnPointerCandidate"), - ObjectCandidate => { - format!("ObjectCandidate") - } + ObjectCandidate => format!("ObjectCandidate"), ClosureCandidate(c, ref s) => { format!("ClosureCandidate({:?},{})", c, s.repr(tcx)) } @@ -2603,9 +2544,7 @@ impl<'o, 'tcx> Iterator for Option<&'o TraitObligationStack<'o, 'tcx>> { *self = o.previous; Some(o) } - None => { - None - } + None => None } } } @@ -2620,15 +2559,11 @@ impl<'o, 'tcx> Repr<'tcx> for TraitObligationStack<'o, 'tcx> { impl<'tcx> EvaluationResult<'tcx> { fn may_apply(&self) -> bool { match *self { - EvaluatedToOk | - EvaluatedToAmbig | - EvaluatedToErr(Overflow) | - EvaluatedToErr(OutputTypeParameterMismatch(..)) => { - true - } - EvaluatedToErr(Unimplemented) => { - false - } + EvaluatedToOk + | EvaluatedToAmbig + | EvaluatedToErr(Overflow) + | EvaluatedToErr(OutputTypeParameterMismatch(..)) => true, + EvaluatedToErr(Unimplemented) => false, } } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index a461297dd95..3d059e27c52 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -930,7 +930,7 @@ impl<'tcx> ctxt<'tcx> { sty_debug_print!( self, ty_enum, ty_uniq, ty_vec, ty_ptr, ty_rptr, ty_bare_fn, ty_trait, - ty_struct, ty_closure, ty_tup, ty_param, ty_open, ty_infer, ty_projection); + ty_struct, ty_closure, ty_tup, ty_param, ty_infer, ty_projection); println!("Substs interner: #{}", self.substs_interner.borrow().len()); println!("BareFnTy interner: #{}", self.bare_fn_interner.borrow().len()); @@ -1374,12 +1374,6 @@ pub enum sty<'tcx> { ty_projection(ProjectionTy<'tcx>), ty_param(ParamTy), // type parameter - ty_open(Ty<'tcx>), // A deref'ed fat pointer, i.e., a dynamically sized value - // and its size. Only ever used in trans. It is not necessary - // earlier since we don't need to distinguish a DST with its - // size (e.g., in a deref) vs a DST with the size elsewhere ( - // e.g., in a field). - ty_infer(InferTy), // something used only during inference/typeck ty_err, // Also only used during inference/typeck, to represent // the type of an erroneous expression (helps cut down @@ -2689,7 +2683,7 @@ impl FlagComputation { self.add_bounds(bounds); } - &ty_uniq(tt) | &ty_vec(tt, _) | &ty_open(tt) => { + &ty_uniq(tt) | &ty_vec(tt, _) => { self.add_ty(tt) } @@ -2964,8 +2958,6 @@ pub fn mk_param_from_def<'tcx>(cx: &ctxt<'tcx>, def: &TypeParameterDef) -> Ty<'t mk_param(cx, def.space, def.index, def.name) } -pub fn mk_open<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { mk_t(cx, ty_open(ty)) } - impl<'tcx> TyS<'tcx> { /// Iterator that walks `self` and any types reachable from /// `self`, in depth-first order. Note that just walks the types @@ -3164,7 +3156,6 @@ pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_vec(ty, _) => ty, ty_str => mk_mach_uint(cx, ast::TyU8), - ty_open(ty) => sequence_element_type(cx, ty), _ => cx.sess.bug(&format!("sequence_element_type called on non-sequence value: {}", ty_to_string(cx, ty))), } @@ -3583,12 +3574,6 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents { TC::All } - ty_open(ty) => { - let result = tc_ty(cx, ty, cache); - assert!(!result.is_sized(cx)); - result.unsafe_pointer() | TC::Nonsized - } - ty_infer(_) | ty_err => { cx.sess.bug("asked to compute contents of error type"); @@ -3747,7 +3732,7 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool { ty_vec(_, None) => { false } - ty_uniq(typ) | ty_open(typ) => { + ty_uniq(typ) => { type_requires(cx, seen, r_ty, typ) } ty_rptr(_, ref mt) => { @@ -4106,14 +4091,6 @@ pub fn deref<'tcx>(ty: Ty<'tcx>, explicit: bool) -> Option<mt<'tcx>> { } } -pub fn close_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { - match ty.sty { - ty_open(ty) => mk_rptr(cx, cx.mk_region(ReStatic), mt {ty: ty, mutbl:ast::MutImmutable}), - _ => cx.sess.bug(&format!("Trying to close a non-open type {}", - ty_to_string(cx, ty))) - } -} - pub fn type_content<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> { match ty.sty { ty_uniq(ty) => ty, @@ -4122,14 +4099,6 @@ pub fn type_content<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> { } } -// Extract the unsized type in an open type (or just return ty if it is not open). -pub fn unopen_type<'tcx>(ty: Ty<'tcx>) -> Ty<'tcx> { - match ty.sty { - ty_open(ty) => ty, - _ => ty - } -} - // Returns the type of ty[i] pub fn index<'tcx>(ty: Ty<'tcx>) -> Option<Ty<'tcx>> { match ty.sty { @@ -4802,7 +4771,6 @@ pub fn ty_sort_string<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> String { } } ty_err => "type error".to_string(), - ty_open(_) => "opened DST".to_string(), } } @@ -6328,16 +6296,15 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) - hash!(p.idx); hash!(token::get_name(p.name)); } - ty_open(_) => byte!(22), ty_infer(_) => unreachable!(), - ty_err => byte!(23), + ty_err => byte!(21), ty_closure(d, r, _) => { - byte!(24); + byte!(22); did(state, d); region(state, *r); } ty_projection(ref data) => { - byte!(25); + byte!(23); did(state, data.trait_ref.def_id); hash!(token::get_name(data.item_name)); } @@ -6666,7 +6633,6 @@ pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec<ty::Region>, ty_projection(_) | ty_param(_) | ty_infer(_) | - ty_open(_) | ty_err => { } } diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 92b0ea905ac..d2469c052ac 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -626,9 +626,6 @@ pub fn super_fold_ty<'tcx, T: TypeFolder<'tcx>>(this: &mut T, ty::ty_vec(typ, sz) => { ty::ty_vec(typ.fold_with(this), sz) } - ty::ty_open(typ) => { - ty::ty_open(typ.fold_with(this)) - } ty::ty_enum(tid, ref substs) => { let substs = substs.fold_with(this); ty::ty_enum(tid, this.tcx().mk_substs(substs)) diff --git a/src/librustc/middle/ty_walk.rs b/src/librustc/middle/ty_walk.rs index 40dfd479364..3336e7ee8bf 100644 --- a/src/librustc/middle/ty_walk.rs +++ b/src/librustc/middle/ty_walk.rs @@ -28,7 +28,7 @@ impl<'tcx> TypeWalker<'tcx> { ty::ty_bool | ty::ty_char | ty::ty_int(_) | ty::ty_uint(_) | ty::ty_float(_) | ty::ty_str | ty::ty_infer(_) | ty::ty_param(_) | ty::ty_err => { } - ty::ty_uniq(ty) | ty::ty_vec(ty, _) | ty::ty_open(ty) => { + ty::ty_uniq(ty) | ty::ty_vec(ty, _) => { self.stack.push(ty); } ty::ty_ptr(ref mt) | ty::ty_rptr(_, ref mt) => { diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 23b63bc2665..15b3c6d9d06 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -20,7 +20,7 @@ use middle::ty::{ReSkolemized, ReVar, BrEnv}; use middle::ty::{mt, Ty, ParamTy}; use middle::ty::{ty_bool, ty_char, ty_struct, ty_enum}; use middle::ty::{ty_err, ty_str, ty_vec, ty_float, ty_bare_fn}; -use middle::ty::{ty_param, ty_ptr, ty_rptr, ty_tup, ty_open}; +use middle::ty::{ty_param, ty_ptr, ty_rptr, ty_tup}; use middle::ty::{ty_closure}; use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_infer}; use middle::ty; @@ -369,8 +369,6 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String { buf.push_str(&mt_to_string(cx, tm)); buf } - ty_open(typ) => - format!("opened<{}>", ty_to_string(cx, typ)), ty_tup(ref elems) => { let strs = elems .iter() diff --git a/src/librustc_back/target/openbsd_base.rs b/src/librustc_back/target/openbsd_base.rs index 42220a87bd4..759147b939c 100644 --- a/src/librustc_back/target/openbsd_base.rs +++ b/src/librustc_back/target/openbsd_base.rs @@ -20,6 +20,11 @@ pub fn opts() -> TargetOptions { linker_is_gnu: true, has_rpath: true, pre_link_args: vec!( + // GNU-style linkers will use this to omit linking to libraries + // which don't actually fulfill any relocations, but only for + // libraries which follow this flag. Thus, use it before + // specifying libraries to link to. + "-Wl,--as-needed".to_string(), ), position_independent_executables: true, .. Default::default() diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index fd7880212f1..67462ab0100 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -105,10 +105,10 @@ fn borrowck_item(this: &mut BorrowckCtxt, item: &ast::Item) { ast::ItemConst(_, ref ex) => { gather_loans::gather_loans_in_static_initializer(this, &**ex); } - _ => { - visit::walk_item(this, item); - } + _ => { } } + + visit::walk_item(this, item); } /// Collection of conclusions determined via borrow checker analyses. @@ -612,13 +612,26 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { }; let (suggestion, _) = move_suggestion(param_env, expr_span, expr_ty, ("moved by default", "")); - self.tcx.sess.span_note( - expr_span, - &format!("`{}` moved here{} because it has type `{}`, which is {}", - ol, - moved_lp_msg, - expr_ty.user_string(self.tcx), - suggestion)); + // If the two spans are the same, it's because the expression will be evaluated + // multiple times. Avoid printing the same span and adjust the wording so it makes + // more sense that it's from multiple evalutations. + if expr_span == use_span { + self.tcx.sess.note( + &format!("`{}` was previously moved here{} because it has type `{}`, \ + which is {}", + ol, + moved_lp_msg, + expr_ty.user_string(self.tcx), + suggestion)); + } else { + self.tcx.sess.span_note( + expr_span, + &format!("`{}` moved here{} because it has type `{}`, which is {}", + ol, + moved_lp_msg, + expr_ty.user_string(self.tcx), + suggestion)); + } } move_data::MovePat => { diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index 4465000d8d8..a2c9930c0ed 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -52,7 +52,7 @@ pub struct DataflowLabeller<'a, 'tcx: 'a> { impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { fn dataflow_for(&self, e: EntryOrExit, n: &Node<'a>) -> String { - let id = n.1.data.id; + let id = n.1.data.id(); debug!("dataflow_for({:?}, id={}) {:?}", e, id, self.variants); let mut sets = "".to_string(); let mut seen_one = false; diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index cdcc9850e42..d9cedc48298 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -806,11 +806,11 @@ fn walk_ty() { let tup2_ty = ty::mk_tup(tcx, vec!(tup1_ty, tup1_ty, uint_ty)); let uniq_ty = ty::mk_uniq(tcx, tup2_ty); let walked: Vec<_> = uniq_ty.walk().collect(); - assert_eq!(vec!(uniq_ty, - tup2_ty, - tup1_ty, int_ty, uint_ty, int_ty, uint_ty, - tup1_ty, int_ty, uint_ty, int_ty, uint_ty, - uint_ty), + assert_eq!([uniq_ty, + tup2_ty, + tup1_ty, int_ty, uint_ty, int_ty, uint_ty, + tup1_ty, int_ty, uint_ty, int_ty, uint_ty, + uint_ty], walked); }) } diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 1a24b3fabf8..26e1a981f1b 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -678,7 +678,7 @@ fn bind_subslice_pat(bcx: Block, } fn extract_vec_elems<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, - left_ty: Ty, + left_ty: Ty<'tcx>, before: uint, after: uint, val: ValueRef) diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs index 903de940207..3ea14d3c589 100644 --- a/src/librustc_trans/trans/adt.rs +++ b/src/librustc_trans/trans/adt.rs @@ -699,7 +699,7 @@ fn struct_llfields<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, st: &Struct<'tcx>, st.fields.iter().filter(|&ty| !dst || type_is_sized(cx.tcx(), *ty)) .map(|&ty| type_of::sizing_type_of(cx, ty)).collect() } else { - st.fields.iter().map(|&ty| type_of::type_of(cx, ty)).collect() + st.fields.iter().map(|&ty| type_of::in_memory_type_of(cx, ty)).collect() } } diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs index 35b6ca7f0f5..b18b7b75d32 100644 --- a/src/librustc_trans/trans/base.rs +++ b/src/librustc_trans/trans/base.rs @@ -676,8 +676,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>, let val = if common::type_is_sized(cx.tcx(), field_ty) { llfld_a } else { - let boxed_ty = ty::mk_open(cx.tcx(), field_ty); - let scratch = datum::rvalue_scratch_datum(cx, boxed_ty, "__fat_ptr_iter"); + let scratch = datum::rvalue_scratch_datum(cx, field_ty, "__fat_ptr_iter"); Store(cx, llfld_a, GEPi(cx, scratch.val, &[0, abi::FAT_PTR_ADDR])); Store(cx, info.unwrap(), GEPi(cx, scratch.val, &[0, abi::FAT_PTR_EXTRA])); scratch.val @@ -1353,7 +1352,7 @@ fn build_cfg(tcx: &ty::ctxt, id: ast::NodeId) -> (ast::NodeId, Option<cfg::CFG>) // the clobbering of the existing value in the return slot. fn has_nested_returns(tcx: &ty::ctxt, cfg: &cfg::CFG, blk_id: ast::NodeId) -> bool { for n in cfg.graph.depth_traverse(cfg.entry) { - match tcx.map.find(n.id) { + match tcx.map.find(n.id()) { Some(ast_map::NodeExpr(ex)) => { if let ast::ExprRet(Some(ref ret_expr)) = ex.node { let mut visitor = FindNestedReturn::new(); diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs index e92960ec7cd..a3ba506fc46 100644 --- a/src/librustc_trans/trans/common.rs +++ b/src/librustc_trans/trans/common.rs @@ -120,14 +120,16 @@ pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T // Is the type's representation size known at compile time? pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { let param_env = ty::empty_parameter_environment(tcx); - ty::type_is_sized(¶m_env, DUMMY_SP, ty) -} - -pub fn lltype_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { - match ty.sty { - ty::ty_open(_) => true, - _ => type_is_sized(cx, ty), + // FIXME(#4287) This can cause errors due to polymorphic recursion, + // a better span should be provided, if available. + let err_count = tcx.sess.err_count(); + let is_sized = ty::type_is_sized(¶m_env, DUMMY_SP, ty); + // Those errors aren't fatal, but an incorrect result can later + // trip over asserts in both rustc's trans and LLVM. + if err_count < tcx.sess.err_count() { + tcx.sess.abort_if_errors(); } + is_sized } pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { @@ -211,9 +213,7 @@ pub fn type_needs_unwind_cleanup<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty< } } -pub fn type_needs_drop<'tcx>(cx: &ty::ctxt<'tcx>, - ty: Ty<'tcx>) - -> bool { +pub fn type_needs_drop<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool { ty::type_contents(cx, ty).needs_drop(cx) } diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 3c0024712b2..5cbe9dd71fb 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -146,8 +146,8 @@ fn const_deref<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, (const_deref_ptr(cx, v), mt.ty) } else { // Derefing a fat pointer does not change the representation, - // just the type to ty_open. - (v, ty::mk_open(cx.tcx(), mt.ty)) + // just the type to the unsized contents. + (v, mt.ty) } } None => { @@ -290,15 +290,7 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, // an optimisation, it is necessary for mutable vectors to // work properly. ty = match ty::deref(ty, true) { - Some(mt) => { - if type_is_sized(cx.tcx(), mt.ty) { - mt.ty - } else { - // Derefing a fat pointer does not change the representation, - // just the type to ty_open. - ty::mk_open(cx.tcx(), mt.ty) - } - } + Some(mt) => mt.ty, None => { cx.sess().bug(&format!("unexpected dereferenceable type {}", ty_to_string(cx.tcx(), ty))) @@ -319,11 +311,12 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, llconst = addr_of(cx, llconst, "autoref", e.id); } Some(box ty::AutoUnsize(ref k)) => { - let unsized_ty = ty::unsize_ty(cx.tcx(), ty, k, e.span); let info = expr::unsized_info(cx, k, e.id, ty, param_substs, |t| ty::mk_imm_rptr(cx.tcx(), cx.tcx().mk_region(ty::ReStatic), t)); - let base = ptrcast(llconst, type_of::type_of(cx, unsized_ty).ptr_to()); + let unsized_ty = ty::unsize_ty(cx.tcx(), ty, k, e.span); + let ptr_ty = type_of::in_memory_type_of(cx, unsized_ty).ptr_to(); + let base = ptrcast(llconst, ptr_ty); let prev_const = cx.const_unsized().borrow_mut() .insert(base, llconst); assert!(prev_const.is_none() || prev_const == Some(llconst)); @@ -366,7 +359,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }; unsafe { let _icx = push_ctxt("const_expr"); - return match e.node { + match e.node { ast::ExprLit(ref lit) => { const_lit(cx, e, &**lit) } @@ -386,7 +379,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (te2, _) = const_expr(cx, &**e2, param_substs); let te2 = base::cast_shift_const_rhs(b, te1, te2); - return match b.node { + match b.node { ast::BiAdd => { if is_float { llvm::LLVMConstFAdd(te1, te2) } else { llvm::LLVMConstAdd(te1, te2) } @@ -440,7 +433,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ast::ExprUnary(u, ref e) => { let (te, ty) = const_expr(cx, &**e, param_substs); let is_float = ty::type_is_fp(ty); - return match u { + match u { ast::UnUniq | ast::UnDeref => { const_deref(cx, te, ty).0 } @@ -477,16 +470,10 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, }; let (arr, len) = match bt.sty { ty::ty_vec(_, Some(u)) => (bv, C_uint(cx, u)), - ty::ty_open(ty) => match ty.sty { - ty::ty_vec(_, None) | ty::ty_str => { - let e1 = const_get_elt(cx, bv, &[0]); - (const_deref_ptr(cx, e1), const_get_elt(cx, bv, &[1])) - }, - _ => cx.sess().span_bug(base.span, - &format!("index-expr base must be a vector \ - or string type, found {}", - ty_to_string(cx.tcx(), bt))) - }, + ty::ty_vec(_, None) | ty::ty_str => { + let e1 = const_get_elt(cx, bv, &[0]); + (const_deref_ptr(cx, e1), const_get_elt(cx, bv, &[1])) + } ty::ty_rptr(_, mt) => match mt.ty.sty { ty::ty_vec(_, Some(u)) => { (const_deref_ptr(cx, bv), C_uint(cx, u)) @@ -527,8 +514,8 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, if expr::cast_is_noop(basety, ety) { return v; } - return match (expr::cast_type_kind(cx.tcx(), basety), - expr::cast_type_kind(cx.tcx(), ety)) { + match (expr::cast_type_kind(cx.tcx(), basety), + expr::cast_type_kind(cx.tcx(), ety)) { (expr::cast_integral, expr::cast_integral) => { let s = ty::type_is_signed(basety) as Bool; @@ -597,13 +584,13 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } let opt_def = cx.tcx().def_map.borrow().get(&cur.id).cloned(); if let Some(def::DefStatic(def_id, _)) = opt_def { - return get_static_val(cx, def_id, ety); + get_static_val(cx, def_id, ety) + } else { + // If this isn't the address of a static, then keep going through + // normal constant evaluation. + let (v, _) = const_expr(cx, &**sub, param_substs); + addr_of(cx, v, "ref", e.id) } - - // If this isn't the address of a static, then keep going through - // normal constant evaluation. - let (v, _) = const_expr(cx, &**sub, param_substs); - addr_of(cx, v, "ref", e.id) } ast::ExprAddrOf(ast::MutMutable, ref sub) => { let (v, _) = const_expr(cx, &**sub, param_substs); @@ -753,7 +740,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } _ => cx.sess().span_bug(e.span, "bad constant expression type in consts::const_expr") - }; + } } } diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs index e0598583a19..8262dbf55dd 100644 --- a/src/librustc_trans/trans/datum.rs +++ b/src/librustc_trans/trans/datum.rs @@ -492,8 +492,6 @@ impl<'tcx> Datum<'tcx, Expr> { -> DatumBlock<'blk, 'tcx, Lvalue> { debug!("to_lvalue_datum self: {}", self.to_string(bcx.ccx())); - assert!(lltype_is_sized(bcx.tcx(), self.ty), - "Trying to convert unsized value to lval"); self.match_kind( |l| DatumBlock::new(bcx, l), |r| { @@ -549,15 +547,10 @@ impl<'tcx> Datum<'tcx, Lvalue> { -> Datum<'tcx, Lvalue> where F: FnOnce(ValueRef) -> ValueRef, { - let val = match self.ty.sty { - _ if type_is_sized(bcx.tcx(), self.ty) => gep(self.val), - ty::ty_open(_) => { - let base = Load(bcx, expr::get_dataptr(bcx, self.val)); - gep(base) - } - _ => bcx.tcx().sess.bug( - &format!("Unexpected unsized type in get_element: {}", - bcx.ty_to_string(self.ty))) + let val = if type_is_sized(bcx.tcx(), self.ty) { + gep(self.val) + } else { + gep(Load(bcx, expr::get_dataptr(bcx, self.val))) }; Datum { val: val, @@ -566,7 +559,8 @@ impl<'tcx> Datum<'tcx, Lvalue> { } } - pub fn get_vec_base_and_len(&self, bcx: Block) -> (ValueRef, ValueRef) { + pub fn get_vec_base_and_len<'blk>(&self, bcx: Block<'blk, 'tcx>) + -> (ValueRef, ValueRef) { //! Converts a vector into the slice pair. tvec::get_base_and_len(bcx, self.val, self.ty) diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs index b5cba9b6740..162881f58c7 100644 --- a/src/librustc_trans/trans/debuginfo.rs +++ b/src/librustc_trans/trans/debuginfo.rs @@ -3828,7 +3828,6 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, } ty::ty_err | ty::ty_infer(_) | - ty::ty_open(_) | ty::ty_projection(..) | ty::ty_param(_) => { cx.sess().bug(&format!("debuginfo: Trying to create type name for \ diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index 78992959a6f..9e9ee453752 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -451,8 +451,6 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let datum_ty = datum.ty; let unsized_ty = ty::unsize_ty(tcx, datum_ty, k, expr.span); debug!("unsized_ty={}", unsized_ty.repr(bcx.tcx())); - let dest_ty = ty::mk_open(tcx, unsized_ty); - debug!("dest_ty={}", unsized_ty.repr(bcx.tcx())); let info = unsized_info(bcx.ccx(), k, expr.id, datum_ty, bcx.fcx.param_substs, |t| ty::mk_imm_rptr(tcx, tcx.mk_region(ty::ReStatic), t)); @@ -462,20 +460,16 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, datum.to_lvalue_datum(bcx, "into_fat_ptr", expr.id)); // Compute the base pointer. This doesn't change the pointer value, // but merely its type. - let base = match *k { - ty::UnsizeStruct(..) | ty::UnsizeVtable(..) => { - PointerCast(bcx, lval.val, type_of::type_of(bcx.ccx(), unsized_ty).ptr_to()) - } - ty::UnsizeLength(..) => { - GEPi(bcx, lval.val, &[0, 0]) - } - }; + let ptr_ty = type_of::in_memory_type_of(bcx.ccx(), unsized_ty).ptr_to(); + let base = PointerCast(bcx, lval.val, ptr_ty); - let scratch = rvalue_scratch_datum(bcx, dest_ty, "__fat_ptr"); - Store(bcx, base, get_dataptr(bcx, scratch.val)); - Store(bcx, info, get_len(bcx, scratch.val)); + let llty = type_of::type_of(bcx.ccx(), unsized_ty); + // HACK(eddyb) get around issues with lifetime intrinsics. + let scratch = alloca_no_lifetime(bcx, llty, "__fat_ptr"); + Store(bcx, base, get_dataptr(bcx, scratch)); + Store(bcx, info, get_len(bcx, scratch)); - DatumBlock::new(bcx, scratch.to_expr_datum()) + DatumBlock::new(bcx, Datum::new(scratch, unsized_ty, LvalueExpr)) } fn unsize_unique_vec<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, @@ -711,7 +705,7 @@ fn trans_field<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, let _icx = push_ctxt("trans_rec_field"); let base_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, base, "field")); - let bare_ty = ty::unopen_type(base_datum.ty); + let bare_ty = base_datum.ty; let repr = adt::represent_type(bcx.ccx(), bare_ty); with_field_tys(bcx.tcx(), bare_ty, None, move |discr, field_tys| { let ix = get_idx(bcx.tcx(), field_tys); @@ -723,7 +717,7 @@ fn trans_field<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, if type_is_sized(bcx.tcx(), d.ty) { DatumBlock { datum: d.to_expr_datum(), bcx: bcx } } else { - let scratch = rvalue_scratch_datum(bcx, ty::mk_open(bcx.tcx(), d.ty), ""); + let scratch = rvalue_scratch_datum(bcx, d.ty, ""); Store(bcx, d.val, get_dataptr(bcx, scratch.val)); let info = Load(bcx, get_len(bcx, base_datum.val)); Store(bcx, info, get_len(bcx, scratch.val)); @@ -809,7 +803,7 @@ fn trans_index<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if type_is_sized(bcx.tcx(), elt_ty) { Datum::new(datum.to_llscalarish(bcx), elt_ty, LvalueExpr) } else { - Datum::new(datum.val, ty::mk_open(bcx.tcx(), elt_ty), LvalueExpr) + Datum::new(datum.val, elt_ty, LvalueExpr) } } None => { @@ -1671,7 +1665,7 @@ fn trans_uniq_expr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, fn ref_fat_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, lval: Datum<'tcx, Lvalue>) -> DatumBlock<'blk, 'tcx, Expr> { - let dest_ty = ty::close_type(bcx.tcx(), lval.ty); + let dest_ty = ty::mk_imm_rptr(bcx.tcx(), bcx.tcx().mk_region(ty::ReStatic), lval.ty); let scratch = rvalue_scratch_datum(bcx, dest_ty, "__fat_ptr"); memcpy_ty(bcx, scratch.val, lval.val, scratch.ty); @@ -1685,16 +1679,13 @@ fn trans_addr_of<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let _icx = push_ctxt("trans_addr_of"); let mut bcx = bcx; let sub_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, subexpr, "addr_of")); - match sub_datum.ty.sty { - ty::ty_open(_) => { - // Opened DST value, close to a fat pointer - ref_fat_ptr(bcx, sub_datum) - } - _ => { - // Sized value, ref to a thin pointer - let ty = expr_ty(bcx, expr); - immediate_rvalue_bcx(bcx, sub_datum.val, ty).to_expr_datumblock() - } + if !type_is_sized(bcx.tcx(), sub_datum.ty) { + // DST lvalue, close to a fat pointer + ref_fat_ptr(bcx, sub_datum) + } else { + // Sized value, ref to a thin pointer + let ty = expr_ty(bcx, expr); + immediate_rvalue_bcx(bcx, sub_datum.val, ty).to_expr_datumblock() } } @@ -2234,16 +2225,15 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, if type_is_sized(bcx.tcx(), content_ty) { deref_owned_pointer(bcx, expr, datum, content_ty) } else { - // A fat pointer and an opened DST value have the same - // representation just different types. Since there is no - // temporary for `*e` here (because it is unsized), we cannot - // emulate the sized object code path for running drop glue and - // free. Instead, we schedule cleanup for `e`, turning it into - // an lvalue. + // A fat pointer and a DST lvalue have the same representation + // just different types. Since there is no temporary for `*e` + // here (because it is unsized), we cannot emulate the sized + // object code path for running drop glue and free. Instead, + // we schedule cleanup for `e`, turning it into an lvalue. let datum = unpack_datum!( bcx, datum.to_lvalue_datum(bcx, "deref", expr.id)); - let datum = Datum::new(datum.val, ty::mk_open(bcx.tcx(), content_ty), LvalueExpr); + let datum = Datum::new(datum.val, content_ty, LvalueExpr); DatumBlock::new(bcx, datum) } } @@ -2260,11 +2250,9 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // owner (or, in the case of *T, by the user). DatumBlock::new(bcx, Datum::new(ptr, content_ty, LvalueExpr)) } else { - // A fat pointer and an opened DST value have the same representation + // A fat pointer and a DST lvalue have the same representation // just different types. - DatumBlock::new(bcx, Datum::new(datum.val, - ty::mk_open(bcx.tcx(), content_ty), - LvalueExpr)) + DatumBlock::new(bcx, Datum::new(datum.val, content_ty, LvalueExpr)) } } diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs index 20956bf795b..c14683aeade 100644 --- a/src/librustc_trans/trans/glue.rs +++ b/src/librustc_trans/trans/glue.rs @@ -34,7 +34,7 @@ use trans::expr; use trans::machine::*; use trans::tvec; use trans::type_::Type; -use trans::type_of::{type_of, sizing_type_of, align_of}; +use trans::type_of::{self, type_of, sizing_type_of, align_of}; use middle::ty::{self, Ty}; use util::ppaux::{ty_to_short_str, Repr}; use util::ppaux; @@ -265,8 +265,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, assert_eq!(params.len(), 1); let self_arg = if type_is_fat_ptr(bcx.tcx(), self_ty) { // The dtor expects a fat pointer, so make one, even if we have to fake it. - let boxed_ty = ty::mk_open(bcx.tcx(), t); - let scratch = datum::rvalue_scratch_datum(bcx, boxed_ty, "__fat_ptr_drop_self"); + let scratch = datum::rvalue_scratch_datum(bcx, t, "__fat_ptr_drop_self"); Store(bcx, value, GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_ADDR])); Store(bcx, // If we just had a thin pointer, make a fat pointer by sticking @@ -284,20 +283,18 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // Add all the fields as a value which needs to be cleaned at the end of // this scope. Iterate in reverse order so a Drop impl doesn't reverse // the order in which fields get dropped. - for (i, ty) in st.fields.iter().enumerate().rev() { + for (i, &ty) in st.fields.iter().enumerate().rev() { let llfld_a = adt::struct_field_ptr(variant_cx, &*st, value, i, false); - let val = if type_is_sized(bcx.tcx(), *ty) { + let val = if type_is_sized(bcx.tcx(), ty) { llfld_a } else { - let boxed_ty = ty::mk_open(bcx.tcx(), *ty); - let scratch = datum::rvalue_scratch_datum(bcx, boxed_ty, "__fat_ptr_drop_field"); + let scratch = datum::rvalue_scratch_datum(bcx, ty, "__fat_ptr_drop_field"); Store(bcx, llfld_a, GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_ADDR])); Store(bcx, info.unwrap(), GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_EXTRA])); scratch.val }; - variant_cx.fcx.schedule_drop_mem(cleanup::CustomScope(field_scope), - val, *ty); + variant_cx.fcx.schedule_drop_mem(cleanup::CustomScope(field_scope), val, ty); } let dtor_ty = ty::mk_ctor_fn(bcx.tcx(), @@ -502,7 +499,10 @@ pub fn declare_tydesc<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) // tydescs. assert!(!ccx.finished_tydescs().get()); - let llty = type_of(ccx, t); + // This really shouldn't be like this, size/align will be wrong for + // unsized types (i.e. [T] will have the size/align of T). + // But we need it until we split this out into a "type name" intrinsic. + let llty = type_of::in_memory_type_of(ccx, t); if ccx.sess().count_type_sizes() { println!("{}\t{}", llsize_of_real(ccx, llty), diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs index 7644ecf2cfd..3411f12886d 100644 --- a/src/librustc_trans/trans/meth.rs +++ b/src/librustc_trans/trans/meth.rs @@ -818,9 +818,6 @@ fn emit_vtable_methods<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, param_substs, substs.clone()).val; - // currently, at least, by-value self is not object safe - assert!(m.explicit_self != ty::ByValueExplicitSelfCategory); - Some(fn_ref).into_iter() } } diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index 7b59e0258ee..d3acd23e641 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -372,38 +372,31 @@ pub fn get_fixed_base_and_len(bcx: Block, (base, len) } -fn get_slice_base_and_len(bcx: Block, - llval: ValueRef) - -> (ValueRef, ValueRef) { - let base = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_ADDR])); - let len = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_EXTRA])); - (base, len) -} - /// Converts a vector into the slice pair. The vector should be stored in `llval` which should be /// by-reference. If you have a datum, you would probably prefer to call /// `Datum::get_base_and_len()` which will handle any conversions for you. -pub fn get_base_and_len(bcx: Block, - llval: ValueRef, - vec_ty: Ty) - -> (ValueRef, ValueRef) { +pub fn get_base_and_len<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, + llval: ValueRef, + vec_ty: Ty<'tcx>) + -> (ValueRef, ValueRef) { let ccx = bcx.ccx(); match vec_ty.sty { ty::ty_vec(_, Some(n)) => get_fixed_base_and_len(bcx, llval, n), - ty::ty_open(ty) => match ty.sty { - ty::ty_vec(_, None) | ty::ty_str => get_slice_base_and_len(bcx, llval), - _ => ccx.sess().bug("unexpected type in get_base_and_len") - }, + ty::ty_vec(_, None) | ty::ty_str => { + let base = Load(bcx, expr::get_dataptr(bcx, llval)); + let len = Load(bcx, expr::get_len(bcx, llval)); + (base, len) + } // Only used for pattern matching. - ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty.sty { - ty::ty_vec(_, None) | ty::ty_str => get_slice_base_and_len(bcx, llval), - ty::ty_vec(_, Some(n)) => { - let base = GEPi(bcx, Load(bcx, llval), &[0, 0]); - (base, C_uint(ccx, n)) - } - _ => ccx.sess().bug("unexpected type in get_base_and_len"), + ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => { + let inner = if type_is_sized(bcx.tcx(), ty) { + Load(bcx, llval) + } else { + llval + }; + get_base_and_len(bcx, inner, ty) }, _ => ccx.sess().bug("unexpected type in get_base_and_len"), } diff --git a/src/librustc_trans/trans/type_.rs b/src/librustc_trans/trans/type_.rs index 0c69a7132a7..d5ec18e641b 100644 --- a/src/librustc_trans/trans/type_.rs +++ b/src/librustc_trans/trans/type_.rs @@ -232,14 +232,6 @@ impl Type { Type::glue_fn(ccx, Type::i8p(ccx)).ptr_to().ptr_to() } - pub fn opaque_trait(ccx: &CrateContext) -> Type { - Type::struct_(ccx, &[Type::opaque_trait_data(ccx).ptr_to(), Type::vtable_ptr(ccx)], false) - } - - pub fn opaque_trait_data(ccx: &CrateContext) -> Type { - Type::i8(ccx) - } - pub fn kind(&self) -> TypeKind { unsafe { llvm::LLVMGetTypeKind(self.to_ref()) diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs index b53ea79804c..97278eb0512 100644 --- a/src/librustc_trans/trans/type_of.rs +++ b/src/librustc_trans/trans/type_of.rs @@ -10,8 +10,6 @@ #![allow(non_camel_case_types)] -pub use self::named_ty::*; - use middle::subst; use trans::adt; use trans::common::*; @@ -183,9 +181,8 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ } let llsizingty = match t.sty { - _ if !lltype_is_sized(cx.tcx(), t) => { - cx.sess().bug(&format!("trying to take the sizing type of {}, an unsized type", - ppaux::ty_to_string(cx.tcx(), t))) + _ if !type_is_sized(cx.tcx(), t) => { + Type::struct_(cx, &[Type::i8p(cx), Type::i8p(cx)], false) } ty::ty_bool => Type::bool(cx), @@ -232,15 +229,11 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ } } - ty::ty_open(_) => { - Type::struct_(cx, &[Type::i8p(cx), Type::i8p(cx)], false) - } - ty::ty_projection(..) | ty::ty_infer(..) | ty::ty_param(..) | ty::ty_err(..) => { cx.sess().bug(&format!("fictitious type {} in sizing_type_of()", ppaux::ty_to_string(cx.tcx(), t))) } - ty::ty_vec(_, None) | ty::ty_trait(..) | ty::ty_str => panic!("unreachable") + ty::ty_vec(_, None) | ty::ty_trait(..) | ty::ty_str => unreachable!() }; cx.llsizingtypes().borrow_mut().insert(t, llsizingty); @@ -270,25 +263,37 @@ pub fn arg_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { } } -// NB: If you update this, be sure to update `sizing_type_of()` as well. -pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { - fn type_of_unsize_info<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { - // It is possible to end up here with a sized type. This happens with a - // struct which might be unsized, but is monomorphised to a sized type. - // In this case we'll fake a fat pointer with no unsize info (we use 0). - // However, its still a fat pointer, so we need some type use. - if type_is_sized(cx.tcx(), t) { - return Type::i8p(cx); - } - - match unsized_part_of_type(cx.tcx(), t).sty { - ty::ty_str | ty::ty_vec(..) => Type::uint_from_ty(cx, ast::TyUs(false)), - ty::ty_trait(_) => Type::vtable_ptr(cx), - _ => panic!("Unexpected type returned from unsized_part_of_type : {}", - t.repr(cx.tcx())) - } - } +/// Get the LLVM type corresponding to a Rust type, i.e. `middle::ty::Ty`. +/// This is the right LLVM type for an alloca containg a value of that type, +/// and the pointee of an Lvalue Datum (which is always a LLVM pointer). +/// For unsized types, the returned type is a fat pointer, thus the resulting +/// LLVM type for a `Trait` Lvalue is `{ i8*, void(i8*)** }*`, which is a double +/// indirection to the actual data, unlike a `i8` Lvalue, which is just `i8*`. +/// This is needed due to the treatment of immediate values, as a fat pointer +/// is too large for it to be placed in SSA value (by our rules). +/// For the raw type without far pointer indirection, see `in_memory_type_of`. +pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> Type { + let ty = if !type_is_sized(cx.tcx(), ty) { + ty::mk_imm_ptr(cx.tcx(), ty) + } else { + ty + }; + in_memory_type_of(cx, ty) +} +/// Get the LLVM type corresponding to a Rust type, i.e. `middle::ty::Ty`. +/// This is the right LLVM type for a field/array element of that type, +/// and is the same as `type_of` for all Sized types. +/// Unsized types, however, are represented by a "minimal unit", e.g. +/// `[T]` becomes `T`, while `str` and `Trait` turn into `i8` - this +/// is useful for indexing slices, as `&[T]`'s data pointer is `T*`. +/// If the type is an unsized struct, the regular layout is generated, +/// with the inner-most trailing unsized field using the "minimal unit" +/// of that field's type - this is useful for taking the address of +/// that field and ensuring the struct has the right alignment. +/// For the LLVM type of a value as a whole, see `type_of`. +/// NB: If you update this, be sure to update `sizing_type_of()` as well. +pub fn in_memory_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { // Check the cache. match cx.lltypes().borrow().get(&t) { Some(&llty) => return llty, @@ -307,7 +312,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { let t_norm = erase_regions(cx.tcx(), &t); if t != t_norm { - let llty = type_of(cx, t_norm); + let llty = in_memory_type_of(cx, t_norm); debug!("--> normalized {} {:?} to {} {:?} llty={}", t.repr(cx.tcx()), t, @@ -331,10 +336,10 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { // of the enum's variants refers to the enum itself. let repr = adt::represent_type(cx, t); let tps = substs.types.get_slice(subst::TypeSpace); - let name = llvm_type_name(cx, an_enum, did, tps); + let name = llvm_type_name(cx, did, tps); adt::incomplete_type_of(cx, &*repr, &name[..]) } - ty::ty_closure(did, _, ref substs) => { + ty::ty_closure(..) => { // Only create the named struct, but don't fill it in. We // fill it in *after* placing it into the type cache. let repr = adt::represent_type(cx, t); @@ -342,41 +347,47 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { // inherited from their environment, so we use entire // contents of the VecPerParamSpace to to construct the llvm // name - let name = llvm_type_name(cx, a_closure, did, substs.types.as_slice()); - adt::incomplete_type_of(cx, &*repr, &name[..]) + adt::incomplete_type_of(cx, &*repr, "closure") } ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => { - match ty.sty { - ty::ty_str => { + if !type_is_sized(cx.tcx(), ty) { + if let ty::ty_str = ty.sty { // This means we get a nicer name in the output (str is always // unsized). cx.tn().find_type("str_slice").unwrap() + } else { + let ptr_ty = in_memory_type_of(cx, ty).ptr_to(); + let unsized_part = unsized_part_of_type(cx.tcx(), ty); + let info_ty = match unsized_part.sty { + ty::ty_str | ty::ty_vec(..) => { + Type::uint_from_ty(cx, ast::TyUs(false)) + } + ty::ty_trait(_) => Type::vtable_ptr(cx), + _ => panic!("Unexpected type returned from \ + unsized_part_of_type: {} for ty={}", + unsized_part.repr(cx.tcx()), ty.repr(cx.tcx())) + }; + Type::struct_(cx, &[ptr_ty, info_ty], false) } - ty::ty_trait(..) => Type::opaque_trait(cx), - _ if !type_is_sized(cx.tcx(), ty) => { - let p_ty = type_of(cx, ty).ptr_to(); - Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, ty)], false) - } - _ => type_of(cx, ty).ptr_to(), + } else { + in_memory_type_of(cx, ty).ptr_to() } } ty::ty_vec(ty, Some(size)) => { let size = size as u64; - let llty = type_of(cx, ty); + let llty = in_memory_type_of(cx, ty); ensure_array_fits_in_address_space(cx, llty, size, t); Type::array(&llty, size) } - ty::ty_vec(ty, None) => { - type_of(cx, ty) - } - ty::ty_trait(..) => { - Type::opaque_trait_data(cx) - } - - ty::ty_str => Type::i8(cx), + // Unsized slice types (and str) have the type of their element, and + // traits have the type of u8. This is so that the data pointer inside + // fat pointers is of the right type (e.g. for array accesses), even + // when taking the address of an unsized field in a struct. + ty::ty_vec(ty, None) => in_memory_type_of(cx, ty), + ty::ty_str | ty::ty_trait(..) => Type::i8(cx), ty::ty_bare_fn(..) => { type_of_fn_from_ty(cx, t).ptr_to() @@ -388,7 +399,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { } ty::ty_struct(did, ref substs) => { if ty::type_is_simd(cx.tcx(), t) { - let llet = type_of(cx, ty::simd_type(cx.tcx(), t)); + let llet = in_memory_type_of(cx, ty::simd_type(cx.tcx(), t)); let n = ty::simd_size(cx.tcx(), t) as u64; ensure_array_fits_in_address_space(cx, llet, n, t); Type::vector(&llet, n) @@ -398,29 +409,11 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { // infinite recursion with recursive struct types. let repr = adt::represent_type(cx, t); let tps = substs.types.get_slice(subst::TypeSpace); - let name = llvm_type_name(cx, a_struct, did, tps); + let name = llvm_type_name(cx, did, tps); adt::incomplete_type_of(cx, &*repr, &name[..]) } } - ty::ty_open(t) => match t.sty { - ty::ty_struct(..) => { - let p_ty = type_of(cx, t).ptr_to(); - Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, t)], false) - } - ty::ty_vec(ty, None) => { - let p_ty = type_of(cx, ty).ptr_to(); - Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, t)], false) - } - ty::ty_str => { - let p_ty = Type::i8p(cx); - Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, t)], false) - } - ty::ty_trait(..) => Type::opaque_trait(cx), - _ => cx.sess().bug(&format!("ty_open with sized type: {}", - ppaux::ty_to_string(cx.tcx(), t))) - }, - ty::ty_infer(..) => cx.sess().bug("type_of with ty_infer"), ty::ty_projection(..) => cx.sess().bug("type_of with ty_projection"), ty::ty_param(..) => cx.sess().bug("type_of with ty_param"), @@ -444,7 +437,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type { _ => () } - return llty; + llty } pub fn align_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) @@ -453,37 +446,22 @@ pub fn align_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) machine::llalign_of_min(cx, llty) } -// Want refinements! (Or case classes, I guess -#[derive(Copy)] -pub enum named_ty { - a_struct, - an_enum, - a_closure, -} - -pub fn llvm_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, - what: named_ty, - did: ast::DefId, - tps: &[Ty<'tcx>]) - -> String { - let name = match what { - a_struct => "struct", - an_enum => "enum", - a_closure => return "closure".to_string(), - }; - +fn llvm_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, + did: ast::DefId, + tps: &[Ty<'tcx>]) + -> String { let base = ty::item_path_str(cx.tcx(), did); let strings: Vec<String> = tps.iter().map(|t| t.repr(cx.tcx())).collect(); let tstr = if strings.is_empty() { base } else { - format!("{}<{:?}>", base, strings) + format!("{}<{}>", base, strings.connect(", ")) }; if did.krate == 0 { - format!("{}.{}", name, tstr) + tstr } else { - format!("{}.{}[{}{}]", name, tstr, "#", did.krate) + format!("{}.{}", did.krate, tstr) } } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index ff397d99430..581279c2c9c 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -305,9 +305,9 @@ fn create_region_substs<'tcx>( rscope.anon_regions(span, expected_num_region_params); if supplied_num_region_params != 0 || anon_regions.is_err() { - span_err!(tcx.sess, span, E0107, - "wrong number of lifetime parameters: expected {}, found {}", - expected_num_region_params, supplied_num_region_params); + report_lifetime_number_error(tcx, span, + supplied_num_region_params, + expected_num_region_params); } match anon_regions { @@ -355,31 +355,14 @@ fn create_substs_for_ast_path<'tcx>( .count(); let mut type_substs = types_provided; + check_type_argument_count(this.tcx(), span, supplied_ty_param_count, + required_ty_param_count, formal_ty_param_count); + if supplied_ty_param_count < required_ty_param_count { - let expected = if required_ty_param_count < formal_ty_param_count { - "expected at least" - } else { - "expected" - }; - span_err!(this.tcx().sess, span, E0243, - "wrong number of type arguments: {} {}, found {}", - expected, - required_ty_param_count, - supplied_ty_param_count); while type_substs.len() < required_ty_param_count { type_substs.push(tcx.types.err); } } else if supplied_ty_param_count > formal_ty_param_count { - let expected = if required_ty_param_count < formal_ty_param_count { - "expected at most" - } else { - "expected" - }; - span_err!(this.tcx().sess, span, E0244, - "wrong number of type arguments: {} {}, found {}", - expected, - formal_ty_param_count, - supplied_ty_param_count); type_substs.truncate(formal_ty_param_count); } assert!(type_substs.len() >= required_ty_param_count && @@ -1847,7 +1830,16 @@ pub fn partition_bounds<'a>(tcx: &ty::ctxt, if ty::try_add_builtin_trait(tcx, trait_did, &mut builtin_bounds) { - // FIXME(#20302) -- we should check for things like Copy<T> + let segments = &b.trait_ref.path.segments; + let parameters = &segments[segments.len() - 1].parameters; + if parameters.types().len() > 0 { + check_type_argument_count(tcx, b.trait_ref.path.span, + parameters.types().len(), 0, 0); + } + if parameters.lifetimes().len() > 0{ + report_lifetime_number_error(tcx, b.trait_ref.path.span, + parameters.lifetimes().len(), 0); + } continue; // success } } @@ -1880,3 +1872,34 @@ fn prohibit_projections<'tcx>(tcx: &ty::ctxt<'tcx>, "associated type bindings are not allowed here"); } } + +fn check_type_argument_count(tcx: &ty::ctxt, span: Span, supplied: usize, + required: usize, accepted: usize) { + if supplied < required { + let expected = if required < accepted { + "expected at least" + } else { + "expected" + }; + span_err!(tcx.sess, span, E0243, + "wrong number of type arguments: {} {}, found {}", + expected, required, supplied); + } else if supplied > accepted { + let expected = if required < accepted { + "expected at most" + } else { + "expected" + }; + span_err!(tcx.sess, span, E0244, + "wrong number of type arguments: {} {}, found {}", + expected, + accepted, + supplied); + } +} + +fn report_lifetime_number_error(tcx: &ty::ctxt, span: Span, number: usize, expected: usize) { + span_err!(tcx.sess, span, E0107, + "wrong number of lifetime parameters: expected {}, found {}", + expected, number); +} diff --git a/src/librustc_typeck/check/implicator.rs b/src/librustc_typeck/check/implicator.rs index 998a4504088..f65e585d23e 100644 --- a/src/librustc_typeck/check/implicator.rs +++ b/src/librustc_typeck/check/implicator.rs @@ -161,12 +161,6 @@ impl<'a, 'tcx> Implicator<'a, 'tcx> { // entering the fn check. We should do this after // the fn check, then we can call this case a bug(). } - - ty::ty_open(_) => { - self.tcx().sess.bug( - &format!("Unexpected type encountered while doing wf check: {}", - ty.repr(self.tcx()))); - } } } diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 53976df75d6..d7db21f3a2f 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -404,26 +404,9 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { all_substs.repr(self.tcx())); // Instantiate the bounds on the method with the - // type/early-bound-regions substitutions performed. The only - // late-bound-regions that can appear in bounds are from the - // impl, and those were already instantiated above. - // - // FIXME(DST). Super hack. For a method on a trait object - // `Trait`, the generic signature requires that - // `Self:Trait`. Since, for an object, we bind `Self` to the - // type `Trait`, this leads to an obligation - // `Trait:Trait`. Until such time we DST is fully implemented, - // that obligation is not necessarily satisfied. (In the - // future, it would be.) But we know that the true `Self` DOES implement - // the trait. So we just delete this requirement. Hack hack hack. - let mut method_predicates = pick.method_ty.predicates.instantiate(self.tcx(), &all_substs); - match pick.kind { - probe::ObjectPick(..) => { - assert_eq!(method_predicates.predicates.get_slice(subst::SelfSpace).len(), 1); - method_predicates.predicates.pop(subst::SelfSpace); - } - _ => { } - } + // type/early-bound-regions substitutions performed. There can + // be no late-bound regions appearing here. + let method_predicates = pick.method_ty.predicates.instantiate(self.tcx(), &all_substs); let method_predicates = self.fcx.normalize_associated_types_in(self.span, &method_predicates); diff --git a/src/librustc_typeck/check/vtable.rs b/src/librustc_typeck/check/vtable.rs index 3666b69d1c6..630530cf11f 100644 --- a/src/librustc_typeck/check/vtable.rs +++ b/src/librustc_typeck/check/vtable.rs @@ -133,14 +133,6 @@ pub fn check_object_safety<'tcx>(tcx: &ty::ctxt<'tcx>, in the supertrait listing"); } - ObjectSafetyViolation::Method(method, MethodViolationCode::ByValueSelf) => { - tcx.sess.span_note( - span, - &format!("method `{}` has a receiver type of `Self`, \ - which cannot be used with a trait object", - method.name.user_string(tcx))); - } - ObjectSafetyViolation::Method(method, MethodViolationCode::StaticMethod) => { tcx.sess.span_note( span, diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 7215ab01b02..7dac1eeb6f1 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -25,7 +25,7 @@ use middle::ty::{ParameterEnvironment, TypeTraitItemId, lookup_item_type}; use middle::ty::{Ty, ty_bool, ty_char, ty_enum, ty_err}; use middle::ty::{ty_param, TypeScheme, ty_ptr}; use middle::ty::{ty_rptr, ty_struct, ty_trait, ty_tup}; -use middle::ty::{ty_str, ty_vec, ty_float, ty_infer, ty_int, ty_open}; +use middle::ty::{ty_str, ty_vec, ty_float, ty_infer, ty_int}; use middle::ty::{ty_uint, ty_closure, ty_uniq, ty_bare_fn}; use middle::ty::{ty_projection}; use middle::ty; @@ -75,7 +75,7 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>, ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) | ty_str(..) | ty_vec(..) | ty_bare_fn(..) | ty_tup(..) | - ty_param(..) | ty_err | ty_open(..) | + ty_param(..) | ty_err | ty_ptr(_) | ty_rptr(_, _) | ty_projection(..) => { None } diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs index 93d9ce3df84..90ca6a79805 100644 --- a/src/librustc_typeck/variance.rs +++ b/src/librustc_typeck/variance.rs @@ -849,7 +849,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { self.add_constraints_from_mt(generics, mt, variance); } - ty::ty_uniq(typ) | ty::ty_vec(typ, _) | ty::ty_open(typ) => { + ty::ty_uniq(typ) | ty::ty_vec(typ, _) => { self.add_constraints_from_ty(generics, typ, variance); } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index d8ef3194e83..a3e0cecdd48 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1619,7 +1619,6 @@ impl<'tcx> Clean<Type> for ty::Ty<'tcx> { ty::ty_closure(..) => Tuple(vec![]), // FIXME(pcwalton) ty::ty_infer(..) => panic!("ty_infer"), - ty::ty_open(..) => panic!("ty_open"), ty::ty_err => panic!("ty_err"), } } diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index a0f42815b43..05d4e0f59fe 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -3074,19 +3074,19 @@ mod tests { #[test] fn test_decode_array() { let v: Vec<()> = super::decode("[]").unwrap(); - assert_eq!(v, vec![]); + assert_eq!(v, []); let v: Vec<()> = super::decode("[null]").unwrap(); - assert_eq!(v, vec![()]); + assert_eq!(v, [()]); let v: Vec<bool> = super::decode("[true]").unwrap(); - assert_eq!(v, vec![true]); + assert_eq!(v, [true]); let v: Vec<int> = super::decode("[3, 1]").unwrap(); - assert_eq!(v, vec![3, 1]); + assert_eq!(v, [3, 1]); let v: Vec<Vec<uint>> = super::decode("[[3], [1, 2]]").unwrap(); - assert_eq!(v, vec![vec![3], vec![1, 2]]); + assert_eq!(v, [vec![3], vec![1, 2]]); } #[test] diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 4d38d17576d..94457a5d714 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -37,6 +37,7 @@ pub trait OwnedAsciiExt { /// Extension methods for ASCII-subset only operations on string slices #[stable(feature = "rust1", since = "1.0.0")] pub trait AsciiExt { + /// Container type for copied ASCII characters. #[stable(feature = "rust1", since = "1.0.0")] type Owned; diff --git a/src/libstd/collections/hash/state.rs b/src/libstd/collections/hash/state.rs index 7e6dd45b51e..3a06d2d03bf 100644 --- a/src/libstd/collections/hash/state.rs +++ b/src/libstd/collections/hash/state.rs @@ -27,6 +27,7 @@ use marker; /// to `Default` when asked to create a hasher. #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] pub trait HashState { + /// Type of the hasher that will be created. type Hasher: hash::Hasher; /// Creates a new hasher based on the given state of this object. diff --git a/src/libstd/io/impls.rs b/src/libstd/io/impls.rs index 7f3ce7924c1..82b69ddebff 100644 --- a/src/libstd/io/impls.rs +++ b/src/libstd/io/impls.rs @@ -12,9 +12,11 @@ use core::prelude::*; use boxed::Box; use cmp; -use io::{self, SeekFrom, Read, Write, Seek, BufRead}; +use io::{self, SeekFrom, Read, Write, Seek, BufRead, Error, ErrorKind}; +use fmt; use mem; use slice; +use string::String; use vec::Vec; // ============================================================================= @@ -22,9 +24,20 @@ use vec::Vec; impl<'a, R: Read + ?Sized> Read for &'a mut R { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { (**self).read(buf) } + + fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<()> { (**self).read_to_end(buf) } + + fn read_to_string(&mut self, buf: &mut String) -> io::Result<()> { + (**self).read_to_string(buf) + } } impl<'a, W: Write + ?Sized> Write for &'a mut W { fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) } + + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { (**self).write_all(buf) } + + fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> { (**self).write_fmt(fmt) } + fn flush(&mut self) -> io::Result<()> { (**self).flush() } } impl<'a, S: Seek + ?Sized> Seek for &'a mut S { @@ -32,7 +45,14 @@ impl<'a, S: Seek + ?Sized> Seek for &'a mut S { } impl<'a, B: BufRead + ?Sized> BufRead for &'a mut B { fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() } + fn consume(&mut self, amt: usize) { (**self).consume(amt) } + + fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<()> { + (**self).read_until(byte, buf) + } + + fn read_line(&mut self, buf: &mut String) -> io::Result<()> { (**self).read_line(buf) } } impl<R: Read + ?Sized> Read for Box<R> { @@ -76,6 +96,15 @@ impl<'a> Write for &'a mut [u8] { *self = b; Ok(amt) } + + fn write_all(&mut self, data: &[u8]) -> io::Result<()> { + if try!(self.write(data)) == data.len() { + Ok(()) + } else { + Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer", None)) + } + } + fn flush(&mut self) -> io::Result<()> { Ok(()) } } @@ -84,5 +113,11 @@ impl Write for Vec<u8> { self.push_all(buf); Ok(buf.len()) } + + fn write_all(&mut self, buf: &[u8]) -> io::Result<()> { + try!(self.write(buf)); + Ok(()) + } + fn flush(&mut self) -> io::Result<()> { Ok(()) } } diff --git a/src/libstd/old_io/extensions.rs b/src/libstd/old_io/extensions.rs index c2a6c515acc..8bd19f063f0 100644 --- a/src/libstd/old_io/extensions.rs +++ b/src/libstd/old_io/extensions.rs @@ -328,7 +328,7 @@ mod test { fn read_bytes() { let mut reader = MemReader::new(vec!(10, 11, 12, 13)); let bytes = reader.read_exact(4).unwrap(); - assert!(bytes == vec!(10, 11, 12, 13)); + assert_eq!(bytes, [10, 11, 12, 13]); } #[test] @@ -337,7 +337,7 @@ mod test { count: 0, }; let bytes = reader.read_exact(4).unwrap(); - assert!(bytes == vec!(10, 11, 12, 13)); + assert_eq!(bytes, [10, 11, 12, 13]); } #[test] @@ -351,7 +351,7 @@ mod test { let mut reader = MemReader::new(vec![10, 11, 12, 13]); let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_ok()); - assert!(buf == vec![8, 9, 10, 11, 12, 13]); + assert_eq!(buf, [8, 9, 10, 11, 12, 13]); } #[test] @@ -361,7 +361,7 @@ mod test { }; let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_ok()); - assert!(buf == vec![8, 9, 10, 11, 12, 13]); + assert_eq!(buf, [8, 9, 10, 11, 12, 13]); } #[test] @@ -369,7 +369,7 @@ mod test { let mut reader = MemReader::new(vec![10, 11]); let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_err()); - assert!(buf == vec![8, 9, 10, 11]); + assert_eq!(buf, [8, 9, 10, 11]); } #[test] @@ -379,7 +379,7 @@ mod test { }; let mut buf = vec![8, 9]; assert!(reader.push_at_least(4, 4, &mut buf).is_err()); - assert!(buf == vec![8, 9, 10]); + assert_eq!(buf, [8, 9, 10]); } #[test] @@ -388,7 +388,7 @@ mod test { count: 0, }; let buf = reader.read_to_end().unwrap(); - assert!(buf == vec!(10, 11, 12, 13)); + assert_eq!(buf, [10, 11, 12, 13]); } #[test] @@ -398,7 +398,7 @@ mod test { count: 0, }; let buf = reader.read_to_end().unwrap(); - assert!(buf == vec!(10, 11)); + assert_eq!(buf, [10, 11]); } #[test] diff --git a/src/libstd/old_io/mem.rs b/src/libstd/old_io/mem.rs index 1fd527014a3..c08a2c1f477 100644 --- a/src/libstd/old_io/mem.rs +++ b/src/libstd/old_io/mem.rs @@ -60,7 +60,7 @@ impl Writer for Vec<u8> { /// let mut w = MemWriter::new(); /// w.write(&[0, 1, 2]); /// -/// assert_eq!(w.into_inner(), vec!(0, 1, 2)); +/// assert_eq!(w.into_inner(), [0, 1, 2]); /// ``` #[unstable(feature = "io")] #[deprecated(since = "1.0.0", @@ -118,7 +118,7 @@ impl Writer for MemWriter { /// /// let mut r = MemReader::new(vec!(0, 1, 2)); /// -/// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2)); +/// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2]); /// ``` pub struct MemReader { buf: Vec<u8>, @@ -321,7 +321,7 @@ impl<'a> Seek for BufWriter<'a> { /// let buf = [0, 1, 2, 3]; /// let mut r = BufReader::new(&buf); /// -/// assert_eq!(r.read_to_end().unwrap(), vec![0, 1, 2, 3]); +/// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2, 3]); /// ``` pub struct BufReader<'a> { buf: &'a [u8], @@ -504,8 +504,8 @@ mod test { assert_eq!(&buf[..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7)); - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]); + assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]); assert!(reader.read(&mut buf).is_err()); } @@ -530,8 +530,8 @@ mod test { assert_eq!(&buf[..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = &mut &*in_buf; - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]); + assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]); assert!(reader.read(&mut buf).is_err()); } @@ -557,8 +557,8 @@ mod test { assert_eq!(&buf[..3], b); assert!(reader.read(&mut buf).is_err()); let mut reader = BufReader::new(&in_buf); - assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3)); - assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7)); + assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]); + assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]); assert!(reader.read(&mut buf).is_err()); } diff --git a/src/libstd/old_io/result.rs b/src/libstd/old_io/result.rs index f42cb6ce8c9..cdf2bae1cba 100644 --- a/src/libstd/old_io/result.rs +++ b/src/libstd/old_io/result.rs @@ -87,7 +87,7 @@ mod test { let mut writer: old_io::IoResult<Vec<u8>> = Ok(Vec::new()); writer.write_all(&[0, 1, 2]).unwrap(); writer.flush().unwrap(); - assert_eq!(writer.unwrap(), vec!(0, 1, 2)); + assert_eq!(writer.unwrap(), [0, 1, 2]); } #[test] diff --git a/src/libstd/old_io/util.rs b/src/libstd/old_io/util.rs index 5ae239014d1..8e49335ed54 100644 --- a/src/libstd/old_io/util.rs +++ b/src/libstd/old_io/util.rs @@ -284,7 +284,7 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2)); { let mut r = LimitReader::new(r.by_ref(), 4); - assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap()); + assert_eq!([0, 1, 2], r.read_to_end().unwrap()); } } @@ -293,9 +293,9 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2)); { let mut r = LimitReader::new(r.by_ref(), 2); - assert_eq!(vec!(0, 1), r.read_to_end().unwrap()); + assert_eq!([0, 1], r.read_to_end().unwrap()); } - assert_eq!(vec!(2), r.read_to_end().unwrap()); + assert_eq!([2], r.read_to_end().unwrap()); } #[test] @@ -305,7 +305,7 @@ mod test { assert_eq!(3, r.limit()); assert_eq!(0, r.read_byte().unwrap()); assert_eq!(2, r.limit()); - assert_eq!(vec!(1, 2), r.read_to_end().unwrap()); + assert_eq!([1, 2], r.read_to_end().unwrap()); assert_eq!(0, r.limit()); } @@ -314,7 +314,7 @@ mod test { let mut r = MemReader::new(vec![0, 1, 2, 3, 4, 5]); let mut r = LimitReader::new(r.by_ref(), 1); r.consume(2); - assert_eq!(vec![], r.read_to_end().unwrap()); + assert_eq!([], r.read_to_end().unwrap()); } #[test] @@ -330,7 +330,7 @@ mod test { let mut s = ZeroReader; let mut buf = vec![1, 2, 3]; assert_eq!(s.read(&mut buf), Ok(3)); - assert_eq!(vec![0, 0, 0], buf); + assert_eq!([0, 0, 0], buf); } #[test] @@ -373,16 +373,16 @@ mod test { let rs = vec!(MemReader::new(vec!(0, 1)), MemReader::new(vec!()), MemReader::new(vec!(2, 3))); let mut r = ChainedReader::new(rs.into_iter()); - assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap()); + assert_eq!([0, 1, 2, 3], r.read_to_end().unwrap()); } #[test] fn test_tee_reader() { let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)), Vec::new()); - assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap()); + assert_eq!([0, 1, 2], r.read_to_end().unwrap()); let (_, w) = r.into_inner(); - assert_eq!(vec!(0, 1, 2), w); + assert_eq!([0, 1, 2], w); } #[test] @@ -390,7 +390,7 @@ mod test { let mut r = MemReader::new(vec!(0, 1, 2, 3, 4)); let mut w = Vec::new(); copy(&mut r, &mut w).unwrap(); - assert_eq!(vec!(0, 1, 2, 3, 4), w); + assert_eq!([0, 1, 2, 3, 4], w); } #[test] diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index d2dc3345120..dad0ff0a15e 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -23,7 +23,6 @@ #[doc(no_inline)] pub use mem::drop; // Reexported types and traits - #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use boxed::Box; #[stable(feature = "rust1", since = "1.0.0")] @@ -45,9 +44,7 @@ #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use result::Result::{self, Ok, Err}; #[stable(feature = "rust1", since = "1.0.0")] -#[doc(no_inline)] pub use slice::AsSlice; -#[stable(feature = "rust1", since = "1.0.0")] -#[doc(no_inline)] pub use slice::{SliceExt, SliceConcatExt}; +#[doc(no_inline)] pub use slice::{SliceExt, SliceConcatExt, AsSlice}; #[stable(feature = "rust1", since = "1.0.0")] #[doc(no_inline)] pub use str::{Str, StrExt}; #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/process.rs b/src/libstd/process.rs index 86604f62171..c24b08deec2 100644 --- a/src/libstd/process.rs +++ b/src/libstd/process.rs @@ -355,11 +355,11 @@ impl Stdio { pub fn capture() -> Stdio { Stdio(StdioImp::Capture) } /// The child inherits from the corresponding parent descriptor. - pub fn inherit() -> Stdio { Stdio(StdioImp::Capture) } + pub fn inherit() -> Stdio { Stdio(StdioImp::Inherit) } /// This stream will be ignored. This is the equivalent of attaching the /// stream to `/dev/null` - pub fn null() -> Stdio { Stdio(StdioImp::Capture) } + pub fn null() -> Stdio { Stdio(StdioImp::Null) } } /// Describes the result of a process after it has terminated. diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs index 0e2766f3889..1a13405633d 100644 --- a/src/libstd/rand/os.rs +++ b/src/libstd/rand/os.rs @@ -188,7 +188,6 @@ mod imp { extern crate libc; use old_io::{IoResult}; - use marker::Sync; use mem; use os; use rand::Rng; @@ -214,10 +213,8 @@ mod imp { #[repr(C)] struct SecRandom; - unsafe impl Sync for *const SecRandom {} - #[allow(non_upper_case_globals)] - static kSecRandomDefault: *const SecRandom = 0 as *const SecRandom; + const kSecRandomDefault: *const SecRandom = 0 as *const SecRandom; #[link(name = "Security", kind = "framework")] extern "C" { diff --git a/src/libstd/sync/barrier.rs b/src/libstd/sync/barrier.rs index b036177af15..f697d10d5df 100644 --- a/src/libstd/sync/barrier.rs +++ b/src/libstd/sync/barrier.rs @@ -33,13 +33,13 @@ use sync::{Mutex, Condvar}; pub struct Barrier { lock: Mutex<BarrierState>, cvar: Condvar, - num_threads: uint, + num_threads: usize, } // The inner state of a double barrier struct BarrierState { - count: uint, - generation_id: uint, + count: usize, + generation_id: usize, } /// A result returned from wait. @@ -54,7 +54,7 @@ impl Barrier { /// A barrier will block `n`-1 threads which call `wait` and then wake up /// all threads at once when the `n`th thread calls `wait`. #[stable(feature = "rust1", since = "1.0.0")] - pub fn new(n: uint) -> Barrier { + pub fn new(n: usize) -> Barrier { Barrier { lock: Mutex::new(BarrierState { count: 0, @@ -115,7 +115,7 @@ mod tests { #[test] fn test_barrier() { - const N: uint = 10; + const N: usize = 10; let barrier = Arc::new(Barrier::new(N)); let (tx, rx) = channel(); diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs index 52561d482c3..aa87abc6e9a 100644 --- a/src/libstd/sync/condvar.rs +++ b/src/libstd/sync/condvar.rs @@ -327,7 +327,7 @@ impl StaticCondvar { } fn verify(&self, mutex: &sys_mutex::Mutex) { - let addr = mutex as *const _ as uint; + let addr = mutex as *const _ as usize; match self.mutex.compare_and_swap(0, addr, Ordering::SeqCst) { // If we got out 0, then we have successfully bound the mutex to // this cvar. @@ -388,7 +388,7 @@ mod tests { #[test] fn notify_all() { - const N: uint = 10; + const N: usize = 10; let data = Arc::new((Mutex::new(0), Condvar::new())); let (tx, rx) = channel(); diff --git a/src/libstd/sync/mpsc/blocking.rs b/src/libstd/sync/mpsc/blocking.rs index 69b1e242b15..2e4155ea351 100644 --- a/src/libstd/sync/mpsc/blocking.rs +++ b/src/libstd/sync/mpsc/blocking.rs @@ -61,17 +61,17 @@ impl SignalToken { wake } - /// Convert to an unsafe uint value. Useful for storing in a pipe's state + /// Convert to an unsafe usize value. Useful for storing in a pipe's state /// flag. #[inline] - pub unsafe fn cast_to_uint(self) -> uint { + pub unsafe fn cast_to_usize(self) -> usize { mem::transmute(self.inner) } - /// Convert from an unsafe uint value. Useful for retrieving a pipe's state + /// Convert from an unsafe usize value. Useful for retrieving a pipe's state /// flag. #[inline] - pub unsafe fn cast_from_uint(signal_ptr: uint) -> SignalToken { + pub unsafe fn cast_from_usize(signal_ptr: usize) -> SignalToken { SignalToken { inner: mem::transmute(signal_ptr) } } diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index b437549a044..7bd1f3542eb 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -94,7 +94,7 @@ //! //! // The call to recv() will return an error because the channel has already //! // hung up (or been deallocated) -//! let (tx, rx) = channel::<int>(); +//! let (tx, rx) = channel::<i32>(); //! drop(tx); //! assert!(rx.recv().is_err()); //! ``` @@ -105,7 +105,7 @@ //! use std::thread; //! use std::sync::mpsc::sync_channel; //! -//! let (tx, rx) = sync_channel::<int>(0); +//! let (tx, rx) = sync_channel::<i32>(0); //! thread::spawn(move|| { //! // This will wait for the parent task to start receiving //! tx.send(53).unwrap(); @@ -123,7 +123,7 @@ //! use std::old_io::timer::Timer; //! use std::time::Duration; //! -//! let (tx, rx) = channel::<int>(); +//! let (tx, rx) = channel::<i32>(); //! let mut timer = Timer::new().unwrap(); //! let timeout = timer.oneshot(Duration::seconds(10)); //! @@ -147,7 +147,7 @@ //! use std::old_io::timer::Timer; //! use std::time::Duration; //! -//! let (tx, rx) = channel::<int>(); +//! let (tx, rx) = channel::<i32>(); //! let mut timer = Timer::new().unwrap(); //! //! loop { @@ -525,7 +525,7 @@ pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) { /// assert_eq!(rx.recv().unwrap(), 2); /// ``` #[stable(feature = "rust1", since = "1.0.0")] -pub fn sync_channel<T: Send>(bound: uint) -> (SyncSender<T>, Receiver<T>) { +pub fn sync_channel<T: Send>(bound: usize) -> (SyncSender<T>, Receiver<T>) { let a = Arc::new(UnsafeCell::new(sync::Packet::new(bound))); (SyncSender::new(a.clone()), Receiver::new(Flavor::Sync(a))) } @@ -1028,7 +1028,7 @@ mod test { use super::*; use thread; - pub fn stress_factor() -> uint { + pub fn stress_factor() -> usize { match env::var("RUST_TEST_STRESS") { Ok(val) => val.parse().unwrap(), Err(..) => 1, @@ -1037,7 +1037,7 @@ mod test { #[test] fn smoke() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); tx.send(1).unwrap(); assert_eq!(rx.recv().unwrap(), 1); } @@ -1058,7 +1058,7 @@ mod test { #[test] fn smoke_shared() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); tx.send(1).unwrap(); assert_eq!(rx.recv().unwrap(), 1); let tx = tx.clone(); @@ -1068,7 +1068,7 @@ mod test { #[test] fn smoke_threads() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let _t = thread::spawn(move|| { tx.send(1).unwrap(); }); @@ -1077,21 +1077,21 @@ mod test { #[test] fn smoke_port_gone() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(rx); assert!(tx.send(1).is_err()); } #[test] fn smoke_shared_port_gone() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(rx); assert!(tx.send(1).is_err()) } #[test] fn smoke_shared_port_gone2() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(rx); let tx2 = tx.clone(); drop(tx); @@ -1100,7 +1100,7 @@ mod test { #[test] fn port_gone_concurrent() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let _t = thread::spawn(move|| { rx.recv().unwrap(); }); @@ -1109,7 +1109,7 @@ mod test { #[test] fn port_gone_concurrent_shared() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let tx2 = tx.clone(); let _t = thread::spawn(move|| { rx.recv().unwrap(); @@ -1119,7 +1119,7 @@ mod test { #[test] fn smoke_chan_gone() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(tx); assert!(rx.recv().is_err()); } @@ -1135,7 +1135,7 @@ mod test { #[test] fn chan_gone_concurrent() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let _t = thread::spawn(move|| { tx.send(1).unwrap(); tx.send(1).unwrap(); @@ -1145,7 +1145,7 @@ mod test { #[test] fn stress() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let t = thread::spawn(move|| { for _ in 0..10000 { tx.send(1).unwrap(); } }); @@ -1157,9 +1157,9 @@ mod test { #[test] fn stress_shared() { - static AMT: uint = 10000; - static NTHREADS: uint = 8; - let (tx, rx) = channel::<int>(); + static AMT: u32 = 10000; + static NTHREADS: u32 = 8; + let (tx, rx) = channel::<i32>(); let t = thread::spawn(move|| { for _ in 0..AMT * NTHREADS { @@ -1184,7 +1184,7 @@ mod test { #[test] fn send_from_outside_runtime() { let (tx1, rx1) = channel::<()>(); - let (tx2, rx2) = channel::<int>(); + let (tx2, rx2) = channel::<i32>(); let t1 = thread::spawn(move|| { tx1.send(()).unwrap(); for _ in 0..40 { @@ -1203,7 +1203,7 @@ mod test { #[test] fn recv_from_outside_runtime() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let t = thread::spawn(move|| { for _ in 0..40 { assert_eq!(rx.recv().unwrap(), 1); @@ -1217,8 +1217,8 @@ mod test { #[test] fn no_runtime() { - let (tx1, rx1) = channel::<int>(); - let (tx2, rx2) = channel::<int>(); + let (tx1, rx1) = channel::<i32>(); + let (tx2, rx2) = channel::<i32>(); let t1 = thread::spawn(move|| { assert_eq!(rx1.recv().unwrap(), 1); tx2.send(2).unwrap(); @@ -1234,21 +1234,21 @@ mod test { #[test] fn oneshot_single_thread_close_port_first() { // Simple test of closing without sending - let (_tx, rx) = channel::<int>(); + let (_tx, rx) = channel::<i32>(); drop(rx); } #[test] fn oneshot_single_thread_close_chan_first() { // Simple test of closing without sending - let (tx, _rx) = channel::<int>(); + let (tx, _rx) = channel::<i32>(); drop(tx); } #[test] fn oneshot_single_thread_send_port_close() { // Testing that the sender cleans up the payload if receiver is closed - let (tx, rx) = channel::<Box<int>>(); + let (tx, rx) = channel::<Box<i32>>(); drop(rx); assert!(tx.send(box 0).is_err()); } @@ -1257,7 +1257,7 @@ mod test { fn oneshot_single_thread_recv_chan_close() { // Receiving on a closed chan will panic let res = thread::spawn(move|| { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(tx); rx.recv().unwrap(); }).join(); @@ -1267,42 +1267,42 @@ mod test { #[test] fn oneshot_single_thread_send_then_recv() { - let (tx, rx) = channel::<Box<int>>(); + let (tx, rx) = channel::<Box<i32>>(); tx.send(box 10).unwrap(); assert!(rx.recv().unwrap() == box 10); } #[test] fn oneshot_single_thread_try_send_open() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); assert!(tx.send(10).is_ok()); assert!(rx.recv().unwrap() == 10); } #[test] fn oneshot_single_thread_try_send_closed() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(rx); assert!(tx.send(10).is_err()); } #[test] fn oneshot_single_thread_try_recv_open() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); tx.send(10).unwrap(); assert!(rx.recv() == Ok(10)); } #[test] fn oneshot_single_thread_try_recv_closed() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(tx); assert!(rx.recv().is_err()); } #[test] fn oneshot_single_thread_peek_data() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); assert_eq!(rx.try_recv(), Err(TryRecvError::Empty)); tx.send(10).unwrap(); assert_eq!(rx.try_recv(), Ok(10)); @@ -1310,7 +1310,7 @@ mod test { #[test] fn oneshot_single_thread_peek_close() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); drop(tx); assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected)); assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected)); @@ -1318,13 +1318,13 @@ mod test { #[test] fn oneshot_single_thread_peek_open() { - let (_tx, rx) = channel::<int>(); + let (_tx, rx) = channel::<i32>(); assert_eq!(rx.try_recv(), Err(TryRecvError::Empty)); } #[test] fn oneshot_multi_task_recv_then_send() { - let (tx, rx) = channel::<Box<int>>(); + let (tx, rx) = channel::<Box<i32>>(); let _t = thread::spawn(move|| { assert!(rx.recv().unwrap() == box 10); }); @@ -1334,7 +1334,7 @@ mod test { #[test] fn oneshot_multi_task_recv_then_close() { - let (tx, rx) = channel::<Box<int>>(); + let (tx, rx) = channel::<Box<i32>>(); let _t = thread::spawn(move|| { drop(tx); }); @@ -1347,7 +1347,7 @@ mod test { #[test] fn oneshot_multi_thread_close_stress() { for _ in 0..stress_factor() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let _t = thread::spawn(move|| { drop(rx); }); @@ -1358,7 +1358,7 @@ mod test { #[test] fn oneshot_multi_thread_send_close_stress() { for _ in 0..stress_factor() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let _t = thread::spawn(move|| { drop(rx); }); @@ -1371,7 +1371,7 @@ mod test { #[test] fn oneshot_multi_thread_recv_close_stress() { for _ in 0..stress_factor() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); thread::spawn(move|| { let res = thread::spawn(move|| { rx.recv().unwrap(); @@ -1405,7 +1405,7 @@ mod test { send(tx, 0); recv(rx, 0); - fn send(tx: Sender<Box<int>>, i: int) { + fn send(tx: Sender<Box<i32>>, i: i32) { if i == 10 { return } thread::spawn(move|| { @@ -1414,7 +1414,7 @@ mod test { }); } - fn recv(rx: Receiver<Box<int>>, i: int) { + fn recv(rx: Receiver<Box<i32>>, i: i32) { if i == 10 { return } thread::spawn(move|| { @@ -1451,8 +1451,8 @@ mod test { #[test] fn test_nested_recv_iter() { - let (tx, rx) = channel::<int>(); - let (total_tx, total_rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); + let (total_tx, total_rx) = channel::<i32>(); let _t = thread::spawn(move|| { let mut acc = 0; @@ -1471,7 +1471,7 @@ mod test { #[test] fn test_recv_iter_break() { - let (tx, rx) = channel::<int>(); + let (tx, rx) = channel::<i32>(); let (count_tx, count_rx) = channel(); let _t = thread::spawn(move|| { @@ -1496,7 +1496,7 @@ mod test { #[test] fn try_recv_states() { - let (tx1, rx1) = channel::<int>(); + let (tx1, rx1) = channel::<i32>(); let (tx2, rx2) = channel::<()>(); let (tx3, rx3) = channel::<()>(); let _t = thread::spawn(move|| { @@ -1550,7 +1550,7 @@ mod sync_tests { use thread; use super::*; - pub fn stress_factor() -> uint { + pub fn stress_factor() -> usize { match env::var("RUST_TEST_STRESS") { Ok(val) => val.parse().unwrap(), Err(..) => 1, @@ -1559,7 +1559,7 @@ mod sync_tests { #[test] fn smoke() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); tx.send(1).unwrap(); assert_eq!(rx.recv().unwrap(), 1); } @@ -1572,7 +1572,7 @@ mod sync_tests { #[test] fn smoke_shared() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); tx.send(1).unwrap(); assert_eq!(rx.recv().unwrap(), 1); let tx = tx.clone(); @@ -1582,7 +1582,7 @@ mod sync_tests { #[test] fn smoke_threads() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { tx.send(1).unwrap(); }); @@ -1591,14 +1591,14 @@ mod sync_tests { #[test] fn smoke_port_gone() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); drop(rx); assert!(tx.send(1).is_err()); } #[test] fn smoke_shared_port_gone2() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); drop(rx); let tx2 = tx.clone(); drop(tx); @@ -1607,7 +1607,7 @@ mod sync_tests { #[test] fn port_gone_concurrent() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { rx.recv().unwrap(); }); @@ -1616,7 +1616,7 @@ mod sync_tests { #[test] fn port_gone_concurrent_shared() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let tx2 = tx.clone(); let _t = thread::spawn(move|| { rx.recv().unwrap(); @@ -1626,7 +1626,7 @@ mod sync_tests { #[test] fn smoke_chan_gone() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); drop(tx); assert!(rx.recv().is_err()); } @@ -1642,7 +1642,7 @@ mod sync_tests { #[test] fn chan_gone_concurrent() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); thread::spawn(move|| { tx.send(1).unwrap(); tx.send(1).unwrap(); @@ -1652,7 +1652,7 @@ mod sync_tests { #[test] fn stress() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); thread::spawn(move|| { for _ in 0..10000 { tx.send(1).unwrap(); } }); @@ -1663,9 +1663,9 @@ mod sync_tests { #[test] fn stress_shared() { - static AMT: uint = 1000; - static NTHREADS: uint = 8; - let (tx, rx) = sync_channel::<int>(0); + static AMT: u32 = 1000; + static NTHREADS: u32 = 8; + let (tx, rx) = sync_channel::<i32>(0); let (dtx, drx) = sync_channel::<()>(0); thread::spawn(move|| { @@ -1692,21 +1692,21 @@ mod sync_tests { #[test] fn oneshot_single_thread_close_port_first() { // Simple test of closing without sending - let (_tx, rx) = sync_channel::<int>(0); + let (_tx, rx) = sync_channel::<i32>(0); drop(rx); } #[test] fn oneshot_single_thread_close_chan_first() { // Simple test of closing without sending - let (tx, _rx) = sync_channel::<int>(0); + let (tx, _rx) = sync_channel::<i32>(0); drop(tx); } #[test] fn oneshot_single_thread_send_port_close() { // Testing that the sender cleans up the payload if receiver is closed - let (tx, rx) = sync_channel::<Box<int>>(0); + let (tx, rx) = sync_channel::<Box<i32>>(0); drop(rx); assert!(tx.send(box 0).is_err()); } @@ -1715,7 +1715,7 @@ mod sync_tests { fn oneshot_single_thread_recv_chan_close() { // Receiving on a closed chan will panic let res = thread::spawn(move|| { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); drop(tx); rx.recv().unwrap(); }).join(); @@ -1725,48 +1725,48 @@ mod sync_tests { #[test] fn oneshot_single_thread_send_then_recv() { - let (tx, rx) = sync_channel::<Box<int>>(1); + let (tx, rx) = sync_channel::<Box<i32>>(1); tx.send(box 10).unwrap(); assert!(rx.recv().unwrap() == box 10); } #[test] fn oneshot_single_thread_try_send_open() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); assert_eq!(tx.try_send(10), Ok(())); assert!(rx.recv().unwrap() == 10); } #[test] fn oneshot_single_thread_try_send_closed() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); drop(rx); assert_eq!(tx.try_send(10), Err(TrySendError::Disconnected(10))); } #[test] fn oneshot_single_thread_try_send_closed2() { - let (tx, _rx) = sync_channel::<int>(0); + let (tx, _rx) = sync_channel::<i32>(0); assert_eq!(tx.try_send(10), Err(TrySendError::Full(10))); } #[test] fn oneshot_single_thread_try_recv_open() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); tx.send(10).unwrap(); assert!(rx.recv() == Ok(10)); } #[test] fn oneshot_single_thread_try_recv_closed() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); drop(tx); assert!(rx.recv().is_err()); } #[test] fn oneshot_single_thread_peek_data() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); assert_eq!(rx.try_recv(), Err(TryRecvError::Empty)); tx.send(10).unwrap(); assert_eq!(rx.try_recv(), Ok(10)); @@ -1774,7 +1774,7 @@ mod sync_tests { #[test] fn oneshot_single_thread_peek_close() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); drop(tx); assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected)); assert_eq!(rx.try_recv(), Err(TryRecvError::Disconnected)); @@ -1782,13 +1782,13 @@ mod sync_tests { #[test] fn oneshot_single_thread_peek_open() { - let (_tx, rx) = sync_channel::<int>(0); + let (_tx, rx) = sync_channel::<i32>(0); assert_eq!(rx.try_recv(), Err(TryRecvError::Empty)); } #[test] fn oneshot_multi_task_recv_then_send() { - let (tx, rx) = sync_channel::<Box<int>>(0); + let (tx, rx) = sync_channel::<Box<i32>>(0); let _t = thread::spawn(move|| { assert!(rx.recv().unwrap() == box 10); }); @@ -1798,7 +1798,7 @@ mod sync_tests { #[test] fn oneshot_multi_task_recv_then_close() { - let (tx, rx) = sync_channel::<Box<int>>(0); + let (tx, rx) = sync_channel::<Box<i32>>(0); let _t = thread::spawn(move|| { drop(tx); }); @@ -1811,7 +1811,7 @@ mod sync_tests { #[test] fn oneshot_multi_thread_close_stress() { for _ in 0..stress_factor() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { drop(rx); }); @@ -1822,7 +1822,7 @@ mod sync_tests { #[test] fn oneshot_multi_thread_send_close_stress() { for _ in 0..stress_factor() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { drop(rx); }); @@ -1835,7 +1835,7 @@ mod sync_tests { #[test] fn oneshot_multi_thread_recv_close_stress() { for _ in 0..stress_factor() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { let res = thread::spawn(move|| { rx.recv().unwrap(); @@ -1853,7 +1853,7 @@ mod sync_tests { #[test] fn oneshot_multi_thread_send_recv_stress() { for _ in 0..stress_factor() { - let (tx, rx) = sync_channel::<Box<int>>(0); + let (tx, rx) = sync_channel::<Box<i32>>(0); let _t = thread::spawn(move|| { tx.send(box 10).unwrap(); }); @@ -1864,12 +1864,12 @@ mod sync_tests { #[test] fn stream_send_recv_stress() { for _ in 0..stress_factor() { - let (tx, rx) = sync_channel::<Box<int>>(0); + let (tx, rx) = sync_channel::<Box<i32>>(0); send(tx, 0); recv(rx, 0); - fn send(tx: SyncSender<Box<int>>, i: int) { + fn send(tx: SyncSender<Box<i32>>, i: i32) { if i == 10 { return } thread::spawn(move|| { @@ -1878,7 +1878,7 @@ mod sync_tests { }); } - fn recv(rx: Receiver<Box<int>>, i: int) { + fn recv(rx: Receiver<Box<i32>>, i: i32) { if i == 10 { return } thread::spawn(move|| { @@ -1915,8 +1915,8 @@ mod sync_tests { #[test] fn test_nested_recv_iter() { - let (tx, rx) = sync_channel::<int>(0); - let (total_tx, total_rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); + let (total_tx, total_rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { let mut acc = 0; @@ -1935,7 +1935,7 @@ mod sync_tests { #[test] fn test_recv_iter_break() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let (count_tx, count_rx) = sync_channel(0); let _t = thread::spawn(move|| { @@ -1960,7 +1960,7 @@ mod sync_tests { #[test] fn try_recv_states() { - let (tx1, rx1) = sync_channel::<int>(1); + let (tx1, rx1) = sync_channel::<i32>(1); let (tx2, rx2) = sync_channel::<()>(1); let (tx3, rx3) = sync_channel::<()>(1); let _t = thread::spawn(move|| { @@ -2007,21 +2007,21 @@ mod sync_tests { #[test] fn send1() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { rx.recv().unwrap(); }); assert_eq!(tx.send(1), Ok(())); } #[test] fn send2() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { drop(rx); }); assert!(tx.send(1).is_err()); } #[test] fn send3() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); assert_eq!(tx.send(1), Ok(())); let _t =thread::spawn(move|| { drop(rx); }); assert!(tx.send(1).is_err()); @@ -2029,7 +2029,7 @@ mod sync_tests { #[test] fn send4() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let tx2 = tx.clone(); let (done, donerx) = channel(); let done2 = done.clone(); @@ -2048,20 +2048,20 @@ mod sync_tests { #[test] fn try_send1() { - let (tx, _rx) = sync_channel::<int>(0); + let (tx, _rx) = sync_channel::<i32>(0); assert_eq!(tx.try_send(1), Err(TrySendError::Full(1))); } #[test] fn try_send2() { - let (tx, _rx) = sync_channel::<int>(1); + let (tx, _rx) = sync_channel::<i32>(1); assert_eq!(tx.try_send(1), Ok(())); assert_eq!(tx.try_send(1), Err(TrySendError::Full(1))); } #[test] fn try_send3() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); assert_eq!(tx.try_send(1), Ok(())); drop(rx); assert_eq!(tx.try_send(1), Err(TrySendError::Disconnected(1))); diff --git a/src/libstd/sync/mpsc/oneshot.rs b/src/libstd/sync/mpsc/oneshot.rs index eb45681fa62..f287712d9d4 100644 --- a/src/libstd/sync/mpsc/oneshot.rs +++ b/src/libstd/sync/mpsc/oneshot.rs @@ -22,7 +22,7 @@ /// /// # Implementation /// -/// Oneshots are implemented around one atomic uint variable. This variable +/// Oneshots are implemented around one atomic usize variable. This variable /// indicates both the state of the port/chan but also contains any tasks /// blocked on the port. All atomic operations happen on this one word. /// @@ -45,9 +45,9 @@ use core::mem; use sync::atomic::{AtomicUsize, Ordering}; // Various states you can find a port in. -const EMPTY: uint = 0; // initial state: no data, no blocked receiver -const DATA: uint = 1; // data ready for receiver to take -const DISCONNECTED: uint = 2; // channel is disconnected OR upgraded +const EMPTY: usize = 0; // initial state: no data, no blocked receiver +const DATA: usize = 1; // data ready for receiver to take +const DISCONNECTED: usize = 2; // channel is disconnected OR upgraded // Any other value represents a pointer to a SignalToken value. The // protocol ensures that when the state moves *to* a pointer, // ownership of the token is given to the packet, and when the state @@ -123,7 +123,7 @@ impl<T: Send> Packet<T> { // There is a thread waiting on the other end. We leave the 'DATA' // state inside so it'll pick it up on the other end. ptr => unsafe { - SignalToken::cast_from_uint(ptr).signal(); + SignalToken::cast_from_usize(ptr).signal(); Ok(()) } } @@ -143,7 +143,7 @@ impl<T: Send> Packet<T> { // like we're not empty, then immediately go through to `try_recv`. if self.state.load(Ordering::SeqCst) == EMPTY { let (wait_token, signal_token) = blocking::tokens(); - let ptr = unsafe { signal_token.cast_to_uint() }; + let ptr = unsafe { signal_token.cast_to_usize() }; // race with senders to enter the blocking state if self.state.compare_and_swap(EMPTY, ptr, Ordering::SeqCst) == EMPTY { @@ -151,7 +151,7 @@ impl<T: Send> Packet<T> { debug_assert!(self.state.load(Ordering::SeqCst) != EMPTY); } else { // drop the signal token, since we never blocked - drop(unsafe { SignalToken::cast_from_uint(ptr) }); + drop(unsafe { SignalToken::cast_from_usize(ptr) }); } } @@ -220,7 +220,7 @@ impl<T: Send> Packet<T> { DISCONNECTED => { self.upgrade = prev; UpDisconnected } // If someone's waiting, we gotta wake them up - ptr => UpWoke(unsafe { SignalToken::cast_from_uint(ptr) }) + ptr => UpWoke(unsafe { SignalToken::cast_from_usize(ptr) }) } } @@ -230,7 +230,7 @@ impl<T: Send> Packet<T> { // If someone's waiting, we gotta wake them up ptr => unsafe { - SignalToken::cast_from_uint(ptr).signal(); + SignalToken::cast_from_usize(ptr).signal(); } } } @@ -283,15 +283,15 @@ impl<T: Send> Packet<T> { // Attempts to start selection on this port. This can either succeed, fail // because there is data, or fail because there is an upgrade pending. pub fn start_selection(&mut self, token: SignalToken) -> SelectionResult<T> { - let ptr = unsafe { token.cast_to_uint() }; + let ptr = unsafe { token.cast_to_usize() }; match self.state.compare_and_swap(EMPTY, ptr, Ordering::SeqCst) { EMPTY => SelSuccess, DATA => { - drop(unsafe { SignalToken::cast_from_uint(ptr) }); + drop(unsafe { SignalToken::cast_from_usize(ptr) }); SelCanceled } DISCONNECTED if self.data.is_some() => { - drop(unsafe { SignalToken::cast_from_uint(ptr) }); + drop(unsafe { SignalToken::cast_from_usize(ptr) }); SelCanceled } DISCONNECTED => { @@ -300,7 +300,7 @@ impl<T: Send> Packet<T> { // propagate upwards whether the upgrade can receive // data GoUp(upgrade) => { - SelUpgraded(unsafe { SignalToken::cast_from_uint(ptr) }, upgrade) + SelUpgraded(unsafe { SignalToken::cast_from_usize(ptr) }, upgrade) } // If the other end disconnected without sending an @@ -308,7 +308,7 @@ impl<T: Send> Packet<T> { // disconnected). up => { self.upgrade = up; - drop(unsafe { SignalToken::cast_from_uint(ptr) }); + drop(unsafe { SignalToken::cast_from_usize(ptr) }); SelCanceled } } @@ -360,7 +360,7 @@ impl<T: Send> Packet<T> { // We woke ourselves up from select. ptr => unsafe { - drop(SignalToken::cast_from_uint(ptr)); + drop(SignalToken::cast_from_usize(ptr)); Ok(false) } } diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs index db8efe19dc1..8de5bbc6206 100644 --- a/src/libstd/sync/mpsc/select.rs +++ b/src/libstd/sync/mpsc/select.rs @@ -71,7 +71,7 @@ use sync::mpsc::blocking::{self, SignalToken}; pub struct Select { head: *mut Handle<'static, ()>, tail: *mut Handle<'static, ()>, - next_id: Cell<uint>, + next_id: Cell<usize>, } impl !marker::Send for Select {} @@ -82,7 +82,7 @@ impl !marker::Send for Select {} pub struct Handle<'rx, T:'rx> { /// The ID of this handle, used to compare against the return value of /// `Select::wait()` - id: uint, + id: usize, selector: &'rx Select, next: *mut Handle<'static, ()>, prev: *mut Handle<'static, ()>, @@ -154,12 +154,12 @@ impl Select { /// the matching `id` will have some sort of event available on it. The /// event could either be that data is available or the corresponding /// channel has been closed. - pub fn wait(&self) -> uint { + pub fn wait(&self) -> usize { self.wait2(true) } /// Helper method for skipping the preflight checks during testing - fn wait2(&self, do_preflight_checks: bool) -> uint { + fn wait2(&self, do_preflight_checks: bool) -> usize { // Note that this is currently an inefficient implementation. We in // theory have knowledge about all receivers in the set ahead of time, // so this method shouldn't really have to iterate over all of them yet @@ -254,7 +254,7 @@ impl Select { impl<'rx, T: Send> Handle<'rx, T> { /// Retrieve the id of this handle. #[inline] - pub fn id(&self) -> uint { self.id } + pub fn id(&self) -> usize { self.id } /// Block to receive a value on the underlying receiver, returning `Some` on /// success or `None` if the channel disconnects. This function has the same @@ -369,8 +369,8 @@ mod test { #[test] fn smoke() { - let (tx1, rx1) = channel::<int>(); - let (tx2, rx2) = channel::<int>(); + let (tx1, rx1) = channel::<i32>(); + let (tx2, rx2) = channel::<i32>(); tx1.send(1).unwrap(); select! { foo = rx1.recv() => { assert_eq!(foo.unwrap(), 1); }, @@ -394,11 +394,11 @@ mod test { #[test] fn smoke2() { - let (_tx1, rx1) = channel::<int>(); - let (_tx2, rx2) = channel::<int>(); - let (_tx3, rx3) = channel::<int>(); - let (_tx4, rx4) = channel::<int>(); - let (tx5, rx5) = channel::<int>(); + let (_tx1, rx1) = channel::<i32>(); + let (_tx2, rx2) = channel::<i32>(); + let (_tx3, rx3) = channel::<i32>(); + let (_tx4, rx4) = channel::<i32>(); + let (tx5, rx5) = channel::<i32>(); tx5.send(4).unwrap(); select! { _foo = rx1.recv() => { panic!("1") }, @@ -411,8 +411,8 @@ mod test { #[test] fn closed() { - let (_tx1, rx1) = channel::<int>(); - let (tx2, rx2) = channel::<int>(); + let (_tx1, rx1) = channel::<i32>(); + let (tx2, rx2) = channel::<i32>(); drop(tx2); select! { @@ -423,9 +423,9 @@ mod test { #[test] fn unblocks() { - let (tx1, rx1) = channel::<int>(); - let (_tx2, rx2) = channel::<int>(); - let (tx3, rx3) = channel::<int>(); + let (tx1, rx1) = channel::<i32>(); + let (_tx2, rx2) = channel::<i32>(); + let (tx3, rx3) = channel::<i32>(); let _t = thread::spawn(move|| { for _ in 0..20 { thread::yield_now(); } @@ -447,8 +447,8 @@ mod test { #[test] fn both_ready() { - let (tx1, rx1) = channel::<int>(); - let (tx2, rx2) = channel::<int>(); + let (tx1, rx1) = channel::<i32>(); + let (tx2, rx2) = channel::<i32>(); let (tx3, rx3) = channel::<()>(); let _t = thread::spawn(move|| { @@ -473,9 +473,9 @@ mod test { #[test] fn stress() { - static AMT: int = 10000; - let (tx1, rx1) = channel::<int>(); - let (tx2, rx2) = channel::<int>(); + static AMT: i32 = 10000; + let (tx1, rx1) = channel::<i32>(); + let (tx2, rx2) = channel::<i32>(); let (tx3, rx3) = channel::<()>(); let _t = thread::spawn(move|| { @@ -500,8 +500,8 @@ mod test { #[test] fn cloning() { - let (tx1, rx1) = channel::<int>(); - let (_tx2, rx2) = channel::<int>(); + let (tx1, rx1) = channel::<i32>(); + let (_tx2, rx2) = channel::<i32>(); let (tx3, rx3) = channel::<()>(); let _t = thread::spawn(move|| { @@ -522,8 +522,8 @@ mod test { #[test] fn cloning2() { - let (tx1, rx1) = channel::<int>(); - let (_tx2, rx2) = channel::<int>(); + let (tx1, rx1) = channel::<i32>(); + let (_tx2, rx2) = channel::<i32>(); let (tx3, rx3) = channel::<()>(); let _t = thread::spawn(move|| { @@ -716,7 +716,7 @@ mod test { #[test] fn sync1() { - let (tx, rx) = sync_channel::<int>(1); + let (tx, rx) = sync_channel::<i32>(1); tx.send(1).unwrap(); select! { n = rx.recv() => { assert_eq!(n.unwrap(), 1); } @@ -725,7 +725,7 @@ mod test { #[test] fn sync2() { - let (tx, rx) = sync_channel::<int>(0); + let (tx, rx) = sync_channel::<i32>(0); let _t = thread::spawn(move|| { for _ in 0..100 { thread::yield_now() } tx.send(1).unwrap(); @@ -737,8 +737,8 @@ mod test { #[test] fn sync3() { - let (tx1, rx1) = sync_channel::<int>(0); - let (tx2, rx2): (Sender<int>, Receiver<int>) = channel(); + let (tx1, rx1) = sync_channel::<i32>(0); + let (tx2, rx2): (Sender<i32>, Receiver<i32>) = channel(); let _t = thread::spawn(move|| { tx1.send(1).unwrap(); }); let _t = thread::spawn(move|| { tx2.send(2).unwrap(); }); select! { diff --git a/src/libstd/sync/mpsc/shared.rs b/src/libstd/sync/mpsc/shared.rs index 729e7991f97..8d14824d37f 100644 --- a/src/libstd/sync/mpsc/shared.rs +++ b/src/libstd/sync/mpsc/shared.rs @@ -101,7 +101,7 @@ impl<T: Send> Packet<T> { token.map(|token| { assert_eq!(self.cnt.load(Ordering::SeqCst), 0); assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); - self.to_wake.store(unsafe { token.cast_to_uint() }, Ordering::SeqCst); + self.to_wake.store(unsafe { token.cast_to_usize() }, Ordering::SeqCst); self.cnt.store(-1, Ordering::SeqCst); // This store is a little sketchy. What's happening here is that @@ -241,7 +241,7 @@ impl<T: Send> Packet<T> { // Returns true if blocking should proceed. fn decrement(&mut self, token: SignalToken) -> StartResult { assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); - let ptr = unsafe { token.cast_to_uint() }; + let ptr = unsafe { token.cast_to_usize() }; self.to_wake.store(ptr, Ordering::SeqCst); let steals = self.steals; @@ -258,7 +258,7 @@ impl<T: Send> Packet<T> { } self.to_wake.store(0, Ordering::SeqCst); - drop(unsafe { SignalToken::cast_from_uint(ptr) }); + drop(unsafe { SignalToken::cast_from_usize(ptr) }); Abort } @@ -380,7 +380,7 @@ impl<T: Send> Packet<T> { let ptr = self.to_wake.load(Ordering::SeqCst); self.to_wake.store(0, Ordering::SeqCst); assert!(ptr != 0); - unsafe { SignalToken::cast_from_uint(ptr) } + unsafe { SignalToken::cast_from_usize(ptr) } } //////////////////////////////////////////////////////////////////////////// diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs index 7b5c614536d..ce40fa2672a 100644 --- a/src/libstd/sync/mpsc/spsc_queue.rs +++ b/src/libstd/sync/mpsc/spsc_queue.rs @@ -69,7 +69,7 @@ pub struct Queue<T> { // Cache maintenance fields. Additions and subtractions are stored // separately in order to allow them to use nonatomic addition/subtraction. - cache_bound: uint, + cache_bound: usize, cache_additions: AtomicUsize, cache_subtractions: AtomicUsize, } @@ -107,7 +107,7 @@ impl<T: Send> Queue<T> { /// cache (if desired). If the value is 0, then the cache has /// no bound. Otherwise, the cache will never grow larger than /// `bound` (although the queue itself could be much larger. - pub unsafe fn new(bound: uint) -> Queue<T> { + pub unsafe fn new(bound: usize) -> Queue<T> { let n1 = Node::new(); let n2 = Node::new(); (*n1).next.store(n2, Ordering::Relaxed); @@ -319,7 +319,7 @@ mod test { stress_bound(1); } - unsafe fn stress_bound(bound: uint) { + unsafe fn stress_bound(bound: usize) { let q = Arc::new(Queue::new(bound)); let (tx, rx) = channel(); diff --git a/src/libstd/sync/mpsc/stream.rs b/src/libstd/sync/mpsc/stream.rs index 2d528662f64..5a1e05f9c15 100644 --- a/src/libstd/sync/mpsc/stream.rs +++ b/src/libstd/sync/mpsc/stream.rs @@ -43,7 +43,7 @@ pub struct Packet<T> { queue: spsc::Queue<Message<T>>, // internal queue for all message cnt: AtomicIsize, // How many items are on this channel - steals: int, // How many times has a port received without blocking? + steals: isize, // How many times has a port received without blocking? to_wake: AtomicUsize, // SignalToken for the blocked thread to wake up port_dropped: AtomicBool, // flag if the channel has been destroyed. @@ -146,7 +146,7 @@ impl<T: Send> Packet<T> { let ptr = self.to_wake.load(Ordering::SeqCst); self.to_wake.store(0, Ordering::SeqCst); assert!(ptr != 0); - unsafe { SignalToken::cast_from_uint(ptr) } + unsafe { SignalToken::cast_from_usize(ptr) } } // Decrements the count on the channel for a sleeper, returning the sleeper @@ -154,7 +154,7 @@ impl<T: Send> Packet<T> { // steals into account. fn decrement(&mut self, token: SignalToken) -> Result<(), SignalToken> { assert_eq!(self.to_wake.load(Ordering::SeqCst), 0); - let ptr = unsafe { token.cast_to_uint() }; + let ptr = unsafe { token.cast_to_usize() }; self.to_wake.store(ptr, Ordering::SeqCst); let steals = self.steals; @@ -171,7 +171,7 @@ impl<T: Send> Packet<T> { } self.to_wake.store(0, Ordering::SeqCst); - Err(unsafe { SignalToken::cast_from_uint(ptr) }) + Err(unsafe { SignalToken::cast_from_usize(ptr) }) } pub fn recv(&mut self) -> Result<T, Failure<T>> { @@ -350,7 +350,7 @@ impl<T: Send> Packet<T> { } // increment the count on the channel (used for selection) - fn bump(&mut self, amt: int) -> int { + fn bump(&mut self, amt: isize) -> isize { match self.cnt.fetch_add(amt, Ordering::SeqCst) { DISCONNECTED => { self.cnt.store(DISCONNECTED, Ordering::SeqCst); diff --git a/src/libstd/sync/mpsc/sync.rs b/src/libstd/sync/mpsc/sync.rs index 36b50b0d4af..33c1614e1b2 100644 --- a/src/libstd/sync/mpsc/sync.rs +++ b/src/libstd/sync/mpsc/sync.rs @@ -64,7 +64,7 @@ struct State<T> { queue: Queue, // queue of senders waiting to send data blocker: Blocker, // currently blocked task on this channel buf: Buffer<T>, // storage for buffered messages - cap: uint, // capacity of this channel + cap: usize, // capacity of this channel /// A curious flag used to indicate whether a sender failed or succeeded in /// blocking. This is used to transmit information back to the task that it @@ -101,8 +101,8 @@ unsafe impl Send for Node {} /// A simple ring-buffer struct Buffer<T> { buf: Vec<Option<T>>, - start: uint, - size: uint, + start: usize, + size: usize, } #[derive(Debug)] @@ -137,7 +137,7 @@ fn wakeup<T>(token: SignalToken, guard: MutexGuard<State<T>>) { } impl<T: Send> Packet<T> { - pub fn new(cap: uint) -> Packet<T> { + pub fn new(cap: usize) -> Packet<T> { Packet { channels: AtomicUsize::new(1), lock: Mutex::new(State { @@ -442,8 +442,8 @@ impl<T> Buffer<T> { result.take().unwrap() } - fn size(&self) -> uint { self.size } - fn cap(&self) -> uint { self.buf.len() } + fn size(&self) -> usize { self.size } + fn cap(&self) -> usize { self.buf.len() } } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index b71cc0c2653..02b2db572ec 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -50,7 +50,7 @@ use sys_common::mutex as sys; /// use std::thread; /// use std::sync::mpsc::channel; /// -/// const N: uint = 10; +/// const N: usize = 10; /// /// // Spawn a few threads to increment a shared variable (non-atomically), and /// // let the main thread know once all increments are done. @@ -377,9 +377,9 @@ mod test { #[test] fn lots_and_lots() { static M: StaticMutex = MUTEX_INIT; - static mut CNT: uint = 0; - static J: uint = 1000; - static K: uint = 3; + static mut CNT: u32 = 0; + static J: u32 = 1000; + static K: u32 = 3; fn inc() { for _ in 0..J { @@ -501,7 +501,7 @@ mod test { let arc2 = arc.clone(); let _ = thread::spawn(move|| -> () { struct Unwinder { - i: Arc<Mutex<int>>, + i: Arc<Mutex<i32>>, } impl Drop for Unwinder { fn drop(&mut self) { diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs index a45048be24c..31f3dfd877c 100644 --- a/src/libstd/sync/task_pool.rs +++ b/src/libstd/sync/task_pool.rs @@ -89,7 +89,7 @@ impl TaskPool { /// # Panics /// /// This function will panic if `threads` is 0. - pub fn new(threads: uint) -> TaskPool { + pub fn new(threads: usize) -> TaskPool { assert!(threads >= 1); let (tx, rx) = channel::<Thunk>(); @@ -142,7 +142,7 @@ mod test { use super::*; use sync::mpsc::channel; - const TEST_TASKS: uint = 4; + const TEST_TASKS: usize = 4; #[test] fn test_works() { diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs index b5cd42219e1..228362e3d62 100644 --- a/src/libstd/sys/common/net.rs +++ b/src/libstd/sys/common/net.rs @@ -503,7 +503,7 @@ pub fn connect_timeout(fd: sock_t, #[cfg(windows)] use libc::WSAEWOULDBLOCK as WOULDBLOCK; // Make sure the call to connect() doesn't block - try!(set_nonblocking(fd, true)); + set_nonblocking(fd, true); let ret = match unsafe { libc::connect(fd, addrp, len) } { // If the connection is in progress, then we need to wait for it to @@ -533,7 +533,7 @@ pub fn connect_timeout(fd: sock_t, }; // be sure to turn blocking I/O back on - try!(set_nonblocking(fd, false)); + set_nonblocking(fd, false); return ret; #[cfg(unix)] @@ -626,7 +626,7 @@ pub struct Guard<'a> { #[unsafe_destructor] impl<'a> Drop for Guard<'a> { fn drop(&mut self) { - assert!(set_nonblocking(self.fd, false).is_ok()); + set_nonblocking(self.fd, false); } } @@ -723,7 +723,7 @@ impl TcpStream { fd: self.fd(), guard: self.inner.lock.lock().unwrap(), }; - assert!(set_nonblocking(self.fd(), true).is_ok()); + set_nonblocking(self.fd(), true); ret } @@ -862,7 +862,7 @@ impl UdpSocket { fd: self.fd(), guard: self.inner.lock.lock().unwrap(), }; - assert!(set_nonblocking(self.fd(), true).is_ok()); + set_nonblocking(self.fd(), true); ret } @@ -887,9 +887,7 @@ impl UdpSocket { storagep, &mut addrlen) as libc::c_int })); - sockaddr_to_addr(&storage, addrlen as uint).and_then(|addr| { - Ok((n as uint, addr)) - }) + Ok((n as uint, sockaddr_to_addr(&storage, addrlen as uint).unwrap())) } pub fn send_to(&mut self, buf: &[u8], dst: SocketAddr) -> IoResult<()> { @@ -910,11 +908,8 @@ impl UdpSocket { }; let n = try!(write(fd, self.write_deadline, buf, false, dolock, dowrite)); - if n != buf.len() { - Err(short_write(n, "couldn't send entire packet at once")) - } else { - Ok(()) - } + assert!(n == buf.len(), "UDP packet not completely written."); + Ok(()) } pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> { diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index 9119a3c60d8..fb9d6fef1fa 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -1202,11 +1202,11 @@ mod tests { string.code_points().map(|c| c.to_char()).collect::<Vec<_>>() } let mut string = Wtf8Buf::from_str("é "); - assert_eq!(cp(&string), vec![Some('é'), Some(' ')]); + assert_eq!(cp(&string), [Some('é'), Some(' ')]); string.push(c(0xD83D)); - assert_eq!(cp(&string), vec![Some('é'), Some(' '), None]); + assert_eq!(cp(&string), [Some('é'), Some(' '), None]); string.push(c(0xDCA9)); - assert_eq!(cp(&string), vec![Some('é'), Some(' '), Some('💩')]); + assert_eq!(cp(&string), [Some('é'), Some(' '), Some('💩')]); } #[test] diff --git a/src/libstd/sys/unix/fs2.rs b/src/libstd/sys/unix/fs2.rs index 92a47c6c385..c6b9c2cba52 100644 --- a/src/libstd/sys/unix/fs2.rs +++ b/src/libstd/sys/unix/fs2.rs @@ -18,7 +18,7 @@ use libc::{self, c_int, c_void, size_t, off_t, c_char, mode_t}; use mem; use path::{Path, PathBuf}; use ptr; -use rc::Rc; +use sync::Arc; use sys::fd::FileDesc; use sys::{c, cvt, cvt_r}; use sys_common::FromInner; @@ -31,14 +31,18 @@ pub struct FileAttr { } pub struct ReadDir { - dirp: *mut libc::DIR, - root: Rc<PathBuf>, + dirp: Dir, + root: Arc<PathBuf>, } +struct Dir(*mut libc::DIR); + +unsafe impl Send for Dir {} +unsafe impl Sync for Dir {} + pub struct DirEntry { - buf: Vec<u8>, - dirent: *mut libc::dirent_t, - root: Rc<PathBuf>, + buf: Vec<u8>, // actually *mut libc::dirent_t + root: Arc<PathBuf>, } #[derive(Clone)] @@ -109,7 +113,7 @@ impl Iterator for ReadDir { let mut entry_ptr = ptr::null_mut(); loop { - if unsafe { libc::readdir_r(self.dirp, ptr, &mut entry_ptr) != 0 } { + if unsafe { libc::readdir_r(self.dirp.0, ptr, &mut entry_ptr) != 0 } { return Some(Err(Error::last_os_error())) } if entry_ptr.is_null() { @@ -118,7 +122,6 @@ impl Iterator for ReadDir { let entry = DirEntry { buf: buf, - dirent: entry_ptr, root: self.root.clone() }; if entry.name_bytes() == b"." || entry.name_bytes() == b".." { @@ -130,9 +133,9 @@ impl Iterator for ReadDir { } } -impl Drop for ReadDir { +impl Drop for Dir { fn drop(&mut self) { - let r = unsafe { libc::closedir(self.dirp) }; + let r = unsafe { libc::closedir(self.0) }; debug_assert_eq!(r, 0); } } @@ -147,9 +150,13 @@ impl DirEntry { fn rust_list_dir_val(ptr: *mut libc::dirent_t) -> *const c_char; } unsafe { - CStr::from_ptr(rust_list_dir_val(self.dirent)).to_bytes() + CStr::from_ptr(rust_list_dir_val(self.dirent())).to_bytes() } } + + fn dirent(&self) -> *mut libc::dirent_t { + self.buf.as_ptr() as *mut _ + } } impl OpenOptions { @@ -279,14 +286,14 @@ pub fn mkdir(p: &Path) -> io::Result<()> { } pub fn readdir(p: &Path) -> io::Result<ReadDir> { - let root = Rc::new(p.to_path_buf()); + let root = Arc::new(p.to_path_buf()); let p = try!(cstr(p)); unsafe { let ptr = libc::opendir(p.as_ptr()); if ptr.is_null() { Err(Error::last_os_error()) } else { - Ok(ReadDir { dirp: ptr, root: root }) + Ok(ReadDir { dirp: Dir(ptr), root: root }) } } } diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs index b79ad7031fa..632270bc5cc 100644 --- a/src/libstd/sys/unix/mod.rs +++ b/src/libstd/sys/unix/mod.rs @@ -214,9 +214,9 @@ pub fn wouldblock() -> bool { err == libc::EWOULDBLOCK as i32 || err == libc::EAGAIN as i32 } -pub fn set_nonblocking(fd: sock_t, nb: bool) -> IoResult<()> { +pub fn set_nonblocking(fd: sock_t, nb: bool) { let set = nb as libc::c_int; - mkerr_libc(retry(|| unsafe { c::ioctl(fd, c::FIONBIO, &set) })) + mkerr_libc(retry(|| unsafe { c::ioctl(fd, c::FIONBIO, &set) })).unwrap(); } // nothing needed on unix platforms diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs index 3c9cdc65975..1446600a77e 100644 --- a/src/libstd/sys/unix/pipe.rs +++ b/src/libstd/sys/unix/pipe.rs @@ -235,9 +235,9 @@ impl UnixListener { _ => { let (reader, writer) = try!(unsafe { sys::os::pipe() }); - try!(set_nonblocking(reader.fd(), true)); - try!(set_nonblocking(writer.fd(), true)); - try!(set_nonblocking(self.fd(), true)); + set_nonblocking(reader.fd(), true); + set_nonblocking(writer.fd(), true); + set_nonblocking(self.fd(), true); Ok(UnixAcceptor { inner: Arc::new(AcceptorInner { listener: self, diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index 2be841989e6..68c5c65e7cd 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -69,7 +69,6 @@ impl Process { K: BytesContainer + Eq + Hash, V: BytesContainer { use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp}; - use libc::funcs::bsd44::getdtablesize; mod rustrt { extern { @@ -82,6 +81,15 @@ impl Process { assert_eq!(ret, 0); } + #[cfg(all(target_os = "android", target_arch = "aarch64"))] + unsafe fn getdtablesize() -> c_int { + libc::sysconf(libc::consts::os::sysconf::_SC_OPEN_MAX) as c_int + } + #[cfg(not(all(target_os = "android", target_arch = "aarch64")))] + unsafe fn getdtablesize() -> c_int { + libc::funcs::bsd44::getdtablesize() + } + let dirp = cfg.cwd().map(|c| c.as_ptr()).unwrap_or(ptr::null()); // temporary until unboxed closures land @@ -345,8 +353,8 @@ impl Process { unsafe { let mut pipes = [0; 2]; assert_eq!(libc::pipe(pipes.as_mut_ptr()), 0); - set_nonblocking(pipes[0], true).ok().unwrap(); - set_nonblocking(pipes[1], true).ok().unwrap(); + set_nonblocking(pipes[0], true); + set_nonblocking(pipes[1], true); WRITE_FD = pipes[1]; let mut old: c::sigaction = mem::zeroed(); @@ -362,7 +370,7 @@ impl Process { fn waitpid_helper(input: libc::c_int, messages: Receiver<Req>, (read_fd, old): (libc::c_int, c::sigaction)) { - set_nonblocking(input, true).ok().unwrap(); + set_nonblocking(input, true); let mut set: c::fd_set = unsafe { mem::zeroed() }; let mut tv: libc::timeval; let mut active = Vec::<(libc::pid_t, Sender<ProcessExit>, u64)>::new(); diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process2.rs index 06fa5c4bba7..b7a1b002f55 100644 --- a/src/libstd/sys/unix/process2.rs +++ b/src/libstd/sys/unix/process2.rs @@ -141,7 +141,6 @@ impl Process { -> io::Result<Process> { use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp}; - use libc::funcs::bsd44::getdtablesize; mod rustrt { extern { @@ -154,6 +153,16 @@ impl Process { assert_eq!(ret, 0); } + #[cfg(all(target_os = "android", target_arch = "aarch64"))] + unsafe fn getdtablesize() -> c_int { + libc::sysconf(libc::consts::os::sysconf::_SC_OPEN_MAX) as c_int + } + + #[cfg(not(all(target_os = "android", target_arch = "aarch64")))] + unsafe fn getdtablesize() -> c_int { + libc::funcs::bsd44::getdtablesize() + } + let dirp = cfg.cwd.as_ref().map(|c| c.as_ptr()).unwrap_or(ptr::null()); with_envp(cfg.env.as_ref(), |envp: *const c_void| { diff --git a/src/libstd/sys/unix/tcp.rs b/src/libstd/sys/unix/tcp.rs index c8f9d318482..b08f6ef9b90 100644 --- a/src/libstd/sys/unix/tcp.rs +++ b/src/libstd/sys/unix/tcp.rs @@ -67,9 +67,9 @@ impl TcpListener { -1 => Err(last_net_error()), _ => { let (reader, writer) = try!(unsafe { sys::os::pipe() }); - try!(set_nonblocking(reader.fd(), true)); - try!(set_nonblocking(writer.fd(), true)); - try!(set_nonblocking(self.fd(), true)); + set_nonblocking(reader.fd(), true); + set_nonblocking(writer.fd(), true); + set_nonblocking(self.fd(), true); Ok(TcpAcceptor { inner: Arc::new(AcceptorInner { listener: self, diff --git a/src/libstd/sys/windows/fs2.rs b/src/libstd/sys/windows/fs2.rs index 8abcd90efe8..117f819eeeb 100644 --- a/src/libstd/sys/windows/fs2.rs +++ b/src/libstd/sys/windows/fs2.rs @@ -19,6 +19,7 @@ use libc::{self, HANDLE}; use mem; use path::{Path, PathBuf}; use ptr; +use sync::Arc; use sys::handle::Handle as RawHandle; use sys::{c, cvt}; use vec::Vec; @@ -27,12 +28,20 @@ pub struct File { handle: RawHandle } pub struct FileAttr { data: c::WIN32_FILE_ATTRIBUTE_DATA } pub struct ReadDir { - handle: libc::HANDLE, - root: PathBuf, + handle: FindNextFileHandle, + root: Arc<PathBuf>, first: Option<libc::WIN32_FIND_DATAW>, } -pub struct DirEntry { path: PathBuf } +struct FindNextFileHandle(libc::HANDLE); + +unsafe impl Send for FindNextFileHandle {} +unsafe impl Sync for FindNextFileHandle {} + +pub struct DirEntry { + root: Arc<PathBuf>, + data: libc::WIN32_FIND_DATAW, +} #[derive(Clone, Default)] pub struct OpenOptions { @@ -61,7 +70,7 @@ impl Iterator for ReadDir { unsafe { let mut wfd = mem::zeroed(); loop { - if libc::FindNextFileW(self.handle, &mut wfd) == 0 { + if libc::FindNextFileW(self.handle.0, &mut wfd) == 0 { if libc::GetLastError() == c::ERROR_NO_MORE_FILES as libc::DWORD { return None @@ -77,15 +86,15 @@ impl Iterator for ReadDir { } } -impl Drop for ReadDir { +impl Drop for FindNextFileHandle { fn drop(&mut self) { - let r = unsafe { libc::FindClose(self.handle) }; + let r = unsafe { libc::FindClose(self.0) }; debug_assert!(r != 0); } } impl DirEntry { - fn new(root: &Path, wfd: &libc::WIN32_FIND_DATAW) -> Option<DirEntry> { + fn new(root: &Arc<PathBuf>, wfd: &libc::WIN32_FIND_DATAW) -> Option<DirEntry> { match &wfd.cFileName[0..3] { // check for '.' and '..' [46, 0, ..] | @@ -93,13 +102,15 @@ impl DirEntry { _ => {} } - let filename = super::truncate_utf16_at_nul(&wfd.cFileName); - let filename: OsString = OsStringExt::from_wide(filename); - Some(DirEntry { path: root.join(&filename) }) + Some(DirEntry { + root: root.clone(), + data: *wfd, + }) } pub fn path(&self) -> PathBuf { - self.path.clone() + let filename = super::truncate_utf16_at_nul(&self.data.cFileName); + self.root.join(&<OsString as OsStringExt>::from_wide(filename)) } } @@ -312,7 +323,11 @@ pub fn readdir(p: &Path) -> io::Result<ReadDir> { let mut wfd = mem::zeroed(); let find_handle = libc::FindFirstFileW(path.as_ptr(), &mut wfd); if find_handle != libc::INVALID_HANDLE_VALUE { - Ok(ReadDir { handle: find_handle, root: root, first: Some(wfd) }) + Ok(ReadDir { + handle: FindNextFileHandle(find_handle), + root: Arc::new(root), + first: Some(wfd), + }) } else { Err(Error::last_os_error()) } diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index a756fb29f81..3acb372f658 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -192,12 +192,12 @@ pub fn wouldblock() -> bool { err == libc::WSAEWOULDBLOCK as i32 } -pub fn set_nonblocking(fd: sock_t, nb: bool) -> IoResult<()> { +pub fn set_nonblocking(fd: sock_t, nb: bool) { let mut set = nb as libc::c_ulong; - if unsafe { c::ioctlsocket(fd, c::FIONBIO, &mut set) != 0 } { - Err(last_error()) - } else { - Ok(()) + if unsafe { c::ioctlsocket(fd, c::FIONBIO, &mut set) } != 0 { + // The above function should not return an error unless we passed it + // invalid parameters. Panic on errors. + Err(last_error()).unwrap(); } } diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 3451232f40a..6caa4df5dfe 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -25,6 +25,8 @@ pub type wrlen_t = i32; pub struct Socket(libc::SOCKET); +/// Checks whether the Windows socket interface has been started already, and +/// if not, starts it. pub fn init() { static START: Once = ONCE_INIT; @@ -38,10 +40,16 @@ pub fn init() { }); } +/// Returns the last error from the Windows socket interface. fn last_error() -> io::Error { io::Error::from_os_error(unsafe { c::WSAGetLastError() }) } +/// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1) +/// and if so, returns the last error from the Windows socket interface. . This +/// function must be called before another call to the socket API is made. +/// +/// FIXME: generics needed? pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> { let one: T = Int::one(); if t == -one { @@ -51,11 +59,14 @@ pub fn cvt<T: SignedInt>(t: T) -> io::Result<T> { } } +/// Provides the functionality of `cvt` for the return values of `getaddrinfo` +/// and similar, meaning that they return an error if the return value is 0. pub fn cvt_gai(err: c_int) -> io::Result<()> { if err == 0 { return Ok(()) } cvt(err).map(|_| ()) } +/// Provides the functionality of `cvt` for a closure. pub fn cvt_r<T: SignedInt, F>(mut f: F) -> io::Result<T> where F: FnMut() -> T { cvt(f()) } @@ -112,7 +123,7 @@ impl Socket { impl Drop for Socket { fn drop(&mut self) { - unsafe { let _ = libc::closesocket(self.0); } + unsafe { cvt(libc::closesocket(self.0)).unwrap(); } } } diff --git a/src/libstd/sys/windows/tcp.rs b/src/libstd/sys/windows/tcp.rs index 4804ca510cb..25b70918591 100644 --- a/src/libstd/sys/windows/tcp.rs +++ b/src/libstd/sys/windows/tcp.rs @@ -192,7 +192,7 @@ impl TcpAcceptor { c::WSAEventSelect(socket, events[1], 0) }; if ret != 0 { return Err(last_net_error()) } - try!(set_nonblocking(socket, false)); + set_nonblocking(socket, false); return Ok(stream) } } diff --git a/src/libstd/sys/windows/tty.rs b/src/libstd/sys/windows/tty.rs index 8a8b5309057..c9bac69c434 100644 --- a/src/libstd/sys/windows/tty.rs +++ b/src/libstd/sys/windows/tty.rs @@ -52,7 +52,7 @@ fn invalid_encoding() -> IoError { pub fn is_tty(fd: c_int) -> bool { let mut out: DWORD = 0; - // If this function doesn't panic then fd is a TTY + // If this function doesn't return an error, then fd is a TTY match unsafe { GetConsoleMode(get_osfhandle(fd) as HANDLE, &mut out as LPDWORD) } { 0 => false, diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index 1f70e1526a0..6aad2bbcc7f 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -342,12 +342,15 @@ impl Builder { } } -/// Spawn a new, returning a join handle for it. +/// Spawn a new thread, returning a `JoinHandle` for it. /// -/// The child thread may outlive the parent (unless the parent thread -/// is the main thread; the whole process is terminated when the main -/// thread finishes.) The join handle can be used to block on -/// termination of the child thread, including recovering its panics. +/// The join handle will implicitly *detach* the child thread upon being +/// dropped. In this case, the child thread may outlive the parent (unless +/// the parent thread is the main thread; the whole process is terminated when +/// the main thread finishes.) Additionally, the join handle provides a `join` +/// method that can be used to join the child thread. If the child thread +/// panics, `join` will return an `Err` containing the argument given to +/// `panic`. /// /// # Panics /// diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs index cdd71d440fe..d65156dae96 100644 --- a/src/libstd/thread_local/mod.rs +++ b/src/libstd/thread_local/mod.rs @@ -74,7 +74,7 @@ pub mod __impl { /// use std::cell::RefCell; /// use std::thread; /// -/// thread_local!(static FOO: RefCell<uint> = RefCell::new(1)); +/// thread_local!(static FOO: RefCell<u32> = RefCell::new(1)); /// /// FOO.with(|f| { /// assert_eq!(*f.borrow(), 1); @@ -503,7 +503,7 @@ mod imp { unsafe fn ptr(&'static self) -> Option<*mut T> { let ptr = self.os.get() as *mut Value<T>; if !ptr.is_null() { - if ptr as uint == 1 { + if ptr as usize == 1 { return None } return Some(&mut (*ptr).value as *mut T); @@ -563,7 +563,7 @@ mod tests { #[test] fn smoke_no_dtor() { - thread_local!(static FOO: UnsafeCell<int> = UnsafeCell { value: 1 }); + thread_local!(static FOO: UnsafeCell<i32> = UnsafeCell { value: 1 }); FOO.with(|f| unsafe { assert_eq!(*f.get(), 1); @@ -632,7 +632,7 @@ mod tests { thread_local!(static K2: UnsafeCell<Option<S2>> = UnsafeCell { value: None }); - static mut HITS: uint = 0; + static mut HITS: u32 = 0; impl Drop for S1 { fn drop(&mut self) { @@ -723,8 +723,8 @@ mod dynamic_tests { #[test] fn smoke() { - fn square(i: int) -> int { i * i } - thread_local!(static FOO: int = square(3)); + fn square(i: i32) -> i32 { i * i } + thread_local!(static FOO: i32 = square(3)); FOO.with(|f| { assert_eq!(*f, 9); @@ -733,12 +733,12 @@ mod dynamic_tests { #[test] fn hashmap() { - fn map() -> RefCell<HashMap<int, int>> { + fn map() -> RefCell<HashMap<i32, i32>> { let mut m = HashMap::new(); m.insert(1, 2); RefCell::new(m) } - thread_local!(static FOO: RefCell<HashMap<int, int>> = map()); + thread_local!(static FOO: RefCell<HashMap<i32, i32>> = map()); FOO.with(|map| { assert_eq!(map.borrow()[1], 2); @@ -747,7 +747,7 @@ mod dynamic_tests { #[test] fn refcell_vec() { - thread_local!(static FOO: RefCell<Vec<uint>> = RefCell::new(vec![1, 2, 3])); + thread_local!(static FOO: RefCell<Vec<u32>> = RefCell::new(vec![1, 2, 3])); FOO.with(|vec| { assert_eq!(vec.borrow().len(), 3); diff --git a/src/libstd/thread_local/scoped.rs b/src/libstd/thread_local/scoped.rs index 01220e7bc1f..a2a5d8b81f4 100644 --- a/src/libstd/thread_local/scoped.rs +++ b/src/libstd/thread_local/scoped.rs @@ -24,7 +24,7 @@ //! # Example //! //! ``` -//! scoped_thread_local!(static FOO: uint); +//! scoped_thread_local!(static FOO: u32); //! //! // Initially each scoped slot is empty. //! assert!(!FOO.is_set()); @@ -140,7 +140,7 @@ impl<T> Key<T> { /// # Example /// /// ``` - /// scoped_thread_local!(static FOO: uint); + /// scoped_thread_local!(static FOO: u32); /// /// FOO.set(&100, || { /// let val = FOO.with(|v| *v); @@ -192,7 +192,7 @@ impl<T> Key<T> { /// # Example /// /// ```no_run - /// scoped_thread_local!(static FOO: uint); + /// scoped_thread_local!(static FOO: u32); /// /// FOO.with(|slot| { /// // work with `slot` @@ -269,11 +269,11 @@ mod tests { use cell::Cell; use prelude::v1::*; - scoped_thread_local!(static FOO: uint); + scoped_thread_local!(static FOO: u32); #[test] fn smoke() { - scoped_thread_local!(static BAR: uint); + scoped_thread_local!(static BAR: u32); assert!(!BAR.is_set()); BAR.set(&1, || { @@ -287,7 +287,7 @@ mod tests { #[test] fn cell_allowed() { - scoped_thread_local!(static BAR: Cell<uint>); + scoped_thread_local!(static BAR: Cell<u32>); BAR.set(&Cell::new(1), || { BAR.with(|slot| { diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index c79b510ae2d..656d507ed69 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -702,12 +702,12 @@ impl<'a> AstBuilder for ExtCtxt<'a> { self.expr_lit(sp, ast::LitInt(i as u64, ast::SignedIntLit(ast::TyIs(false), ast::Sign::new(i)))) } - fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr> { - self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8))) - } fn expr_u32(&self, sp: Span, u: u32) -> P<ast::Expr> { self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU32))) } + fn expr_u8(&self, sp: Span, u: u8) -> P<ast::Expr> { + self.expr_lit(sp, ast::LitInt(u as u64, ast::UnsignedIntLit(ast::TyU8))) + } fn expr_bool(&self, sp: Span, value: bool) -> P<ast::Expr> { self.expr_lit(sp, ast::LitBool(value)) } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index bc239d0c7c2..91bfe6f32dc 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -2028,7 +2028,7 @@ foo_module!(); let renamed_crate = renamer.fold_crate(the_crate); let idents = crate_idents(&renamed_crate); let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect(); - assert_eq!(resolved,vec!(f_ident.name,Name(16),int_ident.name,Name(16),Name(16),Name(16))); + assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),Name(16),Name(16)]); } // test the PatIdentRenamer; only PatIdents get renamed @@ -2044,8 +2044,6 @@ foo_module!(); let idents = crate_idents(&renamed_crate); let resolved : Vec<ast::Name> = idents.iter().map(|id| mtwt::resolve(*id)).collect(); let x_name = x_ident.name; - assert_eq!(resolved,vec!(f_ident.name,Name(16),int_ident.name,Name(16),x_name,x_name)); + assert_eq!(resolved, [f_ident.name,Name(16),int_ident.name,Name(16),x_name,x_name]); } - - } diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs index 1c2374e31f1..91262556abd 100644 --- a/src/libsyntax/ext/format.rs +++ b/src/libsyntax/ext/format.rs @@ -417,7 +417,7 @@ impl<'a, 'b> Context<'a, 'b> { parse::AlignUnknown => align("Unknown"), }; let align = self.ecx.expr_path(align); - let flags = self.ecx.expr_usize(sp, arg.format.flags); + let flags = self.ecx.expr_u32(sp, arg.format.flags); let prec = self.trans_count(arg.format.precision); let width = self.trans_count(arg.format.width); let path = self.ecx.path_global(sp, Context::rtpath(self.ecx, "FormatSpec")); @@ -610,7 +610,7 @@ impl<'a, 'b> Context<'a, 'b> { ecx.ident_of_std("core"), ecx.ident_of("fmt"), ecx.ident_of("ArgumentV1"), - ecx.ident_of("from_uint")], vec![arg]) + ecx.ident_of("from_usize")], vec![arg]) } }; diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs index b6563d77b88..72431d8e6aa 100644 --- a/src/libsyntax/ext/mtwt.rs +++ b/src/libsyntax/ext/mtwt.rs @@ -288,19 +288,19 @@ mod tests { fn xorpush_test () { let mut s = Vec::new(); xor_push(&mut s, 14); - assert_eq!(s.clone(), vec!(14)); + assert_eq!(s.clone(), [14]); xor_push(&mut s, 14); - assert_eq!(s.clone(), Vec::new()); + assert_eq!(s.clone(), []); xor_push(&mut s, 14); - assert_eq!(s.clone(), vec!(14)); + assert_eq!(s.clone(), [14]); xor_push(&mut s, 15); - assert_eq!(s.clone(), vec!(14, 15)); + assert_eq!(s.clone(), [14, 15]); xor_push(&mut s, 16); - assert_eq!(s.clone(), vec!(14, 15, 16)); + assert_eq!(s.clone(), [14, 15, 16]); xor_push(&mut s, 16); - assert_eq!(s.clone(), vec!(14, 15)); + assert_eq!(s.clone(), [14, 15]); xor_push(&mut s, 15); - assert_eq!(s.clone(), vec!(14)); + assert_eq!(s.clone(), [14]); } fn id(n: u32, s: SyntaxContext) -> Ident { @@ -389,13 +389,13 @@ mod tests { assert_eq!(marksof_internal (EMPTY_CTXT,stopname,&t),Vec::new()); // FIXME #5074: ANF'd to dodge nested calls { let ans = unfold_marks(vec!(4,98),EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans,stopname,&t),vec!(4,98));} + assert_eq! (marksof_internal (ans,stopname,&t), [4, 98]);} // does xoring work? { let ans = unfold_marks(vec!(5,5,16),EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans,stopname,&t), vec!(16));} + assert_eq! (marksof_internal (ans,stopname,&t), [16]);} // does nested xoring work? { let ans = unfold_marks(vec!(5,10,10,5,16),EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans, stopname,&t), vec!(16));} + assert_eq! (marksof_internal (ans, stopname,&t), [16]);} // rename where stop doesn't match: { let chain = vec!(M(9), R(id(name1.usize() as u32, @@ -403,7 +403,7 @@ mod tests { Name(100101102)), M(14)); let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans, stopname, &t), vec!(9,14));} + assert_eq! (marksof_internal (ans, stopname, &t), [9, 14]);} // rename where stop does match { let name1sc = apply_mark_internal(4, EMPTY_CTXT, &mut t); let chain = vec!(M(9), @@ -411,7 +411,7 @@ mod tests { stopname), M(14)); let ans = unfold_test_sc(chain,EMPTY_CTXT,&mut t); - assert_eq! (marksof_internal (ans, stopname, &t), vec!(9)); } + assert_eq! (marksof_internal (ans, stopname, &t), [9]); } } diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs index 0a39d380904..90df23882a1 100644 --- a/src/libsyntax/util/small_vector.rs +++ b/src/libsyntax/util/small_vector.rs @@ -229,10 +229,10 @@ mod test { assert_eq!(Vec::new(), v); let v = SmallVector::one(1); - assert_eq!(vec![1], v.into_iter().collect::<Vec<_>>()); + assert_eq!([1], v.into_iter().collect::<Vec<_>>()); let v = SmallVector::many(vec![1, 2, 3]); - assert_eq!(vec!(1, 2, 3), v.into_iter().collect::<Vec<_>>()); + assert_eq!([1, 2, 3], v.into_iter().collect::<Vec<_>>()); } #[test] diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs index 0b577f8de74..112525fcce9 100644 --- a/src/libterm/terminfo/parm.rs +++ b/src/libterm/terminfo/parm.rs @@ -652,15 +652,15 @@ mod test { let s = format!("%{{1}}%{{2}}%{}%d", op); let res = expand(s.as_bytes(), &[], &mut Variables::new()); assert!(res.is_ok(), res.err().unwrap()); - assert_eq!(res.unwrap(), vec!(b'0' + bs[0])); + assert_eq!(res.unwrap(), [b'0' + bs[0]]); let s = format!("%{{1}}%{{1}}%{}%d", op); let res = expand(s.as_bytes(), &[], &mut Variables::new()); assert!(res.is_ok(), res.err().unwrap()); - assert_eq!(res.unwrap(), vec!(b'0' + bs[1])); + assert_eq!(res.unwrap(), [b'0' + bs[1]]); let s = format!("%{{2}}%{{1}}%{}%d", op); let res = expand(s.as_bytes(), &[], &mut Variables::new()); assert!(res.is_ok(), res.err().unwrap()); - assert_eq!(res.unwrap(), vec!(b'0' + bs[2])); + assert_eq!(res.unwrap(), [b'0' + bs[2]]); } } diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs index dd272bf639b..96a06968c5f 100644 --- a/src/test/auxiliary/cci_class_cast.rs +++ b/src/test/auxiliary/cci_class_cast.rs @@ -17,7 +17,7 @@ pub mod kitty { pub name : String, } - impl fmt::String for cat { + impl fmt::Display for cat { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.name) } diff --git a/src/test/compile-fail/borrowck-fn-in-const-a.rs b/src/test/compile-fail/borrowck-fn-in-const-a.rs new file mode 100644 index 00000000000..3098807f272 --- /dev/null +++ b/src/test/compile-fail/borrowck-fn-in-const-a.rs @@ -0,0 +1,22 @@ +// 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 we check fns appearing in constant declarations. +// Issue #22382. + +const MOVE: fn(&String) -> String = { + fn broken(x: &String) -> String { + return *x //~ ERROR cannot move + } + broken +}; + +fn main() { +} diff --git a/src/test/compile-fail/borrowck-fn-in-const-b.rs b/src/test/compile-fail/borrowck-fn-in-const-b.rs new file mode 100644 index 00000000000..7e29b2ee0fd --- /dev/null +++ b/src/test/compile-fail/borrowck-fn-in-const-b.rs @@ -0,0 +1,24 @@ +// 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 we check fns appearing in constant declarations. +// Issue #22382. + +// How about mutating an immutable vector? +const MUTATE: fn(&Vec<String>) = { + fn broken(x: &Vec<String>) { + x.push(format!("this is broken")); + //~^ ERROR cannot borrow + } + broken +}; + +fn main() { +} diff --git a/src/test/compile-fail/borrowck-fn-in-const-c.rs b/src/test/compile-fail/borrowck-fn-in-const-c.rs new file mode 100644 index 00000000000..e607397e920 --- /dev/null +++ b/src/test/compile-fail/borrowck-fn-in-const-c.rs @@ -0,0 +1,33 @@ +// 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 we check fns appearing in constant declarations. +// Issue #22382. + +// Returning local references? +struct DropString { + inner: String +} +impl Drop for DropString { + fn drop(&mut self) { + self.inner.clear(); + self.inner.push_str("dropped"); + } +} +const LOCAL_REF: fn() -> &'static str = { + fn broken() -> &'static str { + let local = DropString { inner: format!("Some local string") }; + return &local.inner; //~ ERROR does not live long enough + } + broken +}; + +fn main() { +} diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs index d4decb71349..98a9c713e84 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt::Show; +use std::fmt::Debug; use std::default::Default; use std::marker::MarkerTrait; diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs index b1ee1762b6e..57d25a3bf58 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-unimplemented.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt::Show; +use std::fmt::Debug; use std::default::Default; // Test that two blanket impls conflict (at least without negative diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs index 1f6bb08871c..b3ef79c6cc0 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs @@ -13,7 +13,7 @@ extern crate go_trait; use go_trait::{Go,GoMut}; -use std::fmt::Show; +use std::fmt::Debug; use std::default::Default; struct MyThingy; diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs index c3563792ce3..7b60a5ecbd7 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-multidispatch.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt::Show; +use std::fmt::Debug; use std::default::Default; // Test that a blank impl for all T conflicts with an impl for some diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs index 980e4256d2b..d218b64af05 100644 --- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs +++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt::Show; +use std::fmt::Debug; use std::default::Default; // Test that a blank impl for all T conflicts with an impl for some diff --git a/src/test/compile-fail/coherence-tuple-conflict.rs b/src/test/compile-fail/coherence-tuple-conflict.rs index 9673fb6a213..87b007fdd69 100644 --- a/src/test/compile-fail/coherence-tuple-conflict.rs +++ b/src/test/compile-fail/coherence-tuple-conflict.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt::Show; +use std::fmt::Debug; use std::default::Default; // Test that a blank impl for all T conflicts with an impl for some diff --git a/src/test/compile-fail/fn-trait-formatting.rs b/src/test/compile-fail/fn-trait-formatting.rs index 71e1f7091b2..d682ef7d70c 100644 --- a/src/test/compile-fail/fn-trait-formatting.rs +++ b/src/test/compile-fail/fn-trait-formatting.rs @@ -15,8 +15,7 @@ fn needs_fn<F>(x: F) where F: Fn(isize) -> isize {} fn main() { let _: () = (box |_: isize| {}) as Box<FnOnce(isize)>; - //~^ ERROR object-safe - //~| ERROR mismatched types + //~^ ERROR mismatched types //~| expected `()` //~| found `Box<core::ops::FnOnce(isize)>` //~| expected () diff --git a/src/test/compile-fail/infinite-instantiation.rs b/src/test/compile-fail/infinite-instantiation.rs index 2642ac6204c..d39efa3c2ab 100644 --- a/src/test/compile-fail/infinite-instantiation.rs +++ b/src/test/compile-fail/infinite-instantiation.rs @@ -1,4 +1,4 @@ -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -8,28 +8,34 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// error-pattern: reached the recursion limit during monomorphization -// issue 2258 +//~^^^^^^^^^^ ERROR overflow +// +// We get an error message at the top of file (dummy span). +// This is not helpful, but also kind of annoying to prevent, +// so for now just live with it. +// This test case was originally for issue #2258. -trait to_opt { +trait ToOpt { fn to_option(&self) -> Option<Self>; } -impl to_opt for usize { +impl ToOpt for usize { fn to_option(&self) -> Option<usize> { Some(*self) } } -impl<T:Clone> to_opt for Option<T> { +impl<T:Clone> ToOpt for Option<T> { fn to_option(&self) -> Option<Option<T>> { Some((*self).clone()) } } -fn function<T:to_opt + Clone>(counter: usize, t: T) { +fn function<T:ToOpt + Clone>(counter: usize, t: T) { if counter > 0_usize { function(counter - 1_usize, t.to_option()); + // FIXME(#4287) Error message should be here. It should be + // a type error to instantiate `test` at a type other than T. } } diff --git a/src/test/compile-fail/issue-17441.rs b/src/test/compile-fail/issue-17441.rs index 321b8b260da..9f76f360f26 100644 --- a/src/test/compile-fail/issue-17441.rs +++ b/src/test/compile-fail/issue-17441.rs @@ -14,11 +14,11 @@ fn main() { let _foo = &[1_usize, 2] as [usize]; //~^ ERROR cast to unsized type: `&[usize; 2]` as `[usize]` //~^^ HELP consider using an implicit coercion to `&[usize]` instead - let _bar = box 1_usize as std::fmt::Show; - //~^ ERROR cast to unsized type: `Box<usize>` as `core::fmt::Show` - //~^^ HELP did you mean `Box<core::fmt::Show>`? - let _baz = 1_usize as std::fmt::Show; - //~^ ERROR cast to unsized type: `usize` as `core::fmt::Show` + let _bar = box 1_usize as std::fmt::Debug; + //~^ ERROR cast to unsized type: `Box<usize>` as `core::fmt::Debug` + //~^^ HELP did you mean `Box<core::fmt::Debug>`? + let _baz = 1_usize as std::fmt::Debug; + //~^ ERROR cast to unsized type: `usize` as `core::fmt::Debug` //~^^ HELP consider using a box or reference as appropriate let _quux = [1_usize, 2] as [usize]; //~^ ERROR cast to unsized type: `[usize; 2]` as `[usize]` diff --git a/src/test/compile-fail/issue-18959.rs b/src/test/compile-fail/issue-18959.rs index 368f3c16f51..8fb543fb967 100644 --- a/src/test/compile-fail/issue-18959.rs +++ b/src/test/compile-fail/issue-18959.rs @@ -17,7 +17,11 @@ impl Foo for Thing { fn foo<T>(&self, _: &T) {} } -#[inline(never)] fn foo(b: &Bar) { b.foo(&0_usize) } +#[inline(never)] +fn foo(b: &Bar) { + b.foo(&0usize) + //~^ ERROR the trait `Foo` is not implemented for the type `Bar` +} fn main() { let mut thing = Thing; diff --git a/src/test/compile-fail/lint-missing-doc.rs b/src/test/compile-fail/lint-missing-doc.rs index 73a58741bbb..cb2d4e10e6e 100644 --- a/src/test/compile-fail/lint-missing-doc.rs +++ b/src/test/compile-fail/lint-missing-doc.rs @@ -17,15 +17,15 @@ #![doc="More garbage"] type Typedef = String; -pub type PubTypedef = String; //~ ERROR: missing documentation +pub type PubTypedef = String; //~ ERROR: missing documentation for a type alias struct Foo { a: isize, b: isize, } -pub struct PubFoo { //~ ERROR: missing documentation - pub a: isize, //~ ERROR: missing documentation +pub struct PubFoo { //~ ERROR: missing documentation for a struct + pub a: isize, //~ ERROR: missing documentation for a struct field b: isize, } @@ -36,11 +36,11 @@ pub struct PubFoo2 { } mod module_no_dox {} -pub mod pub_module_no_dox {} //~ ERROR: missing documentation +pub mod pub_module_no_dox {} //~ ERROR: missing documentation for a module /// dox pub fn foo() {} -pub fn foo2() {} //~ ERROR: missing documentation +pub fn foo2() {} //~ ERROR: missing documentation for a function fn foo3() {} #[allow(missing_docs)] pub fn foo4() {} @@ -58,9 +58,9 @@ trait B { fn foo_with_impl(&self) {} } -pub trait C { //~ ERROR: missing documentation - fn foo(&self); //~ ERROR: missing documentation - fn foo_with_impl(&self) {} //~ ERROR: missing documentation +pub trait C { //~ ERROR: missing documentation for a trait + fn foo(&self); //~ ERROR: missing documentation for a type method + fn foo_with_impl(&self) {} //~ ERROR: missing documentation for a method } #[allow(missing_docs)] @@ -68,13 +68,26 @@ pub trait D { fn dummy(&self) { } } +/// dox +pub trait E { + type AssociatedType; //~ ERROR: missing documentation for an associated type + type AssociatedTypeDef = Self; //~ ERROR: missing documentation for an associated type + + /// dox + type DocumentedType; + /// dox + type DocumentedTypeDef = Self; + /// dox + fn dummy(&self) {} +} + impl Foo { pub fn foo() {} fn bar() {} } impl PubFoo { - pub fn foo() {} //~ ERROR: missing documentation + pub fn foo() {} //~ ERROR: missing documentation for a method /// dox pub fn foo1() {} fn foo2() {} @@ -111,9 +124,9 @@ enum Baz { BarB } -pub enum PubBaz { //~ ERROR: missing documentation - PubBazA { //~ ERROR: missing documentation - a: isize, //~ ERROR: missing documentation +pub enum PubBaz { //~ ERROR: missing documentation for an enum + PubBazA { //~ ERROR: missing documentation for a variant + a: isize, //~ ERROR: missing documentation for a struct field }, } @@ -139,14 +152,14 @@ pub fn baz() {} mod internal_impl { /// dox pub fn documented() {} - pub fn undocumented1() {} //~ ERROR: missing documentation - pub fn undocumented2() {} //~ ERROR: missing documentation + pub fn undocumented1() {} //~ ERROR: missing documentation for a function + pub fn undocumented2() {} //~ ERROR: missing documentation for a function fn undocumented3() {} /// dox pub mod globbed { /// dox pub fn also_documented() {} - pub fn also_undocumented1() {} //~ ERROR: missing documentation + pub fn also_undocumented1() {} //~ ERROR: missing documentation for a function fn also_undocumented2() {} } } diff --git a/src/test/compile-fail/lint-unsafe-code.rs b/src/test/compile-fail/lint-unsafe-code.rs index 7b17d887757..8440cf3a88e 100644 --- a/src/test/compile-fail/lint-unsafe-code.rs +++ b/src/test/compile-fail/lint-unsafe-code.rs @@ -15,6 +15,8 @@ use std::marker::PhantomFn; struct Bar; +struct Bar2; +struct Bar3; #[allow(unsafe_code)] mod allowed_unsafe { @@ -46,6 +48,53 @@ impl Baz for Bar { unsafe fn provided_override(&self) {} //~ ERROR: implementation of an `unsafe` method } + +#[allow(unsafe_code)] +trait A { + unsafe fn allowed_unsafe(&self); + unsafe fn allowed_unsafe_provided(&self) {} +} + +#[allow(unsafe_code)] +impl Baz for Bar2 { + unsafe fn baz(&self) {} + unsafe fn provided_override(&self) {} +} + +impl Baz for Bar3 { + #[allow(unsafe_code)] + unsafe fn baz(&self) {} + unsafe fn provided_override(&self) {} //~ ERROR: implementation of an `unsafe` method +} + +#[allow(unsafe_code)] +unsafe trait B { + fn dummy(&self) {} +} + +trait C { + #[allow(unsafe_code)] + unsafe fn baz(&self); + unsafe fn provided(&self) {} //~ ERROR: implementation of an `unsafe` method +} + +impl C for Bar { + #[allow(unsafe_code)] + unsafe fn baz(&self) {} + unsafe fn provided(&self) {} //~ ERROR: implementation of an `unsafe` method +} + +impl C for Bar2 { + unsafe fn baz(&self) {} //~ ERROR: implementation of an `unsafe` method +} + +trait D { + #[allow(unsafe_code)] + unsafe fn unsafe_provided(&self) {} +} + +impl D for Bar {} + fn main() { unsafe {} //~ ERROR: usage of an `unsafe` block diff --git a/src/test/compile-fail/move-in-guard-1.rs b/src/test/compile-fail/move-in-guard-1.rs new file mode 100644 index 00000000000..5d29d0e1fd0 --- /dev/null +++ b/src/test/compile-fail/move-in-guard-1.rs @@ -0,0 +1,25 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(box_syntax)] + +pub fn main() { + let x = box 1; + + let v = (1, 2); + + match v { + (1, _) if take(x) => (), + (_, 2) if take(x) => (), //~ ERROR use of moved value: `x` + _ => (), + } +} + +fn take<T>(_: T) -> bool { false } diff --git a/src/test/compile-fail/move-in-guard-2.rs b/src/test/compile-fail/move-in-guard-2.rs new file mode 100644 index 00000000000..23af2579797 --- /dev/null +++ b/src/test/compile-fail/move-in-guard-2.rs @@ -0,0 +1,25 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(box_syntax)] + +pub fn main() { + let x = box 1; + + let v = (1, 2); + + match v { + (1, _) | + (_, 2) if take(x) => (), //~ ERROR use of moved value: `x` + _ => (), + } +} + +fn take<T>(_: T) -> bool { false } diff --git a/src/test/compile-fail/object-safety-by-value-self-use.rs b/src/test/compile-fail/object-safety-by-value-self-use.rs new file mode 100644 index 00000000000..1b20a902c9d --- /dev/null +++ b/src/test/compile-fail/object-safety-by-value-self-use.rs @@ -0,0 +1,29 @@ +// 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 while a trait with by-value self is object-safe, we +// can't actually invoke it from an object (yet...?). + +#![feature(rustc_attrs)] + +trait Bar { + fn bar(self); +} + +trait Baz { + fn baz(self: Self); +} + +fn use_bar(t: Box<Bar>) { + t.bar() //~ ERROR cannot move a value of type Bar +} + +fn main() { } + diff --git a/src/test/compile-fail/object-safety-by-value-self.rs b/src/test/compile-fail/object-safety-by-value-self.rs index 5ebcc8516ca..976717249e8 100644 --- a/src/test/compile-fail/object-safety-by-value-self.rs +++ b/src/test/compile-fail/object-safety-by-value-self.rs @@ -8,8 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Check that we correctly prevent users from making trait objects -// from traits with a `fn(self)` method. +// Check that a trait with by-value self is considered object-safe. + +#![feature(rustc_attrs)] +#![allow(dead_code)] trait Bar { fn bar(self); @@ -19,29 +21,35 @@ trait Baz { fn baz(self: Self); } +trait Quux { + // Legal because of the where clause: + fn baz(self: Self) where Self : Sized; +} + fn make_bar<T:Bar>(t: &T) -> &Bar { - t - //~^ ERROR `Bar` is not object-safe - //~| NOTE method `bar` has a receiver type of `Self` + t // legal } fn make_bar_explicit<T:Bar>(t: &T) -> &Bar { - t as &Bar - //~^ ERROR `Bar` is not object-safe - //~| NOTE method `bar` has a receiver type of `Self` + t as &Bar // legal } fn make_baz<T:Baz>(t: &T) -> &Baz { - t - //~^ ERROR `Baz` is not object-safe - //~| NOTE method `baz` has a receiver type of `Self` + t // legal } fn make_baz_explicit<T:Baz>(t: &T) -> &Baz { - t as &Baz - //~^ ERROR `Baz` is not object-safe - //~| NOTE method `baz` has a receiver type of `Self` + t as &Baz // legal +} + +fn make_quux<T:Quux>(t: &T) -> &Quux { + t +} + +fn make_quux_explicit<T:Quux>(t: &T) -> &Quux { + t as &Quux } -fn main() { +#[rustc_error] +fn main() { //~ ERROR compilation successful } diff --git a/src/test/compile-fail/object-safety-generics.rs b/src/test/compile-fail/object-safety-generics.rs index 0ca706404c1..fd20accfa1e 100644 --- a/src/test/compile-fail/object-safety-generics.rs +++ b/src/test/compile-fail/object-safety-generics.rs @@ -9,12 +9,18 @@ // except according to those terms. // Check that we correctly prevent users from making trait objects -// from traits with generic methods. +// from traits with generic methods, unless `where Self : Sized` is +// present. trait Bar { fn bar<T>(&self, t: T); } +trait Quux { + fn bar<T>(&self, t: T) + where Self : Sized; +} + fn make_bar<T:Bar>(t: &T) -> &Bar { t //~^ ERROR `Bar` is not object-safe @@ -27,5 +33,13 @@ fn make_bar_explicit<T:Bar>(t: &T) -> &Bar { //~| NOTE method `bar` has generic type parameters } +fn make_quux<T:Quux>(t: &T) -> &Quux { + t +} + +fn make_quux_explicit<T:Quux>(t: &T) -> &Quux { + t as &Quux +} + fn main() { } diff --git a/src/test/compile-fail/object-safety-mentions-Self.rs b/src/test/compile-fail/object-safety-mentions-Self.rs index df0f44c1391..b546774ccbd 100644 --- a/src/test/compile-fail/object-safety-mentions-Self.rs +++ b/src/test/compile-fail/object-safety-mentions-Self.rs @@ -9,7 +9,8 @@ // except according to those terms. // Check that we correctly prevent users from making trait objects -// form traits that make use of `Self` in an argument or return position. +// form traits that make use of `Self` in an argument or return +// position, unless `where Self : Sized` is present.. trait Bar { fn bar(&self, x: &Self); @@ -19,6 +20,10 @@ trait Baz { fn bar(&self) -> Self; } +trait Quux { + fn get(&self, s: &Self) -> Self where Self : Sized; +} + fn make_bar<T:Bar>(t: &T) -> &Bar { t //~^ ERROR `Bar` is not object-safe @@ -43,5 +48,13 @@ fn make_baz_explicit<T:Baz>(t: &T) -> &Baz { //~| NOTE method `bar` references the `Self` type in its arguments or return type } +fn make_quux<T:Quux>(t: &T) -> &Quux { + t +} + +fn make_quux_explicit<T:Quux>(t: &T) -> &Quux { + t as &Quux +} + fn main() { } diff --git a/src/test/compile-fail/recursion.rs b/src/test/compile-fail/recursion.rs index ffc21a5ce61..55f3b995336 100644 --- a/src/test/compile-fail/recursion.rs +++ b/src/test/compile-fail/recursion.rs @@ -1,4 +1,4 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT +// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // @@ -10,10 +10,9 @@ //~^^^^^^^^^^ ERROR overflow // -// We also get a second error message at the top of file (dummy -// span). This is not helpful, but also kind of annoying to prevent, -// so for now just live with it, since we also get a second message -// that is more helpful. +// We get an error message at the top of file (dummy span). +// This is not helpful, but also kind of annoying to prevent, +// so for now just live with it. enum Nil {NilValue} struct Cons<T> {head:isize, tail:T} @@ -28,9 +27,8 @@ impl<T:Dot> Dot for Cons<T> { } fn test<T:Dot> (n:isize, i:isize, first:T, second:T) ->isize { match n { 0 => {first.dot(second)} - //~^ ERROR: reached the recursion limit during monomorphization - // Error message should be here. It should be a type error - // to instantiate `test` at a type other than T. (See #4287) + // FIXME(#4287) Error message should be here. It should be + // a type error to instantiate `test` at a type other than T. _ => {test (n-1, i+1, Cons {head:2*i+1, tail:first}, Cons{head:i*i, tail:second})} } } diff --git a/src/test/compile-fail/trait-test-2.rs b/src/test/compile-fail/trait-test-2.rs index d8b3176787c..b09b10ffa0a 100644 --- a/src/test/compile-fail/trait-test-2.rs +++ b/src/test/compile-fail/trait-test-2.rs @@ -18,4 +18,5 @@ fn main() { 10.dup::<i32>(); //~ ERROR does not take type parameters 10.blah::<i32, i32>(); //~ ERROR incorrect number of type parameters (box 10 as Box<bar>).dup(); //~ ERROR cannot convert to a trait object + //~^ ERROR the trait `bar` is not implemented for the type `bar` } diff --git a/src/test/compile-fail/typeck-builtin-bound-type-parameters.rs b/src/test/compile-fail/typeck-builtin-bound-type-parameters.rs new file mode 100644 index 00000000000..fb6c43a1905 --- /dev/null +++ b/src/test/compile-fail/typeck-builtin-bound-type-parameters.rs @@ -0,0 +1,28 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn foo1<T:Copy<U>, U>(x: T) {} +//~^ ERROR: wrong number of type arguments: expected 0, found 1 + +trait Trait: Copy<Send> {} +//~^ ERROR: wrong number of type arguments: expected 0, found 1 + +struct MyStruct1<T: Copy<T>>; +//~^ ERROR wrong number of type arguments: expected 0, found 1 + +struct MyStruct2<'a, T: Copy<'a>>; +//~^ ERROR: wrong number of lifetime parameters: expected 0, found 1 + +fn foo2<'a, T:Copy<'a, U>, U>(x: T) {} +//~^ ERROR: wrong number of type arguments: expected 0, found 1 +//~^^ ERROR: wrong number of lifetime parameters: expected 0, found 1 + +fn main() { +} diff --git a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs index d8a82d8fbf0..1998f8ab155 100644 --- a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs +++ b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs @@ -18,7 +18,7 @@ struct Number { n: i64 } -impl fmt::String for Number { +impl fmt::Display for Number { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.n) } diff --git a/src/test/parse-fail/issue-22647.rs b/src/test/parse-fail/issue-22647.rs new file mode 100644 index 00000000000..5de86270010 --- /dev/null +++ b/src/test/parse-fail/issue-22647.rs @@ -0,0 +1,25 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + let caller<F> = |f: F| //~ ERROR unexpected token: `<` + where F: Fn() -> i32 + { + let x = f(); + println!("Y {}",x); + return x; + }; + + caller(bar_handler); +} + +fn bar_handler() -> i32 { + 5 +} diff --git a/src/test/parse-fail/issue-22712.rs b/src/test/parse-fail/issue-22712.rs new file mode 100644 index 00000000000..abc9e599467 --- /dev/null +++ b/src/test/parse-fail/issue-22712.rs @@ -0,0 +1,19 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +struct Foo<B> { + buffer: B +} + +fn bar() { + let Foo<Vec<u8>> //~ ERROR unexpected token: `<` +} + +fn main() {} diff --git a/src/test/parse-fail/trailing-plus-in-bounds.rs b/src/test/parse-fail/trailing-plus-in-bounds.rs index e8f9ed4d2cf..8febbf8309e 100644 --- a/src/test/parse-fail/trailing-plus-in-bounds.rs +++ b/src/test/parse-fail/trailing-plus-in-bounds.rs @@ -8,11 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt::Show; +use std::fmt::Debug; fn main() { - let x: Box<Show+> = box 3 as Box<Show+>; + let x: Box<Debug+> = box 3 as Box<Debug+>; //~^ ERROR at least one type parameter bound must be specified //~^^ ERROR at least one type parameter bound must be specified } - diff --git a/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot index bee4a120d59..51c6b14e1de 100644 --- a/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f07.dot-expected.dot @@ -22,12 +22,12 @@ digraph block { N3 -> N4; N4 -> N5; N5 -> N6; - N6 -> N8; - N8 -> N9; + N6 -> N9; N9 -> N10; N10 -> N11; N11 -> N12; - N12 -> N13; + N12 -> N8; + N8 -> N13; N13 -> N14; N14 -> N15; N15 -> N7; diff --git a/src/test/run-make/graphviz-flowgraph/f13.dot-expected.dot b/src/test/run-make/graphviz-flowgraph/f13.dot-expected.dot index 76e66513515..fb7d2ad97bd 100644 --- a/src/test/run-make/graphviz-flowgraph/f13.dot-expected.dot +++ b/src/test/run-make/graphviz-flowgraph/f13.dot-expected.dot @@ -32,16 +32,16 @@ digraph block { N6 -> N7; N7 -> N8; N8 -> N9; - N9 -> N11; - N11 -> N12; - N12 -> N13; + N9 -> N12; + N12 -> N11; + N11 -> N13; N13 -> N14; N14 -> N15; N15 -> N10; - N11 -> N16; - N16 -> N17; + N9 -> N17; N17 -> N18; - N18 -> N19; + N18 -> N16; + N16 -> N19; N19 -> N20; N20 -> N21; N21 -> N22; diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs index 652f21c2ae3..d2e9bc2efe7 100644 --- a/src/test/run-pass/auto-ref-sliceable.rs +++ b/src/test/run-pass/auto-ref-sliceable.rs @@ -23,5 +23,5 @@ pub fn main() { let mut v = vec!(1); v.push_val(2); v.push_val(3); - assert_eq!(v, vec!(1, 2, 3)); + assert_eq!(v, [1, 2, 3]); } diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs index 575c32baeac..daff321efcf 100644 --- a/src/test/run-pass/class-separate-impl.rs +++ b/src/test/run-pass/class-separate-impl.rs @@ -54,7 +54,7 @@ fn cat(in_x : uint, in_y : int, in_name: String) -> cat { } } -impl fmt::String for cat { +impl fmt::Display for cat { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.name) } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs index f87f2e07c9d..2473b4b674e 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs @@ -22,5 +22,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = vec!(1, 2, 3, 100); bar(&mut the_vec); - assert_eq!(the_vec, vec!(100, 3, 2, 1)); + assert_eq!(the_vec, [100, 3, 2, 1]); } diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs index 4f97e6a2081..ea09bb3904d 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs @@ -18,5 +18,5 @@ fn bar(v: &mut [uint]) { pub fn main() { let mut the_vec = vec!(1, 2, 3, 100); bar(&mut the_vec); - assert_eq!(the_vec, vec!(100, 3, 2, 1)); + assert_eq!(the_vec, [100, 3, 2, 1]); } diff --git a/src/test/run-pass/coherence-multidispatch-tuple.rs b/src/test/run-pass/coherence-multidispatch-tuple.rs index 04a69bbf3a2..b16b033c22f 100644 --- a/src/test/run-pass/coherence-multidispatch-tuple.rs +++ b/src/test/run-pass/coherence-multidispatch-tuple.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::fmt::Show; +use std::fmt::Debug; use std::default::Default; // Test that an impl for homogeneous pairs does not conflict with a diff --git a/src/test/run-pass/generic-static-methods.rs b/src/test/run-pass/generic-static-methods.rs index 7f84efcdd5d..010f54dd559 100644 --- a/src/test/run-pass/generic-static-methods.rs +++ b/src/test/run-pass/generic-static-methods.rs @@ -24,5 +24,5 @@ impl<T> vec_utils<T> for Vec<T> { } pub fn main() { - assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), vec!(2,3,4)); + assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), [2,3,4]); } diff --git a/src/test/run-pass/issue-22577.rs b/src/test/run-pass/issue-22577.rs new file mode 100644 index 00000000000..1ecdd39ca7a --- /dev/null +++ b/src/test/run-pass/issue-22577.rs @@ -0,0 +1,29 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::{fs, net}; + +fn assert_both<T: Send + Sync>() {} + +fn main() { + assert_both::<fs::File>(); + assert_both::<fs::Metadata>(); + assert_both::<fs::ReadDir>(); + assert_both::<fs::DirEntry>(); + assert_both::<fs::WalkDir>(); + assert_both::<fs::OpenOptions>(); + assert_both::<fs::Permissions>(); + + assert_both::<net::TcpStream>(); + assert_both::<net::TcpListener>(); + assert_both::<net::UdpSocket>(); + assert_both::<net::SocketAddr>(); + assert_both::<net::IpAddr>(); +} diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index f4b85e03eae..be4d4752295 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -101,7 +101,7 @@ impl AsciiArt { // Allows AsciiArt to be converted to a string using the libcore ToString trait. // Note that the %s fmt! specifier will not call this automatically. -impl fmt::String for AsciiArt { +impl fmt::Display for AsciiArt { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Convert each line into a string. let lines = self.lines.iter() diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs index 457c0a35fd7..0d563f1a714 100644 --- a/src/test/run-pass/monad.rs +++ b/src/test/run-pass/monad.rs @@ -44,11 +44,11 @@ fn transform(x: Option<int>) -> Option<String> { pub fn main() { assert_eq!(transform(Some(10)), Some("11".to_string())); assert_eq!(transform(None), None); - assert!((vec!("hi".to_string())) + assert_eq!((vec!("hi".to_string())) .bind(|x| vec!(x.clone(), format!("{}!", x)) ) - .bind(|x| vec!(x.clone(), format!("{}?", x)) ) == - vec!("hi".to_string(), - "hi?".to_string(), - "hi!".to_string(), - "hi!?".to_string())); + .bind(|x| vec!(x.clone(), format!("{}?", x)) ), + ["hi".to_string(), + "hi?".to_string(), + "hi!".to_string(), + "hi!?".to_string()]); } diff --git a/src/test/run-pass/move-guard-const.rs b/src/test/run-pass/move-guard-const.rs new file mode 100644 index 00000000000..64c4f1fdbae --- /dev/null +++ b/src/test/run-pass/move-guard-const.rs @@ -0,0 +1,25 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(box_syntax)] + +fn main() { + let x = box 1; + + let v = (1, 2); + + match v { + (2, 1) if take(x) => (), + (1, 2) if take(x) => (), + _ => (), + } +} + +fn take<T>(_: T) -> bool { false } diff --git a/src/test/run-pass/object-safety-sized-self-by-value-self.rs b/src/test/run-pass/object-safety-sized-self-by-value-self.rs new file mode 100644 index 00000000000..ae092333134 --- /dev/null +++ b/src/test/run-pass/object-safety-sized-self-by-value-self.rs @@ -0,0 +1,46 @@ +// 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 a trait is still object-safe (and usable) if it has +// methods with by-value self so long as they require `Self : Sized`. + +trait Counter { + fn tick(&mut self) -> u32; + fn get(self) -> u32 where Self : Sized; +} + +struct CCounter { + c: u32 +} + +impl Counter for CCounter { + fn tick(&mut self) -> u32 { self.c += 1; self.c } + fn get(self) -> u32 where Self : Sized { self.c } +} + +fn tick1<C:Counter>(mut c: C) -> u32 { + tick2(&mut c); + c.get() +} + +fn tick2(c: &mut Counter) { + tick3(c); +} + +fn tick3<C:?Sized+Counter>(c: &mut C) { + c.tick(); + c.tick(); +} + +fn main() { + let mut c = CCounter { c: 0 }; + let value = tick1(c); + assert_eq!(value, 2); +} diff --git a/src/test/run-pass/object-safety-sized-self-generic-method.rs b/src/test/run-pass/object-safety-sized-self-generic-method.rs new file mode 100644 index 00000000000..1a42c4b6ef6 --- /dev/null +++ b/src/test/run-pass/object-safety-sized-self-generic-method.rs @@ -0,0 +1,46 @@ +// 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 a trait is still object-safe (and usable) if it has +// generic methods so long as they require `Self : Sized`. + +trait Counter { + fn tick(&mut self) -> u32; + fn with<F:FnOnce(u32)>(&self, f: F) where Self : Sized; +} + +struct CCounter { + c: u32 +} + +impl Counter for CCounter { + fn tick(&mut self) -> u32 { self.c += 1; self.c } + fn with<F:FnOnce(u32)>(&self, f: F) { f(self.c); } +} + +fn tick1<C:Counter>(c: &mut C) { + tick2(c); + c.with(|i| ()); +} + +fn tick2(c: &mut Counter) { + tick3(c); +} + +fn tick3<C:?Sized+Counter>(c: &mut C) { + c.tick(); + c.tick(); +} + +fn main() { + let mut c = CCounter { c: 0 }; + tick1(&mut c); + assert_eq!(c.tick(), 3); +} diff --git a/src/test/run-pass/object-safety-sized-self-return-Self.rs b/src/test/run-pass/object-safety-sized-self-return-Self.rs new file mode 100644 index 00000000000..7f075bbb6c2 --- /dev/null +++ b/src/test/run-pass/object-safety-sized-self-return-Self.rs @@ -0,0 +1,47 @@ +// 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 a trait is still object-safe (and usable) if it has +// methods that return `Self` so long as they require `Self : Sized`. + +trait Counter { + fn new() -> Self where Self : Sized; + fn tick(&mut self) -> u32; +} + +struct CCounter { + c: u32 +} + +impl Counter for CCounter { + fn new() -> CCounter { CCounter { c: 0 } } + fn tick(&mut self) -> u32 { self.c += 1; self.c } +} + +fn preticked<C:Counter>() -> C { + let mut c: C = Counter::new(); + tick(&mut c); + c +} + +fn tick(c: &mut Counter) { + tick_generic(c); +} + +fn tick_generic<C:?Sized+Counter>(c: &mut C) { + c.tick(); + c.tick(); +} + +fn main() { + let mut c = preticked::<CCounter>(); + tick(&mut c); + assert_eq!(c.tick(), 5); +} diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs index 5f4b18df6e1..0dedf621a4f 100644 --- a/src/test/run-pass/trait-generic.rs +++ b/src/test/run-pass/trait-generic.rs @@ -44,9 +44,9 @@ fn bar<U:to_str,T:map<U>>(x: T) -> Vec<String> { } pub fn main() { - assert_eq!(foo(vec!(1)), vec!("hi".to_string())); - assert_eq!(bar::<int, Vec<int> >(vec!(4, 5)), vec!("4".to_string(), "5".to_string())); + assert_eq!(foo(vec!(1)), ["hi".to_string()]); + assert_eq!(bar::<int, Vec<int> >(vec!(4, 5)), ["4".to_string(), "5".to_string()]); assert_eq!(bar::<String, Vec<String> >(vec!("x".to_string(), "y".to_string())), - vec!("x".to_string(), "y".to_string())); - assert_eq!(bar::<(), Vec<()>>(vec!(())), vec!("()".to_string())); + ["x".to_string(), "y".to_string()]); + assert_eq!(bar::<(), Vec<()>>(vec!(())), ["()".to_string()]); } diff --git a/src/test/run-pass/unboxed-closures-infer-upvar.rs b/src/test/run-pass/unboxed-closures-infer-upvar.rs index 087ef5dcf05..1401fe7470b 100644 --- a/src/test/run-pass/unboxed-closures-infer-upvar.rs +++ b/src/test/run-pass/unboxed-closures-infer-upvar.rs @@ -18,5 +18,5 @@ fn f<F: FnMut()>(mut f: F) { fn main() { let mut v: Vec<_> = vec![]; f(|| v.push(0)); - assert_eq!(v, vec![0]); + assert_eq!(v, [0]); } |